Deborah Foley Portfolio Deborah Foley Portfolio

Design Ops

Design Leadership & Delivery

How I run design

The frameworks, processes, and methodologies I’ve built over my career for how design actually works inside agile — scoping and estimating, phasing and staffing, protecting a team, and making the case for the right process. Leaders have often acknowledged it as an unusual hybrid: a design manager and a program manager in one. It grew from the build side — I came up as a front-end developer and was trained as a scrum master to help run process and delivery — which is why the program practice is as tried-and-true as the design. It’s the practice behind every case study on this site.

My methodology for running a large initiative
How I run a large initiative. One repeatable way to take an ambiguous, multi-team problem to a shipped product — and the map for every framework below.

Click any image to enlarge.

At a glance

The frameworks I built

The 8-week framework · t-shirt sizing · dual-track phasing · the 75/25 reserve · team-by-gaps · the transparency cadence

What it’s built on

Design degree · front-end from the Flash era · certified scrum master · years leading & scaling teams

Where my methodologies were developed

Startup → Ropes & Gray → Goldman Sachs → Chase (CBO & my managed domains) → Amazon Appstore

What this is

Processes I built, run, and teach partners to work within — told as lessons earned across real orgs, not a playbook

The thesis

Design can be agile — if you build the practice for it

Very little has been written about how design actually operates inside agile. I built these frameworks because I came to design from the build side: I can tell when rigor is genuinely needed and when it’s indulgence, and I’d rather be wrong in a cheap prototype than in production.

Origins

Where the practice came from

Startup · as an engineer

Agile, introduced one sprint at a time

My first CTO rolled agile out method by method until it stuck — where I learned to introduce process when the pain is felt, not before.

Wait for the pain point

Ropes & Gray · scrum master + solo UX

Every hat — and a lesson in testing cheap

I was hired as a UX designer on the internal team for the global law firm — but I was a faster, stronger front-end developer, so I built the front end too, and got scrum-certified to help with process and delivery. On my very first ask there, I built a resource-heavy, high-fidelity prototype to the knowledge-management team’s requirements — and when the risk-management SMEs finally saw it, the requirements had been wrong, so the whole solution was too. That pain point taught me the lesson I spent the rest of my tenure teaching: put low-fi work in front of users early and iterate up, instead of investing heavily in a polished prototype built on unvalidated assumptions. It’s the design process — research, testing, iteration — I brought to the many internal, external, and intranet solutions we built after.

Test cheap, before you build

Goldman Sachs · rebuild lead

Where systems, component thinking, and Visual QA got real

I was hired to rebuild and refactor an application that wasn’t performing or scaling well. I built a system and component library — before “design systems” was a term — and trained both design and development on responsive design and how to reuse and extend systems. Designers had been handing off “posters” that didn’t scale across viewports; a biweekly cadence to close those gaps became Visual QA, and I learned that VQA, regression, and iteration belong in the estimate.

Visual QARegression in the estimateComponents before “design systems”

Chase · CBO — where the practice was born

The 8-week framework

No design-to-solution runs longer than eight weeks — every week produces a real design deliverable partners can react to (an analysis, an ideation, a journey map, lo-fi to hi-fi mocks), or it gets phased.

8

Eight weeks, maximum. If a solution can’t fit, it gets phased (vision → MVP → per-sprint flows): deliver small, learn what matters, build up — the diagram below shows why.

The classic case against waterfall delivery: build it all up front — and this is how much of it actually gets used.

“Simplicity — the art of maximizing the amount of work not done — is essential.”

Principle #10 · Principles behind the Agile Manifesto
7%
13%
16%
19%
45%
Always
Often
Sometimes
Rarely
Never
~20%
used often
64% rarely or never used

Feature-usage study: Standish Group (Jim Johnson), keynote, XP 2002 — four internal-use applications.

The figure is of its era — as discovery and research practices have matured (the work in this framework), that waste has come down. Which is the point: validate before you build at scale.

Discover
Analyze
Ideate
Prototype & Test
Design & Handoff
Week 1

Discover

SME knowledge transfer, journey mapping, competitive analysis.

ArtifactRaw inputs gathered
Week 2

Analyze

Findings & recommendations, shared back.

ArtifactDefined scope
Week 3

