One module at a time · One core · No big bang

Move Ingenium to Rust. One piece at a time.

Orbit puts a stable Web API in front of Ingenium so COBOL and Rust can serve the same core together. Each module is isolated, redesigned and moved at its own level of readiness — while the rest keeps operating.

See the migration journey See a module example

Orbit Hybrid Core

Policy request

Stable Web API

01COBOL modules

02Rust modules

Routing shifts by module, without a single shared cutover day.

Hybrid by design

The old and new run together behind a stable boundary

Orbit creates a shared facade for policy processing and administration capabilities. Callers do not need to know whether the module behind it currently runs in COBOL or Rust.

One Web API

Digital channels, services and Flows call the same contract throughout the migration journey.

Move by module

Each business capability gets its own boundary and pace, matched to its complexity and risk.

Keep a way back

COBOL continues serving until the Rust implementation has been reconciled and is trusted to receive routing.

Module-by-module

Four steps for one piece of COBOL to become Rust

Orbit starts by drawing a boundary around the existing module. Reimplementation begins only after its inputs, outputs and responsibility are clear.

01COBOL + RUST

Run hybrid

Place Orbit in front of Ingenium so requests can reach COBOL or Rust behind the same API.

02STABLE CONTRACT

Isolate the module

Split the core by business capability, define the contract and wrap the current COBOL module behind that boundary.

03VERIFY

Redesign in Rust

Build a Rust implementation against the same contract and reconcile its results with the running logic.

04RUST

Complete the move

Shift routing to Rust when confidence is sufficient, stabilize it in practice and retire the corresponding COBOL.

A large core is modernized through many small, verifiable decisions instead of one wholesale replacement.

An example first module

Premium Allocation: a small boundary rich in business rules

When a customer pays, the module splits that money according to rules configured for the product.

Orbit isolates the current COBOL logic behind a contract, builds an equivalent Rust implementation, reconciles the results and shifts routing when confidence is sufficient.

Customer payment

OPremium Allocation

SuspenseHold money until the appropriate time.
Policy accountAllocate money to the policy account.
ExcessMove the amount beyond conditions into excess.

Inside the EVA model

Orbit is the Agent for policy processing and administration

Hybrid-core capabilities are offered as Skills through the Web API. Echelon can give Orbit a Task inside a Flow without depending on whether the implementation currently runs in COBOL or Rust.

Echelon FlowAssigns business Tasks and keeps the journey.

Orbit AgentSelects a policy Skill through the Web API.

Hybrid CoreRoutes to a COBOL or Rust module.

Policy skills Inquiry Validation Processing Administration

Foundation / Direction

Orbit has technical connection points; the product is still taking shape

The current source shows the direction through a Rust Web API, authentication and COBOL communication. The next round will turn those parts into a coherent module migration architecture.

FOUNDATION · AVAILABLE

The initial hybrid bridge

Rust Web API service
Authentication and role mapping
COBOL IPC and multi-worker dispatcher
An initial policy-processing structure

DIRECTION · TAKING SHAPE

The core migration path

A stable contract for each module
COBOL and Rust running side by side
Reconciliation before routing shifts
Orbit Skills for Echelon Flows

Orbit is not positioned as a core replacement ready today. Each module will need its own scope, evidence and migration criteria.

Choose a module small enough to begin and real enough to prove.

Start with a capability that has a clear boundary, running logic and results that can be reconciled. Binean will help define the contract, hybrid path and routing criteria that fit it.

Discuss a module View BENOVA