Engineering, integration and compliance technology.
Each service line ends the same way: working software, a test suite and documentation in a repository you own.
Engineering
We design and build custom software systems: web applications, internal tools, back-office systems and APIs. Work starts from a written specification and ends with a handover you can maintain without us.
A system that does not fit costs you every day, in workarounds, double entry and staff who go back to the spreadsheet. This service suits companies whose process does not fit off-the-shelf software, or whose current system has become the bottleneck.
Written specification
A document that states what the system does, the data it holds, who can do what and the acceptance tests it must pass. You sign it off before we write code.
Automated tests
Unit and integration tests run on every commit. The acceptance tests from the specification run before each release.
A repository you control
Source code, infrastructure configuration and deployment scripts sit in your repository from day one. If we disappeared tomorrow, another team could pick it up.
Documentation and handover
Architecture notes, a runbook for operating the system and a setup guide that gets a new developer to a running build. Handover includes a recorded walkthrough.
Integration
We connect systems that were never designed to talk to each other: ERPs, banks, payment gateways, government portals, legacy databases and third-party APIs. Where one side has no API, we build the adapter. The work includes data migration when you retire an old system.
A broken integration is expensive in a quiet way. Orders re-keyed by hand, payments reconciled in a spreadsheet, month-end held up by a file that did not arrive. So we map every field and every edge case before we write the first adapter. Then we build the checks that tell you when a connection stops.
Interface audit
We document what each system exposes, how it authenticates, what it rate-limits and what it silently drops. We find the surprises here, not in production.
Field-level data mapping
A mapping document for every field that crosses a boundary: source, target, conversion rule and what happens when the value is missing or malformed.
Government and bank portals
Automated filing to portals built for a person with a browser, with the retries and error handling those portals need. We keep a copy of each submission and the acknowledgement that came back.
Retries, queues and alerts
Adapters that retry on failure, queue when the other side is down and alert a named person when something needs a human. Logs show every message that crosses the boundary.
Data migration with reconciliation
Migration scripts run against a copy first. A reconciliation report shows record counts and totals on both sides before we switch anything over.
Compliance technology
We build software for processes that regulators audit: audit trails, reporting, KYC and record-keeping, access controls and data retention. We build it for banks, insurers, healthcare providers and other licensed businesses. Before we design anything, we list the rules, the records and the reports the system must produce. That list becomes the acceptance test.
When a compliance system fails, the cost is not a bug ticket. It is an audit finding, a fine or a licence at risk. An auditor will ask what happened, who did it and when. Then they will ask whether anyone could have changed the record afterwards. We design for those questions first, then the workflow.
Append-only audit trails
The system logs every change to a regulated record with the user, the time and the values before and after. The application cannot edit or delete log entries. An auditor can search them without a developer in the room.
Regulatory reporting
Reports generated from the system of record in the format the regulator specifies, with a reproducible query behind every figure.
KYC and record-keeping
Customer identity records, document storage and verification workflows with a complete history of who checked what and when.
Access controls
Role-based permissions, approval steps and segregation of duties, so the person who raises a transaction cannot be the one who approves it. Reviewers can see who could access what on any given date.
Data retention
Retention rules enforced in code. The system keeps records for the required period, then archives or deletes them on schedule and keeps proof that it happened.
How an engagement runs
Each step produces a document or a release you can inspect before the next one starts.
You write to us
Send what you need built or fixed, in as much or as little detail as you have. We reply within 2 working days with questions or a suggested first call.
Discovery
Every engagement starts with a 1-week discovery. We read your existing documentation, interview the people who run the current process and write the specification. You can take that document elsewhere.
Fixed-scope proposal
We quote against the specification: scope, price, timeline and what counts as done. Changes after sign-off go through a written change request.
Build and review
Work ships to a staging environment every 2 weeks. You test each increment against the acceptance criteria, so you see real features early, not a demo at the end.
Go-live, handover and support
The acceptance suite runs before go-live, with a written rollback plan. You receive the repository, documentation and credentials. We fix defects found in the first 30 days at no charge. After that, we offer a maintenance agreement.
Describe the system you need, and we reply within 2 working days with questions or a proposed discovery scope.
Start a project