The RPG Black Box: Banking Core Reclaiming Documented Process Flows

The most dangerous code in your bank isn’t the new API—it’s the RPG logic no one remembers writing.

For decades, the IBM i (AS/400) has been the silent engine of the financial world. It is reliable, performant, and utterly opaque. Today, major financial institutions are sitting on a $3.6 trillion global technical debt mountain, much of it locked inside fixed-format RPG (Report Program Generator) code that lacks even basic documentation. When the original developers retire, the "tribal knowledge" required to maintain these systems vanishes, leaving the bank with a "black box" core that is impossible to audit, let alone modernize.

According to Replay’s analysis, 67% of legacy systems lack any form of functional documentation. In the context of a banking core, this isn't just a technical hurdle; it’s a regulatory and operational risk. The traditional path—manual discovery and a total rewrite—is a recipe for disaster. Statistics show that 70% of legacy rewrites fail or significantly exceed their timelines, often stretching past the 18-month mark.

Replay offers a radical alternative: Visual Reverse Engineering. By recording real user workflows on these legacy green screens, Replay allows for a banking core reclaiming documented state in weeks rather than years, saving an average of 70% in modernization time.

TL;DR:

• •The Problem: RPG-based banking cores are undocumented "black boxes" that create massive technical debt and operational risk.
• •The Solution: Replay uses Visual Reverse Engineering to convert screen recordings of legacy workflows into documented React components and process flows.
• •The Impact: Reduce modernization timelines from 18-24 months to just weeks, reclaiming 70% of documented process flows automatically.
• •The Tech: AI-driven extraction of UI logic, SOC2/HIPAA compliance, and automated Design System generation.

The High Cost of the "Green Screen" Documentation Gap#

In a typical regional or tier-one bank, the core system handles everything from ledger entries to loan originations. These processes are often buried in thousands of lines of RPG code, where business logic is inextricably linked to the display files (DSPF).

When a bank attempts to modernize, the first step is usually "Discovery." This involves hiring consultants to sit with tellers and back-office staff, manually mapping out every "F-key" press and subfile selection. Industry experts recommend against this manual approach because it is prone to human error and ignores the "edge cases" that only appear in real-world usage.

Video-to-code is the process of capturing these live interactions as video data and using AI to parse the visual elements into structured code and architectural diagrams.

By utilizing Replay, banks can bypass the manual discovery phase entirely. Instead of 40 hours spent documenting a single complex screen, Replay reduces the effort to just 4 hours. This efficiency is the cornerstone of a banking core reclaiming documented processes that were previously thought lost to time.

Why Manual Documentation Fails in Financial Services#

Manual documentation is static; banking workflows are dynamic. An RPG program might behave differently based on hidden indicators or specific user permissions that aren't visible on the surface. When a business analyst writes a functional requirement document (FRD) based on an interview, they are capturing a recollection of the process, not the process itself.

The Documentation Debt Comparison#

As shown in the table, the shift from manual to automated discovery isn't just a marginal improvement—it's a paradigm shift. For a banking core reclaiming documented flows, the accuracy of the "Flows" feature in Replay ensures that every branch of a transaction is accounted for before a single line of new code is written.

Learn more about Legacy Modernization Strategies

Reclaiming the Flow: How Visual Reverse Engineering Works#

Replay doesn't just look at the code; it looks at the behavior. For an RPG system, the code is often "spaghetti," but the user interface—the 5250 terminal—is structured and predictable. By recording a teller performing a wire transfer, Replay’s AI Automation Suite identifies:

1. •Input Fields: Where data enters the system.
2. •Validation Logic: How the system responds to errors (e.g., "Insufficient Funds" messages).
3. •Navigation Paths: How the user moves from Screen A to Screen B.
4. •State Changes: How the UI updates based on backend triggers.

This process is what we call banking core reclaiming documented logic. It turns a visual recording into a "Blueprint," which serves as the bridge between the old world and the new.

From Green Screen to React: A Code Transformation#

Consider a standard RPG subfile used for displaying account transactions. In the legacy world, this is a wall of text. In the modern world, this needs to be a responsive React component with sorting, filtering, and accessibility features.

Here is how Replay might translate a legacy account summary screen into a documented TypeScript component:

typescript
// Generated by Replay Blueprints
// Source: RPG Core - ACCT_SUMM_01
import React from 'react';
import { Table, Badge, Button } from '@/components/ui';

interface Transaction {
  id: string;
  date: string;
  description: string;
  amount: number;
  status: 'pending' | 'cleared' | 'flagged';
}

export const AccountTransactionGrid: React.FC<{ data: Transaction[] }> = ({ data }) => {
  return (
    <div className="p-6 bg-white rounded-lg shadow-sm">
      <h2 className="text-xl font-bold mb-4">Account Transactions</h2>
      <Table>
        <thead>
          <tr>
            <th>Date</th>
            <th>Description</th>
            <th>Amount</th>
            <th>Status</th>
            <th>Actions</th>
          </tr>
        </thead>
        <tbody>
          {data.map((txn) => (
            <tr key={txn.id}>
              <td>{txn.date}</td>
              <td>{txn.description}</td>
              <td className={txn.amount < 0 ? 'text-red-500' : 'text-green-500'}>
                {new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(txn.amount)}
              </td>
              <td>
                <Badge variant={txn.status === 'flagged' ? 'destructive' : 'default'}>
                  {txn.status}
                </Badge>
              </td>
              <td>
                <Button variant="outline" size="sm">View Details</Button>
              </td>
            </tr>
          ))}
        </tbody>
      </Table>
    </div>
  );
};

