Omegaswift
Industries

Fintech

A fintech product is judged on whether the money is right and whether the service is up. We build the payment flow, the ledger and the checks around them with both of those as the starting point.

How We Help

What the work looks like in Fintech.

Getting the Money Right

A payment request can time out after the money has already moved. Build for that on day one and the ledger stays clean for years. Add it afterwards and you spend those years chasing balances that will not add up. We use immutable double entry records, an idempotency key on every operation that moves value, and an event history that can be replayed to explain any balance on any date. Corrections are posted as new entries rather than edits, so a support agent and an auditor read the same story.

KYC and Onboarding

Onboarding is where you lose customers who would have been good ones. We build the flow so a straightforward applicant clears in one pass and only the cases that need a person reach one. Document, sanctions and watchlist checks run through the providers you have chosen, and the result is stored against the customer with the reason for the decision. When a partner bank or a regulator asks why someone was accepted, the answer is already in the record and nobody has to reconstruct it.

The Rails You Do Not Own

Your product sits on a partner bank, a card processor and whatever open banking connections you use. None of them belong to you and all of them will have a bad day. We choose timeout and retry behaviour for each integration separately, keep an honest customer facing state for a payment stuck in between, and put the integration layer where an API change can be absorbed without the product noticing. Monitoring covers the money path first, so you hear about a stalled settlement from an alert rather than from a customer on social media.

Support Is Where a Fintech Actually Fails

The customer app gets the design attention and the internal console gets built last, which is why the engineering team ends up being the support team at eleven at night, reading rows out of a database to answer a question about one payment. Build the console early instead. A support agent should be able to see a payment's whole history, including every callback received and what the partner said and when, the state it is genuinely in rather than a friendly summary of it, and then take the two or three actions that resolve most tickets: resend, refund, retry, escalate. Each of those is recorded against the customer and the operator who did it. An internal tool that can move money is the largest fraud risk in a small company, so its permissions deserve the same care as the customer's.

Fraud Is a Rate, Not a Switch

You do not stop fraud. You choose how much of it you are willing to carry and how many good customers you are prepared to lose getting there. That is a commercial decision and it belongs to the business rather than to whoever writes the rules engine. Our part is making the trade visible: rules and thresholds that can be changed without a release, velocity and device checks that catch the obvious patterns cheaply, and an estimate of the review queue a rule will generate before it is switched on. A model with nobody staffed to work its queue is decoration, and a queue growing faster than the team clears it turns into blanket approvals within a fortnight. Measure both sides, the losses and the customers you turned away.

Common Challenges

What we are usually called in to fix.

  • Payments that time out after the money has already moved, then get retried
  • KYC checks that block good customers and still miss the ones you needed to catch
  • Reconciliation against partner statements done by hand, days after the fact
  • Partner banks and processors you depend on and cannot control
What You Get

What is different once the work is done.

  • A double entry ledger where every movement is idempotent and can be replayed
  • Onboarding that clears most customers in one pass and escalates only the rest
  • Automated reconciliation against partner files, with breaks raised the same day
  • An honest state shown to the customer when a payment is neither confirmed nor failed
What we build

Software we build for fintech

  • The ledger

    Immutable double entry records, an idempotency key on every operation that moves value, and an event history that can be replayed to explain any balance on any date without anyone reconstructing it.

  • Payment and payout integrations

    Each provider integrated with its own timeout, retry and reconciliation behaviour, because averaging those decisions across three providers is how one stuck payment becomes two.

  • Onboarding and KYC flows

    The flow around the check rather than the check itself: what a straightforward applicant sees, what reaches a human, and how a decision is explained a year later when somebody official asks.

  • Customer apps

    The part customers judge you on, built so the honest state of their money is visible, including the uncomfortable state where a payment is neither confirmed nor failed yet.

  • The operations console

    Where support, finance and risk actually work. Built early, permissioned properly and logged, because it is the tool that can move money with no customer anywhere near it.

  • Reconciliation and settlement

    Automated comparison against partner and scheme files, with breaks raised the same day rather than found at month end when the counterparty has moved on to other things.

Systems

What we work alongside

  • Partner and sponsor banks

    Your permissions, your rails and your settlement account sit with somebody else. Their onboarding, certification and change calendar will shape your roadmap more than any technical decision you make.

  • Card issuing and processing platforms

    Authorisation, clearing and settlement each arrive on their own timetable. A product designed as though they arrive together produces balances that cannot be explained to a customer or an auditor.

  • Payment gateways and acquirers

    Different failure behaviour, different dispute rules, different files. We keep those differences inside an integration layer rather than letting each one leak into the shape of the product.

  • KYC, AML and sanctions providers

    Document, watchlist and screening services. The result and the reason for the decision are both stored against the customer, because the question comes back later and it comes from someone official.

  • Open banking and account aggregator APIs

    Consented access to data you do not hold, with consent lifecycle, expiry and revocation treated as first class rather than bolted on after launch when a customer asks to withdraw it.

  • Accounting, tax and invoicing

    The ledger is not your accounts. Somebody still has to close a month, and the mapping between the two is worth agreeing with your finance team before launch rather than in April.

