Modernization · legacy to Rust, OCaml, or Elixir: Modernize without a rewrite
We call it a port: your system moved to a modern stack, every rule and record intact.
Your system works. The platform under it is the problem: end-of-life versions, an upgrade treadmill, a dependency tree nobody can audit, and operating costs that rise every year. A port moves it onto a stack built for the next decade, without changing what it does.
Your IP: Keep what you paid for
Your code holds years of business logic: the rules your teams worked out, the edge cases they found, the fixes they made after something went wrong. That is critical IP. You paid for it, and your people earned it. A rewrite throws it away and learns it again the hard way. A port carries it across intact, and parity proves nothing was lost.
- The rules. Treaty allocations, trust-account disbursements, margin calls, currency reconciliations: kept exactly as they work today.
- The edge cases. The exceptions nobody wrote down, preserved because the old system is the spec.
- The fixes. Every hard-won correction comes across, instead of coming back as a new bug.
It’s your domain, codified once already. A port keeps it, writes it down as specifications, and moves it onto a stack built to last.
Ownership: Your code, ported. Still yours.
If we port your system, you own the result outright: the repo, the history, the specs, and the tests. The foundations we bring, from login and permissions to AI middleware, ship with full source under our license, so you can run and change them too.
Why port: What a port changes
Your logic stays the same, and what changes is the cost to run, ship, and defend it: one compiled binary on fewer machines, a single artifact to deploy, and security built in.
The difference: Port vs rewrite, side by side
A rewrite starts from a blank page: requirements are re-specified, old edge cases are rediscovered the hard way, and everything ships at once. A port treats the running system as the specification and changes only the stack underneath it.
Starting point
- Rewrite
- A new spec, written from memory
- Port
- The running system is the spec
Behavior
- Rewrite
- Re-decided, often by accident
- Port
- Kept, and proven equal
Data and contracts
- Rewrite
- Migrated, remapped, renegotiated
- Port
- Unchanged: same schema, APIs, exports
Release
- Rewrite
- One big switch-over
- Port
- Module by module, with a route back
Bugs
- Rewrite
- New ones, all at once
- Port
- Old ones fixed on purpose
| Criterion | Rewrite | Port |
|---|---|---|
| Starting point | A new spec, written from memory | The running system is the spec |
| Behavior | Re-decided, often by accident | Kept, and proven equal |
| Data and contracts | Migrated, remapped, renegotiated | Unchanged: same schema, APIs, exports |
| Release | One big switch-over | Module by module, with a route back |
| Bugs | New ones, all at once | Old ones fixed on purpose |
Parity method: Parity is proven, not assumed
“It looks the same” isn’t a test. Before any module switches over, we show it behaves the same, with evidence you can check.
- Permissions compared. We build the permission matrix for the old system and the new one, and diff them. Every role sees exactly what it saw before.
- Your tests, both sides. The existing test suite runs against the old and the new system. A port isn’t done until both pass the same suite.
- Outputs byte-compared. Exports, reports, and generated files are compared byte for byte, so finance and compliance get the numbers they got before.
- One owner per module. Each module has one named engineer who signs off its parity. No module is everybody’s job.
Why ports go faster: We port your logic, not the plumbing
Much of a legacy system’s risk sits in the parts every system has: login and permissions, reports, and the mapping of data in and out. We don’t rebuild those from zero. Our foundations already do them, hardened across our projects, so the port spends its time on the business logic that makes your system yours.
From → to: What we port, and where it goes
These platforms built a great deal of good software, and we still maintain and harden systems built on them. The trouble starts when a version reaches end of life and the system on it can’t move.
From
- PHP
- Long-lived apps on versions past security support, like a law firm’s trust-accounting system.
- Node.js
- Services pinned to old runtimes and deep dependency trees, like a real-time margin service.
- React and Vue single-page apps
- Vue 2 and older React builds that need a full migration to stay supported.
- Ruby on Rails
- Apps several major versions behind, like a multi-currency ledger.
- Java and Scala
- Systems on aging JVMs and frameworks, from a reinsurance treaty platform on Java 8 to Scala services.
To
- Rust
- Our default for services and server-rendered web apps.
- OCaml
- For trading and quantitative systems.
- Elixir and Phoenix
- For Rails teams who want fault tolerance and real-time concurrency.
Why Rust: A compiler that refuses whole classes of bugs
Rust catches at compile time the mistakes that become outages and breaches elsewhere. That matters more now that AI writes a growing share of code: the compiler reviews every line, whoever or whatever wrote it.
- Memory safety, no garbage collector. No use-after-free or buffer overflows, without pauses for garbage collection.
- Fearless concurrency. Data races are compile errors, not production incidents.
- No null, no unhandled cases. Missing values and unmatched states have to be handled before the code builds.
- Small, fast binaries. One self-contained program, quick to start and efficient to host.
- Low, predictable latency. Low memory use and steady response times under load.
- Code that lasts. Strong types and stable releases keep code readable and buildable for years.
Why OCaml: Correctness and speed for trading systems
OCaml is the language serious trading firms rely on for systems where a wrong answer costs money in milliseconds. Its type system makes illegal states hard to write, and it compiles to fast native code. We use it for real-time margin and risk calculations, pricing, and order handling.
Why Elixir: The natural next step for Rails teams
Elixir and Phoenix feel familiar to Rails developers and run on the BEAM, a runtime built for systems that must stay up. Processes fail and restart in isolation, real-time features come built in, and one server handles very large numbers of concurrent connections.
Cutover: Switch over a module at a time
Nobody has to bet the business on one weekend. Old and new run side by side, and traffic moves one module at a time.
- 01
Map
We map the system’s modules, data, integrations, and contracts, and write them down as specifications.
- 02
Port and prove
Each module is ported and passes the parity checks against the live system.
- 03
Switch
Traffic for that module moves to the new code. The old path stays ready.
- 04
Route back
If anything looks wrong, that module switches back while we fix it. Then the next module.
After the port: Port, then level up
A port gets your system onto a stack that can carry more. The next step is what turns it into an advantage. The AI middleware is one of our foundations. Beacon’s software is embedded in your system, and its market data comes from a data service we run, for a monthly fee. Neither has to wait for the port: both can connect to the system you run today, through its APIs, a read-only copy of its database, or its web interface.
- AI you can see, secure, and tune. Our AI middleware redacts confidential details before a request leaves your system, routes each request to a private or public model by sensitivity, cost, and speed, and records every call, so your team can see what each AI workflow sends, to which model, and at what cost.
- Competitive intelligence, wired in. Beacon, our competitive intelligence module, reads what the world publishes about your market and feeds decision support and early warnings into the workflows where people act.
Questions: What leaders ask before a port
Isn’t a port riskier than leaving it alone?
Staying on an unsupported platform is a risk too, and it grows every month without security patches. A port takes that risk on in small, reversible steps, with parity proven at each one.
Can’t we just upgrade?
Sometimes, and we’ll tell you if that’s the cheaper path. When an upgrade means rewriting most of the app anyway (Vue 2 to 3, several Rails majors, an old JVM stack), porting to a stack with far less upgrade churn is often the better use of the same budget.
What does it cost?
It depends on the size of the system and the order we port it in. Discovery ends with a fixed scope per module, so you see the cost of each step before you approve it. Our foundations keep the cost of login, permissions, and reporting down. And once it’s live, lower operating costs start paying it back.
Will it be faster?
Often, yes: around 10x faster is a common result. Compiled code, fewer layers, and server-rendered pages do less work per request. It’s a typical result, not a promise; discovery tells you what to expect for your system.
How long does it take?
Because cutover is module by module, the first module reaches production long before the whole port is done. Discovery gives you the full timeline.
Who owns the ported code?
You do. The foundations come with full source under our license, so nothing in your system is a black box.
Can our team maintain Rust, OCaml, or Elixir?
Yes. You get the repo, CI, specs, tests, and a handover, and the code is written to be read. We can train your team, or stay on call for support, priced per request.
What happens to our data?
It stays where it is, in the same shape. A port changes the code, not the schema, and exports are byte-compared to prove it.
Tell us what you’re stuck on
Name the system and the version. We’ll tell you whether to port, upgrade, or leave it alone.