How clinic managers lock specialist shifts and auto-fill the rest by skill

If you run a clinic with a small number of specialists and a wider bench of generalist staff, your scheduling problem looks nothing like a hospital's. You don't need an enterprise rostering system. You need two things, reliably, every week:

1. The ability to pin a specific shift to a named clinician, the cardiologist on Tuesday morning, the on-call dermatologist on Saturday, and have the system treat that as untouchable.
2. The ability to then auto-fill everything else around those pins using the right credentials, availability, and labor rules.

Most clinics try to do this in Excel. That works until it doesn't, until a specialist swaps out, a nurse's BLS expires, or a part-time MA picks up a third shift and tips into overtime. This guide explains exactly how locked shifts plus skill-based auto-fill works, what to test during a trial, and how Soon handles it differently from the systems built for 500-bed hospitals.

The two-layer scheduling model

Clinic scheduling is best thought of in two layers, in order:

Layer 1: Locked shifts. You reserve specific shifts for specific people first. These are the non-negotiables, a specialist's clinic day, a procedure room booked for a single physician, an attending's on-call block. Once locked, the auto-scheduler is not allowed to touch them.

Layer 2: Skill-matched auto-fill. Everything else, front desk, MAs, RNs, phlebotomy, after-hours coverage, gets generated automatically. The engine reads each open shift's required role and certifications, looks at who's available, and assigns the right people while respecting contracts, rest rules, and your fairness objective.

Get the order right and you stop solving the same conflicts every week. Locks define what must be true. Auto-fill handles the combinatorial mess underneath.

A worked example: a 12-provider multispecialty clinic

Picture a clinic with three cardiologists, two dermatologists, one endocrinologist, six MAs, four RNs (two are BLS-certified for in-office procedures), and three front-desk staff. Open Monday to Saturday, 7 AM to 7 PM. A typical week looks like this:

Locked first (manager does this manually, once):

• Dr. A (cardio): Mon/Wed/Fri 8-4
• Dr. B (cardio): Tue/Thu 8-4, Sat 8-12
• Dr. C (cardio, on-call rotation): Sat 12-7
• Dr. D (derm): Mon/Tue/Thu 9-5
• Dr. E (derm): Wed/Fri 9-5
• Dr. F (endo): Tue/Wed/Fri 10-6
• Procedure room: Wed PM reserved for Dr. A only

That's 23 shift-blocks locked. The auto-scheduler treats them as fixed inputs.

Auto-filled next (the engine does this in seconds):

• Each provider shift needs 1 MA assigned. MAs assigned to cardiology need EKG competency tagged on their profile.
• The procedure room on Wednesday PM needs an RN with BLS certification.
• Front desk requires 2 staff during peak (9-12, 2-5) and 1 during off-peak.
• No staff member exceeds 40 hours unless explicitly contracted to.
• No back-to-back closing-then-opening shifts (minimum 11 hours between).
• Fairness objective: distribute optional Saturday shifts evenly across eligible MAs over a rolling 8-week window.

The engine produces a draft schedule. The manager reviews, overrides if needed (with the reason captured for audit), and publishes.

Workflow

• Step 1, Define the rules once
• Tag each staff member with roles + certifications (RN, BLS, EKG, phlebotomy, etc.)
• Set expiry dates on certifications
• Define minimum staffing per shift type
• Set labor rules: max hours, min rest, contract minimums
• Step 2, Lock the non-negotiables (weekly, ~10 min)
• Drag specialist shifts onto the calendar
• Mark procedure rooms / reserved equipment
• Mark any pre-approved time off
• Step 3, Run auto-fill (seconds)
• Engine reads locks as fixed
• Matches open shifts to qualified, available staff
• Respects contracts, rest, fairness objective
• Surfaces conflicts it cannot resolve
• Step 4, Review and publish (weekly, ~15 min)
• Manager reviews the draft
• Overrides where clinical judgment trumps the algorithm (with reason logged)
• Publishes to the team, push notifications go out
• Step 5, Handle changes intraday
• Sick call to engine suggests qualified replacements
• Walk-in surge to drag-and-drop reassignment with live coverage view
• Every change preserves the locked layer

