Skip to content
gmartinezgmartinez

Uptempo GmbH

Turning a Request for “Approval Workflows” into a Governance Engine

Uptempo is a B2B SaaS platform for enterprise financial marketing operations, used by global brands like Porsche, Estée Lauder, Amazon, and IKEA.

I led end-to-end product strategy and definition, turning an ambiguous client mandate into a validated governance engine, and aligned Product, Design, and executive stakeholders around it.

Senior Product & UX Designer · PO responsibilities6 months · 202614 people · cross-functional
  1. 1Problem

    Three Tier-1 clients asked for “approval workflows” with no specification — and a hundred other clients would inherit whatever we built.

  2. 2Approach

    AI-assisted discovery, early co-creation with PMs and designers, and a decoupled engine where complexity is opt-in.

  3. 3Result

    One platform product instead of three custom builds: an audit-ready MVP shipped to pilot clients.

3→1custom builds into one platform product
100+clients the engine was built to serve
3 mofrom scope to pilot MVP
Project details Role · Team · Core challenge · Scope · Skills
Role
Senior Product & UX Designer (with cross-functional PO responsibilities)
Cross-functional reach
3 Product Managers, 4 Product Designers (incl. myself), 6 Developers, 1 Product Lead, and Management stakeholders
Core challenge
Satisfy the most demanding Tier-1 accounts without over-complicating the platform for everyone else.
Scope
A centralized approval workflow system spanning the marketing operations modules
Skills
End-to-End Design Ownership, Leadership & Stakeholder Alignment, Pragmatic MVP Scoping, AI-Powered Product Discovery, Systems Architecture, Cross-Functional Co-Design
Back to top

Section 1 · The Problem

A Requirement Without a Definition

The brief was a feature name. Defining the problem became my first job.

Three Tier-1 accounts, each a household name in its industry, demanded centralized financial governance, which reached us as a single, ambiguous mandate: "Uptempo needs approval workflows."

The Problem: We had no formal specifications, user stories, or defined scope. All we had was a static conceptual model from one client and a feature name. Three demanding clients needed it, and a hundred more would inherit whatever we built.

The client's raw approval-workflow model, provided as the only starting reference

Client’s starting modelThe only input we had: one client’s static concept.

Organizational Alignment: I started by facilitating initial discovery workshops to align Product Managers, establish a unified definition of enterprise governance, and evaluate technical feasibility.

Workshop output mapping the budget/activity lifecycle and how it translates into Uptempo

Lifecycle workshopMapping the workflow against a marketing activity's lifecycle.

Section 2 · Validation

Prototyping: Proposing and Validating Logic

With no requirements to wait for, I built a rough prototype for clients to react to.

Rather than waiting on nonexistent requirements, I built a baseline prototype for clients to react to. While the initial logic was rough and full of gaps, it successfully communicated the core system mechanics, and our Tier-1 clients enthusiastically validated the foundational approach.

Section 3 · Discovery

From Raw Demands to Platform Strategy

Mid-sized clients needed governance, just not Tier-1 overhead.

With client availability for follow-up interviews weeks away and sparse Tier-1 data, I led an AI-accelerated Design Thinking discovery sprint to close the gap and keep momentum. By synthesizing industry and internal domain expertise across Product, Customer Success, and Services, I mapped complex edge cases, approver hierarchies, and threshold rules.

Reviewing our discovery models with my Financial Management counterpart revealed a stark contrast: mid-sized clients desperately needed governance, but without the Tier-1 overhead.

AI-driven discovery

Sparring with AI, validating against the source of truth.

AI was used as an accelerator, not an oracle. Every output was strictly cross-referenced against actual client data and internal knowledge before earning a place in the solution.

  1. Input

    Discovery data

    CS, PS & PM feedback

  2. AI

    Synthesize

    Patterns and edge cases from the raw feedback

  3. Gate 1 · Me

    Source of truth

    I validate and lock the synthesis

    Claude Projects · NotebookLM

  4. AI

    Design Thinking

    Empathize → Frame → Ideate

  5. Gate 2 · Me

    Focus & features

    I turn ideas into functional features

  6. AI

    Layered builds

    One structured prompt per feature

    Claude · Figma Make

