If you ask ten chief residents how long it takes to build the schedule, you’ll get ten different answers. Two weeks. A month. “During a scheduling retreat.”

But it runs along the same lines: An unreasonable number of hours, spread across late nights, weekends, and moments squeezed between clinical work.

One chief resident I spoke to told me she started working on the schedule during her ICU block. She’d open Excel after sign-out, adjust a few rotations, then come back the next day and discover that one small change had broken three other parts of the schedule. And she had to save 10+ different versions, just in case.

Another chief told me to build his schedule, he had 5 tabs - spread across Amion, New Innovations, Excel and Word Document.

If you’ve never built a residency schedule before, it’s easy to assume the process must be more developed than this. Medicine is full of complex systems surely residency scheduling should be solved. Yet for many programs, the schedule still lives inside one giant spreadsheet. And the team of chief residents are the operating system.

The real job of building a residency schedule

On paper, a residency schedule looks simple.

Residents on one axis. Dates on the other. Fill in the rotations, make sure coverage exists, and you’re done.

But the moment you start actually building the schedule, the complexity appears. Every residency program operates under layers of constraints: ACGME duty hours. Clinic requirements. Block staffing minimums. Resident requirements to pass the year. Night float coverage. Vacation requests. Board exam time. Program-specific rules that only exist in someone’s memory. And none of these rules exist in isolation, they interact with each other.

If one resident moves off a rotation, another service might become understaffed. If you change night float coverage for the weekend, you may violate the day call on Mondays. This is why chiefs often describe scheduling as a fragile puzzle where every piece moves when you touch it (and it’s an especially large puzzle).

Internal medicine programs can easily involve 60–180+ residents, multiple hospital sites, clinic schedules, visiting residents, subspecialty rotations, and overnight coverage patterns. The schedule is not just a calendar. I’d say it’s an operational blueprint of the program for an entire year.

Why Excel became the default tool

Despite all this complexity, most programs still start with Excel. And that’s not because chiefs or program directors love spreadsheets.

It’s because Excel is flexible (and free too lol). You can create tables quickly. You can color-code rotations. You can duplicate last year’s schedule and modify it. And for the longest time, it works.

Chiefs gradually build formulas to check duty hours or highlight conflicts. Over time, the spreadsheet becomes more elaborate: hidden columns, conditional formatting, manual tracking of weekends or night shifts. Certain formulas are copied carefully from previous years, and the chief resident becomes the only person who truly understands how it works. This is why many schedules feel inherited rather than designed.

Why scheduling tools have historically struggled

Recognizing how painful this process is, many programs have tried alternatives. Some use scheduling software designed for hospital staff. Some attempt to build in-house. Others outsource a person to do Excel work for them. A lot of Chiefs I've spoken to have splurged on ChatGPT to solve scheduling. But these solutions often fail and the reason comes down to understanding what kind of problem scheduling actually is.

Most tools treat it as a calendar problem. Put people in slots, fill the month, done. But residency scheduling isn't like booking conference rooms. Blocks are deeply interdependent. Moving one resident can ripple across the entire schedule.

So it's really a constraint problem. Every program has its unique constraints. One program runs a 4+1 model. Another uses traditional block scheduling with clinic weeks scattered. Some services require specific PGY levels. Others need particular combinations of residents. These rules often live in a chief's head, learned through years of living the program. Most tools fail here because they only understand shifts, not the logic underneath.

On top of that, it’s also an optimization problem. Even if you could encode every constraint, you'd still need to balance competing goals simultaneously: coverage, ACGME compliance, fair distribution of nights and weekends, vacation requests, making sure interns don't get crushed with brutal blocks back-to-back, making sure seniors get the rotations they need to graduate. None of these goals are independent. Improving one often comes at the cost of another.

This is why chiefs end up iterating for weeks. Move one resident → scroll across the spreadsheet → check if something breaks → move another → scroll again. Sometimes the only way to know if the schedule works is to keep checking until it "feels" right. That instinct isn't imprecise, it's expertise. Chiefs know which rotations are brutal, which services need stronger seniors, which patterns of nights will make residents miserable. But expertise shouldn't require weeks of manual trial and error.

What building a schedule should actually feel like

If you step back from the spreadsheet for a moment, residency scheduling actually has a fairly clear structure.

Every program runs on a set of rules: duty hours, staffing minimums, rotation requirements, and clinic schedules. These constraints stay fixed. The hard part is arranging the year to satisfy them all. Today, chiefs do this by hand: move residents, check coverage and conflicts, and repeat until it works.

But much of that effort is really just searching through possibilities and computers (not AI) are actually very good at that part. Ideally, the system should be able to explore all the possible schedules first, filtering out the ones that break the rules and surfacing options that satisfy the program’s constraints, that way the chief resident isn’t spending nights manually testing combinations inside Excel.

Why fairness is actually harder than coverage

Interestingly, a lot of chief resident I’ve spoken with says the same thing: coverage isn’t the hardest part. If you really needed to, you could fill every shift on the schedule, but that wouldn’t make it a good schedule. What chiefs are really trying to protect is fairness (and as a resident physician, I will always salute them).

Fairness is harder to define than it sounds. It isn’t just about counting how many nights or weekends each resident works. It’s about how those assignments are distributed across the year. Did someone end up with ICU followed immediately by night float? Did someone quietly accumulate most of the worst weekends? Did one resident lose both Thanksgiving and New Year’s?

These patterns are surprisingly easy to miss when everything is sitting inside a spreadsheet grid. Chiefs often find themselves scrolling through the schedule repeatedly, trying to notice imbalances that the tool itself doesn’t surface.

The opportunity

After speaking with dozens of chief residents, one thing has become very clear to me.

Most chiefs don’t actually mind being responsible for the schedule. In fact, many of them want to stay involved, because they understand the culture and needs of their program better than anyone else. What they dislike is the mechanical work. The endless moving of cells and updating of systems (that looks like the 1900s).

What chiefs seem to want isn’t a system that takes control away from them. They want tools that make the underlying structure of the schedule easier to see. Tools that surface conflicts earlier. Tools that show whether nights or weekends are drifting out of balance. Tools that let them test ideas quickly in demo, and not in production. In other words, tools that support the way residency programs actually operate.

Why we started working on this

This is exactly the problem we’ve been thinking about at Standard Form.

As a physician, I’ve seen firsthand how much invisible work goes into building these schedules. It’s one of those responsibilities that can sit with the chief resident for months, sometimes on top of an already demanding clinical workload.

The goal isn’t to replace the chief resident or automate away their judgment. Chiefs understand their programs in ways that software never will. But software can help with the mechanical side of the problem: constraint checking, exploring possible schedules, and detecting conflicts that might otherwise stay hidden.

Residency scheduling will probably always be complicated. But that complexity is part of what it takes to train excellent physicians, and we believe every residency program should have access to these tools. This is a deeply personal mission for me and hope you can follow along on the journey.