🔒 www.katiefusco.design
Product Designer  ·  AI Design Technologist  ·  Claude Code Architect
Katie Fusco
Case Studies
Ask me anything about Katie's work
"I know Katie's work inside out — case studies, design decisions, everything. Where should we start?"
Her AI work
What makes her different?
Are you biased towards Katie?
Design process
Take me to a case study →
Nasdaq
1 of 4
Design Strategy · Product Evolution · 2022–2025
Introducing design leadership to an enterprise platform managing thousands of financial indexes
Nasdaq's Index Management System had evolved for years without a design practice — no research, no shared visual language, no feedback loops. A formal design strategy was developed, presented to Nasdaq leadership, and accepted. What followed was a two-year overhaul that reshaped every surface of a system used daily by 30–40 index analysts.
Client
Nasdaq — Index Management
Role
Product Designer & Design Strategist
Scope
4 interconnected enterprise applications
Timeline
2 years
4
Apps designed & shipped
30–40
Index analysts daily
783+
Active indexes managed
2 yr
End-to-end engagement
Context
What is the Index Management System?

IMS is the internal platform Nasdaq uses to manage the lifecycle of every financial index in its portfolio — from initial research and approval through ongoing rebalances, reconstitutions, and compliance attestations. It serves index portfolio managers, operations analysts, launch coordinators, and compliance teams. Every index Nasdaq publishes — hundreds of them, tracking trillions in assets — flows through this system.

The Problem
A system that worked, but nobody loved

IMS had been built sprint by sprint for years — every screen a direct response to a feature request, never to a user need. There was no research practice, no design system, no shared visual language, and no structured feedback loop. The result: dense forms with no hierarchy, a navigation structure that reflected internal team vocabulary rather than user tasks, and an application that Nasdaq — a company that takes its brand seriously — would never have shipped externally.

Original IMS — Add New Index form
Before
Original IMS Add New Index form — dense, no hierarchy
The most-used workflow in the system. 5-column field grid, 9-step stepper bar, no visual hierarchy, labels indistinguishable from values. This is what analysts saw every day.
The Design Strategy
A formal strategy — not a redesign request

The response wasn't to start making screens prettier. A formal design strategy was developed and presented to Nasdaq stakeholders — a structured proposal for how to introduce design maturity into a project that had never had it. The strategy was accepted and became the operating framework for the next two years of product evolution.

01
User Research Plan
Structured interviews, card sorting exercises, user shadowing, surveys, and A/B testing protocols — establishing a proactive research practice where none existed. Every design decision would trace to documented user evidence.
02
North Star Metrics
Seven quantitative and qualitative metrics defined — overall user satisfaction, feature adoption rate, workflow completion time, error rate, monthly active users, support ticket volume, and NPS. Measured quarterly to track the impact of design changes over time.
03
Prototype-First Development
A new development protocol: every high-impact feature prototyped one sprint before engineering begins. Prototypes built directly in Appian — interactive, testable with real users, and reusable as production code. No throwaway mockups.
User Research
Understanding who we were building for

Structured discovery sessions, workflow shadowing, and stakeholder interviews produced a set of user personas that became the foundation for every design decision — documenting who the analysts were, how they spent their time, what frustrated them, and what they actually needed the system to do.

User Persona — Index Portfolio Analyst
Research
Persona: Index Portfolio Analyst
User Persona — Index Operations
Research
Persona: Index Operations
📋
Task clarity above everything
R&R evaluation tasks had due dates buried across multiple views. Analysts had no single surface showing what needed their attention and when.
📜
Record-keeping was table stakes
"I want to make sure there's a record tracked for Index changes." Audit trail and historical visibility weren't nice-to-haves — they were regulatory requirements.
Approval workflows created anxiety
Analysts needed confidence their R&Rs were correct before escalating to their lead. The system gave them no validation signals to calibrate against.
Information Architecture
Restructuring before redesigning

