Healthcare is hard. Building software for healthcare? Even harder.
You’re working with legacy systems, real-world consequences, regulatory overhead, and zero room for error. That’s the space Patchwork Health chose to challenge.

And here’s how Code & Pepper helped them do it.

The Mission: Fixing the Broken Backbone of Healthcare Staffing

Patchwork Health is solving a massive problem: workforce management for healthcare professionals. They’re transforming how clinicians work, and how hospitals manage them.

Built in collaboration with NHS clinicians, Patchwork helps medical staff take control of their time. The platform lets them book shifts, manage time off, and stay compliant with complex regulations.

For hospitals and healthcare providers, it streamlines operations, reduces reliance on agencies, and improves both cost-efficiency and care quality.

It’s a real business with real users and real stakes.

The Challenge: Scaling Fast Without Losing Stability

Patchwork had traction, funding, and adoption across the UK.
But growth creates pressure. The product team needed to:

  • Improve core scheduling flows
  • Add new features fast
  • Meet NHS and UK compliance standards
  • Avoid downtime or technical debt

To pull this off, they needed experienced engineers, fast. Specifically, Ruby on Rails developers who could work in a fast-moving codebase, and QA experts who could keep quality high without slowing delivery.

That’s when they brought in Code & Pepper.

The Solution: Bringing in the Right People at the Right Time

At Code & Pepper, we’ve supported HealthTech and FinTech companies for nearly 20 years. We don’t send random contractors. We build reliable, senior product teams that ship.

For Patchwork, we provided:

  • Ruby engineers to work across their core monolith
  • React.js & TypeScript devs to improve UX and modernize views
  • QA specialists using Cypress for end-to-end confidence
  • A collaborative model that plugged into their workflow from day one

We didn’t just build features. We improved architecture, reduced bugs, and added resilience to a system that thousands of healthcare workers rely on every day.

The Tech: Ruby, React, and the Right Architecture

Patchwork runs on a monolith. That’s not a dirty word, especially for scaling startups.
A well-maintained monolith can move faster than a poorly split microservices mess.

That said, we’ve also supported their transition. Where it made sense, we built standalone Ruby and Python microservices.

Here’s a look under the hood:

  • Backend: Ruby on Rails (monolith + microservices)
  • Frontend: React.js + TypeScript
  • Testing: Cypress for automation and peace of mind
  • Compliance: Systems aligned with NHS workforce regulations

We made sure the product didn’t just grow. It grew in the right direction.

Real Impact: Building Scheduling Features That Actually Work

One major improvement? The scheduling module.
This lets clinicians manage work, rest, and on-call time, without needing a spreadsheet and a headache.

The logic here is complex. UK labor laws require specific break times between shifts.
We helped engineer a backend that can handle all those edge cases, while giving users a clear, fast booking flow.

Soon, this will become one of Patchwork’s flagship modules.
It’s already making a difference in how hospitals schedule work and how doctors balance life.

Collaboration That Feels Like One Team

The Code & Pepper team didn’t work in isolation. We embedded into Patchwork’s structure.

Some of our developers joined their core product squad. Others worked on new feature pods. The split team model worked because we understood the dependencies, kept feedback loops tight, and stayed flexible.

This is what staff augmentation should feel like:
You get extra capacity without extra complexity.

What’s Next for Patchwork

The next big push? A cleaner booking experience and improved UX for clinicians.
Because even the best logic fails if users can’t get through the UI.

Our team is already working on it – redesigning shift views, optimizing flows, and ensuring everything supports workforce wellbeing.

And the backend? It’s stable, scalable, and ready for whatever comes next.

Why Code & Pepper?

We’re not new to HealthTech.
We’ve built and supported platforms for:

  • AI-guided mental health tools
  • Insurance claim automation
  • Patient onboarding and compliance
  • Scheduling and booking systems
  • And now: workforce management at scale

Our teams are made up of vetted, experienced engineers who know what production means.
We don’t outsource outsourcing. We do the work. We build with you.

Thinking About Outsourcing Your HealthTech Development?

Here’s what we’ve learned:

  • A good monolith is better than a bad microservice mess
  • Ruby is still an amazing tool when used right
  • Compliance isn’t a blocker. It’s a design requirement
  • Fast isn’t good enough. You need fast and right
  • The right partner doesn’t just write code. They make your product better

At Code & Pepper, we help HealthTech companies launch, scale, and improve products that actually make a difference.