Modernization path

Modernize an AS/400 estate to cloud-native architectures.

Migration of AS/400 applications (IBM i, RPG, DB2/400) to Java, .NET Core, or TypeScript. ATLAS methodology, business knowledge preservation, progressive cutover.

Key figures
< 100
new RPG developers trained per year worldwide
IBM
8:1
rewrite ratio from RPG Free Form to Java or TypeScript
By batches
incremental delivery, duration set at scoping
ATLAS methodology applied

From scoping to deployment, five structured phases.

Each phase aggregates one or more of the ten ATLAS steps. No phase starts until the previous one has delivered its validated artefact. The ATLAS methodology makes AS/400 migration predictable and auditable.

  1. 01Phase 1

    Scoping

    ATLAS steps
    E1 Intake · E2 Discovery · E2b Functional specification

    Understand the existing RPG, COBOL/400, CL estate. Rebuild a usable functional analysis. Define scope, constraints, and success criteria.

    Phase deliverable
    Estate inventory + functional specification + pricing
  2. 02Phase 2

    Capture & dependencies

    ATLAS steps
    E2e Existing-system capture · E3 Dependency mapping

    Set the ground truth: 5250 screens, reports, datasets, recorded transactions. Map subsystems, queues, DB2/400 databases, integrations exhaustively.

    Phase deliverable
    Reference transaction bench + complete mapping
  3. 03Phase 3

    Target architecture

    ATLAS steps
    E4 Target architecture · E4b Pre-migration tests

    Choose the target (Java + Spring Boot, .NET Core, TypeScript), design RPG migration patterns, SFL subfiles, data queues. Prepare the characterization test suite before any porting.

    Phase deliverable
    Signed target architecture + characterization test suite
  4. 04Phase 4

    Migration & parity

    ATLAS steps
    E5 Migration · E6 Parity validation

    Translate pattern by pattern with line-by-line traceability. Incremental migration by subsystem (strangler fig). Signed parity audit between legacy and target on every delivered batch.

    Phase deliverable
    Target code + parity audit per subsystem
  5. 05Phase 5

    Deployment & handover

    ATLAS steps
    E7 Delivery

    Progressive go-live, IBM i ↔ target coexistence whose duration is set at scoping based on risk profile, batched transactional cutover, internal classified discrepancy registry, ops handover to the client team.

    Phase deliverable
    Application in production + autonomous client team
At the core of the ATLAS method

AI to understand RPG / AS-400, not to translate it.

On IBM i, RPG and the DB2/400 database are intertwined: programs rely on native record-level access and on constraints carried by the system rather than the schema. Automatic RPG conversion produces target code assuming a conventional relational database, while integrity rules lived elsewhere. End-to-end automatic translation isn't a modernization method, it's a debt transfer.

Our approach is the opposite. ATLAS relies on multiple readings of the source code, from several angles. Here, what we read first: native record-level access to translate into set-based queries, and system-carried integrity rules to re-express in the target schema. AI comes in as a comprehension accelerator, to decipher years of accumulated business logic, reverse-document uncommented branches, surface the intent behind the code. It doesn't decide and it doesn't translate. It informs the architect's work, who then designs the target architecture and drives the migration pattern by pattern, under parity audit.

This understanding still requires humans who know the source technologies. That's our edge: where Europe and North America face a retirement wave on these skills, Tunisia retains experienced RPG and IBM i developers, paired with modern architects. Together they ensure continuity between the original business intent and the target system.

Who is concerned

Business context and modernization stakes.

AS/400 in companies today

AS/400 — renamed IBM i since 2008 — remains remarkably present in SMEs and mid-caps in distribution, manufacturing, logistics, food industry, retail sectors. Many of these companies acquired their AS/400 in the 1990s to 2005s and still operate it today. The platform stands out for its exceptional operational stability (availability above 99.99% without intervention), its integrated model (OS, integrated DB2/400 database, native security), and its longevity (code written in 1995 still runs today without recompilation).

Why modernize AS/400

Three forces push for IBM i modernization: growing shortage of RPG developers (IBM indicates fewer than 100 new developers trained per year worldwide), significant IBM Power license costs at hardware renewal, and integration limitations with modern REST, GraphQL, event APIs. IT departments hesitate because AS/400 works perfectly, but the demographic cliff of RPG skills makes the decision inevitable in 5-10 years. Our ATLAS methodology is suited to this long trajectory.

AS/400 source languages

An AS/400 estate typically combines three languages: RPG (the most common, from RPG II to modern RPG Free Form), COBOL (sometimes coexisting with RPG), CL (Control Language for system scripts). Each language has its own migration patterns. Classic RPG II / III is harder to migrate than RPG Free Form which is closer to a modern language. COBOL on AS/400 follows the COBOL to Java or .NET Core path. CL is generally rewritten directly in shell script or modern orchestrator (Airflow, Kubernetes CronJobs).

