Software development

Payment software, engineered for licensed financial institutions.

We design, build, integrate and maintain the systems our clients run under their own licences — payment platforms, ledgers, risk tooling and back-office applications.

We build the software. Our clients hold the licences, own the deployments and operate the systems.

We build Payment platform software Ledger & reconciliation software Compliance & risk software Back-office platforms

What we build

Six engineering practices, one delivery team.

Financial software fails on the parts nobody demos: reconciliation, idempotency, audit trails, failure recovery. That is the work we specialise in.

Payment platform software

We build the checkout and invoicing interfaces, transaction state machines, webhook delivery and reconciliation tooling that our clients run on their own platforms.

  • Integration code against acquirer, gateway and banking-core APIs, on credentials held by the client
  • Event-driven transaction pipelines
  • Reconciliation and dispute tooling

Compliance & risk software

Software interfaces for the controls our clients are required to operate: onboarding workflows, rule engines, case management, monitoring dashboards and audit-ready event logs.

  • Integration with the identity-verification vendor contracted by the client
  • Configurable rule and scoring engines
  • Immutable audit and evidence trails
  • We perform no verification, screening or monitoring on anyone's behalf

Ledger & reconciliation software

We implement double-entry ledger cores, balance and limit engines, fee and rate calculation modules, payout scheduling logic and end-of-day close routines.

  • Double-entry accounting cores
  • Multi-currency balance modelling
  • Statement and reporting exports
  • Our clients configure, deploy and run them

Client & back-office platforms

Self-service portals, onboarding journeys, internal administration consoles, role and permission models, operational reporting and support tooling.

  • Design systems and component libraries
  • Granular RBAC and four-eyes approvals
  • Operations and reporting dashboards

API design & integration

Versioned public APIs, SDKs and reference implementations, sandbox environments, developer documentation, and integrations with third-party providers on client instruction.

  • OpenAPI-first contract design
  • SDKs, sandboxes and sample apps
  • Legacy system modernisation

QA, DevOps & SRE

Automated test suites, load and failover testing, CI/CD pipelines, infrastructure as code, observability instrumentation and post-release maintenance under SLA.

  • Test automation and load testing
  • IaC, CI/CD and release management
  • Monitoring configuration and runbooks handed to the client's operations team
  • Code-level escalation support only — the client operates the system

How we work

A delivery process our clients can audit.

Every engagement runs under a written software development agreement with a defined scope, acceptance criteria, IP assignment and a support term. No work starts without one.

01

Discovery

Requirements workshops, system and data mapping, integration constraints, regulatory obligations the client must meet, and a written scope with estimates.

02

Architecture & design

Solution architecture, data model, API contracts, threat model and interface design, reviewed and signed off by the client before a line of production code is written.

03

Build

Two-week sprints, trunk-based development, mandatory peer review, static analysis and dependency scanning on every merge, demo at the end of each sprint.

04

Quality assurance

Unit, integration and end-to-end suites, load and failover scenarios, and a documented UAT cycle run by the client against agreed acceptance criteria.

05

Deployment

Deployment into infrastructure owned and controlled by the client. Handover includes source code, IaC, runbooks and architecture documentation.

06

Support & evolution

Warranty period, SLA-backed maintenance, security patching, and a roadmap of further increments delivered by the same team.

Who owns what

Systems we build are deployed, owned and operated by our clients on their own infrastructure. Intellectual property in bespoke deliverables is assigned to the client on payment. Billions Works FZE LLC does not operate our clients' production systems, does not act on end users' instructions, and holds no client or end-user funds at any point.

Engineering standard

Built to be reviewed by someone else's auditor.

Our clients are supervised businesses. Their auditors, their banking partners and their regulators eventually read the systems we deliver — so we build for that reading from the first sprint.

  • Secure SDLC: threat modelling, peer review, SAST and dependency scanning in CI
  • Least-privilege access, MFA and per-environment credential separation
  • Every state change written to an append-only, timestamped audit log
  • Encryption in transit and at rest; secrets never in source control
  • Signed NDAs and confidentiality clauses on every engagement
  • Practices aligned to ISO/IEC 27001 and OWASP ASVS. We are not currently certified to ISO/IEC 27001
ledger.ts reconcile.ts audit.ts
// Double-entry posting — balanced or rejected.
// Idempotent by construction: same key, same result.
export async function post(entry: JournalEntry) {
  const sum = entry.lines.reduce(
    (a, l) => a + l.amountMinor, 0
  );
  if (sum !== 0)
    throw new LedgerError("unbalanced_entry");

  return db.tx(async (t) => {
    const prior = await t.findByKey(entry.idempotencyKey);
    if (prior) return prior;          // replay-safe

    const posted = await t.insertLines(entry.lines);
    await t.appendAudit({
      event: "journal.posted",
      actor: entry.actor,
      at:    t.serverTime,
    });
    return posted;
  });
}

Illustrative code written for this website. Not client code.

Technology

A deliberately boring stack.

We choose technologies our clients can hire for, audit and keep running after we hand over. Nothing exotic ends up in a production financial system.

Backend
Java / KotlinGoNode.jsTypeScriptPythongRPC
Data
PostgreSQLRedisKafkaClickHouseDebezium
Frontend
ReactNext.jsTypeScriptDesign systems
Platform
AWSKubernetesTerraformGitHub ActionsOpenTelemetryGrafana

Engagement models

Three ways to contract us.

Dedicated engineering team

A named, full-time team reporting into the client's product owner. Billed monthly per allocated engineer.

Fixed-scope project

Defined deliverables, milestones and acceptance criteria at a fixed fee, invoiced on milestone sign-off.

Staff augmentation

Individual specialists embedded into an existing client team, billed at agreed day rates.

All engagements are priced in day rates, monthly team rates or fixed project fees. We do not charge transaction-based or volume-based fees of any kind.

Contact

Tell us what you need built.

Send a short description of the system, the timeline and the constraints. An engineer — not a sales team — replies within two business days.

  • Email
  • Telephone
  • Office hours
    Sunday–Thursday, 09:00–18:00 (GST, UTC+4)
  • Address
    Unit CWS-1V-227764, 26th Floor,
    Amber Gem Tower, Ajman,
    United Arab Emirates

By submitting this form you agree that we may use the details provided to respond to your enquiry, as described in our Privacy Policy. We do not sell your data. We use it only to respond to your enquiry.