Three of the largest payers in the country, UnitedHealthcare, Cigna, and Centene, recently committed to CertifyOS’s new national shared credentialing program, designed to cut the duplicate submissions providers face. It’s a real step, and anything that reduces the credentialing and provider enrollment burden is welcome. But I’m watching it with caution, because we have seen this before. This isn’t the first attempt to bring credentialing and enrollment onto a shared platform, and in my experience, the promise of consolidation often falls short once you’re redirected right back to each payer’s individual process.
What matters more is this: credentialing is only one piece of the problem, and it is challenging. But, the harder one is provider enrollment, and it’s where cash flow goes and hopes to be realized.
Credentialing and enrollment are not the same thing
These two terms get used interchangeably, and they shouldn’t be.
Credentialing verifies that a provider is qualified to practice: their education, licensure, work history, and standing. That’s the piece the big payers’ new shared program addresses.
Enrollment is what comes next, and it’s where the money lives. It’s the process of getting that credentialed provider set up with a payer so you can actually bill for the care they deliver. A provider can be fully credentialed and still unable to generate a paid claim, because enrollment isn’t finished.
Why enrollment is so hard
Enrollment is hard for two reasons, and only one of them is the payers.
The payers control the process, and they don’t make it easy. You submit an online form that often gives you no tracking number and no way to follow up. You check in again and again just to get acknowledgment the request was received. You fill out the file they require, in their format, on their timeline. You wait for them to process it. You finally get an effective date, and then, more often than not, you appeal that effective date to recover revenue for the period the provider was already working.
Enrollment with some payers takes months, sometimes six or more, often because the payer is behind, or short-staffed, and there is no lever you can pull to speed it up. It gets worse around the holidays, when payer offices are short-staffed or closed and already-slow timelines stretch into the new year.
The second reason gets less attention: the people doing the work often don’t have the tools to do it well. In my experience, a startling number of organizations and vendors still run enrollment out of spreadsheets. Tracking providers across dozens of payers, each with its own form, timeline, and status, in a spreadsheet is a losing game, and it only gets worse as the provider count climbs. At any real volume, things fall through the cracks, follow-ups get missed, and nobody can answer “where does this provider stand right now?” without digging.
There is credentialing and enrollment software built for this, and yes, it costs money. But the return shows up quickly, in faster enrollments, fewer missed follow-ups, and cash that comes in instead of sitting in a hold or denial bucket. Or at least it should. Every option I’ve worked with has real gaps, and when you hit one, the answer tends to be some version of “that’s in a future release” or “submit the suggestion on our website.” So the tooling is better than a spreadsheet, but it’s rarely the complete solution it’s sold as.
This second reason is the one that matters most, because it’s the one you actually control. You can’t make a payer move faster. But you can make sure the people doing your enrollment, whether your own team or an outsourced partner, have the right tools and the discipline to use them well. How you confirm that is the next question.
How do you know if your enrollment function is failing?
Most leaders know something is wrong because the number is staring at them: the enrollment hold bucket is high, and it keeps climbing. But the hold bucket is a symptom, not the problem. It tells you money is stuck. It doesn’t tell you why, or where. Most organizations stop at the symptom, and that’s exactly why it never gets fixed.
The way to actually diagnose it is to track the timeline. Enrollment is a series of handoffs, and if you timestamp each one, the gaps between them show you precisely where the breakdown is. The dates I watch:
- When HR or onboarding was notified of the new provider (the clock starts here, not on their first day)
- When all required credentialing and enrollment documentation was sent to the provider
- When the provider returned the completed packet, and when reminders went out for missing items or expanded information, like claims history or employment gaps
- When the signed forms were sent to each payer
- When each follow-up with the payer happened
- The effective date the payer finally assigned
When you can see these dates, the problem stops being a mystery. A long gap between notification and documentation sent points one direction. A long gap between packet returned and forms submitted to the payer points another. A long gap after submission, with the payer sitting on it, points somewhere you don’t control. The timeline doesn’t just tell you that you have a problem. It tells you whose problem it is.
One honest caveat: these target timelines vary by payer, payer type, and state. State Medicaid programs in particular are all over the map, so you benchmark by payer, not against a single universal number.
But there is one enrollment that has become standardized enough to be a real test, and it surprises people to hear it: traditional Medicare. It used to be one of the hardest, slowest enrollments. Over the last twenty years, CMS has made it genuinely learnable and predictable, to the point that it’s now often easier than many commercial payers. If your mental model of “which payers are hardest” is based on how things worked years ago, it’s probably wrong now.
That’s exactly why traditional Medicare has become a real test. When an enrollment team doesn’t do it well, it’s one of the clearest signals that the process isn’t being held to a standard. The failures tend to be specific and preventable. One is not setting up surrogacy. Once a provider approves surrogacy, the enrollment team can complete the forms online and route them back to the provider for a quick electronic signature, a process CMS has made genuinely easy. Another is submitting a reassignment of benefits before confirming the provider’s individual Medicare enrollment is active and in good standing. These are knowable steps. Missing them isn’t bad luck. It’s a process that nobody made mandatory.
And this is where the real lesson lives. Many of these errors are technically recoverable. However, there’s often a very short window to go back and correct them. And that window slips through your fingers when you’re onboarding ten providers a week. At volume, you cannot clean your way out of this. The hold bucket grows faster than anyone can work it down, and the recoverable revenue quietly becomes bad debt.
The fix isn’t better clean-up. It’s prevention. The organizations that get this right make the critical steps mandatory, so the error never happens in the first place, rather than hoping someone catches it inside a recovery window they don’t have time to use.
If you outsource enrollment, this is exactly what you should be asking your partner to prove. Can they show you the timeline, by provider and by payer? Can they tell you where every provider stands right now, without having to go dig? What’s their process for preventing the common, knowable failures, not just recovering from them? If a vendor can’t answer those clearly, you’ve found at least part of your problem.
The bottom line
Provider enrollment is one of the most underestimated, under-resourced functions in the revenue cycle. It’s not glamorous, and it doesn’t get the attention that higher-profile revenue cycle work does. But done poorly, it ties up the cash that keeps a practice running.
It deserves an owner, real tracking, and a standard it’s actually held to, not a spot on whoever’s desk happens to have room.
If your group is carrying a high enrollment hold bucket and no clear view of why, that’s exactly the kind of operational problem I help practices diagnose and fix.