By skyforbes 
About a month ago, our team reached a milestone — launching the developer preview of a new API at the Centers for Medicare & Medicaid Services (CMS). Nava has had a team of designers, engineers, and product managers working on the Quality Payment Program (QPP) at CMS for over eight months to help modernize Medicare and how it pays doctors for the care they provide. The launch of this developer preview was a significant technological achievement within CMS; but perhaps more importantly, it was an essential step in the enabling the broader program to succeed in helping the government deliver modern, accessible services to its citizens.
Background
Let’s back up a bit — what’s QPP, you ask? Where does this all come from? As we’ve written about earlier, Medicare, a program that has 57 million beneficiaries and used $588 billion of the federal budget in 2016, is in the midst of a massive modernization project mandated by a bill known as MACRA (Medicare Access CHIP Reauthorization Act), a bipartisan piece of legislation passed in 2015. Medicare has thus far been operating with a fee-for-service model, meaning clinicians get reimbursed flat rates by Medicare each time they perform a service, test, etc. But this model doesn’t work — it incentivizes delivering more healthcare, instead of better care.
Under the fee-for-service model, clinicians are rewarded for the quantity of services they provide, rather than focusing on how those services contribute to a patient’s overall health and well-being.
QPP was designed to be a step in the right direction to fix this. Under this new program, clinicians will receive an adjustment to their reimbursements determined by the quality of the services they provide. In order to know how to do that, Medicare has to be able to know what kind of benefit clinicians are providing their patients, at massive scale.
Essentially, Medicare needs to collect the right data to measure quality of service and outcomes while being conscious of the compliance burden on the more than half a million Medicare doctors who are submitting it.
This is where Nava comes in: we’re building what’s called the “Submission API”, which gives clinicians a programmatic and automated way to submit their performance data to CMS. This process used to be very manual and required hours to get feedback on the validity of the data format; with our API, it will be instantaneous. After it’s been submitted and stored in CMS databases, the agency will use the data to determine an overall score for the clinician — a process that used to take months will now be nearly instantaneous.
The Submissions API
The Submissions API is actually replacing three legacy systems set up to receive data from clinicians because this is not the first time CMS has run a performance-based reporting system. Our task was to consolidate these systems into one web service that would automate a lot of previously manual submission methods to make sure it would handle the scale of what QPP has set out to implement. With the Submissions API, users within the developer preview program are now able to start programmatically sending data to CMS.
Although the full program won’t roll out until 2018, it was essential that we get the API up-and-running as soon as possible. A lot of this performance data is sent through third-party aggregators, like registries and electronic health record companies, that compile and send data on behalf of clinicians. These aggregators write their own software to automatically submit this data and show the results to clinicians, and their software has to integrate directly with this Submissions API — so we had to be ready to go well before the launch date. To further help integrators understand our APIs and the functionality it has, we also wanted to do as much work as we could out in public — we’ve open-sourced a few of our repositories already, and more are on the way, to help integrators better understand how to use these new endpoints.
From a technological standpoint, this API is a landmark achievement for CMS. Not only is it one of the first APIs that CMS has ever released and by far the most feature-rich, it also required intense collaboration between lots of different groups.
We weren’t alone in this undertaking.
While we are the technical architects and developers of the core API, there are a number of other parts of the QPP ecosystem that had to be developed alongside our API, including but not limited to: a scoring engine that gives clinicians an overall score, an API Gateway to forward traffic to the right place, and an authentication verification service (and more to come).
Everyone working on the project all came together with one motivation: delivering a modern government web service on-time. And we successfully hit our first benchmark for that goal!
Why this milestone matters
This was an essential achievement for CMS because Medicare’s future depends quite a bit on whether QPP works. The API’s launch — and taking the necessary actions to ensure its smooth integration into a legacy system — is a big step toward making sure the program succeeds.
The future still holds many challenges.
MACRA designated that the fee-for-service payment model needs to be changed, but adopting quality-based practices is still extremely complex. In order to tackle this challenge inline with our core values, we have to engage with the community, practice transparency, and build trust with users for this program to succeed. Our software needs to be stable, consistent, and, of course, always online. Our documentation has to be clear and informative, answering essential questions and pointing users in the right direction as best we can. As we get closer to the program launching in 2018, we’ll be working closely with integrators to make sure we deliver on these promises.
So, that’s why this milestone matters — it’s an essential step in the right direction of delivering a modern, accessible government web service that moves our country forward. We’ve got plenty of more work to do, but for just a moment, we’re celebrating an important benchmark in a program that will impact millions of Americans.
Sam Keller is a Software Engineer at Nava currently working on modernizing Medicare. You can reach him at [email protected]. Interested in working with us on Medicare or another project? Shoot us a note at [email protected].