This isn't just a UI component; it's a piece of documented logic. The

variant for "flagged" transactions captures a business rule that was previously hidden in an RPG indicator (e.g., ).

Banking Core Reclaiming Documented Workflows via AI#

The most significant challenge in banking is the "Flow." A single customer onboarding might span 15 different screens, including KYC checks, address verification, and core ledger initialization.

According to Replay’s analysis, manual flow mapping is the primary cause of project delays. When a banking core reclaiming documented workflow happens through Replay Flows, the AI automatically stitches together individual screen recordings into a comprehensive architectural map.

Automating the Design System#

One of the biggest hurdles in modernization is "Design Debt." Banks often have hundreds of internal applications that all look and feel different. Replay’s "Library" feature extracts the underlying patterns from legacy UIs to create a unified Design System.

Component-driven development is the practice of building user interfaces using isolated, reusable pieces, ensuring consistency and speed across an entire enterprise.

When Replay processes a banking core, it identifies repeating patterns—like "Customer Search" or "Currency Input"—and standardizes them into a React-based component library. This ensures that the modernized core doesn't just work better; it looks and feels like a cohesive product.

typescript
// Standardized Banking Input Component
// Reclaimed from Legacy RPG Field Validation Logic
import { useFormContext } from 'react-hook-form';

export const CurrencyInput = ({ name, label, min = 0 }) => {
  const { register, formState: { errors } } = useFormContext();

  return (
    <div className="flex flex-col gap-2">
      <label className="text-sm font-medium text-slate-700">{label}</label>
      <div className="relative">
        <span className="absolute left-3 top-1/2 -translate-y-1/2 text-slate-400">$</span>
        <input
          {...register(name, { required: true, min })}
          type="number"
          className="pl-8 pr-4 py-2 border rounded-md focus:ring-2 focus:ring-blue-500"
          placeholder="0.00"
        />
      </div>
      {errors[name] && <span className="text-xs text-red-500">Invalid amount</span>}
    </div>
  );
};

Security and Compliance in Regulated Environments#

For Financial Services, Healthcare, and Government, "cloud-only" is often a non-starter. Legacy modernization must happen within the bounds of strict regulatory frameworks.

Replay is built for these environments. With SOC2 compliance, HIPAA-readiness, and the option for On-Premise deployment, banks can perform a banking core reclaiming documented process without their sensitive data ever leaving their controlled network.

Industry experts recommend that any modernization tool used in banking must provide:

1. •Full Audit Trails: Who recorded the flow? Who approved the generated code?
2. •PII Masking: Automated blurring of sensitive customer data during the recording process.
3. •Air-Gapped Compatibility: The ability to run without an active internet connection for high-security zones.

The ROI of Automated Documentation

Reclaiming the Future: Beyond the Core#

Once the core logic is documented and converted to React, the bank is no longer tethered to the release cycles of the 1980s. They can begin to implement modern features like real-time fraud detection, AI-driven customer insights, and seamless mobile experiences.

The transition from a "black box" RPG system to a documented, componentized React architecture is the difference between surviving and thriving in the fintech era. By focusing on a banking core reclaiming documented flows, institutions can finally pay down their technical debt and focus on innovation.

The 70% time savings offered by Replay isn't just about speed—it's about accuracy. It’s about ensuring that the business logic that has kept the bank running for 40 years is preserved, understood, and improved for the next 40.

Frequently Asked Questions#

How does Replay handle complex RPG logic that isn't visible on the screen?#

Replay captures the outcome of the logic through the UI. While it focuses on Visual Reverse Engineering, the generated "Blueprints" identify the data requirements and state changes that the backend must support. This allows developers to map modern APIs to the exact expectations of the legacy logic.

Is Replay a "no-code" tool that replaces developers?#

No. Replay is an accelerator for Senior Architects and Developers. It handles the "grunt work" of discovery and boilerplate generation (saving 40 hours per screen), allowing the engineering team to focus on high-level architecture, security, and integration.

Can Replay work with green screens that use non-standard terminal emulators?#

Yes. Because Replay uses visual analysis of video recordings, it is agnostic to the underlying terminal emulator. As long as a user can interact with the screen, Replay can record, analyze, and convert it.

How does the "banking core reclaiming documented" process help with audits?#

Regulators often require proof of how a transaction is processed. Replay’s "Flows" provides a visual, step-by-step audit trail of legacy processes, converted into modern documentation that is easily readable by compliance officers and auditors.

What is the typical ROI for a Replay pilot in a bank?#

Most enterprise pilots see a 70% reduction in the time required to move from "Legacy State" to "Documented React Prototype." For a standard module with 50 screens, this equates to a saving of approximately 1,800 engineering hours.

Ready to modernize without rewriting? Book a pilot with Replay