Fintech & payments

PCI scope is an architecture decision. You make it in week one.

A payments product gets expensive at the moment someone decides how the card field renders. That one choice sets which Self-Assessment Questionnaire you fall under, and the distance between SAQ A and SAQ D is roughly twenty controls against three hundred. This is PCI compliant app development written as engineering: the SAQ fork, a ledger that survives an audit, and what PSD2 demands of a European architecture. It comes from regulatory and engineering knowledge. We have no published fintech clients and we don’t claim any.

Scope a payments build

The fork

Three checkout architectures, three different companies.

PCI DSS v4.0.1 has twelve requirement families. Where the card number travels on its way to the processor decides which of them bind your engineering team, and almost nothing else does.

SAQ A

Full redirect, or an iframe your origin never serves

The customer lands on the processor page, or the card field lives inside a frame whose contents come entirely from the processor. Your servers never see a primary account number, and your origin doesn’t affect the security of the transaction. v4.0.1 rebuilt SAQ A eligibility around precisely that attestation. Smallest control set, cheapest assessment, least control over how checkout looks and behaves.

SAQ A-EP

Your page serves the script that touches the field

Hosted fields, a tokenising SDK, a direct post. The PAN still bypasses your backend, but your origin ships the code around it, and that alone moves you. You inherit quarterly ASV scanning, penetration testing, a documented secure SDLC, and requirements 6.4.3 and 11.6.1: an authorised inventory of every script on the payment page plus tamper detection on it, both mandatory since 31 March 2025. Magecart is why those two exist.

SAQ D

The PAN reaches your server

You now store, process or transmit account data, and effectively all twelve requirement families apply. Requirement 3 by itself means PAN rendered unreadable at rest, documented key management with split knowledge and dual control, and sensitive authentication data (full track, card verification value, PIN blocks) never retained after authorisation, encrypted or not. Add segmentation testing, file integrity monitoring, internal and external scanning. Past roughly six million card transactions a year an SAQ is off the table entirely and a QSA writes a Report on Compliance.

The position we take: never store a PAN. Treat scope reduction as a design goal from the first sprint rather than a clean-up in month nine, because scope spreads by accident. One debug line that logs a request body drags an entire logging cluster, its backups and everyone with read access into the cardholder data environment. Network segmentation is the cheapest control you’ll ever buy. Build it before an assessor asks for it.

Tokenisation is the same argument in different clothes. A token from your processor, or a network token from the scheme, keeps the card number somewhere you don’t have to defend. Operating your own token vault turns you into a Level 1 service provider, with the scope, the assessment and the annual cost that implies. Some businesses genuinely need it. Most companies that build one wanted portability between processors, and could have bought that instead.

Money-movement correctness

Your processor is not your system of record.

A balance isn’t a column. The moment a mutable integer represents what someone is owed, two concurrent writes will eventually disagree with the truth, and you find out at month end with no way to reconstruct what happened. Double entry is the only defensible model: every movement writes two or more entries that sum to zero within a currency, and you derive the balance by summing them. Entries are append-only. Nothing gets updated or deleted, and you correct a mistake with a compensating reversal that leaves both the error and the fix visible forever.

Money is an integer in minor units with the currency stored beside it, and never a float. The exponent isn’t always two. JPY has none; KWD, BHD and JOD have three. A hardcoded multiplication by one hundred is a bug waiting for its first customer in Tokyo. When you split an amount, allocate the remainder deliberately so the parts sum exactly to the whole, instead of rounding each share on its own and losing a unit per transaction. For anything cross-border, capture the FX rate, its source, its timestamp and the quote identity at the moment it applied. Authorisation-time rate and capture-time rate are different numbers, and the difference belongs in its own ledger account rather than quietly inside revenue.

Every write path takes an idempotency key, stored with the response it produced and a unique constraint that makes a replay return the original result instead of moving money twice. Webhooks are at-least-once and arrive out of order, so exactly-once is an illusion you build on top of them: deduplicate on event identity, gate handlers on the object version rather than assuming arrival order is causal order, and re-fetch the object instead of trusting the payload. Authorisation, capture and settlement are three distinct states with their own timers, partial captures and expiries, and collapsing them into one boolean is the most common data-model mistake in this vertical.

Then reconciliation, as a first-class scheduled job with alerting rather than a spreadsheet somebody opens in January. A three-way match between your ledger, the processor settlement file and the bank statement catches what every other control misses: fees you never modelled, a refund that landed twice, reserve holds, payout timing, a chargeback that silently reversed a transaction you still show as complete. It’s unglamorous, it’s the difference between a product and a liability, and it’s the same engineering discipline behind our Next.js and TypeScript platform work.

Europe

PSD2 is a set of build constraints, not a compliance chapter.

If any of your payers sit in the EEA or the UK, four of these five rows change your data model and one of them changes your infrastructure. PSD3 and the Payment Services Regulation are still moving through the legislative process, and nothing here assumes a date for them.

Strong Customer Authentication

Two independent factors

Knowledge, possession, inherence. Any two, and compromising one must not compromise the other. That’s an architecture constraint rather than a checkout preference. An OTP delivered to the same device that already holds the authenticated session is a conversation you’ll end up having with your acquirer.

Dynamic linking

Amount and payee bound to the code

For remote payments the authentication code has to be dynamically linked to the specific amount and the specific payee, and a change to either invalidates it. Your authorisation request and your challenge payload have to agree, which is where partial captures and post-authorisation amount edits start to hurt.

Exemptions

An actuarial bet, not a feature

Low value, transaction risk analysis, trusted beneficiaries, recurring fixed amounts, merchant-initiated transactions. TRA thresholds hang off a reference fraud rate held by the payment service provider claiming them: the 100, 250 and 500 euro bands sit behind rates of 0.13, 0.06 and 0.01 percent. Chasing exemptions is betting that a number someone else measures stays where it is.

