Modernizing Your IBM i: More Than Code, It’s a Mindset

 ☕ Today’s Coffee: Dunkin’ Medium Roast — familiar, reliable, and quietly excellent. Like the IBM i, it’s often underestimated but built to last when brewed right.

Modernization Isn’t Just About the Code

Everywhere you turn, someone’s talking about modernizing IBM i.
But modernization isn’t a single project or a new UI. It’s not about leaving RPG behind or rewriting everything in Java. It’s about using the full power of the platform you already have — and aligning it with the way modern development teams work.

Modernization means evolution, not abandonment.

The Three Dimensions of Modernization

When we talk about modernizing IBM i, we’re really talking about three interconnected layers:

1. Modern Developers

The biggest modernization challenge isn’t code — it’s people.
Many RPG developers learned in an era of SEU, SDA, and fixed-form logic. Those tools worked brilliantly for their time, but the next generation expects modern experiences — VS Code, RDi, Git, and CI/CD pipelines.

A modern IBM i team:

  • Uses VS Code or RDi with syntax highlighting, linting, and AI assistance.
  • Checks code into GitHub or GitLab — no more emailing source members.
  • Writes in fully free-form RPG and embedded SQL.
  • Builds unit tests and automation into the process.

This isn’t about throwing away experience — it’s about amplifying it with modern workflows.

2. Modern Environments

For years, IBM i shops have lived with a divide: “the i” runs business logic, and everything else runs on separate Linux or Windows servers.

That separation creates friction — duplicate infrastructure, different skillsets, and fragile integrations.

But the IBM i platform has quietly supported open-source technologies and virtualization for years. You can now:

In other words, modernization doesn’t have to mean migration.
You can move Linux workloads onto IBM i — unifying your ecosystem instead of fragmenting it further.

3. Modern Tools

IBM i modernization means using tools that have existed for years — just not widely adopted yet.

  • RDi and VS Code for i bring modern editing, debugging, and Git integration.
  • Access Client Solutions (ACS) delivers powerful SQL scripting, schema management, and even run SQL scripts for CI pipelines.
  • Db2 for i Services give you REST-style access to system data — everything from job queues to object metadata — directly through SQL.
  • Open-source runtimes like Python and Node.js connect IBM i logic with cloud services and web APIs.

These are not futuristic features. They’re here now, and they’ve been quietly powering enterprise systems for years. Modernization just means using them to their full potential.

What Modernization Looks Like in Practice

Let’s take a common scenario:
A company wants to move their invoice process off an aging Windows server and integrate it into IBM i.

Old approach:

  • Maintain two separate servers (Windows + IBM i).
  • Use batch file transfers and scheduled jobs for sync.
  • Different teams manage each environment.

Modern approach:

  • Host the invoice microservice in a Linux partition on IBM i.
  • Use Db2 for i as the central database.
  • Expose order data via RPG REST APIs built with IWS or Node.js.
  • Use GitHub Actions or Jenkins for CI/CD and test automation.

The result? A cleaner architecture, fewer moving parts, and one cohesive ecosystem.

The Human Side of Modernization

Modernization succeeds when leadership sees it as a team transformation, not just a tech upgrade.

That means:

  • Giving developers time and training to learn new tools and workflows.
  • Aiding them through the change, because not everyone embraces it right away.
    Some developers resist — not because they don’t care, but because they’ve mastered the old ways. They take pride in being fast and dependable within their familiar tools. Modernization can feel like starting over.
    That’s where strong leadership matters. We have to coach, not command.
    Pair experienced developers with modern tools gradually. Show them real benefits — faster debugging, easier source control, better collaboration.
  • Recognizing modern practices in performance goals and reviews.
  • Making small, incremental changes instead of one big rewrite.

If you want lasting change, it has to feel like empowerment, not replacement.
The goal isn’t to prove the old ways wrong — it’s to build on them.

Final Sips

☕ As I finish my Dunkin’ Medium Roast, I’m reminded that modernization isn’t about chasing trends — it’s about rediscovering the strength of what’s already there.

IBM i has always been ahead of its time. It’s secure, integrated, and built for resilience. The real shift now is mindset — embracing open tools, empowering new developers, and using the full platform, not just the RPG layer.

Modernization means this:
New developers. New tools. Same rock-solid foundation.

It’s time to stop talking about replacing the IBM i — and start talking about realizing it.

☕ Follow The RPG Blend for more IBM i modernization strategies, RPG examples, and leadership insights.
📖 Blog
📂 GitHub
💼 LinkedIn

Comments

Post a Comment