One to Four:
Building the Team
I grew design from one person into a team of four — and built everything around it from zero: Confluence documentation, a design skills repository, review rituals, onboarding, and the operating model that keeps us aligned across multiple product streams.
The starting point
When I joined, design was me — one person covering research, UI, and delivery across every product area, with no shared documentation, no design space, and no team rituals. Scaling meant hiring thoughtfully and building the infrastructure that would let a team stay consistent without me holding all the context.
How I lead
Beyond hiring, my role spans multi-product leadership, design operations, and strategic contribution — keeping design aligned with product and engineering while the team grows into more independent contributors.
Multi-product leadership. I manage design across multiple concurrent product streams, ensuring alignment between design, product, and engineering on priorities and quality.
Design operations. I set up and maintain scalable processes — design review rituals, documentation practices, dev handoff checklists, and retros — so the team stays consistent and efficient as we scale.
Mentorship & team development. I mentor junior designers into more independent contributors and improve how design collaborates with cross-functional partners.
Design system ownership. I lead the evolution of our shared design library — automation rules, copy guidelines, and patterns that improve reusability and speed up handoffs.
Strategic contributor. I work closely with leadership on OKRs, roadmap alignment, and impact tracking — manually managing KPI data where tooling is still limited.
User-first mindset. I've increased the frequency and structure of research activities and feedback loops so design decisions stay grounded in real user needs.
AI discovery & adoption. I drive how AI fits into the design workflow — exploring Figma Make, Markdown specs for Lovable, Cursor-to-Figma integration, and other tools that extend what the team can ship.
What we built
from zero
Starting with nothing, I built the design team's operating layer — documentation, rituals, and guidelines that let four people work across products without losing consistency.
A full Confluence space. An entire documentation hub — design principles, rules and guidelines, dev handoff checklists, and a Design Task Scoping & Estimation Guide — so onboarding and day-to-day work don't depend on tribal knowledge.
A design team repository for skills and assets. Versioned alongside product work — components, patterns, and agent-ready skills that keep design and engineering in sync.
Weekly alignment and design reviews. Standing sessions to walk through work in progress, review common topics, unblock decisions early, and keep quality consistent across designers.
From sprints to OKRs. We started with sprint-based delivery and recently shifted to an OKR approach — tracking outcomes alongside project work, not just ticket velocity.
Internal impact tracking. Where tooling was limited, we tracked metrics manually — resolved frontend requests, percentage of discovery tickets with design involvement, and other signals of design's reach across the org.
Onboarding and 1:1s. Structured onboarding for new team members plus regular 1:1s for feedback, career growth, and catching friction before it compounds.
Learnings
Build the infrastructure before you need it. Confluence, checklists, and a skills repo felt like overhead early on — but they're what let the team scale without me as a bottleneck.
Operating models evolve. Sprints worked while we were finding our rhythm; OKRs fit better once we needed to tie design work to company-level outcomes.
Measure what you can, even manually. Tracking discovery involvement and frontend resolution rates gave us language to show design's impact where dashboards didn't exist yet.
AI is a team capability, not a solo experiment. Exploring Figma Make, Lovable workflows, and Cursor integration as a team — not just as personal tooling — is how adoption actually sticks.
A team of four — me as lead, two senior product designers, and a working student — running across multiple product streams on shared documentation, weekly reviews, OKRs, and a design ops layer we built from scratch.