AIS and PIS

A licence, not a library

Account information and payment initiation are regulated roles. Acting as an AISP or a PISP requires authorisation or registration from a national competent authority. A software studio can’t supply that. You bring the permission or the agent arrangement, and we build against it.

QWACs and QSealCs

The certificate stack nobody mentions

Common and secure communication under the RTS runs on eIDAS certificates from a qualified trust service provider: a QWAC identifying you at the transport layer in mutual TLS, a QSealC sealing the message itself for non-repudiation. Your roles and your competent-authority identifier are carried inside the certificate. Renewal, revocation and role changes are operational work with a calendar attached, and every EU open-banking build hits it.

The card networks meet PSD2 through EMV 3-D Secure 2. Your 3DS server passes a large device and behaviour payload to the directory server, the issuer access control server decides frictionless or challenge, and a successfully authenticated transaction shifts fraud-dispute liability to the issuer. Read that last clause narrowly: the shift covers fraud reason codes, not a customer who says the goods never arrived. Building the challenge flow properly inside an app is real work. The redirect, the return, the state that has to survive a backgrounded process all live in there, and it’s the kind of thing our React Native and native mobile engineering has to get right on the first attempt rather than the third.

The surface nobody scopes

Onboarding, disputes, and the logs that outlive the payment.

KYC and AML onboarding is an asynchronous state machine wearing a form. A customer sits in pending, then documents-requested, then vendor-review, then manual-review or approved, and the transitions arrive as callbacks hours or days later from an identity or screening provider. Model it as a state machine on day one, or retrofit one under pressure. Sanctions screening isn’t a signup-time check either. The OFAC, EU, UN and UK lists change, so you rescreen the whole customer base on a schedule, recording every hit, disposition and reviewer.

Disputes are where missing data becomes money. Representment deadlines run in days, and the evidence that wins can only come from fields captured at authorisation: device fingerprint, IP, address and card-verification results, delivery confirmation, the authentication outcome. If you didn’t log it then, the dispute is unwinnable, and you pay the transaction plus the fee. Audit logs outlive the transaction by years. PCI DSS wants twelve months retained with three immediately available and clocks synchronised across the estate, while EU anti-money-laundering record keeping runs to five years after the relationship ends. Those are two different clocks on the same data, and you have to design them together.

Transaction monitoring is the one place in this vertical where a model genuinely belongs, and also the one place where an unexplainable model becomes a regulatory problem rather than an engineering preference. A freeze or a decline is an adverse decision a customer can contest, so every alert needs a reason code, the feature attributions behind it, the model version, and a stored snapshot of the inputs, with a human review path attached. That’s how we’d build the pipeline in an AI automation engagement, and whether a model is even the right tool for a given alert class is what an AI readiness assessment exists to answer before anyone writes a training pipeline.

Where we would tell you not to build

Most companies asking for this should buy instead.

If payments are a feature of your product rather than the product, stop here. Take the hosted checkout, stay at SAQ A, and spend the engineering budget on the thing customers actually buy. That’s a different job with its own page on Stripe integration. This page is about being a payments product; that one is about a product that takes payments.

If you need to issue cards or hold customer funds, that’s a licence and a sponsor relationship before it’s a codebase. Build on an issuer-processor or a banking-as-a-service provider rather than against a scheme directly. And if you’re a lender writing a few hundred loans a month, a configured origination and servicing platform will beat a custom build on both cost and time. We’d rather integrate you into one than sell you a rewrite of it.

What we can’t bring: EdgeBrain Studios is not a Qualified Security Assessor, not an Approved Scanning Vendor, and holds no PCI attestation, SOC 2 report or payments licence. Those come from your assessor, your scanning vendor, your acquirer and your regulator. A software studio can make sure the architecture they assess is the small one rather than the large one, and that the evidence they ask for already exists. Treat any plan where compliance comes later as a rewrite scheduled for a date nobody has picked yet. If you’re still deciding how to staff this, our breakdown of in-house versus agency versus freelancer covers the tradeoff, and our published case studies show the engineering standard we hold ourselves to.

Budget and timeline

What a payments build costs here.

Architecture and scope review

from $3,500

1 to 2 weeks

The SAQ fork settled on paper before anyone writes checkout code, a cardholder data environment boundary drawn, a ledger schema, and the integration list with the painful ones flagged. You get a document your assessor and your acquirer can both read, and the fee is credited in full against a build that starts within 30 days.

Payments platform build

from $28,000

10 to 20 weeks

Ledger, idempotent write paths, webhook ingestion, reconciliation jobs, dispute workflow, and the admin and operations surfaces around them. Most projects across the studio land between $18,000 and $45,000; payments work sits in the upper half of that because the correctness bar is higher.

The bands above are estimates, shown in US dollars and drawn from comparable work already delivered, because no two projects carry the same scope. Your own quote is not an estimate: it is fixed in writing after scoping, before kickoff, and it does not move.

Three things move the number. Which SAQ you land in, because A-EP adds scanning, testing and script controls to the build and D changes the shape of the company. How many currencies and corridors, since one currency is a ledger and four is a ledger plus an FX policy. And whether you’re entering the EEA, where SCA, the certificate stack and open-banking interfaces are all real weeks of work. None of the assessment, scanning or licensing cost sits inside these numbers, so budget for it separately. Our breakdown of what an MVP actually costs explains how we build a number instead of guessing one.

Decide the SAQ before you write the checkout.

Tell us who moves money to whom, in which currencies, and under whose licence. We reply with a scope, the SAQ we think you land in, and a price inside two working days.