Telemedicine software development: how we shipped an MVP in 6 weeks

CoreHealth came to us in July 2023 with a brief that most development companies would have turned down.

Their major client needed a fully functional doctor consultation platform. The previous contractor had left behind a legacy codebase that was outdated and impossible to integrate with modern tools. CoreHealth had 6 weeks. Their budget was tight. The platform needed to connect with multiple third-party systems from day one.

We took the project. We delivered in 6 weeks. And what started as a single MVP became 3 separate telemedicine products over the following year.

Here's what happened, and what it took.

The brief was brutal

In England, 1 in 10 people wait more than 3 weeks to see a general practitioner. For CoreHealth, a UK healthtech company that has been building telemedicine platforms since 2006, that gap is the business case. Every week a platform is delayed is a week patients wait longer for care they need.

So when CoreHealth's major client needed their consultation platform modernized, CoreHealth gave themselves 1.5 months. No buffer.

The technical situation made it harder. The platform had been built by a previous contractor and couldn't support modern integrations. A full rewrite was necessary, not a patch job. The budget didn't allow for a large team or a slow start.

We were the development partner CoreHealth chose to get it done.

Why most teams miss these deadlines

The industry average for a comparable telemedicine MVP is 4 to 6 months. Some teams take longer.

That's usually a process problem, not a technology problem.

Large teams create coordination overhead. When 10 or 12 people are building the same platform, handoffs multiply, decisions slow down, and meetings become the most productive thing happening. Speed goes down as headcount goes up.

Skipping discovery to save time creates scope drift. A team that starts coding before mapping every user flow and integration point will hit blockers mid-build. Those blockers cost more time to fix than a proper discovery phase would have taken. Integrations are the most common culprit: when video calling, scheduling, prescription management, and pharmacy fulfillment all need to talk to each other, planning them as an afterthought is expensive.

Stack choices compound the problem. A monolithic backend not designed for API-heavy workflows turns every new integration into a retrofit. The first integration takes a week. The fifth takes three.

What we did differently

We put 5 people on the CoreHealth project: 1 frontend developer, 1 backend developer, 1 QA engineer, 1 UI/UX designer, and a project manager. Each person owned a lane. No overlap, no ambiguity about who was responsible for what.

Before any development started, we ran discovery. That meant reviewing the existing application to find every technical and logical gap across all user flows, then decomposing the platform into functional modules. Deliverables: Q&A documentation, user story documentation, a project estimation and roadmap, a low-fidelity prototype, and completed UI/UX design. All of that before a single line of production code.

For the stack, we chose React.js on the frontend and Node.js on the backend. The platform needed multiple third-party integrations from day one, and this stack is well-suited for API-heavy architectures. It also let us build fast without cutting corners on quality.

We also work with AI-augmented workflows across coding, project management, QA, and CI/CD. Our architects own the structure and the long-term decisions. AI handles the repetitive implementation work. A 5-person team working this way builds at a pace a traditional 10-person team often doesn't reach, because administrative overhead drops out of the process entirely.

The 6-week process

Here's how the delivery broke down:

Team allocation across phases:

Step 1: Discovery

We reviewed the entire application and mapped technical and logical gaps across every user flow. Then we applied feature-based decomposition, breaking the platform into modules that could be built and tested independently. By the end of discovery, we had Q&A docs, user story documentation, a project estimation, a roadmap, a low-fidelity prototype, and completed UI/UX design.

This is the phase where deadlines are saved or lost. Teams that skip it to move faster run into integration blockers and scope drift mid-build. Those problems cost more to fix than the discovery phase would have taken.

Step 2: Design

Using the discovery artefacts, we refined the prototype through a client feedback loop before moving to development. The goal was an interface that was clear and build-ready, with no rework needed once coding started.

Step 3: Development

The full team built the frontend in React and the backend in Node. External integrations were scoped and built from the start, not added after the fact. QA ran part-time in parallel, catching issues as they were introduced rather than in a testing sprint at the end.

Step 4: Delivery

We delivered the MVP on time. CoreHealth presented it to their client. The response was exactly what they'd hoped for.

The relationship didn't end there. Read the full case study

What the MVP became

That first delivery opened a door.

The architecture we built wasn't scoped for one use case. It was designed for the complexity CoreHealth operates in. Over the following months, it expanded into 3 distinct telemedicine products.

Doctor consultation platform

Patients book consultations online, browse doctors by specialty, and pick time slots that fit their schedule. The platform supports real-time video consultations and secure data handling for both patients and providers.

SaaS platform for pharmacies

Built for pharmacies offering online prescription services. Patients consult with licensed doctors by video, and if a prescription is approved, it goes directly to the pharmacy for immediate collection. For cases that don't require a live session, patients can complete a medical form online instead.

Healthcare platform for prisons

A secure telemedicine solution compatible with Samsung Tab A8 tablets. Prisoners consult with healthcare providers directly from their cells. When a physical assessment is needed, providers can conduct it remotely via the tablet camera.

All 3 products share the same core architecture from the original 6-week MVP. That wasn't a coincidence. It's what a discovery-first, integration-ready build makes possible.

What this tells you about telemedicine software development

A few things from this project are worth naming, because they run counter to how many teams approach healthcare builds.

Discovery is the phase that makes everything else go faster. Every hour spent mapping user flows and decomposing features saves 2 to 3 hours of rework in development. Teams that skip it in the name of speed end up losing more time than they saved.

Your stack choice is an integration decision. Telemedicine platforms talk to a lot of systems: video APIs, booking tools, pharmacy management, EHR systems, payment processors. React and Node work well here because the JavaScript ecosystem is built for API-heavy applications. There are other valid choices, but the tradeoffs are real and worth thinking through before you start building.

Team completeness beats team size. 5 people who each own a defined lane move faster than 12 people with overlapping responsibilities. Communication overhead grows with every person you add to a project. For a well-scoped MVP, a lean, complete team will consistently outpace a larger one.

Compliance belongs in week 1. In the US, HIPAA compliance typically adds $15,000 to $50,000 to a healthcare build, covering encrypted storage, access controls, and penetration testing. In the UK and EU, the relevant frameworks are GDPR and CQC standards. Either way, building compliance into the architecture from the start costs significantly less than retrofitting it later.

You can also see how this approach plays out across other industries in our case studies.

How to plan your telemedicine MVP

Start with your integrations. List every external system your platform needs to connect to: video calling, appointment scheduling, EHR or patient records, pharmacy systems, payment processing. This list determines your stack and your timeline more than any other single factor.

Know what discovery should produce. A real discovery phase delivers user stories broken down by role (patient, doctor, admin), feature decomposition by module, a low-fidelity prototype reviewed with your end-user or client, and a project estimation with a roadmap. If a development partner doesn't produce these before they start building, that's worth asking about.

Minimum viable team for a telemedicine MVP:

Set realistic timeline expectations. A focused MVP with well-defined scope can ship in 6 to 10 weeks. Every integration added after the build starts costs 2 to 4 additional weeks. The scope you lock in during discovery is the scope you'll ship.

Plan compliance before architecture. HIPAA in the US, GDPR and CQC in the UK and EU. Designing for it from week 1 costs less than building it in after the fact.

If you're still evaluating development partners, our guide to top MVP development companies covers what to look for and how to compare.

Want to talk through what your telemedicine build would actually involve? Get in touch and we'll give you an honest estimate.