COBOL modernization
Your COBOL isn't the problem. Who can read it is.
Pebble Stream turns COBOL batch programs into spreadsheets your finance, operations and audit teams can check, and your systems can run, proven field for field against the original.
Evaluation terms online · secure upload · you choose when your code is deleted
Before · CBACT04C, paragraph 1300-COMPUTE-INTEREST
COMPUTE WS-MONTHLY-INT
= ( TRAN-CAT-BAL * DIS-INT-RATE) / 1200After · readable in Excel
=ROUNDDOWN(D2 * G2 / 1200, 2)Column note: replaces 1300-COMPUTE-INTEREST; truncates like COBOL
The problem
Decades of business rules, readable by a shrinking few.
Interest accrual, fee schedules, allocations, tax withholding: each is a rule your finance team owns, written in COBOL paragraphs they can't open.
The authors are retiring
The people who wrote and maintained the code are leaving, and their knowledge goes with them.
The owners can't verify it
Finance, operations and audit answer for rules they have no way to read.
Every change waits
A rate change or a new fee is a project for a specialist, not an edit.
The usual fix
Rewriting COBOL in Java or C# moves the rules. It doesn't open them up.
Same problem. Newer language.
Still code
The logic is still something only developers can read.
Still COBOL, in disguise
Automated translation often yields Java that reads like COBOL, sometimes called JOBOL.
Still closed to the business
Finance, operations and auditors still can't check the rules they answer for.
Tomorrow's legacy
In a decade, it's the system someone else has to migrate.
A different target
Put the rules where the business already works: the spreadsheet.
From
A COBOL batch program
Its paragraphs, copybooks and the JCL that runs it.
To
An Excel workbook
Worksheets and formulas, with PebbleScript in each column's note saying how data flows.
Run as
A governed, versioned service
Pebble Stream compiles the workbook into an API that Flow runs in your cloud.
Finance reads it in Excel. Your systems call it like any other service.
The data flow
The whole program, on one page.
Inputs: the four VSAM files and the JCL PARM. Calculations: keyed reads, the rate lookup, interest and the control break. Outputs: the TRANSACT file and the updated account master.
In COBOL, this flow is scattered across JCL, file definitions and paragraphs. Zen draws it from the workbook.
PebbleScript
Every COBOL construct has a spreadsheet equivalent.
And the result is a PSOSF package: plain text, diffable in Git, signed, with its tests inside, and it round-trips with Excel.
| COBOL | PebbleScript |
|---|---|
| Copybook record layout | Typed columns; pebblestream:text keeps leading zeros |
| Keyed VSAM read | join and outer-join |
| SORT and control breaks | sort, group and sum |
| 88-level conditions | allowed-values |
| ABEND on bad data | fail, which stops the run |
| Packed-decimal arithmetic | BigDecimal mode; ROUNDDOWN truncates like COBOL |
The conversion
An LLM translates. Verification proves it.
- 1
Parse
A COBOL parser maps copybooks, paragraphs and data flow, and slices the program into rules.
- 2
Translate
An LLM writes each rule as worksheets, formulas and PebbleScript, checked against the directive registry.
- 3
Run both
The original COBOL and the workbook process the same input files.
- 4
Compare
Outputs are diffed field by field; mismatches go back to the LLM until every field agrees.
- 5
Keep the proof
Every parity case becomes a test inside the PSOSF file, run on every change.
Proof point
We converted the interest calculation in AWS's open-source CardDemo.
COBOL program CBACT04C: rate lookup with a default fallback, monthly interest, transaction records and account updates. Run in Pebble Stream on test data built to hit every branch, the workbook matched the original's output field for field, down to how it truncates cents.
Also found
A latent defect: the original never updates the last account it processes. One switch replicates it for parallel running; flip it to correct it.
- 12
- worksheets
- 7
- tests inside the file
- 100%
- of fields matched the original
The rules become something the business owns again.
Finance reads the formulas
Every rate, rounding rule and exception is visible in Excel.
Auditors trace every rule
Each column's note names the COBOL paragraph or field it replaces.
Fixes are reviewable
Change the workbook, rerun the tests, sign the new version.
No second legacy
The next team inherits a spreadsheet, not another codebase.
Parallel running is built in: match the mainframe first, quirks included, then correct them as reviewed changes.
Send us one program
See your rules as a spreadsheet, tested against the original.
Tell us about the program and accept our evaluation terms online (or send your NDA). We confirm within one business day, then you upload it securely. You choose how long we keep your code; it's deleted automatically when that time is up.
Free COBOL evaluation
About three minutes to start. Programs, copybooks and JCL, or a zip of them.
Start your evaluationOpens our evaluation page with COBOL already selected.