# Contact
Source: https://docs.heystandard.com/contact-us/contact
Get in touch with Standard Form
We're happy to help.
* **Message or WhatsApp:** [+1 415 972 9824](https://wa.me/14159729824)
* **Email:** [liz@heystandard.com](mailto:liz@heystandard.com)
* **Schedule a call:** [Book a time](https://calendar.app.google/pmYEbpb4Qk1TWswg7)
**When to reach out:** Didn't receive your invitation email, technical issues, questions about feasibility or billing, feature requests, or feedback on call schedules.
# Welcome
Source: https://docs.heystandard.com/index
Residency and physician scheduling that works
Standard Form generates fair, feasible schedules for residency and physician teams. You add your people, blocks, coverage, and rules. The system does the assignments.
## What you get
* A schedule that respects coverage, mandates, and leave
* Alerts that flag problems before the rotation starts
* One-click regeneration when inputs change
* Linked call schedules built from your block schedule
## Pick your starting point
Five steps from a blank slate to a generated schedule.
Read the table, understand alerts, see linked call schedules.
Edit inputs and regenerate, or make manual changes.
Put each resident's schedule on their phone after you publish.
## Getting access
You'll get an invitation email from Standard Form. Click the link to sign up or accept the invite, then log in. If you don't see it, check your spam folder, or [contact us](/contact-us/contact).
## Want a walkthrough?
We're happy to show you the product. [Schedule a call](https://calendar.app.google/7i3T12m5yoTfGC3Y6) or [contact us](/contact-us/contact).
## Next steps
* [Make your first schedule](/make-your-first-schedule/overview)
# The basics
Source: https://docs.heystandard.com/make-your-first-schedule/1-basics
Schedule name, team, dates, slot size, physicians, blocks
This step captures everything the system needs to set the shape of your schedule.
## Name and team
Give the schedule a name like "Senior Residents Schedule" and your team a name like "CPMC Internal Medicine." Pick your specialty and facility type from the dropdowns.
## Dates and block size
Set a **start date** and **end date** for the schedule. Most teams set this to one academic year, but you can use any range.
Pick a **block size**: Day, Week, Two Week, or Month. This is the smallest unit the system assigns rotations in. Most block-based programs use Week or Two Week.
Set **statutory leave days** per person if your jurisdiction guarantees a number of leave days each person gets.
## Your physicians
Upload a CSV with your physician roster. The CSV needs three columns:
* **First Name** (required)
* **Last Name** (required)
* **Email** (optional but recommended)
Click **Template** to download a starter CSV with the right headers.
**Screenshot to add:** the physician upload area showing the Template download button and the dropzone.
Rows missing a required field or with a duplicate email are flagged. You can fix the CSV and re-upload, or import the rest and skip the bad rows.
For details on what we track per person, see [People](/reference/people).
## Your blocks
[Blocks](/reference/blocks) are the rotations or activities you schedule (Wards, Clinic, Nights, Vacation). For each block, fill in:
* **Label** (e.g. "MICU")
* **Description** (optional)
* **Load type**: Light, Medium, or Heavy
* **Type**: regular, leave, or on-call
* **Allowed roles**: which ranks can be assigned (e.g. PGY1 to PGY4)
**Screenshot to add:** the blocks table with a couple of example blocks filled in.
For details on each field, see [Blocks](/reference/blocks).
# Rules
Source: https://docs.heystandard.com/make-your-first-schedule/2-rules
Plain-language rules for how the schedule should behave
This step captures how the schedule should behave. You write rules in plain language and the system uses them to constrain the assignments.
There are three kinds of rules: coverage, mandates, and behavior rules.
## Coverage
For each block you defined in the previous step, write a short note describing how many people must be on at any time, and any conditions.
Examples:
* "Wards: minimum 4 residents at all times. PGY1 and PGY2 only."
* "Night float: 1 resident, PGY2 to PGY4."
You'll see one text box per block.
## Mandates
Mandates are minimums per person. For each block, set how many times each person must be assigned to it across the schedule.
Examples:
* "Every PGY1 does Wards at least 3 times."
* "Every senior resident does at least 2 night float blocks."
The wizard shows this as a table where you fill in the number per role per block.
**Screenshot to add:** the mandate table showing rows per block and inputs per role.
## Behavior rules
Behavior rules cover everything else: patterns the schedule should follow, things to avoid, fairness rules. You add them as cards.
Each rule has a **strict** toggle:
* **Strict** — the system treats it as a hard constraint and won't break it. Use for rules that must always hold (e.g. "MICU must be scheduled in two consecutive blocks").
* **Flexible** — the system treats it as a soft preference and will try to honor it. Use for rules you'd like but can live without (e.g. "Avoid placing ICU immediately after a night float block").
**Screenshot to add:** a rule card with the strict/flexible toggle visible.
# Outside rotators
Source: https://docs.heystandard.com/make-your-first-schedule/3-rotators
Visiting residents or rotating staff who affect coverage
Outside [rotators](/reference/rotators) are people from outside your team who appear on the schedule but aren't on your physician roster. For example, family medicine residents rotating in from another program.
The wizard first asks whether you have outside rotators.
## If you don't
Pick **No** and continue. The wizard skips the rest of this step.
## If you do
Pick **Yes**, then tell us about them in two parts.
### Who they are
Upload a CSV or Excel file with their names, ranks, and emails. Or list them in the text box: one per line, in any format that works for you.
Example list:
```
Jane Smith, PGY2, FM, jsmith@hospital.org
Tom Lee, PGY1, FM, tlee@hospital.org
```
### How they fit into the schedule
Describe in plain language how rotators participate. The more detail, the better.
Example:
> FM residents rotate every 4 weeks. They should not be placed on night float and follow a lighter load schedule. Each does one block of Wards per quarter.
# Past schedules
Source: https://docs.heystandard.com/make-your-first-schedule/4-past-schedules
Upload a prior schedule so the system can match patterns your team is used to
This step is optional. If you have a schedule from a previous year, upload it and the system uses it to learn patterns your team is used to.
## What to upload
Drop a file in the upload area or click to browse. Supported formats:
* CSV
* Excel (`.xlsx` or `.xls`)
* PDF
The file can be in whatever format your team already uses. The system parses what it can.
## What we do with it
Past schedules help the system detect patterns: how blocks tend to be distributed, common rotation orders, fairness norms your team has historically followed.
Past schedules **inform** the system. They don't override the [rules](/make-your-first-schedule/2-rules) you set in the previous step. Rules are what constrain the assignments.
## No past schedule?
Skip this step. The schedule still generates from the rules and people you've defined.
# Who's who
Source: https://docs.heystandard.com/make-your-first-schedule/5-who-is-who
Director, chiefs, and coordinators on your team
This step captures the people who run scheduling, separate from the people being scheduled.
## Program director
The senior person responsible for the program. Add their name, email, and phone.
## Chiefs
The chief residents who own the schedule day to day. Add as many as you have. For each, fill in name, email, and phone.
## Coordinators and admins
Anyone else involved in scheduling: program coordinators, administrators, support staff. For each, fill in name, role, and email.
When you finish this step, the schedule generates and you'll land in [the table](/view-your-schedule/the-table).
# Overview
Source: https://docs.heystandard.com/make-your-first-schedule/overview
What setup asks for and what you'll have when you're done
Setup is five short steps. Fill in what you can and the system uses it to generate your first schedule. You can edit any input later.
## What you'll have at the end
A generated [block schedule](/reference/schedule-types) for your team that respects your [rules](/make-your-first-schedule/2-rules). From there you can view it on [the table](/view-your-schedule/the-table), read [alerts](/view-your-schedule/alerts), [regenerate](/update-your-schedule/edit-and-regenerate), or link a [call schedule](/view-your-schedule/call-schedules).
![A finished block schedule showing physicians assigned to color-coded blocks across weeks]()
## What to gather before you start
You don't need everything to begin, but having these on hand makes setup faster:
* The [people](/reference/people) on your team, with their ranks (e.g. PGY1 to PGY4)
* The [blocks](/reference/blocks) or rotations you schedule (e.g. Wards, Clinic, Nights, Leave)
* Rules your team already follows (e.g. coverage per block, mandates per person, call frequency, weekend rotation, [leave policy](/reference/leave))
* A past schedule in any format, if you have one
## The five steps
### The basics
Schedule name, team name, specialty, facility, start and end dates, slot size, statutory leave days, your physicians, and your blocks.
See [The basics](/make-your-first-schedule/1-basics).
### Rules
Plain-language rules for how the schedule should behave. Coverage (how many people per block) and mandates (minimum times each person hits a block) are kinds of rules. Examples: "no back-to-back call", "spread weekends fairly", "max two nights per month."
See [Rules](/make-your-first-schedule/2-rules).
### Outside rotators
Visiting residents or other [rotators](/reference/rotators) who share blocks with your team but aren't on your roster.
See [Outside rotators](/make-your-first-schedule/3-rotators).
### Past schedules
A prior schedule you can upload so the system matches the patterns your team is used to. Helpful but not required.
See [Past schedules](/make-your-first-schedule/4-past-schedules).
### Who's who
The director, chiefs, and coordinators who run scheduling.
See [Who's who](/make-your-first-schedule/5-who-is-who).
## Tips
* **Fill in what you have.** Setup captures the starting state. You can update any input after the schedule is generated and regenerate.
* **Take your time on Rules.** Rules drive most of how the schedule behaves.
* **No past schedule? Skip that step.** It helps the system learn your patterns, but it isn't required.
# Inviting residents
Source: https://docs.heystandard.com/puffin-for-residents/inviting-residents
How a resident connects the app to their record on your schedule
Each resident connects the app to their record once, using a single-use **link code**. After that, their published schedule appears automatically and stays up to date.
## How a resident joins
Each resident gets their own 8-character code by email. The code is tied to that one person's record, so it shouldn't be shared.
The invite email links to [Puffin on the App Store](https://apps.apple.com/us/app/puffin-physician-calendar/id6785436659). Android is coming soon.
In the app, a resident signs in with **Apple** or with a **one-time code sent to their email**. No password to manage.
On the link screen, the resident types in the code. This connects the app to their record on your schedule.
Once linked, the resident's calendar fills in right away from your published schedule. They don't have to wait for you to republish. From then on, republishing keeps it up to date.
Link codes are issued by the Standard Form team, not from the dashboard yet. To get your residents onto the app, [contact us](/contact-us/contact) and we'll send their invites. Make sure each resident is [on the schedule with an email](/puffin-for-residents/set-up-for-the-app) first, and that the schedule is published and enabled in the app.
## A code only works once
A link code is good for a single resident, one time. Once it's been used, entering it again reports that the account is already linked. If a resident needs a fresh code, for a new phone or a wrong account, [contact us](/contact-us/contact) for a replacement.
## If linking doesn't work
* **"Could not link"**: the code was mistyped or isn't valid. Codes use digits and uppercase letters only (no `I`, `L`, `O`, or `U`), so check for look-alike characters.
* **Already linked**: that code has been redeemed. The resident is likely already connected, and can pull to refresh their calendar.
* **Signed in but no schedule**: the account is linked, but the schedule isn't published yet or isn't enabled in the app. See [Set up your schedule for the app](/puffin-for-residents/set-up-for-the-app).
# Overview
Source: https://docs.heystandard.com/puffin-for-residents/overview
The mobile app your residents use to see their own schedule
Puffin for residents is the mobile app for the people *on* your schedule. Once you publish a schedule and enable it in the app, each resident sees their own rotations and shifts as a calendar on their phone, without opening the dashboard.
It works alongside the platform. You build, publish, and enable the schedule on the web. Residents read theirs in the app.
![The Puffin resident app on a phone, showing one resident's own shifts as a color-coded calendar]()
This is a different thing from **Puffin**, the [scheduling assistant](/puffin/overview) inside the dashboard, and from a [published share link](/view-your-schedule/publish), which is a read-only web page. The resident app shows each person their *own* calendar, signed in.
## What residents can do
Their assignments appear as day, week, and month views, color-coded by rotation. They swipe between dates and tap any shift for details.
Residents can add their own events alongside their shifts, like study time, appointments, or reminders, and edit or delete them.
Times follow the schedule's timezone by default. A resident who travels can switch the display timezone and every shift moves with it.
Each resident signs in with Apple or a one-time email code, then links to their record once with a code you provide.
## How residents get on the app
There are two halves, one on your side and one on theirs.
Put residents on the schedule, publish it, and switch on **Enable in app** so their calendars fill in.
Each resident signs in and enters a single-use link code once to connect the app to their record.
Order doesn't matter much. A resident who links after you've enabled the app sees their calendar right away. If you enable the app later, everyone who's linked gets their shifts on the next publish.
## Good to know
* **Residents only see their own calendar.** The app shows the signed-in resident's assignments, not the whole team's grid.
* **Republish keeps it current.** When the app is on, republishing pushes your latest changes to every linked resident automatically. There's no separate step.
* **Editing a shift is local.** A resident can drag or rename a shift, but the schedule details (title, start, end) are restored from the program the next time you republish. Personal touches like color and notes stick.
* **Leave and swaps still run through you.** Submitting leave requests or swaps from inside the app isn't available yet. Those stay on the dashboard for now.
# Set up your schedule for the app
Source: https://docs.heystandard.com/puffin-for-residents/set-up-for-the-app
Enable a schedule in the app and keep it up to date
A resident's calendar is built from your **published** schedule, and only once you've enabled that schedule for the app. So two things have to be true before residents see their shifts: it's published, and it's enabled in the app.
## Get the schedule ready to publish
The app only fills in calendars for [people](/reference/people) who are on the schedule. Add every resident you want on the app, and set their email. That email is how their invite reaches them.
Events in the app need a time of day. For each [block](/reference/blocks), set its shift times: the start and end for each weekday it runs. A block with no shift times falls back to a **9:00 AM to 5:00 PM** event, which is rarely what you want.
Overnight and on-call windows, where the end time is earlier than the start, are handled for you. The event carries over to the next morning instead of collapsing.
Publishing builds from the **last saved version**, not your in-progress edits. If the header shows unsaved changes, save first, or those edits won't reach anyone's app.
## Enable the schedule in the app
Everything residents see lives behind the **Publish** button in the schedule header. Open it to publish and to turn the app on.
![The Publish popover in the schedule header, showing when it was last published, the Visibility dropdown, the Republish button, and the Enable in app toggle]()
Click **Publish** in the schedule header. Choose who can view it under **Visibility** (your team and linked residents, or anyone with the link), then click **Publish**. See [Publish](/view-your-schedule/publish) for what visibility means.
In the same popover, switch on **Enable in app**. This pushes each linked resident's assignments to their Puffin calendar, expanded day by day from your shift times. The switch takes effect the moment you flip it.
**Enable in app** is off until you turn it on, and you can only turn it on once the schedule is published. A published schedule is visible to your team on the web whether or not the app is on. The app is a separate switch.
## Keep the app up to date
Once a schedule is enabled, **Republish** keeps the app in sync. Whenever you change the schedule, save it and click **Republish**, and every linked resident's calendar updates. There's no separate "push to app" step.
New residents are handled for you too. When someone links their account, their calendar fills in right away from the published schedule. You don't need to republish each time a resident joins.
## Turning the app back off
Switch **Enable in app** off and the schedule stops syncing to phones. Shifts already on residents' calendars stay put, so nobody's calendar suddenly empties. Future changes simply won't reach the app until you turn it back on, at which point the next republish catches everyone up.
## What residents see once it's on
* One event per working day of each assignment, titled with the rotation or block.
* Times drawn from the block's shift times, or 9 to 5 where none are set.
* A stable color per rotation, so the same rotation always looks the same.
* Everything in the **schedule's timezone**, until the resident picks a different display timezone on their device.
## When a resident's calendar is empty
| What they see | Why | Fix |
| ----------------------- | ------------------------------------------------- | -------------------------------------------------------------------------- |
| No shifts at all | The schedule isn't enabled in the app | Turn on **Enable in app** in the Publish popover |
| No shifts at all | The schedule was never published | [Publish](/view-your-schedule/publish) it, then enable the app |
| No shifts at all | They aren't on the schedule, or aren't linked yet | Add them, or send their [invite](/puffin-for-residents/inviting-residents) |
| Shifts all show 9 to 5 | The block has no shift times set | Set shift times on the block |
| Missing a recent change | The change wasn't saved before republishing | Save, then **Republish** |
## Next steps
* [Inviting residents](/puffin-for-residents/inviting-residents)
# Puffin's answers
Source: https://docs.heystandard.com/puffin/answers
How to read explanations, plans, comparisons, and tables
Puffin answers with more than plain text. Depending on what you asked, you'll see explanations, tables, alert summaries, or suggested changes you can accept with one click.
This page walks through each kind of answer and how to read it.
## Explanations
For most questions, Puffin replies with prose. Names of people, blocks, rules, and alerts appear as small colored chips. Click any chip to see the full entity in context on the schedule.
The chip colors are consistent across the chat, the schedule grid, and the alerts list. The same person or block always gets the same color, so you can spot them at a glance.
## Tables
When numbers matter, Puffin returns a table. Per-person hour counts, per-week coverage, side-by-side rule parameters. Numbers are color-coded against their targets, so anyone over or under stands out.
Tables are a good way to get something you can paste into an email or document for another team.
## Plan cards
A plan card is a concrete change Puffin is suggesting. It shows the person, the slot, and the block move (from one block to another).
Under each plan card, small chips show what the change would do to your alerts:
* **Resolved** alerts go away if you accept the change.
* **Improved** alerts get less severe.
* **Worsened** alerts get more severe.
* **Added** alerts are new ones the change would introduce.
These chips are computed by checking the plan against every rule on your schedule. Puffin never suggests a plan it hasn't already tested.
To apply the change, click **Accept**. A new schedule version is generated. To discard the suggestion, click **Dismiss**.
## Comparison cards
When there's more than one good way to fix something, Puffin shows two or three options side by side. Each option contains its own plan inside. Pick the one you prefer, then accept it.
Comparisons are useful when the tradeoffs aren't obvious. The text around the comparison usually explains what each option costs and what it gains.
## Alert summaries
For questions about violations, Puffin can return a grouped triage view of your alerts. Groups are sorted by severity, with the most urgent at the top.
This is the right format when you want the lay of the land before deciding what to fix first.
## Status updates
For slow steps, Puffin shows a small italic line telling you what it's doing. Things like "Reading 30 alerts" or "Computing coverage for 12 residents." This is a status indicator, not an answer. Wait for the answer to follow.
## When Puffin gets it wrong
Puffin is good but not perfect. If a suggestion looks off, ask why, or ask for an alternative. The chat is the right tool for refining a fix.
If a plan card looks right but you have concerns, you can also accept it and inspect the resulting schedule. The previous version is always available if you want to go back.
## Next steps
* Back to [Puffin overview](/puffin/overview)
* Read about [Alerts](/view-your-schedule/alerts) to understand the alert chips
# Asking Puffin
Source: https://docs.heystandard.com/puffin/asking
Open a conversation and ask a good question
You can open Puffin in two places. From the **left sidebar** any time, or **from a selection** on the schedule when you already know which cells you're asking about.
## Open from the sidebar
Click the **Puffin icon in the left sidebar**. The Puffin panel opens. Type your question and press send.
The panel stays open while you work, so you can keep going back to it. Follow-up questions in the same thread share context with what you've already asked.
## Open from a selection on the schedule
If you already know which cells are causing the trouble, highlight them first. Puffin opens with that selection as context, so you don't have to describe what you're looking at.
Click and drag to select a person's slots, a column for one week, or a rectangular range across several people.
The button appears at the bottom of the screen alongside the other actions for that selection.
Puffin already knows what you've selected. You can write things like "why is this week short" or "find a swap for this person" without naming names or slot numbers.
## What kinds of questions work well
Puffin is best at questions about your specific schedule. Some examples that work:
* Why is CCU short in week 7?
* Who can cover the Thursday night shift?
* Show me unresolved alerts by rule type.
* Suggest a way to fix Patel's leave conflict in week 12.
* Compare two options for filling the gap in week 14.
* What changed between the last two versions?
* Give me the call counts per person for sharing with surgery.
Plain English is fine. You don't need to use the platform's terms (block, rule, constraint). Puffin translates.
The more specific the question, the better the answer. "Why is week 7 broken?" works. "Why is CCU short in week 7?" works better.
## What Puffin reads
Puffin sees the same data you see. Your schedule, the people on it, the blocks, the assignments, the rules, the alerts, your labels, and any backup coverage you've set up.
It only sees the schedule you're currently looking at. If you're working on one schedule, Puffin is only thinking about that one.
## Your conversation is saved
Each schedule has its own conversation history. Close the tab, come back tomorrow, and the same thread is waiting for you. You can also start a fresh conversation at any time if you want a clean slate.
## Next steps
* [Reading Puffin's answers](/puffin/answers)
# Puffin
Source: https://docs.heystandard.com/puffin/overview
The scheduling assistant inside Standard Form
Puffin is the scheduling assistant inside Standard Form. It helps you understand what's going on with your schedule, share what you've built with other teams, and fix the things that are broken.
Tell Puffin what you're trying to do, in your own words, and it figures out the rest.
## Where Puffin lives
The main way to talk to Puffin is the chat panel. Click the **Puffin icon in the left sidebar** to open it.
![Puffin chat panel showing a plan card with proposed person and block swaps, with chips under the card marking which alerts the change would resolve]()
Puffin also flags changes in the corner of your schedule. A small badge appears when alerts have changed since you last looked, so you don't miss anything.
![Puffin button in the corner of the schedule grid with a small badge showing the number of new or changed alerts since the last visit]()
## Three things Puffin is good at
Ask why someone is on a block, why a week looks short, or what changed since last version.
Ask for coverage summaries, call counts, or an alert digest you can paste into an email.
Suggest a swap or have Puffin find one. Every proposal is pre-checked against your rules.
## How to use Puffin
How to open Puffin and ask a good question.
What plan cards, comparisons, and tables mean, and how to act on them.
## What Puffin won't do
Puffin doesn't change your rules, your people, or the blocks defined in your schedule. Those stay where they are. If you need to update them, the rest of the platform is the right place. Puffin works with what's already there.
It also doesn't make changes on its own. Every change you see is a suggestion. Nothing moves until you accept it.
# Blocks
Source: https://docs.heystandard.com/reference/blocks
Add the rotations or activities you're scheduling
Blocks are the rotations or activities you're scheduling — for example Wards, Clinic, Nights, ICU, or Leave.
## What to set for each block
* **Name (label)** and optional description.
* **Load type** and **allowed roles** — which ranks can be assigned to this block.
* **Leave block** — Mark a block as leave so the system can assign leave time; this ties in with [leave preferences](/creating-block-schedules/leave).
* **On-call** — Mark if the block is for call.
## Where to add blocks
* The **Blocks** step when creating or editing a schedule, or
* Inside the schedule in your dashboard.
The order and list of blocks matter: coverage and mandate are defined per block. Use clear, unique names so your team can understand the schedule.
Next: [Define coverage](/creating-block-schedules/minimum-coverage) and [Mandate](/creating-block-schedules/mandate).
# Leave preferences
Source: https://docs.heystandard.com/reference/leave
How residents submit leave and how it's used in the schedule
Residents submit when they need time off (vacation, conference, personal leave). The system uses those dates so it doesn't assign them during leave.
## How it works
1. You send a **leave preferences** link (e.g. by email) to your team.
2. They open the link, choose their leave dates or ranges, and submit.
3. Those dates are stored and used when you generate or regenerate the schedule.
## Your role
* Trigger or send the leave preference invitations (or share the link yourself).
* Collect leave before generating or regenerating so the solver can respect it.
If too many people have leave at the same time, the schedule might not be possible to generate. See [Failure to generate](/creating-block-schedules/failure-to-generate) and [People](/creating-block-schedules/people).
# People
Source: https://docs.heystandard.com/reference/people
Add and manage your team (physicians or residents)
Add everyone who will be on the schedule. The number of people and their roles determine whether the system can meet your coverage and mandates.
## What you need
* **First name, last name, email** — Required for each person.
* **Rank** — e.g. PGY1, PGY2, PGY3, PGY4. Roles are used for coverage and mandates.
## Where to add people
* **Dashboard** → Physicians, or
* The **People** step when you're creating or editing a schedule.
Each person has one account (one email). You can add, edit, or remove people; if someone needs to submit leave, they'll use the [leave form](/creating-block-schedules/leave). If the schedule can't be generated, check that you have enough people for your [coverage](/creating-block-schedules/minimum-coverage) and [mandates](/creating-block-schedules/mandate) — see [Failure to generate](/creating-block-schedules/failure-to-generate).
# Rotators
Source: https://docs.heystandard.com/reference/rotators
Outside rotators and how they affect coverage
Placeholder. Content to be drafted.
Rotators are people from outside your core team who appear on the schedule. They affect coverage but aren't on your roster.
This page will cover:
* What counts as a rotator vs a core team member
* How rotators contribute to coverage
* Common rules teams apply to rotators (no night float, lighter loads)
* Uploading a rotator file vs entering them by hand
## Where this comes up in setup
* [Outside rotators](/make-your-first-schedule/3-rotators)
# Schedule
Source: https://docs.heystandard.com/reference/schedule-types
Block schedules and call schedules, and how they differ
Standard Form supports two schedule types. Most teams build a block schedule first and link a call schedule to it.
## Block schedule
A block schedule assigns people to full rotations over multi-day or multi-week blocks. For example, "Alex is on Wards for Weeks 1 to 4."
It answers: who is on what rotation, and when.
## Call schedule
A call schedule assigns people to specific time slots within a day. For example, "Dr. Patel covers night call on Monday from 7p to 7a."
It answers: who is on call, and when.
## How they relate
A call schedule can link to a block schedule so the call assignments respect who is on which rotation. See [Schedule links](/view-your-schedule/schedule-links).
## Next steps
* [Make your first schedule overview](/make-your-first-schedule/overview)
* [Call schedules](/view-your-schedule/call-schedules)
# Invite members
Source: https://docs.heystandard.com/settings/invite-members
Add team members to your organization
Account owners (and others with permission) can invite team members to the organization. Invitees get an email with a link to accept and join.
## How to invite
1. Go to **Dashboard** → **Settings** → **Team** (or **Invite**).
2. Enter the person's email and choose their role if your plan has roles (e.g. owner vs member).
3. They receive an email; they click the link, sign up or log in, and accept the invite.
4. After accepting, they see the organization in their dashboard.
If someone didn't receive the invite, [contact us](/contact-us/contact).
# Edit inputs and regenerate
Source: https://docs.heystandard.com/update-your-schedule/edit-and-regenerate
When to regenerate and how to do it
Each time you generate or regenerate a schedule, the system creates a new **version**: a snapshot of the assignments. What you see is the latest version.
## When to regenerate
Regenerate after you:
* Change [people](/reference/people), [blocks](/reference/blocks), or [rules](/make-your-first-schedule/2-rules)
* Collect new [leave](/reference/leave) preferences and want them reflected
* Want a fresh solution
## How to regenerate
Use **Regenerate** (or **Refresh**) in the schedule view. You'll get a confirmation: regenerating replaces the current solution with a new one, and any draft changes to the schedule will be lost.
# Manual edits
Source: https://docs.heystandard.com/update-your-schedule/manual-edits
Change the schedule by hand without regenerating
Placeholder. Content to be drafted.
Sometimes the right move is to make a small change by hand instead of regenerating.
This page will cover:
* Selecting cells and making single-cell edits
* Swapping two assignments
* What happens to alerts when you edit
* When to edit manually vs when to regenerate
# Alerts
Source: https://docs.heystandard.com/view-your-schedule/alerts
Information about your schedule that you should pay attention to
Alerts are information about your schedule that you should pay attention to. They mainly contain rule violations: places where the current assignments break a rule you set in [Rules](/make-your-first-schedule/2-rules).
Alerts refresh every time you save a [schedule edit](/update-your-schedule/edit-and-regenerate).
## What you can do with an alert
### See the violations
Click into an alert to view the list of violations of that rule. Each entry tells you which person, block, or time slot is involved.
### Highlight violations on the schedule
Click the **highlight** button (magnifying glass icon) next to an alert. The schedule table marks every cell where the violation occurs with a red dog-ear in the corner.
![An expanded rule violation alert listing the people, blocks, and weeks involved, with a highlight button next to each entry]()
### Fix a violation manually
Click on a cell with a red dog-ear to fix the violation by hand. See [Manual edits](/update-your-schedule/manual-edits) for how cell edits work.
### Hide an alert
Click the **eye** button on an alert to hide it. The violation disappears from the schedule table and the alert is no longer counted in the violations chart.
# Call schedules
Source: https://docs.heystandard.com/view-your-schedule/call-schedules
Call schedules and how they differ from block schedules
**Call schedules** are different from block schedules. In a block schedule, people are assigned to full rotations (e.g. "Week 1–4: Wards"). In a call schedule, assignments are time slots on specific days (e.g. "Monday 7a–7p").
## When to use call schedules
Use call schedules for call rotas and similar needs where you're assigning people to time slots within days rather than to multi-week blocks.
## Key ideas
* **Time slots** — Day of week, start time, end time. You can define standard and extended slots.
* **Coverage and rules** still apply within a call schedule.
You can create a call schedule from the same "Create schedule" or start flow — choose the **Call** schedule type. If your call schedule should respect who is on which rotation when, see [Schedule links](/view-your-schedule/schedule-links).
**We're improving call schedules.** We'd love to learn how you build your call schedules so we can shape the product. [Reach out](/contact-us/contact) to share your process.
# Export
Source: https://docs.heystandard.com/view-your-schedule/export
Download your schedule for sharing or printing
The schedule header has a **download** button that exports the current schedule. The format depends on the schedule type.
## Block schedules
Block schedules export as a single Excel file (`.xlsx`). The file is built to read like the on-screen grid:
* **Columns:** Role | Physician | one column per date.
* **Cell colors** match the grid — each block type keeps its color, and admin-customized block colors carry through.
* **Consecutive same-block runs are merged** into a single cell. A person assigned to Wards for five straight days shows as one wide "Wards" cell, not five identical cells.
* **Rows are grouped by role**, sorted by role name then first name — the same order as the on-screen grid. The Role column merges vertically across each group, so the role label appears once per section.
* **Frozen panes:** the header row and the Role + Physician columns stay pinned when you scroll through dates.
If the schedule has [labels](/view-your-schedule/labels), they appear as:
* The label's text replaces the block name in the cell.
* The cell's background stays the underlying block's color.
* The label's color becomes the text color, bold.
* A label that spans two different blocks renders as two adjacent cells — each labeled, each with its own block fill underneath. This preserves the block-color signal across the transition.
The filename is `.xlsx`.
## Call schedules
[Call schedules](/view-your-schedule/call-schedules) export as a zip of CSV files, one per block type, named ` - .csv`. The zip is named ` - Call Schedules.zip`. Call-schedule data is structured differently (slot-on-day rather than block-per-week), so it stays in the simpler CSV format.
## Draft vs saved
If you have unsaved draft edits, the export uses the draft state — you don't need to save first to preview your in-progress changes in a downloadable form.
# Labels
Source: https://docs.heystandard.com/view-your-schedule/labels
Annotate a person's slot range with custom text and color
Labels are coordinator-authored annotations on the schedule. A label is attached to one person across a contiguous range of slots, with a short text (e.g. "Conference", "Backup", "Boards prep") and a color.
Labels do not change the underlying assignment. They sit on top of the grid as a visual overlay so you can call out context that the schedule itself doesn't carry.
## Create and edit labels
1. Select cells on the schedule grid for one person — a contiguous range across consecutive slots.
2. Click the **label** button in the selection action bar at the bottom of the screen.
3. The label editor opens.
![Label editor popover anchored to a 'Ward 49' label on the schedule: text field with the label text, a row of six color swatches with one selected, and Delete / Cancel / Save buttons]()
In the editor:
* **Label** — the text shown on the badge.
* **Color** — pick one of six colors. The selected swatch has a ring around it.
* **Save** writes the label to the schedule.
* **Delete** removes the label. Only shown when you're editing an existing label.
To edit an existing label, click its badge on the grid. The same editor opens with the current text and color filled in.
## Label multiple people at once
When you select a rectangular range that spans more than one person, the label button opens a bulk editor with one row per person. Each person can have their own label text on the same slot range, and all rows are saved together in a single operation.
## Labels and the schedule
* Labels are saved per schedule and shared across everyone viewing it.
* They are immutable-versioned: each save creates a new version, so a conflicting concurrent edit surfaces a reload prompt rather than silently overwriting.
* Labels do not affect rule violations, alerts, or solver behavior. They are purely an annotation layer.
## Labels in exports
When you [export a block schedule](/view-your-schedule/export), the label's text replaces the block name in each cell it covers, and the label's color becomes the cell's text color. The block's fill color stays as the cell background so the underlying rotation is still visible.
# Publish
Source: https://docs.heystandard.com/view-your-schedule/publish
Share a read-only link to your schedule that survives edits
Publishing creates a sharable link to your schedule. Anyone with the link can open it in their browser. No login or account needed.
The link doesn't change when you edit the schedule, so you can share it once and reuse it.
Publishing also pushes each linked resident's assignments to [Puffin for residents](/puffin-for-residents/overview), the mobile app. If you use the app, [set the schedule up for it](/puffin-for-residents/set-up-for-the-app) first.
## Publish a schedule
Click the **Publish** button in the schedule header. A popover opens.
The first time you publish, the popover shows a single **Publish** button. Click it and a public link appears.
After that, the popover always shows the link. Click the link to copy it.
## What the link shows
The shared page shows your schedule the same way the dashboard does:
* The schedule grid with all assignments.
* [Labels](/view-your-schedule/labels) layered on top.
* The Stats panel for coverage and counts.
* The jeopardy pool, if your schedule has one.
It is read-only. Visitors cannot edit anything, and they cannot see your other schedules.
## Update the published version
Click **Republish** in the popover to push your latest changes. The link stays the same, so anyone who already has it sees the new version on their next refresh.
A small dot next to the **Publish** button tells you whether the shared version is current:
* **Green** means the link matches what you see today.
* **Yellow** means you have changes that haven't been published yet. Open the popover and you'll see "Behind current schedule".
Anything that changes the schedule turns the dot yellow:
* Saving a new schedule version (manual edits or solver runs).
* Adding or editing labels.
* Editing the jeopardy pool.
## Stop sharing
Click **Stop sharing** at the bottom of the popover, then confirm. The link goes dead. Anyone who opens it after that will see a "not found" page.
You can publish again later. The new link will be different.
## About the link
The link is built from your schedule name plus a short random code, for example `/share/icu-2026-q1-x7k2m9pd`. The random part is what keeps the link guessable only to the people you give it to.
Renaming your schedule does not change the link.
# Schedule links
Source: https://docs.heystandard.com/view-your-schedule/schedule-links
Linking a call schedule to a block schedule
A schedule can be linked to a **parent** schedule. For example: a yearly block schedule is the parent, and a call schedule is the child. The child's availability (when people can be on call) can follow the parent's block assignments.
## Why use it
* **Parent** = block schedule (who is on which rotation when).
* **Child** = call schedule (who is on call which days).
The call schedule then only assigns people when they're available according to the parent block schedule.
## Where to set it
Set the parent schedule when creating or editing the child schedule (e.g. in schedule settings or the create flow). Versioning and [regenerating](/managing-block-schedules/regenerate) work as usual; changes to the parent can affect the child.
# Schedule table
Source: https://docs.heystandard.com/view-your-schedule/the-table
Read the schedule, spot violations, navigate the chart
The schedule table is where you'll spend most of your time. Rows are people, columns are time slots, cells are assignments.
## Color-coded blocks
Block types are color-coded so you can see the structure of the schedule at a glance. Each block (Wards, Clinic, Nights, Vacation, etc.) has its own color, applied to every cell where that block is assigned.
![Schedule table with color-coded block types: Wards, Pulm, Clinic, ICU, ED]()
## Violations chart
At the top of the table, you'll see a chart showing where rule violations occur across the schedule. The chart spans the same time range as the table below, so you can scan to see which weeks or blocks have problems and where they cluster.
![Violations chart spanning the schedule date range with red markers at violation locations]()
To understand what each violation means and how to act on it, see [Alerts](/view-your-schedule/alerts).
## Annotate with labels
You can add short, colored annotations to a person's slot range — for example to mark "Boards prep" weeks or "Backup" stretches that aren't part of the rotation structure. See [Labels](/view-your-schedule/labels).
## Export
To download the schedule as an Excel file, see [Export](/view-your-schedule/export).