---
topic: system-design
author: Crashtech Editorial
published: Nov 14, 2026 · read: 4 min
---

One Checkout for Many Products: Designing a Unified Payments Layer

Why every product building its own payments breaks at the first regulation, and the design: opaque payloads, stateless actions, and async confirmation.

– –

Payments look like a feature until you have five products. Then you discover Apple Pay works for scheduled rides but not on-demand ones, a local method exists in only two of the five, and every security feature was written four times by four teams.

Why fragmentation gets expensive

Each line of business (rides, food delivery, bikes, transit tickets, rentals) built backend payment logic around its own needs. Over time:

ProblemExample
Inconsistent methodsA wallet works in one product and not another
Duplicated security workTwo-factor checks and device fingerprinting reimplemented per product
Uneven local coverageRegional methods such as Brazil’s PIX or India’s UPI present in some products only
Slow complianceA mandate like Strong Customer Authentication in the EU must be built in every system separately
Higher riskMore codebases handling money means more places to get it wrong

The compliance example is the killer. A regulatory change has a deadline and affects every product on the same day.

Four design principles

Products are external clients minimal assumptions
The payments layer knows as little as possible about each product’s internals. A new delivery feature must not require a payments change.
Payment logic stays out of products separation of concerns
Authentication, risk scoring and transaction processing live in checkout. Product teams do not need to learn card networks.
Generic by design build once
Wallets, local methods, 2FA, device fingerprinting and error recovery are capabilities of the platform. Adding PIX once adds it everywhere.
Scalable global traffic
Handles worldwide volume and absorbs new methods and regulations without a redesign.

The core components

  1. Payment profile preparation

    Collect and prepare what the payment needs, including exchanging short-lived tokens with third parties such as a wallet provider. The product never touches card data.

  2. Risk evaluation and securing funds

    Score the request for fraud and other risk, then secure funds as the strategy dictates: place a temporary hold when the final amount is known only after the service (a ride), or charge up front when it is known.

  3. Checkout actions

    A stateless framework of reusable steps: verify identity, confirm account ownership, collect data, and recover from problems with retries or a new payment method.

  4. Event handling

    Listen for asynchronous confirmations from processors. On success, confirm the order and notify the product. On failure, cancel and trigger a corrective action.

Assume payment results arrive later

Many methods do not confirm in the same request: bank redirects, wallet approvals, local networks. Design every order as pending until an event says otherwise, make event handling idempotent, and never mark an order paid because a redirect returned to your site.

Two ways to adopt it

ModelHow it worksFits
ModularThe product’s backend talks to checkout and renders prompts in its own UI. Payloads are opaque: the product relays them but cannot read or change themMature products that want a native experience
HostedThe checkout takes over the screen: order summary, method selection, payment, then hands control backSmall teams and new verticals that want everything out of the box

Opaque payloads matter. They keep sensitive decisions inside the payments layer and mean a new action type can ship without every product changing code.

Advertisement

Actions: before and after the request

Pre-checkout actions deterministic, known in advance
Done before the request reaches the backend: pick a card in the wallet, capture a device fingerprint for risk, generate a short-lived payment token. Predictable steps handled upfront simplify everything after.
Post-checkout actions conditional, triggered by results
Driven by what happened: payment authorisation waiting on a bank, an expired card prompting a method update, a high-risk flag requiring a one-time code or biometric check.

Because the action framework is stateless, each action carries what it needs and can be processed independently, which is what makes it reusable across products and easy to scale.

Outcomes reported

Uber reported a roughly 3 percent lift in checkout conversion, about 4.5 percent more sessions recovered through corrective actions, and consistent global payment coverage across products. Treat those as one company’s results, but the mechanism is general: recovery actions turn failed payments into completed ones, and uniform coverage removes places where a customer cannot pay.

Building one yourself

Do

Keep one payments boundary with a small, versioned contract. Handle method-specific logic inside it, surface prompts to products through opaque, typed actions, and make every confirmation path idempotent and event-driven.

Don't

Let each product call card processors directly “to move faster”. You will pay it back with every compliance change, and with a security review for each copy.

If you are small, you do not need the platform on day one. You need the boundary: one module through which every payment flows, so extraction later is a lift, not a rewrite.

Takeaway

Payments are a cross-cutting capability that deserves a single owner. Treat products as outside clients, hide card and method complexity behind a generic layer, express user steps as stateless actions before and after the request, and confirm outcomes through events. Then a new regulation or payment method is one project instead of five.

Advertisement

Frequently asked questions

Why centralise payments instead of letting each product build its own?

Payment features and regulations apply to every product at once. With separate implementations, each change such as strong customer authentication or a new local payment method must be built, tested and secured repeatedly. A shared layer implements it once, and keeps payment methods consistent across products.

What is an opaque payload in a checkout integration?

A blob the checkout service returns and the calling product passes back without reading or changing it. The product can display prompts and relay data, but cannot interpret payment details, which keeps sensitive logic and security decisions inside the payments layer.

Why must payment confirmation be handled asynchronously?

Banks, wallets and local payment networks often confirm minutes later, or require extra user steps. A checkout that assumes an instant yes or no breaks. Treat the order as pending, listen for processor events, and let the event handler move it to confirmed or failed.

What are pre-checkout and post-checkout actions?

Pre-checkout actions are predictable steps done before the payment request, such as choosing a wallet card, fingerprinting the device or generating a short-lived token. Post-checkout actions are conditional steps triggered by the result, such as re-authentication, a one-time code or switching payment method.

Sources & further reading

/* Comments */