Skip to content

Custom software · legacy modernization · AI: We build and modernize business-⁠critical software. Specified, tested, and yours to own.

For complex, risky, or regulated processes: new software built around how you work, and legacy systems moved to a modern platform without a rewrite. We use AI to deliver faster, and senior engineers design the system, direct the work, and verify every release.

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.

How we work: Your business rules, specified and built in

The hard part of business software is the rules it runs on: pricing, approvals, compliance, and their exceptions. We write them down as specifications and build them into one system your team owns, with a test that proves each rule.

Diagram: we learn the rules from the people who run the process and extract them from the system you run today, write each rule down as a specification you keep, and build it as code with a test for each rule, so every later change is checked against the same rules.

One rule, in English and in code (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(pct: f64, overdue: bool) -> Margin {
  use Margin::*;
  match (pct, overdue) {
    (_, true) => Liquidate,
    (p, _) if p < 20.0 => Liquidate,
    (p, _) if p < 30.0 => Call { due: "16:00" },
    _ => Healthy,
  }
}
Illustrative. Invented thresholds; every outcome must be handled before the code will build.

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

New software built around how your team works, or your current system moved to Rust, OCaml, or Elixir with its rules, edge cases, and fixes intact.

Diagram: two paths from your business. Build new: your rules are specified and approved before any code, our foundations supply login, permissions, and reporting, and the result is your own system with no per-⁠seat fees or renewals. Modernize: your Java, PHP, Node, or Rails system moved to Rust, OCaml, or Elixir one module at a time, each module proven to keep the same behavior, data, and exports before it switches over.

Clients and track record: Risk, uncertainty, and complexity, at scale

Any business that runs complex, risky, or regulated processes at volume has the same hard problem: a wrong answer costs money or breaks the law. That’s the work we take on, in any industry. Our clients include hedge funds, law firms, large insurance firms, finance startups, and 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+

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.

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: Safer from AI attacks, and safer using AI

Attackers now use AI to probe every public system for weaknesses, and old runtimes are the easiest targets. When your system uses AI, every request goes through our AI middleware. It removes names and account numbers before the request leaves your system, and it records every call.

Diagram: a request from your app passes through the AI middleware. Names and account numbers are redacted, the request is routed to a private or public model by sensitivity, cost, and speed, the details are put back with sources cited, and the user sees only what they may see. Every call is recorded.

Operate · deploy · secure: Lower operating cost, simpler deployment, stronger security

Fewer moving parts to monitor, patch, and pay for, and security that is a requirement from the first specification.

Diagram: before a port, production runs your application on a framework, an interpreter or JVM, thousands of packages to patch and scan, and a base image. After a port, it runs one compiled binary in a small container. Our modernization projects routinely cut operating costs by around 75%, modernized systems often run around 10x faster, and Java and Scala systems moved to Rust run at least 3x faster on a tenth of the memory.

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

Ready to build something you own?