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: people management, design direction, design operations, and hands-on systems work. I partner with product managers, engineering managers, and product leadership.
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.
“Waiting on design” is no longer something we hear. Designers moved from reactive product partners to proactive design leaders, driving architectural changes like the tables and global navigation redesigns, and review prep dropped from about an hour to about ten minutes.
A senior team shouldn't require a manager in every decision.
The feedback kept coming from engineering and product: “we’re waiting on design.” It got louder as the engineering team grew and adopted AI. We were launching faster, with less design confidence and more pressure on the team, and we were stretched thin trying to be in more places at once.
The real problem wasn’t design capacity. We were spending our time on tedious, tactical work, and we had no repeatable structure for raising the bar on strategic work or for helping others make good design decisions. Not every outcome needed a 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 or to be a decision gatekeeper; it was to create enough structure and context that designers could 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
Senior designers engaging earlier, driving alignment, and operating with greater autonomy.
Designers have led architectural changes, including the tables and global navigation redesigns.
Better judgment
More informed critique, intentional validation, and more attention to shared patterns.
Mobile app architecture is now scaled strategically instead of by hunch, with shorter time to launch and more effective launches.
Less coordination overhead
AI and lightweight operations make context, feedback, and cross-team awareness easier to maintain.
Review prep 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 needed room to own their work, while the team still needed visibility into shared patterns, conflicting initiatives, upcoming needs, and chances to collaborate.
I introduced Design Triage: a space to align on our shared work and pull in design system and architecture 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 when useful. Documented decisions and shared notes.
Open design channel
Broader access to the design team and to feedback. Quicker ideas into tickets.
1. Designers gained room to drive bigger architectural changes in support of the product roadmap, including the tables and global navigation redesigns.
2. I gained earlier 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 several senior designers across simultaneous initiatives created an unexpected constraint: useful feedback required reconstructing a lot of context before every review.
So I built a review-prep workflow. Give it a project name, it gathers recent context across Slack, Drive, and Figma and structures it around the questions I need answered before a critique.
prep
1. Faster context and fewer basic questions, so reviews go straight to better feedback. 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.
Risk scoring, a library of validation methods—heuristic review, analytics, live in-product validation, surveys, interviews, usability testing—discussion in Design Triage, and an AI-supported analysis tool open to the broader org.
Rather than enforce one "design process," I wanted designers to share a framework for deciding how much evidence a decision required.
Mobile app architecture decisions are now made strategically rather than by hunch, which has shortened time to launch and made launches more effective.
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 three designers and created a career growth framework and leveling rubric for the design team.
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
PM-designer-EM collaboration serves us better instead of creating another designer-maintained artifact.
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. It's about building systems that make my involvement less necessary.
Clear ownership creates autonomy. Shared frameworks distribute judgment. AI reduces the cost of context. And good design architecture lets individual decisions compound into something larger.
My role increasingly became finding where the team was losing leverage and designing the conditions that let talented designers do better work without waiting for me.
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.