The first design deliverable wasn't a screen — it was a sitemap. IMS had grown organically for years, with navigation reflecting internal team vocabulary rather than user tasks. The IA overhaul renamed, consolidated, and restructured every section of the application into 8 clear primary areas before a single interface was redesigned.

IMS Sitemap — Q1 2024 · 8 primary sections
IA Deliverable
IMS information architecture sitemap
Index Inventory
783 indexes, instantly navigable

The Index Inventory was the main entry point to IMS — and in the original system, it was a flat searchable table with no summary metrics and no way to understand the portfolio at a glance. The redesign added a contextual sidebar with quick actions, a KPI strip surfacing the most important numbers, and a table that could be filtered and customized without leaving the page.

Redesigned Index Inventory — sidebar, KPI strip, filterable table
Redesigned
Redesigned Index Inventory
614 active in-scope indexes, 4 launched, 6 terminated — all visible before a single filter is applied. The sidebar surfaces the most common actions (Manage Assignments, Bulk Reassignment, Add New Index) where users need them.
Index Record
The screen analysts live in

The Index Record is where analysts spend most of their day — reviewing evaluation schedules, tracking rebalance and reconstitution details, managing team assignments, and monitoring outstanding tasks. The redesign replaced a flat form-heavy layout with a structured two-panel view: a persistent sidebar for contextual information and a tabbed main panel for deep content navigation.

Index Record — Index Evaluations tab
Redesigned
Index Record
Sidebar: analyst assignments with role badges, compliance alerts, attached documents, outstanding tasks. Main panel: rebalance/reconstitution schedules, reference date configurations, upcoming and past evaluation tables. The pre-attestation compliance warning appears prominently rather than buried in a field row.
Outcomes
What changed
Results
Four interconnected enterprise applications designed, prototyped, and shipped with a unified visual language applied for the first time.

A design strategy accepted by Nasdaq leadership that established a user research practice, a prototyping standard, and a north star metrics framework where none had existed — and sustained it across a two-year engagement.

Measurable adoption and satisfaction gains tracked through the metrics framework established in the design strategy. The system went from a tool analysts tolerated to one they could navigate, trust, and give feedback on.

The most meaningful outcome wasn't a screen or a metric. It was that a product that had never had a design culture now had one — and it showed in every interaction.
katiefusco.design/case-studies/nasdaq Ready
State of Florida
2 of 4
Systems Design at Scale · 2024–2025
Redesigning a state licensure system with the practitioner at the center
The Florida Department of Health's Medical Quality Assurance division ran its licensing operations on a system built in the early 2000s. Paper checklists. Manual workflows. Siloed data. The redesign wasn't just about modernizing the state's internal convenience — it was about meeting MQA's core mission: licensing practitioners efficiently so that care can be provided to Floridians without delay.
Client
Florida Dept. of Health — MQA
Role
Business Lead & Sr. Design Technologist
Delivered
Prototype
200+
License types modernized
40
Regulatory boards
194
Subprocesses reengineered
50+
Stakeholders in UAT
The Challenge
A legacy system built for a different era

MQA's legacy system — LEIDS — had accumulated decades of workarounds. Processors managed PDF checklists stored locally on their desktops. Applicants had no visibility into where their application stood. Deficiencies were communicated by phone and letter. Everything needed to be rethought.

The Approach
Design before a single screen

Before any interface work, the team mapped every process end to end. 49 parent processes. 194 subprocesses. Two full rounds of stakeholder review documented in a living BPR matrix. Every design decision traced back to a business need, a statutory requirement, or a documented user pain point.

Design Framework
8 improvement goals across every workflow

Before designing anything, the team defined the outcomes they were optimizing for — a design philosophy applied to government operations.

Automate Manual Tasks
Improve User Experience
Increase Transparency
Integrate Disparate Systems
Enhance Data Accuracy
Standardize Processes
Reduce Cycle Time
Strengthen Audit Readiness
Processor Experience
Every application's urgency visible at a glance

The processor queue replaced a flat list of 500+ records with role-based tabs, deadline-coded rows, and KPI cards that surface what needs attention before a processor has to look for it.