Source platform

AS/400 (IBM i, RPG, DB2/400, CL)

Target technology

Java, .NET Core, TypeScript, PostgreSQL, containers

Technology alternatives

Compare target trajectories.

Java 21 + Spring Boot + PostgreSQL + Kubernetes

Strategic AS/400 estate, need for transactional robustness, Java teams in-house or accessible via integrators. Default choice for SMEs and mid-caps wanting maintainable code long-term.

.NET Core 8 + C# + SQL Server + Azure

Microsoft ecosystem dominant in IT, integration with Dynamics 365 or Power Platform. See COBOL to .NET Core for arithmetic subtleties.

TypeScript + Node.js + PostgreSQL + Cloudflare/Azure Functions

Moderate workloads, priority on velocity and cloud cost. Suited to management and e-commerce applications. See COBOL to TypeScript.

Rehosting via IBM i on cloud (IBM Power Virtual Server, Skytap)

Urgency to exit physical hardware without immediate redesign. Lift-and-shift approach preserving RPG on IBM cloud. Useful as temporary stepping stone, not as final target.

Scoping reference

Typical duration and team for this path.

An AS/400 modernization is structured as a sequence of functional batches, with the cadence set at scoping based on volume and criticality. The cell combines an AS/400-cloud architect capable of bridging both worlds, a tech lead on the target language (Java, .NET, TypeScript), developers ideally with an RPG or COBOL background, a DB2/400-PostgreSQL DBA for data migration, a cloud network engineer, a QA. Composition and headcount are not fixed upfront: they are determined after the POC and scoping, once the real work has been measured.

Challenges

  • Porting RPG logic to a modern language with functional parity.
  • Migrating DB2/400 databases to PostgreSQL or SQL Server.
  • Reproducing specific mechanisms (subfiles, data queues).

ATLAS approach

  • Existing-system capture: RPG programs, 5250 screens, databases.
  • Choice of target architecture per client priorities.
  • Incremental migration with parity audit.

Expected outcomes

  • Modern, maintainable, deployable applications.
  • Automated test suite, complete documentation.
Identified pitfalls and ATLAS response

What we learned on this migration path.

Pitfall 01

Underestimating the specificity of RPG subfiles (SFL). 5250 subfiles are tabular display patterns with native pagination that have no direct equivalent in modern web.

ATLAS response

Explicit porting of subfiles to web data tables (AG Grid, Material UI Table) with cursor-based pagination. Native AS/400 functions (READC, REFRESH, UPDATE) are reproduced as REST endpoints with client-side state management. UX parity tests on bulk entry/consultation workflows.

Pitfall 02

Ignoring data queues and data areas AS/400, inter-program communication mechanisms specific to IBM i.

ATLAS response

Replacement with modern message queues (Azure Service Bus, RabbitMQ, Apache Kafka per context). Global data areas become entries in Redis or a key-value database. Unit tests on producer-consumer communication patterns to validate isofunctionality.

Pitfall 03

Forgetting DB2/400 specifics. DB2 for i differs from classic DB2 and PostgreSQL by its integrity rules, triggers, naming constraints (long names vs system tables 10 characters).

ATLAS response

Exhaustive DB2/400 schema mapping from discovery phase. Migration to PostgreSQL with table name adaptation, triggers ported as PL/pgSQL functions, materialized views reproduced. Parity tests on representative datasets with automatic reconciliation.

Pitfall 04

Neglecting IBM i security mechanisms (user profiles, authorities, system groups). IBM i has very fine integrated security that target systems do not natively reproduce.

ATLAS response

Target RBAC model designed from the architecture (Role-Based Access Control). AS/400 user profiles are mapped to a modern directory (Active Directory, Keycloak, Auth0) with granular roles and permissions. Non-regression tests on each user profile with representative access scenarios.

Pitfall 05

Wanting to migrate everything at once. An AS/400 estate accumulated over 15 to 25 years often contains forgotten programs, hidden dependencies, undocumented workflows.

ATLAS response

Mandatory strangler fig strategy. We migrate subsystem by subsystem, the least critical transactions first. IBM i-cloud coexistence for 2 to 4 years. Progressive decommissioning of migrated programs. See the ATLAS methodology for the detailed protocol.

Cell composition

A specialized cell for this modernization path.

Several distinct profiles, mobilized over the full program duration. Reproducing this cell internally is rarely realistic — the legacy skills shortage and ATLAS expertise depth make outsourcing structurally faster and less risky.

Duration
Set at scoping based on volume and criticality
Volume
Determined after the POC and scoping
Profiles

AS/400 ↔ Cloud architect

Bridge between both worlds, target design, technical governance

Target language Tech Lead

Java 21 / .NET Core 8 / TypeScript depending on the architecture choice

Developers

Ideally with an RPG or COBOL background for pattern-by-pattern translation