What to test during a trial

Whichever system you evaluate, run these five checks before signing anything. They're the difference between a system that says it supports locked shifts and one that actually does.

1. The lock test. Lock a specialist for a specific day. Run auto-fill twice. Confirm the lock holds in both runs and the rest of the schedule adapts around it. Try to assign someone else to that shift manually, the system should warn or block.

2. The skill test. Mark one MA as EKG-certified and three others as not. Create three cardiology shifts. Auto-fill. Confirm only the EKG-certified MA is eligible, and that the engine handles the scarcity (rotates them, flags the shortage, or surfaces it as an open shift to escalate).

3. The expiry test. Set a BLS certification to expire mid-schedule. Run auto-fill spanning the expiry date. Confirm that staff member is eligible before the expiry and ineligible after, and that the system alerted you before it became a problem.

4. The override + audit test. Manually override an auto-assigned shift. Confirm the override is recorded with who, when, and (ideally) why. This matters for compliance reviews and for understanding why a schedule looks the way it does six weeks later.

5. The intraday test. Publish a schedule. Simulate a sick call. Confirm the system surfaces qualified replacements ranked by availability and fairness, not just anyone with the right title.

If a system fails any of these in a sales demo, it will fail them in production.

The metrics that matter

Most scheduling pitches default to "save hours per week." That's real, but it's not what a clinic manager actually defends in a quarterly review. Track these instead:

• Time to publish a weekly schedule. Baseline it before the trial. Most clinics on Excel land somewhere between 3 and 8 hours per week. A working auto-fill setup should pull this under one hour, including review.
• Qualification mismatches caught before publishing. Count how many would have slipped through manually, expired certs, role mismatches, BLS gaps. This is the safety case.
• Open-shift fill time. When a shift opens unexpectedly, how long until it's covered? Sub-hour is achievable when the system can ping every qualified, available person at once instead of the manager texting individuals.
• Overtime hours per pay period. A skill-based auto-fill that respects contracts should reduce accidental overtime materially. Track this monthly.
• Fairness drift. Over a rolling 8-week window, look at how evenly weekend and evening shifts are distributed across eligible staff. Drift is a leading indicator of resentment and turnover.

Where Soon fits, and where it doesn't

There's a real spectrum in this market. At the high end, systems like QGenda, UKG, and Allocate are built for hospitals and large multi-site health systems with union contracts, complex on-call rotations, and deep EHR/payroll integrations. They're powerful and expensive, and most clinics with 10-80 staff don't need 80% of what they do.

At the other end, generalist scheduling apps like Deputy and When I Work handle the basics well but get thin on healthcare-specific needs, certification expiry tracking, skill-tiered auto-fill, and the specific lock-then-fill workflow above. Shiftboard and Quinyx sit in the middle and lean toward larger, more complex deployments.

Soon is built for the gap: clinics and specialist practices that have outgrown Excel and Google Sheets but don't need an enterprise rollout. The auto-scheduler handles the lock-and-fill model natively, pin what you need, set your constraints (contracts, rest, skills, fairness), pick an objective, and the engine produces a draft in seconds. The whole setup is designed to be live the same day, not after a six-month implementation.

If you're scheduling more than 200 clinicians across multiple sites with union rules and complex on-call rotations, look at QGenda or UKG. If you're a clinic of 10 to 150 staff currently solving this in a spreadsheet, Soon is built for you.

Getting started

The fastest way to know if this works for your clinic is to try it on next week's actual schedule. Import your team, tag certifications, lock your specialists, and run auto-fill once. You'll either see it click or you'll see exactly where it doesn't, both are useful answers in under an hour.

Start a free trial or read the Clinic Shift Scheduling Blueprint for the structural design work that makes auto-fill more accurate.

Related reading

• Clinic Shift Scheduling Blueprint, the structural design layer beneath any auto-fill setup
• Auto-scheduling software, how Soon's constraint engine works
• Healthcare scheduling, overview of Soon for healthcare teams