Process
I operate as a strategic product force.
Not executing briefs. Influencing roadmap. Designing systems that scale. Shipping outcomes that move business metrics. The interfaces you see are final artifacts of strategy, alignment, and systems thinking.
Strategy shapes product, not the other way around
Before any interface exists, clarity on user problem, business model, and success metrics. Design serves strategy, never competes with it.
Systems thinking beats component thinking
Real constraints: technical debt, org structure, stakeholder incentives, market timing. Optimize for those first. The screen is the final artifact of all upstream decisions.
Tradeoffs are where leadership happens
Every choice excludes something else. Speed vs. robustness. Depth vs. breadth. Naming tradeoffs explicitly is how you prevent misalignment down the line.
Agentic systems need trust architecture, not just task flows
When AI acts on a user's behalf, the design problems are transparency, control, and failure recovery. Every agent action must be visible, and where stakes are high, approved.
Diagnose
Most briefs describe a symptom. Find the disease.
The stated problem is almost never the real problem. Before any direction, I map the actual system: stakeholder incentives, technical debt, business model constraints, team capacity. Where does the problem live? Who owns it? What breaks if we touch it?
Most product failures trace back to a wrong diagnosis, not a wrong solution. Getting the problem right costs almost nothing. Building the wrong thing costs a quarter.
Spend more time on the problem than you think you need to.
Align
Unresolved tradeoffs become someone else's emergency later.
Before any design work, I get stakeholders on the same page about what we are actually optimizing for. Speed vs. completeness. User delight vs. operational cost. Short-term feature vs. long-term platform. These conversations are uncomfortable. They are also far cheaper than discovering the disagreement during a launch review.
Alignment is not a soft skill. It is how you prevent rework. I document decisions, name the tradeoffs explicitly, and make sure everyone is building toward the same definition of done.
The most expensive design work is the kind that gets thrown out.
Structure
Model the system before opening Figma.
Object models, state machines, data flows, decision trees. What are the actual entities? How do they change? What rules govern transitions? For AI products, add agent decision points, confidence thresholds, and intervention surfaces. This architecture is the real design. The screens are just how it becomes visible.
Jumping to UI before this is resolved produces interfaces that fight their own system. Structure first means every visual decision has a constraint behind it, not just a preference.
Systems scale. Component collections don't.
Explore
Cheap tests protect expensive builds.
Once structure is clear, speed matters. Rough flows, throwaway prototypes, scrappy sessions. Surface what breaks before you've committed to polish. AI tools when they accelerate; paper when it forces precision.
A rough solution that gets tested teaches more than a polished one that doesn't. Ship incomplete if it generates signal. Iteration is a strategy, not an admission of uncertainty.
Fast feedback loops compress the cost of being wrong.
Execute
Design is specification, not decoration.
Screens, flows, interactions. Every choice in hierarchy, motion, and type tells the user what matters and what to do. When that communication works, the design disappears into the experience. That disappearance is the goal.
Build the system as you go. Name components with operational precision. Document intent, not just appearance. Handoff that requires a follow-up call is incomplete work.
If it needs explanation in a Loom, it is not finished.
Measure
Define what success looks like before shipping, not after.
Adoption rate, time-to-value, support ticket reduction, revenue per user. Design decisions influence these directly. If you cannot connect a design choice to a metric, it may not be the priority.
Pressure-test before full launch. Edge cases, error states, load conditions, the users who fail first. Then measure what actually happens in production. That data feeds the next cycle.
Shipped and unmeasured is not done.
What actually matters
This framework evolves with every project. The constants are alignment, clarity, and measurable outcomes. Everything else is tactical.
The teams I work with know the tradeoffs we made and why. They can make decisions without me. That is the only metric of success that matters.