Building a Governance Engine from Zero Requirements

Tier-1 enterprise clients like IBM, Dell, and Porsche required centralized financial governance, which reached Uptempo as a single vague demand: "the platform needs approval workflows." With zero specifications, user stories, or defined scope, and one raw model provided by a single client.

I started by facilitating a workshop to align Product Managers, define what an approval workflow meant for Uptempo, and assess its technical feasibility.

When requirements are absent, you don't wait for clarity — you manufacture something concrete for people to react to. Rather than asking clients what they wanted, we proposed a working logic and put it in front of their reality.

Though rough and full of gaps, the prototype successfully communicated the core logic to clients, who validated our foundational approach and responded with enthusiastic feedback.

Requirements from three Tier-1 clients lacked the depth to validate an enterprise solution, and more client interviews were weeks away; to maintain momentum, I led an AI-Accelerated discovery sprint, synthesizing all internal domain expertise across Product, Customer Success, and Services to secure buy-in.

To close the gap, I synthesized all insights using an AI-assisted Design Thinking sprint to accelerate the mapping of complex edge cases, approver hierarchies, and threshold rules against internal and external industry domain expertise.

The output volume was enormous. AI is an accelerator, not an oracle — every source had to be validated and cross-referenced against our clients' actual data and our internal knowledge before it earned a place in the solution.

Synthesizing feedback into defined roles established our permission and visibility hierarchy. Empathy mapping then exposed the friction behind each role—from campaign manager risk during stalled requests to the specific data approvers needed for confident sign-off.

Journey mapping revealed hidden cross-departmental handoffs and human bottlenecks that static roles missed. These friction points directly dictated the governance engine's touchpoints, delegation rules, and escalation logic.

I validated my AI-accelerated discovery with my Financial Management counterpart; cross-checking fresh feedback against our discovery showed that mid-sized clients needed approval workflows without Tier-1 overhead.

With the actors, journeys, and segment requirements established, we could draft the first approval workflow model—its logic, intersections, and touchpoints across the Uptempo platform. This is where discovery started producing structure.

I concluded the product had to be architected as a decoupled, administrative governance engine rather than approval logic hardcoded inside individual product modules. Anything module-specific would have to be rebuilt every time governance was needed somewhere new.

We didn't want to release only an MVP — development needed a roadmap and a picture of where the product was going over the following six to nine months, so MVP decisions wouldn't quietly foreclose the vision.

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

At the volume this inbox runs — hundreds of requests a month — governance stops being about a single approval and starts being about proving, later, that the process held. Filters, an immutable history, and delegation rules exist for that.

I designed a solution were each process is a flow: a threshold amount, and the approval steps required to clear it. Admins configure both — the trigger amount and the form fields each step requires — without touching code.

That structure delivered two capabilities directly:

Enterprise representatives validated the initial design, but real-world usage revealed a disconnect between buyer expectations and operational reality. Approvals ran into the hundreds, breaking our process-centered architecture. A single organizational change meant updating dozens of processes individually—proving that process-level configuration couldn't survive enterprise scale.

To solve this, I decoupled the workflow engine into a modular, object-based architecture. Rather than hardcoding isolated processes, we broke the system down into three reusable building blocks:

Processes as Reusable Templates: Shifted from static workflows to flexible templates mapped directly to the client's financial hierarchy—including Budgets, Cost Centers, and Marketing Activities.

Independent Threshold Entities: Reengineered threshold rules into standalone governance objects that administrators could dynamically map and add multiple approval flows.

With a functional MVP shipped to pilot clients for real-world testing and feedback, and the Approval Engine in active development, the response from clients was strongly positive — positive enough that others began requesting additional capabilities for future releases.

Compromises are part of any development cycle, and the administration area was no exception in this first iteration: third-party integrations via Workato held thresholds and comparable functionality in place until launch, scheduled for the third phase.

The application form includes only the business case description and the deadline set by the activity owner, who can also select the approver directly in the absence of approval flows.

This is the same inbox from the full vision, scoped to what clients actually needed in three months rather than everything the vision allowed. It compresses an activity's lifecycle and skips its approval steps, both held back for later stages; domain scoping and layered filtering waited too, because deadline and request type were what actually let an approver sort a queue — and clients weren't blocked without the rest.

We addressed edge cases — such as multi-quarter approvals — kept the Built-In Compliance and Audit Safeguards intact, and retained the key features needed for customer testing, with the understanding that the rest of the vision would follow in subsequent iterations.