No code? Low code? Citizen developers?
But let's start at the beginning. With new technology, you always get new terminology as a gift. We briefly explain the most important terms here.
- NO-code is the term we use to build applications in a graphical interface. So with drag and drop and completely without having to write code.
- With low-code we aim in a way of building software that is also largely graphical, but that provides the space to shape complex logic into easy-to-understand scripts.
- Citizen developers are people who work on the business side and are therefore 'officially' not a developer, but who, thanks to no-code and low-code, can still build software without in-depth technical knowledge. The classic high-code developer is often referred to as a “full-stack developer” to make the distinction.
- Power Platform is Microsoft's low-code environment. Power Platform integrates seamlessly with the other parts of the Microsoft cloud, such as Teams, Office, and Azure.
Low-code applications
The use cases for low-code are very diverse. And we're discovering new ones every day. Here are a few of the most important ones.
Mobile and web apps
A customer portal or mobile communication app for frontline workers? They are often done much faster if you don't build them in code.
Collaborate
Stop emailing and calling, start really working together. That's the essence of many low-code apps. Use the power of Power Platform to ensure that documents are in the right folders, that deadline reminders are sent automatically, and that everyone always has the right information.
Automate processes
HR processes such as entering and approving vacation requests or expense reports, processing service tickets or sending monthly reports: most business processes can not only be built with Power Platform, but can also be improved.
Data integrations
A major strength of Power Platform is making data accessible and usable. By working with the connectors offered as standard, or with connectors made especially for you, citizen developers can get to work with your existing data very quickly.
Noise on the line
There is often the idea that testing is not necessary around low-code. You click an app together and hop, it can go to production. That is, code, low-code or no-code, not a scalable, secure and manageable way of developing software. Do you need a team of 20 testers for your low-code apps? Probably not. But you do need to take a serious and company-wide look at what needs to be checked off and caught before a Power Platform application can enter your organization. After all, you want to deliver quality.
“But why not build it properly all at once?” It is a question that is asked quite often. Logical, because we are software makers and we like to tell you that we are good at it. So why does our work need to be tested? With low-code, that applies twice. In fact, that software is already half finished before we start, right? So why do you need testers?
The answer lies in communication. A user must explain to a builder what an app should do. And there is always noise on that line. Technical communication is also communication between people. And people sometimes misunderstand each other. That's why we always make good agreements to take a fresh look at an app when construction is over. Even with low-code.
Testing the Yin and Yang of Software
Testers are often accused of just seeing problems, but that's actually not how it works. A software tester is primarily someone who asks themselves at every bit of business logic: “What does that actually mean?” Fully thinking through the functionality of your app and working out what it takes to make all your logic work under all circumstances is a profession in itself. So yes, a tester finds things that could go wrong. That is the negative side. On the positive side: a tester ensures quality. You make things. A tester helps you make it really good. This builds trust in the product and ensures trouble-free deployment and productive use. If all is well, these two things are in balance. A bit like Yin and Yang.
Three test phases
We do tests at three levels:
1. Requirements testing
Before you get to work, you need a plan. Good requirements are also very important when it comes to low-code. In this phase, we let a tester take a look at it right away, because they are good at seeing gaps in requirements that can cause problems later.
2. Integration and functional tests
We can usually skip the most detailed, technical test level (the “unit test”) with low-code. But testing the functionality of the app and integrations with other systems is of course important. Do the modules talk to each other? Will the data arrive? Making assumptions in this area is dangerous and can cause you serious problems and delays in the next round of testing, or in production. In a functional test, a tester acts as a user and performs all actions as described in the requirements. This way, we know whether the app also does what the user asked.
3. User test
In the last round of tests, the user can also view that for themselves. Never skip this phase! A user looks at software from a completely different perspective than we IT professionals. So they will definitely have more comments.
The more users, the more demands
A common misconception is that low-code user tests are enough. But users test software from their own perspective and usually not very systematically. This means that you don't always uncover dangerous assumptions from the development process. A user consciously or unconsciously assumes that a developer has thought of everything. But 'everything' is quite a lot, even for an experienced developer, and that assumption does not have to be correct. Low-code fuels these kinds of assumptions, because the development process is less technical and it is therefore easy to assume that “everything is automatic”.
Of course, how many rounds of testing you need depends on the complexity of the app and the number of users. Did you make an app for yourself? Then you can indeed click through your app critically and find that it does what you want quite well. But if more users are going to work with the app, more is needed. Even an app that is used by 5 people can already present surprises.
The larger the app and the more users, the greater the risk of unintended effects. And the stricter your quality requirements must be. In addition, you also need other things that you will undoubtedly recognize from full-stack development processes: documentation, manuals and governance agreements about naming, rights, access and cleaning up data. Deployment and update processes must also be defined if you want to roll out a low-code app widely.
Low-code specific tests
The great thing about Power Platform is that a lot of things are already ready. Microsoft ensures that your app always starts and that the infrastructure is in order. You don't have to worry about that. Standard integrations and connections that you've used in your app will also work.
But the users themselves are responsible for the accessibility of the data. That can go wrong. But what if you use a team in your app and that team gets deleted? Or if certain folders are inaccessible? These are exceptions that you should test. The processing and presentation of the data must also be tested.
With low-code, you usually don't have a 100% idea of what functionality is supported. Platforms change every day, and you can't know everything. For example, you might want to have a rain emoji in the title of your app in case of bad weather, but test that it also works on all devices and that there are no unexpected effects. It would be a shame if e-mails did not arrive as a result.
Also, keep in mind that the use of an app can grow. Three users who store all their files in one folder may still be fine. With 3,000 users, that's really a different story.
Want to know more? read our white paper
As big Power Platform fans and experienced software developers, we like to combine the accessibility and pragmatics of low code with the principles and best practices of professional software development. In our white paper, we have described the five key principles of this and want to provide you with a valuable tool to help you get started when you get started with the Power Platform.
.jpg)
