Low-code development was conceived with a vision that the best applications are the product of diversely skilled teams — professional developers, business analysts, domain experts, customer champions, UX designers, et al. In this scenario, sometimes team members work together in real time. Sometimes asynchronously. Sometimes from one location, most times from several. But always, their work needs to be coordinated, synchronized, quality-checked, controlled, integrated.

So it is absolutely imperative that a low-code platform fully support these teams and distributed workflows without any compromises in capabilities or performance. Hence, low-code principle #6:

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.

Collaboration is a theme that runs through all the principles of low-code (and is a principle unto itself, as described in a previous post). Supporting collaborative development requires enterprise-grade multi-user capabilities. Low-code successfully demonstrates that a model-based, visual development platform that enables a spectrum of developers can still deliver the sophistication and functionality even hard-core developers expect in a multi-user environment.

What’s the diff?

The heart of any multi-user capability is version control; it’s simply mandatory for any development environment. No serious developer would consider working without robust and reliable version control. So when the founders of Mendix conceived our low-code platform, they architected-in version control that is on par with, or better than, the best of any development platform.

A proper low-code platform allows developers to look back, tracing bugs and issues to their source; to roll back to a previous version to analyze and remedy an issue; to control users and their privileges to maintain proper governance and compliance; and to perform “code reviews,” even though there’s no code (the principle remains the same).

Diffing, branching, merging — all the multi-user development capabilities you’d expect in a bona fide, grown-up, enterprise-grade development environment, you’ll find in a full-featured low-code platform such as Mendix.

The ‘new normal’ of remote collaboration

I think we will always remember the Spring of 2020 as the time when the way we work fundamentally changed. We’ve had to make distributed teams and distributed workflows work, and it’s possible that, going forward, remote work will be commonplace in a much greater number of industries and careers. For developers used to a multi-user, cloud-based environment — including our platform — the transition was not traumatic. Depending on their remote equipment and connection, it was virtually seamless.

In the low-code platform, everything is done in the cloud. No one need work alone. It’s a Google Doc-like experience for app development. Users can work together on an application from wherever they are. I see what you’re doing, you see what I’m doing, in real time. Ultimately, multiple users will be able to actually edit together at the same time, though as yet, that capability is still evolving. But the efficiencies of remote pair programming — the extra set or sets of eyes, the second (or third or fourth) perspective on solution paths — is live right now.

Democratized development

There is one additional multi-user advantage low-code delivers that no other development methodology can match: the ability of non-technical users to actively participate in making applications. The ubiquitous visual language means that everyone from professional developers to business analysts can see the pieces that make up the application, understand them, manipulate them, and add and subtract them. That’s just not possible in a code-full environment.

This kind of collaboration completely redefines the playing field. The continuous cross-pollination between business and IT throughout the process invariably results in solutions that are more relevant, more useful, more business-impacting, perhaps even game-changing, than in a typical waterfall-type workflow.

You break it, don’t worry

When it’s difficult to roll back an app, see what’s going on inside, and fix it if needed, you’re reluctant to push the boundaries. You don’t want to break it. But it’s only through experimenting and exploring that possibilities are uncovered and innovation achieved. It’s only through constantly iterating that you achieve agility.

With low-code, citizen developers can learn their way around without damaging things. They can start building things on their own without burning the house down. (And if it looks like something that’s going to scale up, IT can step in and guide it). Pro developers can explore what-if scenarios and test out functionality, interfaces, and crazy ideas with abandon. If something gets broken in the process, it’s easy to go back and fix it (within reason).

When the other user is a bot

As AI grows more and more sophisticated, it can become more human. Rather than a bot acting literally like a robot, it can act like a pair programmer, reviewing the work, commenting on the “code,” offering suggestions, being genuinely helpful. So even the solitary genius developing apps in the garage benefits from a multi-user environment, in this case, having a team of AI fellows to add their expertise to the application.

Genuine multi-user

The low-code principle of multi-user means true multi-user, as in, developers used to ‘git’ feel right at home. True multi-user as in, all code artifacts — libraries, extensions, custom Javascript and Java components, all the resources the application needs — are all present and available to all users in the model in real time.

The magic of the low-code environment is that it gracefully accommodates that ideal development team that includes diverse skills and mindsets from both the business and IT spheres. It would be unrealistic to expect a professional developer to accept anything less than a full-featured, enterprise-grade, multi-user environment. And equally unrealistic to expect a non-technical, citizen developer to master sophisticated (code-based) development tools and languages.

With low-code, everyone on the team can work together efficiently and effectively, in real-time or asynchronously, wherever they’re located. It’s clear that a remote workforce and distributed workflows will have a role in the enterprise to a greater or lesser degree, going forward. Low-code makes that style of productivity easy to achieve.