From 4GL to Low-Code: The Long Journey Back to Software Productivity

The idea of simplifying software creation isn't new — it goes all the way back to the early days of computing with languages like COBOL, which already aimed to make programming accessible to business people, not just engineers.

Thirty years ago, I was building business applications on a VAX/VMS system using a toolset called PowerHouse — a suite often described back then as low-code or no-code, even if the term didn't exist yet. It was part of a class of tools we called 4GLs — Fourth Generation Languages.

PowerHouse was fast, simple, and highly productive. You could design screens, data flows, and logic without drowning in boilerplate code. Everything lived on a single system — a "mini" with multiple terminals — and you had the feeling of sculpting an entire application from a coherent, elegant environment.

Then the web happened.

JavaScript and asynchronous operations changed everything. We moved from centralized computing to distributed, stateless systems, and that beautiful productivity disappeared overnight. The new world was asynchronous and browser-based — and JavaScript, at the time, simply wasn't equipped to bring back the same developer experience. Cognos (PowerHouse's maker) even tried to adapt with a web-based successor called Axiant, but it fell short. We went back to writing everything by hand — back to L3Gs — and productivity plummeted.

Since then, JavaScript and its ecosystem have evolved dramatically. We now have frameworks like React, Next.js, Node.js, TypeScript, and complete CI/CD toolchains that make web apps richer and faster than ever before. Yet despite all the progress, building software remains labor-intensive and slow to iterate. The promise of visual productivity never quite returned — until recently.

The Violin Maker's Lesson

Earlier in my career, I started out as a software developer, then spent several years as a professional violin maker, before eventually returning to software.

There's a common misconception that luthiers cling to old methods purely out of tradition. In truth, we continue to use Renaissance-era techniques because they still produce the best results. The goal has always been the same: to create instruments that sound and feel right to musicians and listeners.

I see a similar pattern among software developers. We're not obsessed with frameworks for their own sake — we're searching for tools that help us deliver value faster, with less friction. Every generation of tools aims for the same goal: to move from idea to production faster, and to adapt to real-world changes with less effort.

Enter the New Wave of Low-Code

For a long time, I was disappointed by low-code tools. Many focused on front-ends, leaving you juggling APIs, databases, and glue code to make a complete system. They didn't recreate the integrated experience that made 4GLs so powerful.

Then I discovered DAZZM (full disclaimer: I worked there for a few months), and it rekindled that sense of excitement I hadn't felt since the PowerHouse days. DAZZM is a fully integrated front-end/back-end environment — but it doesn't even ask you to think in those terms. Instead, it's built on Domain-Driven Design (DDD) principles: you model your data domain first, and the rest of the application — screens, workflows, permissions — organically grows around it.

It's incredibly fast to prototype an application this way. Rename a field, add a relationship, or remove an entity, and the system adapts instantly. You can extend it with JavaScript whenever you need to. The focus shifts from technical details to business logic — from "how do I code this?" to "how does this help the user?"

At that point, you stop feeling like a developer and start feeling like a product builder — someone who delivers tangible value instead of lines of code. You can even prototype live with your customer, iterating in real time as they describe their workflow. It's a complete mindset shift.

Back to the Future

In many ways, we've come full circle — from the 4GLs of the '90s to today's low-code revolution. But this time, we have something far more powerful: cloud scalability, APIs, modern UX frameworks, and integrated data-driven design.

Low-code isn't just about saving time. It's about returning to what made software creation exciting in the first place — transforming ideas into working applications at the speed of thought.

We finally have tools that let us build better and faster — not by writing more code, but by writing just enough.

Try it yourself — get a tailored estimate in minutes

Curious what a modern low-code build could look like for your use case (cost, timeline, and ROI)?

Run my quick estimator: lowcode.devtom.ca

You'll get a personalized snapshot you can use to kick off a discussion — and if it's a fit, we can turn it into a live prototype rapidly.