Modernizing Software Development with Low-Code and Containers

Deel dit bericht

At its heart, modernization is about optimizing performance. So rather than analyzing code and reading vmstats, developers should be optimizing organizational processes and inefficiencies.

But instead, as engineers, we’ve wasted moonlit hours to track down differences in code and dependencies between systems (“It works on my machine!”) or go back to the whiteboard when the software we built isn’t what the users want. The further we get in the software development lifecycle without resolving bugs or design problems, the more time, money, and effort we waste.

For example, if it costs us one dollar to fix a defect in the software during the design phase; it will cost us 100x more, a hundred dollars in our example, to fix the problem once the software is released (maintenance phase). Here’s an overview of the relative cost increase from design through maintenance phase:


The further we get in the software development lifecycle without resolving bugs or design problems, the more time, money, and effort we waste.

What organizations and developers need is to modernize software development by adopting tools that eliminate software development inefficiencies, contain the development cost, and foster better collaboration with the operations and business stakeholders.

Modernizing with containers
“But it worked on my machine!”, “Why is the version of Python different in staging and prod?”, “We need the latest version of the Requests library and we’re running one from 2015!” Sound familiar? As a developer, I’m sure you’ve experienced something similar more than once. Containers offer the technical solution to these common software development problems and also helps us better collaborate with our colleagues in operations. But first, let’s define containers.

A container is an isolated filesystem containing the code, dependencies, and machine instructions for running an application. Through elegant use of cgroups, Linux namespaces, and chroot, containers package code and any dependencies of that code into a portable, executable software bundle that runs on any Linux system. The same container can then be deployed in any environment, without variation, allowing provably repeatable automated deployments.

Consistent deployments make our colleagues in Operations very happy. Containers facilitate this by providing a source controllable build manifest (usually a Dockerfile) that describes our code and dependencies, all in one place. This file represents the intersection between Operations and Development teams. Developers can use containers to actively collaborate with Operations engineers on resolving application dependencies, minimizing the effort spent on managing disparate environments; all the while increasing the speed at which new solutions are delivered.

Automated deployments and DevOps collaboration are great but does the application meet end-user requirements? Removing barriers between development and operations is only one half of the picture. It does not address inefficiencies caused by a lack of collaboration with business stakeholders throughout the app development process. No one wants to end up with a software that’s technically and functionally superior but fails to deliver value to its users. To avoid this, it’s necessary that the software development process involves business stakeholders right from the design phase of development.

True modernization with low-code
Low-code tools like Mendix empower business stakeholders and engineering units to operate on a higher abstraction level than traditional code. Instead of passing requirements back and forth through emails and risking miscommunication, Mendix model-driven development platform provides a common platform for developers, operations, and business users to collaborate actively throughout the app development process. Involving business stakeholders early on in the development process helps avoid costly, time-consuming friction between business and IT, and ensures IT builds apps that satisfy end-user and business requirements.

In addition to model-driven development, the Mendix platform lives and breathes container native architecture. Applications developed on Mendix low-code interface produce well-architected and extensible software that is automatically packaged in containers and granular APIs that can be utilized by your build and deployment (CI/CD) pipeline.

Ultimately, the goal of modernizing software development is to increase the speed at which we deliver high-value software to our end-users. Technology like low-code and containers helps us achieve this goal by accelerating the time from ideation to software delivery, removing inefficiencies in the development process, and actively encouraging collaboration between operations, development, and business stakeholders.

More information about Mendix model-driven development.

Joe Carroll is Product Marketing Manager at Mendix.