Bank Review

Operating model · v1.2

mCards · Bank Review

The Product Assembly Line

How internally developed feature add-ons are designed, governed, and packaged so a sponsor bank or regulator can review a complete spec — not a demo in search of a story. Official backend build starts only after that approval.

16 September 2026 · This is a process specification, not legal advice. AI drafts; humans decide. Gate 1 is conditional bank approval of the package. Devin tokens start only after Gate 1.

1 · Why this line exists

Why this line exists

mCards builds add-on experiences on the core member and administrator platform — rewards, card controls, reporting, gifting, and similar programs. Those experiences touch customers, operators, partners, funds, and data. They cannot go to a sponsor bank as a slide deck and a hope.

The Product Assembly Line is the only path from idea to a package a bank compliance officer can open, interact with, and sign. Studio is the authoring system. Bank Review is the system of record for the finished package, the discussion, and the gates.

Nothing is “ready for the bank” until Design, Compliance, Architecture, and Marketing have each completed their station and the package is frozen. Nothing is ready for Devin until that frozen package has passed bank and regulatory review.

2 · What the line produces

What the line produces

Each product yields one bank- and regulatory-ready package:

  • Interactive prototypes for every party who uses the product, including empty, error, expired, cancel, and help states.
  • Product requirements: who the users are, what the feature does, what “done” means.
  • A compliance map of servicers, licensed partners, and the structure required so the experience is not built on an unapproved backend.
  • Backend architecture and APIs derived from the front end and from compliance’s constraints.
  • Marketing and communications, including the terms each user accepts, naming the providers and partners in the solution.
  • Funds-flow narrative: who holds title, control, and possession at each step.
  • The questions a bank or regulator would ask, already answered or explicitly unanswered. Unanswered items stay visible.
  • mCards Product and Compliance attestations that the package is ready for external review. Bank approval is later.

After bank and regulatory approval of that exact package, the line’s final output is a comprehensive Markdown backend specification. Once that file is approved, it automatically queues a Devin session to build Staging, UAT, and Production. Hardening then connects frontend and backend to the approved spec; QA automates tests against it in Devin.

01

Design

Product Owner, in Studio

Mapping the user experience and UI for all parties that interface directly with the product.

Design owns every interface a human uses to operate the feature: member applications (mobile and web), administrator and distributor consoles, and any other in-scope operator view.

The Product Owner opens Studio and describes the add-on. A voice design agent interviews them — one qualifying question at a time — until the experience is specified well enough to prototype: who the member is; happy, empty, error, expired, and help paths; who the administrator is (setup, funding, exceptions, reconciliation, shutdown); and what the UI claims so later stations can test those claims.

Studio builds a live prototype in a real iPhone viewport and a desktop browser. The Product Owner keeps talking until they mark Product Prototype Vn completed. Bank reviewers never see the live Studio session.

Design does not invent the ledger, the license, or the partner. It specifies the experience those things must serve.

ExitMember and admin (and any other in-scope) flows exist as interactive prototypes. Experience requirements are written. Prototypes use synthetic data only. The Product Owner has accepted the draft.

02

Compliance

mCards Compliance, with Legal as required

AI reviews the prototype first, flags compliance and regulatory issues, and drafts answers. Human Compliance then refines those drafts with the voice agent — before Architecture is built.

When the Product Owner marks the prototype complete, Compliance AI runs an initial review of every screen. It highlights flags a bank will raise and drafts proposed answers. Those drafts are labeled AI draft. They are not determinations.

Human Compliance (Legal as required) then sits with the voice agent and confirms, corrects, or marks items uncertain — consumer harm, disclosures and consent, title and control of funds, FBO/safeguarding, money-transmission characterization, data sharing, third parties, complaints, accessibility, and change triggers.

AI never records that a law applies as a final determination. Uncertain items stay in the package as gaps. Human time at this station is review and judgment, not a blank-page interview.

The output is permission and constraint: the box Architecture is allowed to build in. Compliance names the kind of license or structure required. It does not pick vendor names unless a human names them, and it does not write the APIs.

ExitHuman determinations on the bank-question matrix (AI drafts confirmed or replaced). Remaining gaps visible. mCards Compliance has approved that Architecture may proceed inside those constraints.

03

Architecture

Engineering / Architecture

Take Product and Compliance outputs, design the backend and APIs, and identify the key parties and licensed entities that must be connected — then send that architecture to a Human Architect to approve before Marketing and Legal.

Architecture AI receives two inputs: the screens, states, and events the UI will emit or consume; and Compliance’s constraint box. It drafts domain services, event and webhook contracts, ledgers, identity, idempotency, reconciliation, adapters, and the licensed parties the product must connect to (sponsor bank, processor, network, MTL/program manager, and similar roles). It does not invent a vendor name unless the spec already has one.

Each member and admin action is traced to an API, event, or posting. Funds movement must match the account titles and rails Compliance named. If the UX cannot be served without a new data use, vendor, or funds path, the product returns up the line.

The Human Architect reviews that draft with the voice agent and approves it. Marketing and Legal do not start until that approval.

ExitHuman Architect approval of backend, APIs, funds postings, and licensed-party map. Engineering can implement from this spec after Gate 1 without reverse-engineering the demo.

04

Marketing

Product Marketing and Legal

AI drafts marketing messaging and the legal T&Cs from the assembled product, compliance, and architecture. Marketing and Legal refine together so claims match the prototype, answer Compliance flags, and describe the architecture that was approved.

