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.
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 pointRopes & 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 buildGoldman 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.
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 Manifestoused often
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
SME knowledge transfer, journey mapping, competitive analysis.
Analyze
Findings & recommendations, shared back.
Ideate
Workshops when ambiguous; an IC delivers options when clear.
Ideate
Converge with partners — engineers in the room.
Prototype
Build the prototype and flows.
Test
Usability research (generative can run earlier).
Design
Iterate on feedback to final.
Handoff
Redlines & specs for the build.
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.
A week or two to recruit users; generative earlier, usability at week 6.
Engineers at ideation — kills feasibility churn.
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.
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
- Design delivery only
S
Small enhancement
- Concept
- Feedback
- Final design
M
New feature
- Ideation
- Concept
- Feedback iteration
- Final design
L
New experience
- Discovery
- Ideation
- Concept & socialization
- Final design
XL
New experience with risk / uncertainty
- Discovery
- Ideation
- Concept
- Research
- Socialization
- Final design
XXL
Large phased project — MVP + phases
- 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.
More unknown → more discovery/research; but I’ll push back when a simple enhancement needs no full study or sprint workshop.
A baseline + usability test can add 2–3 weeks — I lead with the rationale.
Sizing only lands the milestones if partners bring the work early enough to scope.
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.
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.
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.”
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.
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.
- Team meeting — design review, learnings, team-building
- 1:1s with each direct
- Design-lead / product-lead sync
- 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:
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.
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.
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.
Poker planning with the developers, sizing every card on its own merits.
The points they truly deliver per sprint — real capacity, not a wish.
New team? We agree which cards fit one sprint and baseline from there.
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.
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.
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.
- Core flow + nav
- Overview v1
- Data dependency
- Secondary flows
- Notifications
- Content v1
- Integrations
- Consent dependency
- Controls
- Personalization
- Deeper content
- Cross-LOB ingress
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.
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.
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.
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.












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.





















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.
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.