Know the source stack before you pick the target.

COBOL to Java Spring Boot: extract the spec before you write the service

Spring Boot teams fail on COBOL when they port paragraphs instead of rules. This guide shows how to turn copybooks, COMP-3 fields and PERFORM chains into contracts a Java team can build against.

CICS to REST: turning COMMAREAs and BMS maps into OpenAPI 3.1

A CICS transaction already is an API: a COMMAREA in, a COMMAREA or a screen out. This guide shows how to recover that contract and its hidden state before you put REST in front of it or replace it.

VB6 to C# on modern .NET: extract the rules hiding in forms and modules

VB6 applications keep their business logic in button click handlers, global modules and Variant arithmetic. This guide covers the type and error-handling traps and the extraction workflow that turns them into a spec for C#.

PL/SQL stored procedures to microservices: lift rules out of the database

Decades of business logic live in Oracle packages and triggers. This guide shows how to find every rule and every hidden write so service boundaries are drawn around real behavior.

Java EJB to Quarkus: recover the contracts the container was enforcing

Half of an EJB application's behavior lives in deployment descriptors and container semantics, not in Java. This guide shows how to extract both so a Quarkus team builds against the full contract.

Struts to React and FastAPI: move validation from ActionForms into API schemas

Struts apps spread one screen's behavior across struts-config.xml, validation.xml, an ActionForm and an Action. This guide shows how to reassemble it into an API contract and a rule set.

JCL to cloud batch orchestration: translate COND codes, GDGs and PROCs into a job graph

JCL is a dependency graph written in negative logic. This guide shows how to read COND, IF/THEN, GDGs and utility control cards as a specification for Airflow, Argo, Step Functions or any other orchestrator.

VSAM to PostgreSQL: keys, encodings and record layouts done right

A VSAM file has no schema of its own: the schema is the copybook, the keys are in IDCAMS, and the rules are in every program that reads it. This guide shows how to assemble all three into PostgreSQL DDL and data contracts.

IMS DB to relational: extracting tables, keys and access paths from DBDs and DL/I calls

IMS stores a hierarchy and programs navigate it with GU, GN and GNP calls. This guide shows how to derive a relational schema that keeps the keys, ordering and access rules the programs depend on.

COBOL to Go microservices: decimal rules, explicit errors and small services

Go suits small, explicit services, which is the opposite of a 9,000-line COBOL program. This guide shows how to cut the program into decisions and contracts first, and which COBOL semantics Go handles differently.

COBOL to C# and .NET: precision, rounding and compiler options you have to carry over

C# decimal looks like a natural home for COBOL arithmetic, and mostly it is. This guide covers the places it is not, and the extraction workflow that hands a .NET team reviewed decision tables instead of paragraphs.

T-SQL stored procedures to .NET services: return codes, NULLs and hidden writes

SQL Server procedures encode rules in return codes, @@ROWCOUNT checks and three-valued logic. This guide shows how to surface those rules and their side effects so .NET services reproduce them deliberately.

ASP.NET WebForms to React: pull rules out of ViewState, validators and code-behind

WebForms pages hide state in ViewState, validation in server controls and business logic in click handlers. This guide shows how to separate the three so a React front end and an API can be built against a reviewed contract.

WCF to REST: DataContracts to JSON Schema, FaultContracts to error responses

WCF contracts are already formal, which makes them a good starting point and a trap: the serializer adds behavior the attributes do not show. This guide covers both and the workflow to a reviewed OpenAPI document.

Informix 4GL to Java: extracting rules from INPUT blocks, forms and SQL

Informix 4GL applications put validation in AFTER FIELD blocks, constraints in form files and data rules in embedded SQL. This guide shows how to gather all three into a specification for a Java rebuild.

COBOL copybooks to JSON Schema 2020-12: every PIC clause, mapped and traced

Copybooks are the data contracts of a mainframe estate. This guide shows how to turn them into JSON Schema that APIs, event streams and data pipelines can share, without losing precision or meaning.

EJB entity beans to JPA and Spring Data: CMP fields, CMR relationships and EJB QL

EJB 2.x entity beans spread one entity across a bean class, two interfaces, ejb-jar.xml and a vendor mapping file. This guide shows how to assemble the full entity model, with its finders and lifecycle rules, for a JPA rebuild.

Spring XML to Spring Boot: find the business logic hiding in AOP and wiring

Moving Spring XML to @Configuration looks mechanical until an aspect turns out to apply a discount. This guide shows how to inventory wiring, transactions, aspects and properties before you convert any of it.

COBOL batch to Kafka: control breaks, trailers and restart become events and contracts

Nightly batch assumes sorted input, a business date and a rerunnable job. Kafka gives you none of those for free. This guide shows how to extract what the batch relies on so the streaming design provides it deliberately.

VB6 COM and ActiveX components to REST: contracts, transactions and the callers you forgot

VB6 ActiveX DLLs often sit under several applications at once, behind ProgIDs nobody has listed. This guide shows how to extract each component's contract and its consumers before you replace it with a REST service.