Scaling design judgment, not just design output
Evolving a senior product design team from reactive execution toward an autonomous, strategic function.
Tive is a global supply chain visibility platform, growing rapidly as a Series C company.
Enterprise software spanning web, native mobile, and connected hardware, while the engineering team was growing quickly and adopting AI.
Product Design Manager and player-coach, partnering with product managers, engineering managers, and the leadership team.
Product and engineering were increasingly “waiting on design.” A stretched senior team needed a repeatable way to focus on strategic work and let others make good design decisions.
A lightweight operating model for visibility and ownership, an AI-assisted review-prep workflow, and a risk-based framework for how much evidence each decision needs.
We rarely hear “waiting on design” anymore. Designers moved from reactive product partners to proactive design leaders, driving architectural changes like tables and global navigation redesigns, and design review moved from UI critique and context sharing to systemic change and architecture evaluation.
“We're waiting on design.” No, you're waiting on design mocks.
That feedback got louder as the engineering team grew and adopted AI to speed through code. We were launching faster, with less design confidence and more pressure on the team, and we were stretched thin trying to do it all.
We were spending our time on tedious, tactical work, and we had no repeatable framework for big-rock design work or for consistently designing at a high level. Engineers had come to expect every flow and edge-case to have a high-fidelity Figma mock.
We needed to be less reactive and more proactive to keep a high bar for UX while reducing design debt.
The goal wasn't to add process for process’s sake or to be a decision gatekeeper; it was to create enough structure and context that designers could consistently operate more independently while raising the quality and consistency of the work.
The question became: how do I scale design judgment without becoming the bottleneck?
What changed
More ownership
Designers engaging earlier, driving alignment, and operating with greater autonomy.
Designers lead large architectural changes freely and with clearer direction.
Better judgment
More informed critique, intentional validation, and more attention to shared patterns.
Mobile app architecture is now scaled strategically instead of by hunch. Time to launch decreased noticeably and launches are of a higher quality, resulting in fewer “fast-follows.”
Less coordination overhead
AI and lightweight operations make context, feedback, and cross-team awareness easier to maintain.
By my own timing, prepping for design critique dropped from about an hour to about ten minutes across roughly 20 reviews.
“Design is finally involved in product roadmap discussions and it’s a great thing!”Senior product designer
Three places where better systems created leverage.
Autonomy requires visibility, not more approval gates.
Designers were spending long hours on mocks when what we needed was bigger, systemic changes.
In addition to other forums for design alignment, I introduced Design Triage: a dedicated space to align on our shared work and pull in design system and architectural big-rocks alongside our feature work.
Design Triage
Weekly visibility into upcoming work, conflicts, risks, and opportunities.
Async coordination
Less meeting overhead; better awareness of related work, AI-assistance where beneficial.
Design Jam
Earlier collaboration, including PMs. Documented decisions and shared notes.
Product-design-at-Tive Slack Channel
Quicker ideas from anyone into tickets.
1. Designers can now drive bigger architectural changes in support of the product roadmap.
2. I now had visibility into the decisions where my involvement had the most impact.
AI helped me spend less time reconstructing context and more time challenging the work.
Managing senior designers across many simultaneous initiatives created a problem: high quality feedback required gathering a lot of context before every review.
So I built a review-prep workflow in Claude. Give it a project name, it gathers recent context across Slack, Google Drive, and Figma and structures it around the questions I need answered before a critique.
In a few minutes I can see the problem statement, the decisions made during exploration, the tradeoffs and engineering input, and the open questions. It’s like sitting in the planning meetings for every major project. I stop asking designers to replay all of the decisions made, and spend critique on strategy (“Did you consider the work designer B is doing on product X?” “What persona are you targeting with option C?”) instead of pixel-level feedback.
review prep
1. Faster context and fewer basic questions, so reviews go straight to better feedback. By my own timing, prep dropped from about an hour to about ten minutes across roughly 20 reviews.
2. AI didn't replace design judgment. It created more room for it.
Not every design problem deserves the same process.
Four parts that work together.
- Risk scoring: Rate each decision by impact and uncertainty.
- Validation library: Pick the right method, from heuristic review and analytics to live in-product validation, surveys, interviews, and usability testing.
- Design Triage: Talk through risk calls as a team.
- AI analysis tool: Open to the broader org, not just designers.
App architecture decisions are now made strategically rather than by hunch. Time to launch dropped from two or more sprints to one for many initiatives, and launches are higher quality.
A system only works if the designers grow with it.
Bigger scope
One designer led the tables redesign end to end, including PM and engineering alignment. They took ownership of systems work beyond a typical product scope and made systemic architectural changes inside product feature work.
How I coach
Senior designers need space to do their best work. I meet with them 1:1 every week, focus on growing systems-level and holistic solutions over granular pixel-pushing, and keep improving our shared processes so designers can spend their time on the most valuable work.
Hiring and growth
I hired versatile, senior designers and created individual growth frameworks and a design team leveling rubric.
Scaling also meant knowing when to remove process.
Design Brief v1
A running artifact meant to preserve design goals and decisions throughout an initiative.
- Hard to maintain
- Poor discoverability
- Didn't solve a big enough problem
- Added process when it wasn't needed
Closer PM-designer-EM collaboration and project-specific shared documents served us better.
The manager shouldn't be the system.
The biggest shift in my management approach was realizing that scaling a senior team isn't about getting better at keeping track of everything, everywhere. It's about building systems that empower the team to do their most valuable work.
Clear ownership creates autonomy. Shared frameworks build consistency and free up valuable time. AI reduces the cost of context. And good design architecture lets individual decisions compound into something larger.
Some design problems shouldn't be solved one feature at a time.
We kept displaying the same underlying product objects in very different contexts. Solving each instance independently created inconsistency and lengthy, repeated design work.
So we defined each core object once—with shared hierarchy and interaction rules—and let context set the density. Carrier and Driver were the first to be trialed in Pickup Verification and Commodities work.
Explore the five-level object framework
A lightweight reference, anywhere space is tight
Click or tap opens the object at Level 2. No status or metadata—identity only.
Identity plus one glance of status
The default row in a list. Same anatomy everywhere: type icon, name, meta line, status, disclosure. Only the icon, accent, and meta text change per object type.
Inline detail without leaving the page
The form-step and accordion state. Only the fields and actions that matter in context—carrier compliance in a shipment form, say. Everything else waits for Level 4 or 5.
Committed inspection of one object
The user chose to focus. Tabs, related shipments, and primary actions arrive, without navigating away from the task.
The object as a first-class page
Its own address, tabs, and everything related to it. Origin and destination stay Level 1 chips even here—one system, nested inside itself.
Preferred for temperature-sensitive lanes into the Northeast. Requires 24hr appointment scheduling at Boston dock.
Same underlying object. Shared interaction and hierarchy rules. Different information density based on context.
The same objects behave predictably everywhere.
Designers stop reinventing common presentation problems.
New objects inherit an established framework.
Library audits against the codebase
Audited Figma libraries against code; pushed for foundations and components as separate published files, variable names that match code tokens literally, and Code Connect to close the interpretation gap.
A boundary for the platform
Sorted features into Configure / Monitor / Act / Investigate. Configuration lives on web; lightweight action lives on mobile — a rule for what to standardize and what to differentiate.
AI-assisted audits & handoff
A reusable AI workflow for auditing component libraries and generating developer handoff documentation — making the system cheaper to keep honest.