Most IBM i modernization projects do not stall because the target language is hard to write. They stall because a program written in 1988 quietly updates three files nobody documented, and the team finds out in production. An IBM i modernization assessment is the step that catches that program before anyone moves it. It answers the plain question C-suite buyers keep asking: if we change this, what happens?
For banks, insurers, and manufacturers running RPG on IBM i, that question is the whole game. The code has run for decades. The people who wrote it are retiring. A migration that begins without a map is a migration that discovers its own risks the expensive way.
What an IBM i Modernization Assessment Actually Answers
An assessment is not a rewrite, and it is not a sales demo. It is a structured read of your existing system that produces answers your team can act on. Done properly, an IBM i modernization assessment tells you:
- Which programs, files, and copy members depend on each other, and how tightly they are wired together.
- What each program does, written in plain English that your newer staff can actually follow.
- Where copy members are missing or where dependencies cannot be resolved.
- Which parts of the codebase are ready to move and which need human review first.
That last point matters. An assessment that treats every program as equally safe to convert is selling you optimism. Real systems carry dead routines, duplicated logic, and objects that only one nightly job ever touches. You want those flagged early, not discovered during a cutover weekend.
Why 40 Years of RPG Resists a Blind Migration
There is a reason companies have run these systems since the 1970s. IBM i is fast, stable, and does exactly what it was told to do for a very long time. The price of that stability is business knowledge that lives inside the code and nowhere else. Retirements take that knowledge out the door, and the documentation, if it exists, describes a version of the system from three rewrites ago.
RPG also arrives in more than one shape. Fixed-format and free-format source, DDS-defined files, display files, and printer files all behave differently and all have to be understood before they can be modernized. AS/Forward reads six RPG dialects through a proprietary ingestion layer, then builds structured descriptions and dependency maps from what it finds. That structured context is what turns a pile of source into something a team can reason about.
Dependency Mapping: Knowing What Breaks Before You Touch It
The core of the assessment is an interconnection graph of your codebase. Instead of guessing which programs share a file, you see the edges. When someone proposes changing a single field or object, the migration view scopes the blast radius and shows every program, file, and report that moves with it.
This is the difference between a modernization plan and a modernization gamble. A field length change that looks trivial can ripple into a dozen programs and two print jobs. Mapping that impact in advance is how a 40-year codebase gets modernized on a schedule instead of on a prayer. The entire process runs air-gapped inside your own infrastructure, so nothing about your source code leaves your network.
You Choose the Target Language, Not the Vendor
Some shops want to move off RPG entirely. Others want to stay on IBM i and clean up fixed-format code into free-format. Plenty of buyers want to keep their green-screen workflows exactly as they are while modernizing what sits behind them. All of those are valid outcomes.
AS/Forward converts legacy code to the language your team wants to land in, whether that is free-format RPG, Python, or another modern language that fits your stack. The assessment comes first, the target decision comes second, and the second decision is yours. The tool does not force a rewrite you did not ask for.
What Your Team Walks Away With
The output is a report you can hand to a CTO and a lead developer in the same meeting. Each program page pairs the original source with a generated plain-English description, its dependency edges, warnings for anything unresolved, and a readiness status based on how confident the ingestion layer is in what it read.
Because AS/Forward feeds a model both the source code and that generated description, its AI output has real ground truth to work from rather than a guess. The approach is model-agnostic. It runs against Claude, OpenAI, Gemini, or local models on your own hardware, so regulated buyers keep their data private. AS/Forward carries one US patent pending for how it builds that context.
Start With the Map, Not the Rewrite
You do not have to commit to a full migration to get value from an IBM i modernization assessment. The map alone tells you what you own, what it costs to move, and where the real risk sits. That is often the most useful thing an IBM i team can put in front of leadership this year.
Golden Path Digital can run an assessment against your RPG codebase and show you the dependency map before you move a single program. Call 501-232-7188 to talk through your system and what a modernization assessment would surface.