IT + SOFTWARE

Rockland · Ontario

A modern interface. A COBOL calculation.

Follow a synthetic order from a typed web form through a fixed-width record contract to a native business-processing program.

INSIDE THE BUILD

Legacy Bridge

A modern interface connected to established business logic.

Validated request, transformed records, native business logic: a checked result.

$235.63 net · 3 records

SYNTHETIC BATCH / EXCERPTCAD

DEMO00000001

Quantity
3
Unit price
$12.50
Discount
5 %
This record, netRecorded result$35.62

Interface, validated request, record transformation, native business logic, checked result. The first of three records in this batch.

View the JSON request
{
  "currency": "CAD",
  "records": [
    {
      "recordId": "DEMO00000001",
      "quantity": 3,
      "unitPriceMinor": 1250,
      "discountBps": 500
    },
    {
      "recordId": "DEMO00000002",
      "quantity": 2,
      "unitPriceMinor": 9999,
      "discountBps": 0
    },
    {
      "recordId": "DEMO00000003",
      "quantity": 7,
      "unitPriceMinor": 1,
      "discountBps": 5000
    }
  ]
}
FROM INTERFACE TO INFRASTRUCTURE
  1. Interface

    What people see

  2. Application

    The work to be done

  3. API / integration

    Systems exchanging information

  4. Database

    Records and their rules

  5. Server

    The application environment

  6. Network

    Connections and access

  7. Users & operations

    The everyday working reality

Follow a problem through its dependencies.

The problem

Modernizing business software often means introducing a new interface without casually changing the rules that determine money. A clean screen is only useful when the calculation and the integration contract remain explainable.

My role

Website demonstration design and implementation

The result

The demonstration provides an inspectable route from a modern form to a native calculation. Its acceptance criteria focus on exact results and safe failure, with deployment compatibility treated as a separate operational requirement.

Actual native calculation: the synthetic batch returns CAD 235.63.
DEMO CAPTUREActual native calculation: the synthetic batch returns CAD 235.63.Enlarge the capture

Implementation decisions

  • Validate the modern input before serializing a narrow ASCII record protocol, then validate the native output before displaying it.
  • Keep the business calculation in the native program. An unavailable executable produces an unavailable state.
  • Expose the record representation alongside the result so that the integration boundary is inspectable.
  • Keep replay information in the visitor's browser and distinguish repeated input from a changed payload using the same identifier.

Have an established system that needs to work with something new?

This example can be a starting point for defining your own project, its dependencies and acceptance criteria.

Custom software & business applications

Automation & systems integration

Legacy systems & database modernization

Context, architecture and technical evidence

Constraints, alternatives, validation and evidence limitations.

Operational context

This is a purpose-built demonstration with synthetic orders. It makes the boundary between a modern application and a legacy-style processing program visible: JSON, fixed-width records, native execution and parsed results.

Typed input
Validated records
Native COBOL
Checked output
The web boundary validates input, serializes fixed-width records, invokes one packaged program, and validates its response before presenting totals.

My contribution

I designed the bounded record contract and the visitor-facing workflow so that inputs, transformations, calculations and failures can be inspected together. The example demonstrates an integration pattern; it does not represent a customer system or a mainframe deployment.

Constraints

  • At most 25 order records and a 16 KiB request body.
  • Integer minor units, explicit per-line rounding and no floating-point money arithmetic.
  • A fixed executable with bounded input, output and execution time.
  • No visitor-provided source, command, path or network target.

Alternatives considered

  • Reimplementing the calculation in TypeScript would hide the native integration question this example is meant to answer.
  • Accepting arbitrary COBOL or shell commands would create an unrelated execution service and a much larger trust boundary.
  • A floating-point total would make cent-level rounding dependent on representation rather than the declared business rule.

Validation approach

  • Golden batches, zero and full discount, half-cent rounding and maximum allowed values.
  • Malformed records, duplicate identifiers, invalid quantities and out-of-range values.
  • Native process absence, timeout, oversized or corrupt output, and replay conflicts.

Limits of the evidence

  • Synthetic examples establish only the demonstrated behaviour, not production scale or mainframe experience.
  • Native execution depends on the configured runtime; the interface reports dependency failures instead of inventing a result.
  • A browser-local replay ledger is not a shared transaction system.

Inspect the work

Run the Legacy Bridge

Inspect the site's trust boundaries