Modernization through Product Strategy

A complete replatform of a 25-year-old monolith serving 120,000+ people across 80+ facilities.

A modern platform built to scale · One design system across hundreds of pages · Handoffs engineers build from directly

Accounting dashboard with cash, trust, commissary, and commission metrics

Client: McDaniel Supply Company
Type: Enterprise modernization · Replatform
Role: Product strategy, discovery, UX, design systems

The problem

Over 25 years, McDaniel Supply quietly became a software company without ever deciding to. A supply business now serves 120,000+ people across 80+ correctional facilities, all on one aging monolith. It worked, but it couldn't scale, and the experience carried two decades of patches.

Legacy desktop menu editor: a dense blue grid of products with rows of Yes and No checkboxes — Before: the commissary menu editor

Legacy settings window with a Kiosk PIN Control dialog layered over dozens of module checkboxes — Before: kiosk PIN settings

Discovery made the rest possible

We came in as a partner, not a vendor taking a spec. Discovery mapped how 80+ facilities actually operate, where the monolith was load-bearing, and where there was new value beyond rebuilding what already existed. We also studied the people on the other side of the kiosk: how commissary works inside, the language people use, and how it feels.

AI took on the unglamorous, high-risk part: reading the legacy system, mapping its undocumented workflows, and turning 25 years of behavior into documentation we could design and build against.

That groundwork is why everything after moved fast. The early designs held up, and their patterns became the design system instead of throwaway mockups.

Whiteboard map of the legacy inmates module, with screenshots branching into each task and screen — Mapping the legacy system, screen by screen

Research board of sticky notes grouped into user research, terminology, inmate types, and what people think and feel — Research on life on the other side of the kiosk

Design system as a repo, not a Figma file

Instead of static mockups, I built a living design repository: tokens for color, type, and spacing, components that only use those tokens, and navigation and data as configuration. It runs in the browser as a real prototype.

Because it's code, it grew as fast as we learned. Six principles settle any unclear design call. Change a token or component, and every screen that uses it follows.

Design Principles page of the McDaniel Supply design system, listing six numbered principles — Principles: six rules for unclear decisions

Buttons and Badges and Status pages of the design system — Buttons and badges: one primary action, color with meaning

Tables and Data and Cards and Metrics pages of the design system — Tables and metrics: the core of the product

Icon library page showing navigation icons with their meaning and where each is used — Icons: every glyph documented, with where it's used

AI as a design partner, with guardrails

I wrote the design standards as a brief for AI agents, the way you'd onboard a new designer. Every session starts by reading the rules, checking the board, and starting the preview. Then we build together:

A ticket arrives with dense requirements. The agent reads the spec; I set direction.
The agent codes the screen against the tokens and checks it live. I review and push back.
The change is logged, screenshots go on the ticket, and the decision is written down.

Process diagram: an issue and a requirements spec feed the design repo of tokens, components, and standards, which produces a prototype screen, then a handoff issue, then the developer build — From ticket to handoff through one source of truth

Developer-ready handoff

Finished designs ship as self-contained issues in the production repo: screens, interaction rules, and acceptance criteria. Engineers build without re-deriving decisions, and every screen matches because the same rules made all of them.

It also made change cheap. Update a standard once and it carries across hundreds of pages. The system enforces consistency, so nobody has to police it screen by screen.

System and facility screens

We turned a dated, dense experience into modern staff and facility workflows. People work inside a facility and oversee the whole system, so the interface always makes the current scope obvious.

System-level Facilities page listing facilities with average inmates and commissary spend — Facilities: everything under management, at a glance

Accounting dashboard with cash activity, revenue streams, bank accounts, and trust composition — Accounting: cash, trust, and revenue in one view

Facility commissary dashboard with order metrics, quick actions, and open orders — Commissary: orders, quick actions, and the ordering schedule

Facility inmates dashboard with counts, quick actions, and the inmate list — Inmates: booking, release, funds, and invoicing

McDaniel commissary experience on a tablet

The result

McDaniel went from a monolith they couldn't grow on to a modern product and codebase built to scale. Discovery surfaced workflows and value the original "just replatform it" brief never anticipated, and the design repo kept pace: a system that evolved quickly, consistency across hundreds of pages, and handoffs engineers could build from directly.

This is modernization as product strategy, not just engineering: understand the business, use AI to de-risk the legacy mess, and ship something better, not just newer.