This station is Marketing and Legal, working the same draft. AI produces member benefits, admin capabilities, campaign copy, disclosure timing, and user terms that name the licensed parties Architecture listed.

Campaign and in-app claims must match what the prototype actually does — especially value, expiry, eligibility, and fees. A claim the UI does not support is a Design defect, not a copy tweak. T&Cs must not contradict an APPLIES determination or ignore an UNCERTAIN one.

ExitHuman Marketing and Legal approval of messaging and T&Cs. No claim that is false on an expired, error, or empty screen. Bundle may be assembled.

05 · Frozen package → bank and regulatory review

Frozen package → bank and regulatory review

When all four stations are complete, the system assembles a URL and a PDF broken into: UI/UX, Member benefits, Admin capabilities, Marketing, Legal, Compliance — plus Architecture and funds flow, because a bank cannot sign rails it cannot see.

That bundle is emailed to the banking partner (or pushed into their review system). The portal tracks the send, day-3 and day-7 follow-ups, and files any reply on the case. The URL lets a reviewer comment on screens, flows, or compliance sections if they log in. Email is the primary path for sign-off; we do not assume they will use the portal.

This is Gate 1 — conditional approval of the prototype and package. It is not production. Material change requests cut a new version. Approvals bind to a digest.

Gate 1 is the gate — not the end of the line. Only after it does the system emit the backend build specification. No Devin tokens are spent before Gate 1. Like a building: plans, architecture, permits, and marketing before the first shovel.

06

Backend build spec → Devin

Portal + Devin Engineering Gateway

Only after Gate 1 (conditional approval of the prototype and bundle): emit a comprehensive Markdown specification of everything required to support the approved product, then kick off Devin to build Staging, UAT, and Production.

This Markdown file is the only instruction set for backend implementation. It is generated from the frozen package — requirements, screens, architecture, funds flow, partner map, compliance determinations, marketing and T&Cs, and open gaps — bound to the approved digest. Devin does not invent UX, partners, rails, or licenses. If the file is silent, Devin asks; it does not guess.

When a human approves the spec after Gate 1, the portal automatically queues a Devin engineering work package. Devin implements the backend systems, APIs, events, ledgers, and partner adapters, and stands up Staging, UAT, and Production configurations for live testing connected to the named partners. Work is isolated to a branch, opened as a PR, and never self-merged. The portal serving path does not call Devin synchronously.

Staging uses synthetic data and partner sandboxes unless a named sandbox is in the spec. UAT is production-like and bank-visible, with environment-specific identifiers declared and tested. Production is live only after Hardening, QA, and the launch gate. Production credentials never appear in Studio or in the Markdown file.

ExitApproved backend .md bound to the package digest. Devin work package queued. Staging, UAT, and Production artifacts in progress or delivered. OpenAPI, events, and mocks published for the frontend. No undocumented endpoints. Material gaps block Production.

07

Hardening & QA

Hardening team + QA

Oversee that frontend and backend are connected and architected to the approved product spec, and that QA automates testing against that spec inside Devin.

Hardening does not redesign the product. It verifies that the Devin-built backend and the approved frontend implement the same digest: screen keys, APIs, events, funds titles, partner wiring, and environment configs for Staging, UAT, and Production.

QA maps every material requirement and screen to automated tests that run in Devin — contract tests (OpenAPI, JWT/SSO, webhook signatures and retries), end-to-end create → member happy path → admin reconcile → failure/replay, and negatives (duplicate events, expired vs in-flight, missing authority, wrong tenant). A blank result is not a pass. A different digest is not “already tested.”

If Hardening or QA finds a mismatch with the approved spec, the product does not launch. Material product change returns up the line; it is not patched only in Production.

Gate 2 is production testing sign-off from the banking partner. Because Gate 1 already reviewed the product, rails, legal, and compliance, Gate 2 is evidence on a built system — targeted at days, not months, when the package was clean.

ExitFE/BE connected to the approved spec across Staging, UAT, and Production. Automated suite green against that digest in Devin. Gate 2 (production sign-off) may proceed. Hardening does not attest for the bank.

8 · What Studio is — and is not

What Studio is — and is not

Studio is the authoring system for the line: voice capture, live prototypes, spec assembly, and the package. The portal is the system of record for versions, issues, evidence, attestations, and publication.

Studio is not the production ledger, not the bank’s GRC system, and not a replacement for counsel. Prototypes never move real money. AI never attests, never closes a material issue, and never speaks for the bank.

Product Owner brief
        │
        ▼
 [1] DESIGN ──────── UX/UI for every interfacing party
        │  Product Prototype Vn completed
        ▼
 [2] COMPLIANCE ──── Partner / license map + human determinations
        │  Architecture may proceed inside those constraints
        ▼
 [3] ARCHITECTURE ── Backend & APIs that serve the UX compliantly
        │
        ▼
 [4] MARKETING ───── Messaging, communications, T&Cs / partners
        │  Line complete
        ▼
 URL + PDF BUNDLE ──► emailed to bank (portal optional) ──► Gate 1
        │
        ▼
 BACKEND BUILD SPEC (.md) ──► Devin (Staging / UAT / Production)
        │  no Devin tokens before Gate 1
        ▼
 HARDENING + QA vs spec ──► Gate 2 production sign-off

Skipping a station, sending the bank a prototype without the compliance map, architecture, and T&Cs, or kicking off Devin before bank approval of that exact package, is out of process. Historical packages keep the assembly-line version they were frozen under. Published at /assembly-line. Backend contract for Devin: docs/DEVIN_HANDOFF.md.