LEIDS — Legacy application search (501 records, no priority signals)
Before
LEIDS legacy queue
"You have insufficient privileges" error on the main work screen. Flat table with cryptic action icons, no deadline visibility, no status coding.
HELIX — Processor queue dashboard with KPI summary and deadline alerts
After
HELIX Processor Dashboard
Age-coded urgency (red = approaching deadline, amber = aging, green = on track), 5 KPI cards, and tabbed queues separating workflow states.
Deficiency Workflow
The deficiency loop — from broken to automated
Before — LEIDS
Processor manually identifies missing documents
Deficiency letter drafted and mailed — days of delay
Applicant calls to ask what's missing — no portal
Processor tracks responses in a local PDF checklist
No audit trail, no deadline enforcement
After — HELIX
System flags deficiencies automatically on submission
Processor and applicant see the same live checklist
Applicant resolves deficiencies directly from their portal
Application auto-advances when all items cleared
Full audit history maintained automatically
HELIX — Add Deficiencies modal with live checklist
HELIX deficiency checklist
Full checklist visible at once with Y/P/N status per section. Deficiencies selected from a controlled dropdown — consistent language across all processors. Previously flagged items surfaced inline for historical context.
Application Record
The screen processors spend most of their day in

The LEIDS license record was a flat field dump — every piece of data equally weighted, no hierarchy, no task context. HELIX replaced it with a structured two-panel view: a live deficiency checklist on one side, a processing clock against the statutory deadline on the other, and a complete audit trail — all without navigating away.

LEIDS — License record (flat field layout, no hierarchy)
Before
LEIDS legacy license record
HELIX — Application record with live deficiency checklist and processing clock
After
HELIX Application Record
The checklist updates in real time as the applicant responds. The processing clock surfaces the statutory deadline automatically. Every change is logged to the audit trail without processor intervention.
AI Design
AI Knowledge Base — Microsoft Copilot
As institutional knowledge concentrated in one person, I designed and built a Microsoft Copilot knowledge base prompt-engineered against the full project corpus — stakeholder interviews, legacy data exports, workshop transcripts, and regulatory documents. The result: any team member could ask any question and get an accurate, sourced answer instantly. Delivered as a separate use case under the FLDOH engagement.
Outcomes
Tested, validated, and accepted
Results
The HELIX prototype was tested by over 50 internal FLDOH stakeholders across multiple divisions of Medical Quality Assurance. The design received broad acceptance and praise from department leadership — not as a concept, but as the foundation for how FLDOH would approach licensure technology going forward.

The design was accepted to inform FLDOH's future licensure products — the patterns, interaction models, and systems thinking developed in HELIX became the reference point for subsequent modernization efforts across the department.

A legacy system that had operated unchanged for decades was mapped end to end (49 parent processes, 194 subprocesses), reengineered through two complete rounds of stakeholder feedback, and redesigned into a prototype that proved the path forward.
katiefusco.design/case-studies/florida Ready
State of Massachusetts
3 of 4
AI-Native Engineering · 2025 – Present
A modern solution to a persistent problem.
CSC was going live. At the same moment, DALA needed the same application rebuilt with different business logic, a different data schema, and different workflows. One month. Two developers. 800+ interdependent Appian objects. The real problem wasn't how to build the app — it was how to design a system that builds the app automatically.
Client
Massachusetts Exec. Office of Admin. & Finance
Role
Tech Lead & AI Design Architect
Tools
Claude Code · Appian · XML · JSON
800+
Appian objects transformed
1 mo.
Full rebuild timeline
4
State departments served
The Problem
800+ objects. Four departments. One month. Two developers.

The Civil Service Commission (CSC) application was nearly complete. Then came the requirement to deploy the same application — same structure, same logic, same object count — across three additional state departments, each with different group names, different UUIDs, different folder structures, and different data schemas.

Manual rebuilding was off the table. Cloning and editing 800+ Appian objects one by one would take months and introduce errors at every step. The problem wasn't development — it was transformation at scale.