Where to start

Where these projects usually begin

  • A ledger review before launch

    The cheapest week you will spend. Reading the money model before volume arrives is far less painful than reconstructing balances after a year of it.

  • Automating one reconciliation

    Usually the partner file somebody opens in a spreadsheet every morning. It tends to pay for itself in found breaks inside the first few weeks.

  • Building the console the team already needs

    If engineers are answering support questions with database queries, this is overdue. It is a contained piece of work rather than a programme, and it gives you the evening back.

  • Hardening one partner integration

    Timeouts, retries, duplicate and out of order callbacks, and an honest state for a payment stuck in the middle. Normally triggered by a bad afternoon nobody wants to repeat.

FAQ

Questions we get asked

How do you make sure the ledger is always right?

By building for failure from the first day, because a payment request can time out after the money has already moved. Immutable double-entry records, an idempotency key on every operation that moves value, and an event history that can be replayed to explain any balance on any date. Corrections are posted as new entries rather than edits, so support and audit read the same story.

Do we need our own licence?

It depends on what you are doing and who you are doing it with, and it is a question for a regulatory adviser rather than an engineer. What we can do is build so that the answer does not force a rewrite: keeping the regulated boundary explicit means a change of partner or permission is a contained piece of work.

How long does KYC onboarding take to build?

The check itself is an integration; the work is in the flow around it. Deciding what a straightforward applicant sees, what reaches a human, what is stored against the customer and how a decision is explained later takes longer than wiring the provider, and it is what decides whether good customers finish signing up.

What happens when a payment provider has an outage?

It is planned for per integration rather than generally. Timeout and retry behaviour is chosen for each, a payment stuck in between keeps an honest customer-facing state instead of guessing, and monitoring covers the money path first so you hear it from an alert rather than from social media.

Should we build our own ledger or buy one?

Buy, if what you need is bookkeeping for a product whose money movements are simple and whose volumes are modest. There are decent ledger products and no prize for writing your own. Build when the money model is the product: several currencies with your own rates, funds held and released on conditions, fees split between three parties, or a settlement pattern nobody sells off a shelf. The case we are most often called in to fix is neither of those. It is a product that kept balances in its ordinary application tables because that was quick, then found eighteen months later that no two reports agreed. Describe your three most awkward money movements to us and we will tell you which side of that line you are on.

How does PCI DSS affect what we build?

Mostly by deciding what you never touch. If card numbers pass through your servers, your compliance scope grows to include those systems and everything that can reach them, along with the assessment that comes with it. So the design goal is to keep them out: hosted fields or an element from your provider so the number goes from the customer's browser to the provider, tokens stored in place of card data, and nothing sensitive in logs, support tools, screenshots or a customer service mailbox. Those are engineering decisions taken at the start, not a certificate bought at the end. Get it right and your yearly obligation is short. Get it wrong and it becomes an assessment of your whole estate.

What happens when a partner sends the same callback twice, or out of order?

Both happen, most weeks, and a product that assumes otherwise will eventually confirm a payment it then has to reverse. Every callback is stored raw on arrival before anything acts on it, deduplicated on the provider's own identifier, and applied to a state machine that knows which transitions are legal, so a stale message about an earlier state is ignored rather than replayed over a newer one. Where a provider offers no ordering guarantee at all, we reconcile against their API or their settlement file instead of trusting delivery. Keeping the raw payloads matters as much as processing them, because when balances disagree the argument is settled by what actually arrived rather than by what your code decided it meant.

How long does partner certification take?

Longer than the integration, and it is the item plans underestimate most. A sponsor bank or a scheme will typically want your flows demonstrated in a sandbox, a defined set of test cases run and evidenced, your handling of the unhappy paths reviewed, and a production access slot scheduled with their team, all on their calendar rather than yours. Sandboxes also lie in small ways. They return responses your production traffic will not, and they almost never reproduce a timeout, which is the case you most need to have tested. So we build the failure handling against deliberately broken conditions of our own, and we ask for the certification checklist at the start so the queue is joined early rather than discovered late.

Ready to talk about your IT?

We are happy to answer any questions you have and help you work out which of our services fit your needs.