Our API layer speaks CICS, IMS, and batch interfaces the way they were designed to be spoken. No half-baked adapters that need constant patching when your mainframe team changes a transaction layout.
Case studies from Australian enterprises where legacy mainframe systems were connected to modern networks through custom API bridges. Each one documents the architecture, the constraints, and the outcome.
Every engagement we publish follows the same ground rules. We name the system type, the integration pattern, and the constraints we worked inside. We do not publish figures we cannot verify, and we change client identifiers where the contract requires it. If a case study mentions a timeframe or a team size, that detail was confirmed by the client contact named on the page.
Field notes from integration teams who moved mainframe workloads onto modern API rails. Each note names the system, the constraint, and what changed after the bridge went live.
Our AS/400 order system had been running the same RPG routines since 2004. Heirapi mapped the transaction flow, built a REST layer over the old queue, and cut our order lookup time from four minutes to under two seconds. The warehouse team stopped keeping a second screen open just to check inventory.
The mainframe team at the port authority was skeptical about exposing COBOL copybooks to a web dashboard. Heirapi kept the read-only endpoints separate from the update paths, added field-level masking, and gave the operations crew a live view of vessel schedules without touching the core batch jobs.
We had a nightly batch that pushed customer records from the legacy CRM into a data warehouse. The batch kept failing on date formatting mismatches. Heirapi replaced the file transfer with a change-data-capture feed, and the warehouse now sees updates within fifteen minutes instead of the next morning.
The insurance underwriters still relied on a green-screen terminal for policy lookups. Heirapi built a thin API wrapper that let the claims portal query the same mainframe data with proper session handling. The terminal is still there, but nobody opens it more than once a week now.
Connecting the legacy HR system to the new payroll service took longer than expected because the mainframe used EBCDIC encoding and packed decimals. Heirapi documented every field mapping in a shared spec, so the payroll vendor could test against the same contract we used. Go-live took one weekend.
Most integration projects stall on protocol translation, session handling, and audit trails. We build the layer that makes those problems disappear, and we have the case work to show how it holds up in production.
Our API layer speaks CICS, IMS, and batch interfaces the way they were designed to be spoken. No half-baked adapters that need constant patching when your mainframe team changes a transaction layout.
Mutual TLS, service account vaulting, and field-level encryption are part of the bridge itself, not an afterthought. Every call is logged on both sides so your audit team can trace a request end to end.
We add event-driven flows alongside your existing nightly jobs, so you get live data where it matters without re-platforming the mainframe. Change data capture keeps both worlds consistent.
Our reference patterns for session pooling, error mapping, and data normalization cut the usual discovery phase short. One logistics client went from kickoff to a working pilot in under a month.
Every bridge ships with runbooks, retry policies, and monitoring dashboards your NOC can actually use. You are not left holding a black box when something needs tuning.
We work within your change windows, your data residency rules, and your vendor approval process. The bridge fits the way your organisation already runs, not the other way around.