Mainframe developer to FDE: COBOL copybooks meet AI pipelines

Decide from what you already do: a transfer table

Each row starts from a mainframe artefact you work with and says what it proves, what it does not, and what to build on top.

Read the table as a plan. The last column is your learning list, and every item builds on something you have done for years.

The first project: decode a copybook file for an AI retrieval pipeline

An AI assistant that answers questions about policies or accounts needs clean, typed data. On a mainframe, that data is often a fixed-width file with packed decimal (COMP-3) amounts that most engineers cannot even open. Build the bridge.

Suppose a synthetic copybook:

01 POLICY-REC.
   05 POLICY-NO      PIC X(8).
   05 HOLDER-NAME    PIC X(12).
   05 PREMIUM        PIC S9(7)V99 COMP-3.
   05 STATUS-CD      PIC X(1).

PIC S9(7)V99 COMP-3 holds nine digits plus a sign in five bytes, two digits per byte, with the sign in the last half-byte (C for positive, D for negative) and an implied decimal point two places from the right. The Python below builds three synthetic records in that layout and decodes them.

from decimal import Decimal

def pack(value_paise: int, length: int = 5) -> bytes:
    """Encode an integer (amount in paise) as COMP-3 for the synthetic test file."""
    sign = 0xD if value_paise < 0 else 0xC
    digits = str(abs(value_paise)).rjust(length * 2 - 1, "0")
    nibbles = [int(d) for d in digits] + [sign]
    return bytes((nibbles[i] << 4) | nibbles[i + 1] for i in range(0, len(nibbles), 2))

def unpack(raw: bytes, scale: int = 2) -> Decimal:
    nibbles = []
    for b in raw:
        nibbles += [b >> 4, b & 0x0F]
    sign = -1 if nibbles[-1] == 0xD else 1
    number = int("".join(str(n) for n in nibbles[:-1]))
    return Decimal(sign * number).scaleb(-scale)

LAYOUT = [("policy_no", 8, "x"), ("holder", 12, "x"), ("premium", 5, "p"), ("status", 1, "x")]
RECLEN = sum(width for _, width, _ in LAYOUT)

# Synthetic records (hypothetical policies). Real files would also need EBCDIC decoding (cp037).
records = [
    b"PL000101" + b"A SHARMA    " + pack(1845050) + b"A",
    b"PL000102" + b"R IYER      " + pack(-25000) + b"C",
    b"PL000103" + b"K SINGH     " + pack(990000) + b"A",
]
data = b"".join(records)

rows = []
for i in range(0, len(data), RECLEN):
    rec, pos, row = data[i:i + RECLEN], 0, {}
    for name, width, kind in LAYOUT:
        field = rec[pos:pos + width]
        row[name] = unpack(field) if kind == "p" else field.decode("ascii").strip()
        pos += width
    rows.append(row)

for r in rows:
    print(r)

assert RECLEN == 26
assert rows[0]["premium"] == Decimal("18450.50")
assert rows[1]["premium"] == Decimal("-250.00")

It prints three policies with premiums of 18450.50, -250.00 (a refund adjustment) and 9900.00. On a real extract you would decode text fields from EBCDIC (Python's cp037 codec) rather than ASCII, handle REDEFINES by branching on a record-type field, and reconcile the row count and premium total against the batch job's control totals. That reconciliation step is the part to emphasise: it is what makes downstream AI answers trustworthy, and it is exactly the discipline mainframe teams already have.

Extend the project by loading the rows into SQLite, then writing a short note on how an assistant should answer "what is this policy's premium?" only from the reconciled table, and refuse when a policy is missing.

Where the gap is widest

From the table, the hardest rows for most mainframe developers are the last two: modern delivery tooling and distributed systems. Model evaluation is new for almost everyone. If you want a structured route, FDE for Professionals is aimed at experienced engineers and covers production AI, data-platform retrieval, containers and client delivery; its schedule is proposed, so confirm details with a counsellor. For eligible learners meeting attendance and capstone criteria, it includes assured job interviews through our hiring network.

Modernisation and integration roles as the bridge

Look first for modernisation-shaped roles where legacy knowledge is the entry requirement: data or integration engineer on a mainframe modernisation programme, solutions engineer for a product that connects AI to core banking or insurance systems, or a forward deployed role with clients in those sectors. Each lets you add modern skills without discarding the part of your experience that is hardest to replace.

Explaining the move

"I have spent eleven years on COBOL and DB2 in a policy administration system. What I kept seeing was that every new digital or analytics project stalled at our data: nobody else could read a copybook or trust a packed decimal. I taught myself Python by writing the decoder I could show you, with reconciliation against control totals, and then learned SQL on a warehouse and basic container deployment. I want to work on putting AI on top of systems like ours, where the risk is a wrong answer about somebody's policy. I know how to make batch data trustworthy, and I am building the modern delivery skills to go with it."

The FDE hub explains the role and its day-to-day work in more detail.