A Twelve-Dashboard Intelligence Module. Built in Days, Not Months.

Project Intelligence is a deep analytics layer - live health scoring, blocker ranking, risk models, rework analytics and time-series trends across a dozen interconnected dashboards. A build like this normally takes a team a season. Pairing one engineer with Claude Code, given the full context of the codebase, it came together in days.
Claude Code
12 Live dashboards
Days, not months
Minimal rework
Native look & feel

10-20 mins

Sync Time After
↓ 95% reduction (was 4.5 hrs)

-75%

AI Token Cost Reduction
via prompt caching + unified calls

Zero

Silent AI Features Post-Fix
real retry with exponential backoff

Overview

A Multi-Portal Workforce Platform for the Healthcare Industry

Physician scheduling in the US still runs on text threads, spreadsheets, and informal word-of-mouth. Shiftolic was built to replace this with a structured, real-time marketplace — connecting doctors who need coverage with hospitals and staffing companies that need reliable providers.

THE PROBLEM

Physicians needing shift coverage have no centralized platform. Locum companies manually manage pools of providers across spreadsheets and email chains. There is no structured way to post, discover, or claim shifts — resulting in last-minute scrambles and poor visibility for all parties.

The Solution

A four-portal SaaS platform where doctors can post and claim shifts, join specialty groups, verify credentials, and sync their calendar — while locum companies manage provider pools, post open shifts, and build out their facilities. One shared backend serves all portals.

Technology Stack

A four-portal SaaS platform where doctors can post and claim shifts, join specialty groups, verify credentials, and sync their calendar — while locum companies manage provider pools, post open shifts, and build out their facilities. One shared backend serves all portals.
NestJS
MongoDB
Mongoose
JWT Auth
React Native
React Native
Expo
Ant Design
Redux
AWS S3
Sendgrid
Twilio
Stripe
OpenAI
Google OAuth

THE CHALLENGE

A module like this is normally a multi-month
project.

Project Intelligence isn’t one chart. It’s a dozen dashboards, each with its own logic: a single project-health score, an impact-ranked list of every active blocker, certificate readiness, rework and first-pass quality, risk scoring across systems and assets, delivery velocity, and configurable trends over time.Large-scale commissioning and inspection runs on detail. A single project can carry tens of thousands of tags, hundreds of subsystems, and a constant flow of inspection records, punch items, walkdowns and sign-offs, each living in its own part of the platform.

The hard part was never a single calculation. It was the breadth - getting a dozen views right and keeping them consistent — and the finish: every screen had to look, feel and behave like a native part of the existing platform, not a bolted-on analytics tool. Done by hand, that means weeks of building, then more weeks of design QA and rework just to make it all feel like one product.
The expensive part isn’t writing code - it’s the rework. Most of the time in a build like this goes to second passes: re-aligning to conventions, re-styling for consistency, and reconciling one developer’s instincts with the rest of the codebase.

THE APPROACH

Context First. Then Let The Agent Build.

The shortcut wasn’t a clever prompt - it was complete context. Claude Code was given the entire codebase, the existing design system, the domain model, and a precise definition of the outcome we wanted. With that, it could build inside our world instead of inventing its own.

1. The whole codebase

Full read access to the existing repository, so the agent could learn how things are actually done here — not how things are done in general.

2. The design system

The established components, spacing, and theme, so new screens would inherit the product’s look rather than approximate it.

3. The domain model

The real language of the project and the exact questions each dashboard needed to answer, so the logic mapped to reality.

4. A clear target

A concrete picture of the finished module and what “good” looked like — direction the agent could build toward, not guess at.

MONTHS VS DAYS

The Same Module, on Two Very Different Clocks.

The scope didn’t shrink. The time-to-build did — because the slow part, rework, mostly disappeared.

WHY THE QUALITY HELD UP

An Agent That Knows Your Codebase Writes Like Your Team.

Speed only matters if the output is good. The decisive factor wasn’t raw generation — it was that the agent had learned the repository, and built in its grain.

It learned the patterns

By reading the existing code first, the agent picked up the conventions, structure, and idioms already in use — so new code looked like it came from the same hand.

It matched the theme

Because it built on the established design system, every dashboard inherited the product’s components, spacing, and styling — native from the first render, not retrofitted later.

So rework was small

When output matches conventions the first time, review cycles are short. The redesign-for-consistency loop that usually eats weeks barely happened here.

Consistent across all twelve

The same standards applied uniformly to
every dashboard, so the module reads as
one coherent surface instead of twelve screens drifting apart.

Context beat cleverness

The differentiator wasn’t a magic prompt.
It was feeding the agent complete, high-
quality context so it could make the right
call without guessing.

Engineer in the loop

A senior engineer set direction, reviewed
every output, and validated the logic. The agent accelerated the work — it didn’t replace the judgment behind it.

WHAT GOT BUILT

Twelve Live Dashboards, One Coherent View of Project Health.

Each answers a question leadership actually asks — all from live project data, all in the same language and look.

OUTCOMES

Delivered

Give a coding agent the full context of your codebase and a clear goal, and it builds like a senior member of your team - adopting your patterns, matching your design, and delivering in days what once took months.

Days, not months

A season’s worth of build, compressed

12 Dashboards

Delivered as one coherent module

Minimal rework

Conventions matched the first time

Native look & feel

Indistinguishable from the rest of the product

Your next product runs on AI. Let's build it.

Tell us what you're building and we'll show you how AI can make it faster, smarter, and built to last.
Let's Talk