The Insight
This isn't a development problem. It's a transformation problem.

Every Appian object — processes, interfaces, records, data structures — was structurally identical between departments. Only the identifiers changed: group names, UUIDs, folder references, data source names. That's not something you solve by writing code. That's something you solve by writing instructions for Claude Code to execute.

The insight was treating the entire application as a structured document to be transformed, not a codebase to be rewritten. Claude Code reads the source XML, applies a mapping config, validates the output, and packages it for deployment — automatically, repeatably, for any department.

The Pipeline
3-stage agentic architecture

Each stage has a single responsibility. The pipeline is Claude Code orchestrating itself against a structured config — no custom scripts, no brittle regex, no manual intervention.

Stage 01
Transformer
Ingests source XML, substitutes identifiers via mapping config
Stage 02
Validator
12 automated checks, flags ambiguities for review
Stage 03
Packager
Zips output by dependency depth, ready to deploy
Stage 01 — Transform
Transformer
Ingests source XML from CSC. Substitutes all department-specific references — UUIDs, group names, folder structures, data schemas — using dala_mapping.json config. Recurses through the full dependency tree depth-first.
Stage 02 — Validate
Validator
Runs 12 automated checks: no remaining CSC references, UUID integrity verified, dependency tree fully resolved, schema correctness confirmed. Flags anything ambiguous for human review.
Stage 03 — Package
Packager
Zips validated output into a Designer-importable package ordered by dependency depth. Ready to deploy with zero manual intervention. Output: DALA_Batch_[N].zip
Real Prompt
The instruction that runs the whole thing

This is the actual Claude Code prompt used to trigger a standard department transformation. One prompt. One pipeline run. One deployable package.

CLAUDE.md — Standard Transform Prompt
Transform LCMS_CSC_createCase from reference/source-exports/ using config/dala_mapping.json. # Step 1 — Dependency discovery Identify all dependencies: sub-processes, expression rules, constants, data types, record types, groups, folders. Recurse into each sub-process dependency tree depth-first. # Step 2 — Mapping resolution Scan reference/dala-exports/ for DALA equivalents. Add confirmed mappings to config. Flag missing precedents. # Step 3 — Show plan before executing Output: dependency tree · mappings · missing precedents · proposed clone order · ambiguous names for confirmation # Step 4 — After approval Clone missing precedents CSC → DALA recursively. Rename to LCMS_DALA_createCase, update all internal refs. Validate checks 1–12. Package as DALA_Batch_[N].
Outcomes
What shipped
800+
Appian objects propagated in under one month — only possible through AI-native automation
~150
State legal and administrative staff across CSC, DALA, and additional departments served by the modernized platform
0
Manual transformation hours — menial object work eliminated entirely, team time redirected to net-new development
1 prompt
Any developer on the team can now run a full department deployment end to end — the pipeline is documented, repeatable, and team-owned
The Bigger Point
AI-native development isn't a tool. It's a way of thinking.
Takeaway
The Massachusetts pipeline didn't save time by making the old process faster. It made a fundamentally different kind of solution possible — one that wouldn't have existed at all without AI-native thinking.

The design decision was recognizing the problem as a transformation problem, not a development problem. Once that framing clicked, the solution was obvious: write instructions clear enough for Claude Code to execute reliably, validate the output rigorously, and hand off a system the whole team can use.

That's the skill. Not the prompt. The thinking behind it.
katiefusco.design/case-studies/massachusetts Ready
Birdseye
4 of 4
iOS · Consumer Product · In Development
Building the bird app I always wanted to exist
Birdseye started as a question: what would a bird identification app look like if it was designed for the moment of encounter — messy, exciting, incomplete — rather than for the armchair expert with a perfect photo? Three input modes, one conversational AI core, one very good question: what should birding software actually feel like?
Type
Independent · iOS App
Role
Solo Designer & Developer
Tools
Claude Code · Figma · SwiftUI
Status
Prototype complete · App Store TBD
3
Identification modes
5
Core app sections
1
Solo designer & developer
Bird sightings are never perfect

