From Two Months to Two Weeks

How mapping a broken workflow led to a fintech platform that scaled across 10+ clients

There's a kind of engineering work that looks, from the outside, like building software. But when you pull the thread, what you find is something older and simpler: someone needed to understand a process before it could be fixed.

The platform I designed and built at Signicat started exactly there — not with a tech stack decision, not with a feature list, but with the uncomfortable realization that the two months it took to deliver a new fintech client onboarding flow had almost nothing to do with technical difficulty.

The Problem Was Invisible

Signicat operates in identity verification and bank-grade authentication. Their clients — financial institutions, lenders, insurers — need custom onboarding flows for end users: identity checks, document verification, biometric matching, account creation, loan application intake. Each client has different regulatory requirements, different brands, different backend systems, different tolerances for friction in the user journey.

The old approach treated every project as a new project. Discovery, design, architecture, implementation, integration testing, UAT, launch. Repeat. The average delivery time was around eight weeks from first technical brief to production readiness.

Eight weeks sounds reasonable until you account for what those eight weeks actually contained. Not eight weeks of sustained engineering. Eight weeks of coordination overhead, repeated context-switching, tribal knowledge locked in individual heads, undocumented assumptions about how API X behaves when combined with service Y, and a delivery pipeline that had never been formally described — only practiced.

Nobody had drawn a map. There was just the territory, and people who knew parts of it.

Naming Things Correctly Is the Work

The diagnosis was a vocabulary problem, not a capacity problem. Every client project was being treated as novel because nobody had named the things that were the same across all of them.

What I built — before any code — was a grammar.

ConfigurationID was the data layer holding all configurations over the whole platfom for each project. Scenarios let us build end user flows very quickly from a set of reusable, themable pages with set of special ones also holding integrations to external platforms and APIs.

The system is organized around three concepts: **scenarios**, **configuration identifiers**, and a three-tier component model. A scenario is a named, composable unit: a specific flow type, with defined steps, edge cases, language rules, and API behaviors. A configuration identifier is the key that resolves which scenario applies for a given client context, loading the right theme, the right language, the right step sequence, the right SDK integrations. The component model separates elements that are universal (shared across every deployment), platform-level (shared across clients but configurable), and client-specific (custom per engagement). Once the vocabulary existed, the delivery process became the exercise of populating a known structure — not reinventing it.

Once the vocabulary existed, the delivery process became the exercise of populating a known structure — not reinventing it.

CONFIGURATION ID

The unique fingerprint of a business state. Instead of deploying code, we deploy state identifiers that reconstruct the UI and logic in real-time.

SCENARIO

A defined path through the system logic. Scenarios allow for multi-variant testing without branching the main code repository.

LANGUAGE

A domain-specific syntax that non-technical stakeholders use to define validation rules, making the business "self-documenting."

The system doesn't hard-code flows — it reads them. Named, typed scenarios cover the main categories of identity and payment journeys the platform supports. Changing a client's flow means changing the scenario definition, not the codebase.

A Language setting controls two things that look like one thing: the UI language of the interface itself, and the language configuration passed into the SDKs used within the flow — because a biometric SDK and a bank authentication SDK each have their own i18n layer, and they need to stay synchronized.

At runtime, the system is simple to trace: query parameters carry the Configuration ID into the platform API, which resolves the full context — scenario, campaign, configuration — and returns it to the web app. Simultaneously, the client's own SDKs and API integrations initialize in parallel, using the resolved configuration as their setup parameters. The web app renders the result. The client never touches the platform internals; they configure, and the platform executes.

Platforms communication layer at glance

The Platform in Practice

Understanding the vocabulary made the engineering decisions obvious.

The component architecture sorted itself into three categories based on integration depth, not visual complexity. Universal Generic Components are API-agnostic and fully portable — a country select, a document upload input, a table. Pure interface, no opinions about data. Platform Components are pre-wired to the platform's services — the video identity verification module, the bank authentication flow, the consent capture widget. Built once, deployed across every client that needs them. Business Components are client-specific hybrids: they use the platform's primitives but integrate with a particular client's backend systems in ways that don't generalize. They live in the client's own repository and can inherit from Universal Generic Components, or eject and rewrite if their needs diverge.

STRUCTURE
TRI-LAYER COMPONENT ARCHITECTURE

01

UNIVERSAL GENERIC

Pure primitives. Buttons, inputs, and layout grids with zero awareness of business context. The atoms of the design system.

02

PLATFORM

The connective tissue. These components handle data fetching and state synchronization but remain agnostic to specific products.

03

BUSINESS

The facade. Components injected with specific domain logic, e.g., "KYC_ADDRESS_VERIFIER". Highly specialized and immutable.

The deployment model matched the configuration model. Each client gets their own repository and CI/CD pipeline, with staging and production environments on automatically provisioned subdomains. Every pull request spins up a preview deployment — a live URL — so client reviews happen against the actual running implementation, not a static mockup. Semantic versioning runs through the whole stack: component libraries, scenario configs, deployments. You can look at any running flow and identify exactly which version of each component is serving it.

The onboarding pipeline for a new client changed character entirely. The feature design phase became a structured conversation: define the pages needed, define the API integrations required for each page, set up the Configuration ID, provision domains and deployment. The engineering work that followed was scoped and predictable because the vocabulary was defined before the first line of code was written. Parallel tracks — API integration, theme creation, feature implementation — could run concurrently because their interfaces were known in advance.

Average delivery from brief to production: two weeks. Across more than ten clients at varied scale.

COMPRESSION
OF TIME.

LEGACY CYCLE

8.5 Weeks

INQ FRAMEWORK

1.2 Weeks

Why That Number Is the Wrong Thing to Focus On

The two-month-to-two-week compression is real, but stating it as the achievement misses what actually happened. Delivery speed was a symptom. The cause was something more fundamental: the work had been formally described.

When you have a vocabulary for what you're building, you gain the ability to reason about it. You can see which parts repeat and which parts vary. You can build for the pattern, not the instance. You can tell a new team member exactly what a scenario is, what a Configuration ID contains, what the difference is between a Platform Component and a Business Component — and they can contribute without first spending weeks absorbing undocumented tribal knowledge. You can, critically, tell a client what their custom requirements actually cost in terms of deviation from the standard model.

None of this required exotic technology. The stack — React, GitHub Actions, AWS CloudFront, S3, Terraform for infrastructure automation — is standard. The insight was structural.

The scenario-as-config model is structurally
identical to the kind of thinking that makes
prompt engineering effective. You define the
grammar. The system produces the instances.

The Continuity

It would be easy to read this as a story about a past achievement made less relevant by the arrival of AI tooling. If you can prototype a fintech onboarding flow in a weekend with Claude, what did all that architectural thinking buy you?

I'd argue the opposite. What I was doing — identifying the repeating units inside apparently varied work, separating the logic of what needs to happen from the labor of making it happen each time, building systems that execute from configuration rather than requiring full reimplementation — is exactly the move that makes AI tooling powerful. The scenario-as-config model is structurally identical to the kind of thinking that makes prompt engineering effective. You define the grammar. The system produces the instances.

The difference is that in 2024, the system that executes the grammar is an LLM, and the configuration is a prompt, and the cycle from definition to working output is measured in seconds instead of days. The underlying principle — separate what from how, build for the pattern, let the execution layer handle the instances — is the same.

This is why INQ Tech exists. Not because I know how to implement things, but because I've spent enough time watching systems fail at the vocabulary level to know that naming things correctly is almost always the leverage point. The tools change. That problem doesn't.