Ideate

Workshops when ambiguous; an IC delivers options when clear.

ArtifactDirections explored
Week 4

Ideate

Converge with partners — engineers in the room.

ArtifactConcept chosen
Week 5

Prototype

Build the prototype and flows.

ArtifactClickable prototype
Week 6

Test

Usability research (generative can run earlier).

ArtifactResearch + hi-fi
Week 7

Design

Iterate on feedback to final.

ArtifactRefined design
Week 8

Handoff

Redlines & specs for the build.

ArtifactDev-ready handoff
Declare the fidelity & status

A polished Figma mock reads as “done” to stakeholders, so I label it: a concept in refinement, not a final, data-backed decision. Even an “8-week final” keeps iterating after.

Research needs lead time

A week or two to recruit users; generative earlier, usability at week 6.

Builders in early

Engineers at ideation — kills feasibility churn.

Content is a partner — sometimes the lead

Design orgs too often treat content as an editor, not a partner. I’ve been fortunate to work with strong content strategists — and learned that in content- and doc-heavy products, content should run its own track and sometimes lead with content strategy ahead of UX strategy — so I’ll assign them the lead, or find the way for the two leads to collaborate.

Chase · CBO

T-shirt sizing

How I scope and negotiate every plan: size the initiative, and the size sets the sprints, the process, and who delivers.

A recommendation, not a declaration

The size, the weeks, the process — my estimate and my rationale, not a mandate. I make the case, respect product’s goals, and negotiate. My most reliable argument: it’s cheaper to get it wrong in design than in dev and shipping. (See Merchant Services for the field-research example.)

XS

Quick added elements

2–3 days
  • Design delivery only

S

Small enhancement

1 sprint · 2 wks
  • Concept
  • Feedback
  • Final design

M

New feature

2–3 sprints
  • Ideation
  • Concept
  • Feedback iteration
  • Final design

L

New experience

3–4 sprints
  • Discovery
  • Ideation
  • Concept & socialization
  • Final design

XL

New experience with risk / uncertainty

4–5 sprints
  • Discovery
  • Ideation
  • Concept
  • Research
  • Socialization
  • Final design

XXL

Large phased project — MVP + phases

Phased · dual-track
  • Discovery
  • Ideation
  • Concept
  • Research
  • Socialization
  • Final design

The 8-week rule sits at L/XL; past XL a project can’t solve in eight weeks — so it phases and goes dual-track.

Ambiguity is the dial — both ways

More unknown → more discovery/research; but I’ll push back when a simple enhancement needs no full study or sprint workshop.

Research adds real time

A baseline + usability test can add 2–3 weeks — I lead with the rationale.

Come to me early

Sizing only lands the milestones if partners bring the work early enough to scope.

Size can change the staffing, not just the timeline

As work scopes past medium (L–XXL), the answer isn’t always more sprints on one designer — it can mean pairing a second designer (a strategy + execution split), which is a capacity decision before it’s ever a headcount one.

Chase · my managed domains

Dual-track phasing

How the 8-week cycle scales up: phasing a big project into parallel strategy and execution tracks — two teams or just two designers (a strategist and an executioner), depending on the scope. The strategist owns discovery and the recommended concept and runs a cycle ahead on the next phases, while the executioner refines and ships the current one.

The unit

1 cycle · ≤ 8 weeks

→

Too big for one cycle? Phase it — a strategy team a cycle ahead, execution shipping the current phase.

Cycle 1
Cycle 2
Cycle 3
Cycle 4
Strategya cycle ahead
Vision & North StarMap the growth before the MVP.
MVP + P2 discoveryDefine the MVP; start the next phase.
Phase-ahead discoveryIdeate what execution hasn’t reached.
Executioncurrent phase
Build & ship MVPFlows and pages, sprint by sprint.
Build & ship Phase 2What strategy scoped last cycle.
Build & ship Phase 3Always a cycle behind strategy.
North-star vision before MVP

It doesn’t have to be the exact end state, but you have to take the time to learn how the product might scale. Skip that and a break-and-redesign tends to come back too early — right after launch.

Timed deliverables

A large project with many flows and pages doesn’t get designed in one sprint any more than it gets built in one — so I break the design work into sprint-sized deliverables, the same way engineering phases the build.