DBA DB2/400 → PostgreSQL

Schema migration, triggers, materialized views, data parity audit

Cloud network engineer

IBM i / target cloud coexistence, security, integrations

QA & functional parity

Test bench, legacy/target comparison, ATLAS audit validation

Access field experience

This path in real conditions.

Access POC — multi-sector

AS/400 RPG patterns tested as part of our 10 global POCs. Modern RPG Free Form migrates with a ratio close to COBOL, around 8:1 to Java or TypeScript. Specifics (subfiles, data queues, DB2/400) are documented in our ATLAS catalog.

Ratio 8:1 RPG → Java/TS · cataloged patterns
Frequently asked questions

What decision-makers ask about this path.

Does IBM still support AS/400 / IBM i?+

Yes, IBM continues to invest in IBM i. The current version IBM i 7.5 was released in 2022 and a 7.6 version was announced. IBM guarantees support until 2030 minimum for recent versions. The decision to migrate therefore does not come from imminent IBM end-of-support, but from strategic considerations: RPG skills shortage, costs, modern web integration. It's a 5-10 year decision, not urgent.

Can we keep IBM i and just modernize the user interface?+

Yes, this is IBM i web-facing. Tools like Profound UI, looksoftware, Aura, or Rational Open Access for RPG components allow dressing an existing RPG application with a web interface without rewriting the back-end. Pros: fast modernization, business code preservation, lower investment. Cons: vendor dependency, evolution limits, license costs. It's a transition solution, not a long-term strategy — to combine with a progressive back-end migration plan.

What ratio of RPG lines to Java/TypeScript?+

Modern RPG Free Form: ratio about 8:1 (8 RPG lines per 1 Java/TypeScript line), comparable to COBOL. Classic RPG II / III: tighter ratio 5:1, because old RPG is very verbose with its fixed specifications. CL translates with a variable ratio depending on target shell (bash, PowerShell, orchestrator). Target volumes are smaller than sources thanks to modern framework primitives.

How to handle 5250 screens (AS/400 green interface)?+

5250 screens are replaced by a modern web interface (React, Angular, Vue). 5250 workflows oriented to function keys (F3 = exit, F12 = back) are translated to web workflows with explicit buttons and configurable web keyboard shortcuts. 5250 subfiles become paginated web tables. The user experience is rethought — users trained on 5250 need support during transition but generally find the web version more productive after 4 to 6 weeks of use.

How much does an AS/400 modernization cost?+

For an estate of one hundred thousand RPG lines with about fifty 5250 screens in nearshore co-delivery, plan one to one million five hundred thousand euros including UX, development, tests, user training. For three hundred thousand lines, budget two to four million euros. Cost typically lower than mainframe migration thanks to more modest estate sizes. See the delivery models for contractual formats.

Can we do Build-Operate-Transfer on an IBM i modernization?+

Yes, it's even a good fit. The BOT model consists of entrusting the modernization cell to Access for 2-4 years, then progressively transferring the team to your internal organization. Suited to mid-caps wanting to internalize their target skills while avoiding startup risk. See the development center for BOT contractual terms.

When does the AS/400 reach end of life?+

There is no IBM-imposed end of life for the AS/400 — IBM rebranded it to iSeries then IBM i and continues active investment. The current version IBM i 7.5 was released in 2022 with support guaranteed at least to 2030. The decision to modernize therefore does not come from imminent IBM end-of-support. The real drivers are: shrinking RPG developer talent, hardware cost (Power systems are not cheap), modern integration friction (cloud, mobile, AI all require workarounds), and business agility requirements that the green-screen experience cannot match. Modernization is a 5-10 year strategic decision, not an emergency. The ATLAS methodology handles AS/400 modernization to Java, .NET Core, or TypeScript with proven parity. See the AS/400 modernization journey.

Is Java or .NET better for AS/400 modernization?+

It depends on your existing ecosystem and what you want to gain from the migration. Pick Java when your platform is already built around Spring, Kafka, Kubernetes, or open-source databases (PostgreSQL, MariaDB) — Java's library depth on financial transactions, AS/400-style record I/O, and its long-term language stability make it the safer default for large RPG estates. Pick .NET Core 8 when your organization runs on Microsoft (Azure, Dynamics 365, Power Platform) — interop with the rest of the stack saves real money, and modern C# is now on par with Java on every dimension that matters. But the choice of Java vs .NET is the second decision. The first is what experience you want on the other side: leave the green-screen behind, expose the system as APIs, prepare for AI-assisted evolution. A line-for-line port has the worst ROI of all options. The ATLAS methodology frames this with a internal classified discrepancy registry.

Considering AS/400 modernization?

Three concrete ways to start — from a free diagnosis to a full modernization cell. Our AS/400 / IBM i 7.5/7.6 approach is documented, priced, and applicable from the first meeting.