Introducing the Low-Code Manifesto
Introducing the Low-Code Manifesto by Johan den Haan
Greetings from the front lines of software development! It’s great to come in to work every day and know that our team is advancing the frontiers of what is possible with software and ratcheting up its impact on business and the world.
When Mendix helped pioneer low-code, we thought we were solving the major, intractable problems of enterprise software development. We knew we were onto something important and had ambitions to “create the future of software development.”
Turns out, we were and are at the forefront of the most significant movement to drive software development since agile and DevOps.
This is the right time and the right place to make a disruptive difference. But even as we push the boundaries of innovation, it’s important to look back at where we came from and check ourselves against the principles that led to the creation of the Mendix low-code platform. Principles that continue to guide its evolution. We’ve defined our core beliefs in the Low-code Manifesto.
Here’s some back story on where these ideas came from… and why they still matter so much today.
A dozen years ago, our founders were struggling with the fundamental disconnect between what businesses needed and what software was delivered. Communication was poor. It took too long to develop an application. The cost – both in terms of capital and resources – was astronomical.
Because the communication between customer and developer was so flawed from the start and because the process took so long, when the application finally was delivered, it didn’t meet the initial requirements or add any business value. And it all cost so much money. And so much time.
These persistent problems frustrated both the business and the developers. Everyone was working hard, no one was getting what they needed, and the demand for software was only increasing.
Solving for all the X’s
We knew there was a problem. We knew it needed fixing.
These were the most consistent, damaging pain points:
- Business people and IT people were terrible at communicating with each other.
- It took too long to design, code, test, QA, and deploy any kind of application.
- Because of poor communication, the solutions didn’t effectively or elegantly solve the problem.
- It was all very expensive.
- The business value delivered (if any) seldom justified the cost.
Of course, there were other issues to address once you dove into the process, but these were our starting points. These were what we set out to fix at the beginning. And 12 years later, these problems still account for most of the issues and lost opportunities as businesses evolve their digital strategies.
What was the answer? How did we decide to try and fix the disconnect between what the business needed and what traditional development could deliver? With low-code application development.
Low-code aims high
We looked at what was broken about software development, we studied what businesses needed to succeed in the burgeoning digital world, and we peered over the horizon to see what was coming.
Our collective knowledge and understanding led to the creation of the Mendix low-code platform. We wanted not only to solve the pervasive problems in software development but also to provide an adaptable, open environment that was resilient and flexible enough to incorporate the new technologies that were emerging at a dizzying pace.
But the platform wasn’t enough. We couldn’t change how software was built, without also changing how people thought about how software was built. To succeed in the low-code software development paradigm, it’s imperative that how you’re working and what you’re working towards align with these core concepts.
We keep these fundamental truths in mind as we try to bring ideas and innovation to life at an ever-accelerating pace.
Application Development Pillars
- Focus on business impact.
Create alignment, achieve clarity, succeed quickly.
- Unleash all the makers from across the enterprise.
No brainpower goes to waste.
- Do everything with an agile attitude.
Empower small teams, build for the cloud, deploy swiftly and often.
- Assemble from existing business capabilities.
Utilize established assets, don’t default to building from scratch.
- Connect everything.
APIs, integrations, new ways to access data — be open and accessible.
The 9 Principles of Low-Code Application Development
- Model-Driven Development
Transform ideas into applications that deliver business value through abstraction, automation, and openness.
Read more about Model-Driven Development
Leverage a shared visual language to support the interchange of knowledge and ideas between business domain experts and developers.
Read more about Collaboration
- Agile Methodology
Manage the full enterprise application development lifecycle with agile workstreams to eliminate bottlenecks, support iterative delivery and achieve shortest time-to-value.
Read more about Agile
- The Cloud
Cloud enables the ease and speed of application deployment that customers demand.
Read more about The Cloud
Anything can be integrated with an agnostic enterprise application development platform – this removes limitations on what can be built.
Read more about Openness
- Multi-User Development
Multiple developers should be able to work on an application at the same time. The platform must support and synchronize their workstreams.
Read more about Multi-User Development
- Experimentation & Innovation
Development tools need to be affordable and nimble so innovators everywhere can experiment, explore, and create.
Read more about Experimentation and Innovation
- Governance & Control
Robust governance and control processes and protocols are essential.
Read more about Governance and Control
A platform without a community is no platform at all.
Read more about Community
Knowing now, what we knew then
Some of our ideas were fundamental, some prescient, but taken all together, they defined a new way of creating software. One that:
- leverages all the talent available on both the business and IT sides
- is collaborative from start-to-finish and focused on outcomes
- fully realizes the ambitions of agile workflows and BizDevOps
- delivers all the power and functionality software is capable of and that users increasingly expect
Low-code delivers high-quality software quickly. It’s the real deal. It’s here and it’s happening.
In the coming weeks and months, we’ll dive into each of the nine principles in more detail, both from business and technical perspectives, to explain why they’re important, how they work in practice, and how they create success in our connected, digital world.