Service Delivery at Scale

The problem

Government services fail at the moments that matter most: when someone needs help navigating a complex system under time pressure.

The issue wasn’t just bad interfaces. Eligibility systems, intake processes, and case management tools were built to satisfy policy compliance and processing volume—not to support completion, recovery from errors, or the downstream consequences of ambiguous decisions.

Working within constraints

Federal service delivery comes with constraints that can’t be wished away:

• Multi-program coordination across different technical stacks
• Policy requirements that couldn’t be changed (only interpreted and implemented)
• Legacy systems with limited or inconsistent integration points
• Stakeholders measuring success by throughput rather than completion
• High-risk error states where missing documents or misunderstood eligibility create dead ends

The challenge wasn’t to ignore these constraints—it was to find leverage within them.

My approach

I led design work at the intersection of policy intent and delivery reality, focusing on three areas:

Mapping decision points and failure states. I identified where people most commonly failed, abandoned, or got stuck. Instead of treating these as UX quirks, I documented them as operational failures with measurable costs.

Defining consequence moments. Small design choices create downstream harm. I made the cost of ambiguity visible: delays, rework, support burden, and eroded trust.

Building a shared vocabulary across teams. I established terms teams could use to debate service mechanics without bikeshedding UI. This created space for critique focused on decision clarity, recovery, and accountability.

Key work

Intake patterns that prevent late-stage failure

I built reusable patterns for surfacing requirements earlier in the process. The goal was improving legibility of “what happens next” and “why this is needed” while prioritizing recoverability over perfect happy-path flow.

Consequence mapping

I developed a workshop approach that made the downstream impact of design decisions visible to stakeholders. This shifted conversations from “processed” to “completed correctly” and connected service design choices to support load and operational performance.

Pattern development for cross-program use

Because the real leverage is repeatability, not one-off fixes, I focused on building patterns that could travel across programs. These patterns were adopted across multiple federal agencies.

Key decisions

Optimized for recoverability over polish. Dead ends are the true failure mode in high-stakes services. Perfect happy paths don’t matter if people can’t recover from common mistakes.

Surfaced requirements earlier instead of hiding complexity. Late-stage surprises drive abandonment and increase rework. Better to be clear upfront than smooth but misleading.

Built patterns that travel across programs. One-off fixes don’t scale. Reusable patterns create leverage across an ecosystem of services.

What changed

• Patterns adopted across 4+ federal programs
• Reduced avoidable abandonment during intake and verification moments
• “Consequence mapping” approach reused in training and cross-team critique sessions
• Shifted stakeholder conversations from volume metrics to completion and correctness

What this demonstrates

I can walk into complex, politically constrained delivery environments and find leverage points where design decisions create outsized impact.

I don’t need clean slates. I work inside real systems—policy constraints, legacy tooling, operational reality—and improve how decisions get made, communicated, and recovered from when they fail.