Chase & Amazon · my managed domains

The 75/25 rule — capacity planning through the feedback loop

Whether I’ve split a project into dual tracks or not, the hard part is the same: the feedback loop. Once a designer delivers their recommendation, the stakeholder and leadership rounds are unpredictable and a challenge to schedule. The 75/25 rule manages that — it keeps capacity full and the roadmap on track instead of stalling in “hurry up and wait.”

~75%

Committed delivery

The bulk of a designer’s time goes to their next committed initiative. Waiting for each project to be fully done before starting the next would stall everything on that unpredictable churn — moving on at 75% is how I can actually hold my roadmap timelines.

~25%

The reserve

Held on purpose — for the feedback churn I can’t schedule, and the growth work that never fits a deadline.

The reserve absorbs · 1

Feedback churn I can’t schedule

“Hurry up and wait” on stakeholder and leadership loops no one can date — held in the 25% so it never stalls the next kickoff.

The reserve funds · 2

Big rocks — room to think big

Research & POCs, and the strategic storytelling that proves the work — the thinking that never fits a deadline.

The reserve grows · 3

Learning & designer growth

Dedicated capacity for skill development — right now I reserve it for AI training, POCs, and growth toward full-stack — so the team keeps leveling up, not just shipping.

Side note — strategy & execution can tag-team the 75/25

The same split works at the person level: when I don’t want a senior lead stuck in the refinement cycle — they’re better spent on the large, challenging problems — the executional designer carries the iteration rounds while the senior moves to their 75%. It ships the vision in increments and puts senior capacity where it’s worth most.

Chase · my managed domains

Building the team by gaps

I build complementary strengths, grow everyone toward full-stack, and hand the lead to the discipline a product needs.

Strategy & exec presentation

Frames the problem and carries it to leadership.

Systems

Builds and governs the shared foundation.

Complex / product

Untangles the hardest flows.

Visual & illustration

Holds the craft bar and brand.

Motion

Guides the eye — not decoration.

… and everyone is growing toward full-stack UX — the gaps are a starting point, not a box.

The culture

A safe review & mentorship loop

Weekly reviews anyone can sign up for; researchers and content join early; feedback is safe by design.

Cross-domain mentorship — my complex-thinkers and product/consumer designers teach each other.

The call

Who leads is a product decision — not ego

Leaving the org, I helped promote a content strategist to lead Connected Banking — its content and educational needs made that discipline critical.

Research makes the same case — engaged upfront as a partner (generative studies, surveys), not just end-stage usability.

In doc-is-king products (API Portals), content leads the IA — not UX defaulting to “just add filters.”

Across every team I run

The transparency cadence

How I keep a scaling team visible to partners and leadership — without drowning it in meetings.

Flexed by team pulse. I never add a meeting that isn’t earning its place — and when my own team votes a cadence, that one’s near-sacred.

Weekly
  • Team meeting — design review, learnings, team-building
  • 1:1s with each direct
  • Design-lead / product-lead sync
Monthly
  • Product leads + my leadership
  • Stakeholder review — any phase, early feedback
  • Visual newsletter to all

The backbone · the wiki

Each sprint ships one or two artifacts, logged by designer × initiative × phase:

Discover→Ideate→Design→Deliver

Visual QA — the quality gate I established. Design signs off on code, on a severity scale I defined:

Low

Noticeable mainly to a designer; fine for a later release.

Medium

Doesn’t break the product, but needs a fast follow.

High

Can’t ship. Must be fixed before release.

Across my managed domains · the capstone

Roadmapping incremental delivery

The one where every discipline I carry comes together — service design, agile estimation, research-led prioritization, and delivery leadership — turned into a quarter-by-quarter plan the partner owns and can ship against. Each step runs on a different one.

It’s also how I move a partner off “build it all at once.” We sequence vision → MVP → incremental releases together, so the big bet de-risks into releases that deliver value the whole way.
Step 1 · Service design → the backlog Service design & IA

I start with a service design exercise — a service blueprint or a customer-journey map — to see the whole experience, not just the screens: the user’s actions across the journey and the front- and back-stage that has to move with them. The items that come off it become the backlog of features and flows to scope.