Discovery Artefacts

This accelerated synthesis translated scattered data into actionable system logic:

Discovery boardsRaw AI research, captured and clustered, with AI’s help, into pain points, empathy quotes and solution goals before any of it was trusted.

Personas & empathy mapsGrounded our permission model and visibility hierarchy, uncovering the specific operational friction behind each role slowing down sign-offs.

User journey mapRevealed hidden cross-departmental handoffs and human bottlenecks that static roles missed, directly dictating our delegation rules and escalation logic.

With the actors, journeys, and segment requirements locked, we transitioned from discovery into drafting the foundational system architecture.

First workflow modelThe first end-to-end model of the approval logic, covering templates, thresholds, approvers and steps, mapped before a single screen was designed.

Section 4 · Alignment

Aligning People Before Aligning Systems

Governance touches every module, so every owner had to help build it.

PMs had to accept changes to their domains, designers had to converge on a unified model, and engineering needed to trust the architecture. I drove this alignment through three principles:

  1. Co-Creation

    People defend what they help build.

    I integrated PMs and designers into early discovery rather than pitching final solutions.

  2. Tangible Vision

    Something concrete to debate.

    Models and prototypes got stakeholders to agreement faster than theory.

  3. Speaking the Audience's Language

    Every audience hears its own case.

    Edge-case coverage for Customer Success, roadmap discipline for PMs, business value for Executives.

Section 5 · Architecture

One Engine, Not One per Module

One central engine instead of approval logic rebuilt inside every module.

Hardcoding approval logic into individual product modules meant we would have to rebuild it every time a new governance need arose. To prevent this technical debt, I architected a decoupled, centralized engine where administrators could configure custom workflows globally.

System flow chart mapping the decoupled governance engine's objects, attributes, and operations

System flow chartBy mapping the core objects, attributes, and operations first, we made the underlying system structure visible—aligning Engineering and Product before moving into Figma.

Section 6 · Vision

The Full Vision: Designing for Scale

Requests backed by evidence, audit-ready review, and no-code configuration.

We needed to build an MVP without trapping ourselves in a corner. To ensure our early decisions didn't quietly limit the product's future, we designed a 6-to-9-month development roadmap.

Submitting and Reviewing a Request

Campaign managers submit approval requests directly within their planning activities, attaching contextual evidence rather than isolated numbers. These automatically route to a role-based inbox, giving reviewers instant, end-to-end visibility for fast sign-off.

Built-In Compliance and Audit Safeguards

When managing hundreds of requests a month, governance shifts from individual approvals to proving the system held up over time. We introduced filters, delegation rules, and an immutable history to ensure bulletproof auditability.

120+ Screens & Pragmatic AI Execution

120+screen states

I architected and designed the entire UI ecosystem across complex business logic. When the project outgrew its timeline, AI sped up the workflow around it.

  1. Early ideation — AI leads: AI accelerated early ideation.
  2. Complexity exposed — AI limited: Deep contextual complexity exposed its limits—frequently generating invalid business flows.
  3. Mapped by hand — Me by hand: Senior judgment meant knowing when to turn AI off: manually mapping complex system logic and edge cases by hand.
  4. Micro-iterations — AI assists: I re-engaged with AI only for rapid micro-iterations once the underlying architecture was solid.
  1. AI · leads

    Early ideation

    AI accelerated early ideation.

  2. AI · limited

    Complexity exposed

    Deep contextual complexity exposed its limits—frequently generating invalid business flows.

  3. Me · by hand

    Mapped by hand

    Senior judgment meant knowing when to turn AI off: manually mapping complex system logic and edge cases by hand.

  4. AI · assists

    Micro-iterations

    I re-engaged with AI only for rapid micro-iterations once the underlying architecture was solid.