Most bird apps are built for people who already know what they saw. You search by name, browse a field guide, confirm an ID. But real birding is messier — you caught a glimpse, heard a sound through the trees, or saw a flash of color and need to work backwards from a description. No existing app was built for the moment of uncertainty.

Meet the user where the bird is

The core design insight: identification should start with what you have, not what you should have. A photo? Great. A song? Perfect. Just a rough description of a bird you saw in your backyard? Also great. Birdseye is built to work with incomplete information — because that's what birding actually gives you.

Live Prototype
Try it — fully interactive Figma prototype
figma.com · Birdseye birding app · Interactive prototype
🐦
Interactive Prototype
Fully interactive — tap through all 5 sections: Identify, Guide, My Lists, Map, and Profile. Opens in a new tab.
Open Prototype →
Built in Figma · 5 screens · Fully interactive
Section 01
Identify — three ways to know what you're looking at

The core of the app. Three input modes unified under a single tab — Camera, Sound, and Describe. The AI reads whatever you give it and narrows the possibilities down to a confident match.

Identify — Camera mode
Camera
Identify — Sound mode
Sound
Identify — Describe mode
Describe
Why three modes, not one

Each mode solves a different version of the same problem. The design challenge was making them feel unified — same tab, same screen, just different inputs — without making any single mode feel secondary.

📷 Camera
Point and shoot. AI identifies from visual characteristics — plumage, silhouette, size — in real time. Shows "AI READY" when conditions are good. Narrows possibilities in real time.
🎵 Sound
Record a call, song, or alarm note — works up to 30 meters away. Waveform preview confirms the recording is picking up audio. Designed for the moment when the bird is in the tree above you but not visible.
💬 Describe
Conversational AI asks guiding questions — habitat, color, size, behavior. Quick chips for common answers ("In a tree", "Near water") reduce typing friction. Works when you have no photo and no sound.
⚡ Recent identifications
All three modes surface recent identifications below the input — so returning to a sighting is one tap. Confidence percentages (94%, 98%) shown at a glance.
Section 02
Guide — a field guide that knows what you've seen

Search or browse species filtered by type — Songbirds, Raptors, Waterfowl. Each species card shows the AI match percentage from your last sighting. Species you've added to your life list get a checkmark. The field guide is aware of your history.

Field Guide — species list
Browse
Field Guide — species detail
Species detail
Field Guide — species detail scrolled
Full entry
Sections 03 & 04
My Lists + Map — your birding history, two ways

My Lists is your life list — every species ever identified, numbered in order of discovery, with location and date. Filterable by Life List, year, and Trips. The Map plots those same sightings geographically, clustered by density, filterable by Week / Month / Year / All Time.

My Lists
My Lists
Sightings Map
Map
Section 05
Profile — the birding identity you earn

Profile surfaces what makes each birder's journey unique — life list count, total sightings, countries birded, rarest find. Achievements (Raptor Watch, Early Birder, Explorer) unlock based on real behavior, not arbitrary gamification. A weekly activity chart keeps the streak visible.

Profile — Mallard theme
Profile
Design Feature
Four color themes — one for every kind of birder

The app's appearance adapts to the user's chosen bird species theme. Each theme is a complete, cohesive color system — not just an accent swap. Mallard is the default (forest green & amber). Users unlock Robin and Bluebird based on their sighting history.

Mallard
Forest green & amber · Default theme
Mallard theme
Robin
Warm terracotta & rust
Robin theme
Bluebird
Deep navy & sky blue
Bluebird theme
What's Next
From prototype to product
Status & Roadmap
The Figma prototype above is fully interactive and covers all five sections end to end. SwiftUI development is underway — the Camera and Describe flows are functional. Sound identification is next.

This product exists because I wanted to create an experience I could use firsthand to support my own hobbies — and to address what I saw as a gap in the market. Current birding software hasn't kept up with consumer expectations, and Birdseye is my attempt to balance that scale.

Targeting App Store release.
katiefusco.design/case-studies/birdseye Ready