Journey
Discover
Evaluate
Decide
Use
User action
Finds the entry point
Compares the options
Commits
Completes the task
Frontstage
Entry points, prompts
Overview & compare views
Confirmation, guidance
The working tools
Backstage
Nav / CMS
Data aggregation
Business rules, auth
LOB systems, fulfillment
Step 2 · Poker planning → velocity Scrum master & front-end

Then I size the backlog with the engineers — poker planning, card by card. Coming from the build side as a scrum master and front-end developer, I estimate alongside them, not over them, which is why the numbers hold. We learn their real velocity: the story points they actually deliver per sprint.

Estimate together

Poker planning with the developers, sizing every card on its own merits.

Find the velocity

The points they truly deliver per sprint — real capacity, not a wish.

No history? Baseline it

New team? We agree which cards fit one sprint and baseline from there.

Step 3 · Customer value & resource assessment Research & UX

Next I bring in research and product to weigh each card: must-have vs. nice-to-have, customer value against business value, and the dependencies and expensive resources that constrain the order. Lined up by effort (from the estimates) and scored by value, opinion becomes a shared, defensible picture.

Customer value →
Quick wins
Big bets
Fill-ins
Time sinks
Core flow
Overview / dashboard
Integrations
Personalization
Secondary links
Effort / cost →

Top-left = easy and valuable = quick wins; top-right = valuable but heavier = big bets. This is what turns opinion into a plan everyone can defend.

Step 4 · Map the quarterly roadmap Design leadership

This is where it all comes together. Product pulls the cards into quarters against the engineers’ velocity, value-ordered — but my scrum and dev background is what catches the real constraints: when dependencies have to be grouped into the same release, or when a quick win or the MVP needs more runway than the points alone suggest. An MVP they can ship first; the vision held in the later quarters. The roadmap is theirs, built on real capacity.

Q1 MVP
  • Core flow + nav
  • Overview v1
  • Data dependency
Q2 ~velocity
  • Secondary flows
  • Notifications
  • Content v1
Q3 ~velocity
  • Integrations
  • Consent dependency
  • Controls
Q4 Vision
  • Personalization
  • Deeper content
  • Cross-LOB ingress
Deliverable Dependency

Labels illustrative — the method is the point: capacity-constrained, dependency-aware, value-ordered.

Across Chase & Amazon · the people

Growing the people — and keeping them

The frameworks run the work; this is how I run the team. My bias is to give senior designers as much ownership and bias-to-action as I can — I’m the block-remover — and to coach everyone else toward their gaps, pairing designers so they grow each other. Weekly 1:1s, goals set at the start of the year for the person, the team, and the product, and performance managed honestly across the curve.

Retention over headcount

Giving talent away to keep it

A senior designer with a decade at Amazon knew the Fire TV store cold but was burning out as the team’s growth stalled. Rather than lose him, I moved him under another Fire TV leader who could challenge him with new scope. Two years on, he’s still there — going strong.

Promotions, earned

Learning the bar, then clearing it

My first promotion cases for two junior designers didn’t pass review — so I learned exactly how the committee judges scope, gave both larger responsibility governing their own device domains as system governance, and won both promotions the next round. Four promoted over the stretch — and when my org couldn’t offer the growth a designer needed, I placed them into a transitional role elsewhere in the company rather than let them stall.

Managing the craft and the bar

At Amazon I run the talent review honestly across the performance curve — coaching a lower performer through a focused month of concrete tasks before it becomes a crisis, and spending my energy where it compounds. Hiring runs through the trained interview loop and bar-raiser checks; onboarding at Chase is a written system of stakeholders to meet, on- and off-team buddies, and mentoring talent can seek out. I’ve led ICs, design leads, and a design manager (Alexa design systems), and I coach gaps toward full-stack — the right workshop, the right book, the right designer to learn it from.

Teaching the team a new capability

Over the last stretch I helped bring the whole core UX org at Devices & Services onto AI. I joined the adoption tiger team, took prompt-engineering classes and an advanced pixels-and-prompting workshop so I could teach it, held office hours, and brought fresh training examples to the teams bi-monthly. On my own team it was hands-on — vibe-coding, rapid prototypes, and real work inside the system-automation tooling I was building, and taught my team to adopt too — on the 25% growth capacity I protect for exactly this.