Configuring Processes and Thresholds

I designed a no-code configuration flow where each process links a financial threshold to specific approval steps, allowing admins to configure both the trigger amount and the form fields each step requires.

Section 7 · Pivot

The Pivot: When Scale Broke the Design

Real-world scale broke the first design, so I rebuilt its core into reusable parts.

Enterprise buyers validated this initial design, and early feedback was overwhelmingly positive—until it hit real-world operational chaos.

Approvals scaled into the hundreds, breaking our process-centered architecture. A single organizational change could force admins to manually update dozens of processes.

The Fix: Decoupling Processes into Templates

To solve the scaling issue, I decoupled the workflow engine into a modular, object-based architecture. We broke the system down into three reusable building blocks:

Reusable Templates: We replaced static, hardcoded workflows with flexible templates mapped directly to the client's Uptempo financial hierarchy (Budgets, Cost Centers, and Marketing Activities).

Independent Threshold Entities: We reengineered threshold rules into standalone governance objects, allowing admins to dynamically map multiple approval flows to them.

Section 8 · Shipped

What Shipped: The Three-Month MVP

Three months, one pilot: what we cut, what we deferred, and what we refused to cut.

Shipping an enterprise MVP in three months required aggressive scope discipline. To validate the platform with pilot clients without delaying launch, we consciously deferred non-critical capabilities—using temporary third-party integrations (via Workato) for complex threshold rules until native functionality was built in Phase 3.

Streamlined Submission

A minimal application form capturing only the core business case and deadline, with a manual approver selection fallback if no flow applied.

Essential Inbox

A targeted version of our full inbox vision, focused strictly on high-signal attributes (deadlines and request types) while deferring complex domain-scoping filters.

Approval and Audit-Ready Core Logic

Solved complex edge cases—like multi-quarter approvals—while keeping critical compliance safeguards intact for pilot validation.

Section 9 · Impact

Business Impact & Outcomes

Validating a product isn’t proving three clients want it. It’s proving a hundred others can live with what those three asked for.

  • Market & Commercial Signal

    Validated with three Tier-1 global brands

    Turned governance into a deciding pipeline capability for prospective enterprise accounts, contingent on it becoming operational.

    How

    Tested concrete approval logic directly with Tier-1 accounts while establishing a 6–9 month vision alongside MVP scope.

  • Product Sustainability

    One platform product, not three custom builds

    Eliminated parallel maintenance tracks and long-term technical debt.

    How

    Reframed bespoke Tier-1 requests into a progressively configurable engine where complexity is opt-in.

  • Architectural Feasibility

    Extends to new modules without rebuilding the backend

    Proved feasibility within platform constraints.

    How

    Architected a decoupled governance engine. Modeled objects, attributes, and operations cross-functionally instead of hardcoding logic into modules.

  • Cross-Functional Alignment

    Domain resistance turned into shared ownership

    Aligned cross-functional teams behind an unmapped platform initiative.

    How

    Integrated PMs, designers, and executives early through tangible system models translated to each function's goals.

  • Delivery & Production Scale

    An audit-ready MVP shipped to pilot clients

    Ready for real-world operational testing.

    How

    Designed 120+ screen state variations, covering delegation, escalation, and immutable audit trails.

Reflection

What I’d carry into the next platform

Three lessons that outlived the project.

  1. Earn the problem before designing the answer.

    When handed a feature name instead of a problem statement, the instinct is to jump straight into design—which is a mistake. Investing upfront time to understand why three enterprise accounts wanted governance, and what 100+ standard clients could absorb, yielded an architecture that held up over time.

  2. Design Thinking earns the definition, not just ideas.

    Design Thinking isn't just a solution-generation exercise; it is a mechanism for earning an accurate problem definition. The decoupled engine was simply the only architectural model that survived our mapped constraints once the problem was truly understood.

  3. Alignment is part of the design, not after it.

    End-to-end leadership means building the business case and treating stakeholder alignment as an architectural discipline—not an administrative afterthought.

Related Work