Skip to content

Insurance · law · trading · finance · since 2012: Complex businesses, codified. In software you own.

We learn how your business really works: every rule, every exception, every risk. Then we build it into one system that performs at volume, scales with you and stays secure. Built new, or modernized from the system you have today without losing a rule. AI is arming attackers and your competitors alike. That system is your edge.

Illustration: four legacy modules, reinsurance treaties, trust accounting, real-time margin, and a multi-currency ledger, being modernized onto Rust, OCaml, and Elixir one at a time. Three have passed parity checks; the fourth is next, and a route back stays ready throughout.

Our strength: Your domain, codified

The hardest part of business software isn’t the code. It’s the knowledge: reinsurance treaty allocation, law-firm trust accounting and conflict checks, real-time margin and risk, multi-currency reconciliation. And it’s the exceptions to those rules, learned over years of running the business and rarely written down. We learn your domain, write it down as specifications, and codify it into one system your team owns.

Codified rule (illustrative)

The rule

If an account’s equity falls below 30% of its open positions, issue a margin call due by 4 p.m. Below 20%, or if a call is overdue, start liquidating.

The code

enum Margin { Healthy, Call { due: &'static str }, Liquidate }

fn check(equity_pct: f64, call_overdue: bool) -> Margin {
    match (equity_pct, call_overdue) {
        (_, true)              => Margin::Liquidate,
        (p, _) if p < 20.0     => Margin::Liquidate,
        (p, _) if p < 30.0     => Margin::Call { due: "16:00" },
        _                      => Margin::Healthy,
    }
}
Illustrative. Invented thresholds; every outcome must be handled before the code will build.
  1. 01

    Learned

    We sit with the people who run the process (the treaty analyst, the trust accountant, the risk desk, the controller) and map the rules, the roles, and the exceptions.

  2. 02

    Written down

    Every rule becomes a specification you keep: access control, data model, business logic, a journey for every role. Written in controlled language: one rule, one reading.

  3. 03

    Codified

    The specs become one system, with tests that prove each rule, so the knowledge outlives any one person.

The specs and tests stay with the code, so every later change is checked against the same rules.

What we do: Build it new, or modernize what you have

  • Custom builds

    Your rules and processes, codified into one system designed around how your team works. No per-seat fees, annual renewals, or forced upgrades.

    • Specified first Your domain is written down as specs before any code, so you approve what gets built.
    • A head start Login, permissions, and reporting come from our Foundations, so the budget goes to what makes you different.
    • AI-ready from day one LLM features behind your permissions, plus the specs, rules, and tests your team’s AI tools need.
  • Modernize without a rewrite

    Vue 2, Node 14, an old Rails or Java release: the platform hit end of life, but your code holds years of rules, edge cases, and fixes, IP you paid for. We move it to Rust, OCaml, or Elixir intact.

    • Parity is proven Same behavior, data, and contracts: your tests run against both, and exports are compared byte for byte.
    • Cutover by module One module at a time, with a route back at every step.
    • Faster, at lower cost Compiled code that does the same work on far fewer machines.

Fixed-scope build, modernization without a rewrite, or build and revenue share.

Operate · deploy · secure: Built to run on less and stay secure

Codifying your domain is half the job. The other half is how it runs: on fewer machines, shipped as one artifact, with security built in.

  • Lower operating cost

    75%

    Our modernization projects routinely cut operating costs by around 75%, and modernized systems often run around 10x faster.

    • One compiled binary in a small container, instead of a runtime plus thousands of packages.
    • Java and Scala to Rust, in production: 3x faster or better, on a tenth of the memory, with no JVM to run.
    • Fewer moving parts to monitor, patch, and pay for.
    • Smaller instances and fewer replicas, so the cloud bill shrinks with the code.
  • Simpler deployment

    1container to ship

    One artifact, built the same way every time.

    • A single compiled binary and its static files, with no interpreter or node_modules on the server.
    • Fast, repeatable builds with pinned toolchains and a locked dependency tree.
    • Simple rollbacks, and module-by-module cutover with a route back.
    • Runs in your cloud account, which we can operate, or on-premises with your IT staff.
  • Harder to break

    0JavaScript frameworks

    Security is designed in, not reviewed in at the end.

    • Memory safety removes the class behind about 70% of serious security bugs, as reported by Microsoft and by Google’s Chromium team.
    • Rules and permissions enforced on the server. The browser and every API caller are untrusted.
    • A strict Content Security Policy, with no inline scripts and no eval.
    • Dependency audits, a threat model, and security tests on every change.

Extend safely

Specs, tests, and AI-ready rules make every change safe, so your team or your AI tools can extend the system after handoff.

Typical results across the client systems we have modernized, not a guarantee.

Ownership

Your code, built new or modernized, is yours. It lives in your organization’s repo from the first commit, with its CI and docs.

Included in delivery · foundations: We don’t start from zero

Every system needs the same groundwork, from login and permissions to AI features. Rebuilding it for each project is slow and is where security bugs hide. We bring our own foundations, hardened across our projects. That’s why our modernization projects move fast with less risk, and why a foundation can modernize an existing system on its own. They ship with full source under our license.

  • Permission model

    Who can see and do what, defined once and enforced on the server.

    roles · permissions · server-enforced · testable matrix

  • Security layer

    Modern defenses applied by default, not bolted on at the end.

    strict CSP · security headers · origin checks · input validation

  • Reporting engine

    The reports and exports your finance and compliance teams sign off on.

    scheduled · on-demand · exports · byte-comparable output

  • AI middleware

    AI features inside your app, with the data protection, model routing, and observability to run them safely.

    redaction · policy routing · budgets and caching · audit and observability

Plus four more, from login to data mappers.

What you’re left with: A project any good team can pick up

Most handoffs leave you with code and a README. Ours leave you with an industry-standard project, written down. Your auditors can check every rule, and a new team or your AI tools can extend it safely.

What you’re left with
  • Detailed specificationsWhat the system does and why: access control, data model, business rules, billing, messaging, the UI, and the journey for every role.
  • Clean, owned codeOne repo with CI, readable modules, and a clear architecture document.
  • Tests as guardrailsAutomated tests across the system, plus manual test plans for the journeys people use every day.
  • Security, documentedA written threat model and the controls that answer it: permissions, headers, validation, and how secrets are handled.
  • AI-ready instrumentationSpecs and rules AI coding agents read before they change anything, defined agent roles and review skills, and machine-readable docs.

One recent client platform, by the numbers

automated tests
4,798
design and implementation plans
1,084
core specifications
~40
lines of application code
~350K
AI agent roles
8

AI · threat and opportunity: AI cuts both ways

Attackers now use AI to probe weak systems at scale, and old runtimes are the easiest targets. When your system uses AI, every call goes through our AI middleware: confidential details redacted, each request routed by sensitivity, and every call recorded.

Proof: Risk, uncertainty, and complexity, at scale

Trading, legal, insurance, and finance have one thing in common. They price, track, or manage risk and uncertainty, under complex rules, at volume. That’s the work we take on. We build and modernize systems for hedge funds, law firms, large insurance firms, and finance startups, and for media and sports data teams.

  • Intact
  • NASCAR
  • BBC
  • The Guardian
  • Bell Media
  • TSN
  • TSX
  • Reuters

Track record

Projects completed
150+
Computed events
25T+
Lines of code
25M+

Optional module · Beacon: Know what changed in your market

Many systems we build depend on what happens outside them: a rule change, a rival’s move, a supply shock. Beacon, our competitive intelligence module, can be wired into those systems for decision support and early warning. It reads what the world publishes about your market and alerts the right person within minutes.

Ready to build something you own?