Why it’s hereI run mostly senior teams now, so I half-joke that I’m the admin — but growing the team and its capability is the most important part of my job, and always has been. It’s the half of design leadership that never shows up in the screens.

Amazon Appstore · the proof

The collaborative operating model I presented to partners

One example of the kind of presentation I give partner leaders when I recommend how we should collaborate — a ticketed intake-and-collaboration model, adapted from Amazon’s working-backwards practices. This is the actual deck.

The bad-cop edgeDoing both jobs means I can’t only be the “yes, think big” design manager; the program side has to steer to goals and sometimes say “this is all we can do.” I first saw that tension in a developer-manager at Ropes — and it’s part of why I got scrum-certified. Holding both while staying a diplomatic partner is the real challenge of the hybrid.
Reframe: design as support to design maturity.
Work backwards, the PR/FAQ.
The design retrospective.

Solutions to try

  • UX roadmaps — shared early, calling out UX support
  • Quarterly kickoffs — to scope t-shirt sizing and determine capacity availability
  • UX work-backwards plan — to recommend & negotiate discovery and delivery timelines
  • Create SIM tickets — for design-intake accountability
  • Engage design as a strategic partner — where ideation collaboration can help strategy and innovation
  • Design sprint planning — improving prioritization alignment across the org
  • Socialization with design — design needs to be at UI reviews
  • Visual QA — to ensure quality and good CX delivered
UX roadmaps.
Quarterly kickoff to scope.
Sizing the project plan.
SIM-ticket intake.
Design as a strategic partner.
Research first.
Feedback, iteration, refinement.
Visual QA.
The design collaboration checklist.

API Days 2019 · the talk

Teaching the discovery playbook — on stage

I was invited to API Days to share how my team discovers what makes a great developer experience — the research-to-delivery method behind the JPMorgan and Chase developer portals. This is the actual keynote.

Title slide — Dev Portal Discovery Playbook
Our skills — the cross-functional team
JPM, Chase, and Developer Center portals
The discovery process map
Discover — section divider
Qualitative research sessions
Empathy mapping
Personas workshop
Third-party developer persona
Customer journeys — wall and grid
Third-party developer journey detail
MVP user flow
Competitive analysis matrix
Quantitative research
Common developer themes
Ideation to delivery — section divider
Data synthesis
Design sprints — sketch explorations
Prototypes
User testing and iteration
Roadmap 2020 workshop
Why it’s hereA conference invited me to teach this — proof the discovery method isn’t ad hoc, but a repeatable practice others wanted to learn.
The talk traveled

The same discovery playbook — a design-thinking approach to developing developer portals — I also brought to API World and the Developer Relations Conference, co-presented with my product partner. This was the work I led as VP, Head of Design for the Developer Ecosystem at Chase.

AI, from both sides

The same problem, now with AI

A pattern I’ve watched my whole career: an engineering team builds until it works, leadership realizes it isn’t usable or won’t scale, and a UX leader gets pulled in to redesign it — at Ropes, at Goldman, at Chase, at Amazon. AI is the newest version of exactly that.

I see it from both sides, because I started as a developer before I was a designer — and have worked across both ever since. Many believe AI now lets them design and build at once — and at the surface, it can look convincing. But building until it works isn’t the same as building something that scales, performs, and holds together as a system, and closing that gap is a judgment call — the one I’ve spent a career making: when rigor is genuinely needed, and when it’s indulgence.

So I don’t read this as replacing designers or developers — not the way the headlines do. I read it as raising the bar on judgment: seeing what won’t yet scale and why, and reading the code and leading the redesign in the same breath.

And “yet” is the point — this isn’t the end game. I’m helping to train AI to write code and judge design better. We all are. I’d rather shape that judgment than defend against it — the tools change, but the judgment is the job, and teaching that judgment — to the AI, and to the tools I build with it — is part of the work now.

See the AI tooling work →

The practice, matured

The same instincts, aimed higher

What began as an “administrative” ask became half of what I’m known for. These aren’t a template I apply — they’re judgment earned in the weeds of teams scaling 0-to-1, and they’re why I can lead design and delivery at once: scoping, estimation, capacity, prioritization, and the craft. It’s the backbone behind every case study here.

Share Project :

  • Share Project :