Finding the right low-code platform for your needs doesn’t automatically translate to success; it’s only half the battle. We discussed the first half of this battle in the article Low code connoisseurship. The other half of the battle is seamlessly integrating the platform into your business processes.
Ensuring that your chosen low-code platform meets its full potential isn’t always straightforward. Successful software development using low-code platforms is not trivial; it requires many of the same organizational and technological considerations that apply to traditional software development. We’ve identified three key elements for transforming your low-code vision into a platform with high returns on investment:
- The business having realistic expectations of the platform, and effective management of interdepartmental politics.
- IT taking ownership and being an enabler of the platform.
- Business and IT working together to leverage each other’s expertise.
Business expectations
If you’re reading this, there are probably things you want to be able to do that you’re not able to with your current tools. Perhaps you want to look at customer data in a different way, automate communication between platforms, or share information with your colleagues. Often these are important goals, but aren’t on the short term radar of your dev department. So now you’re looking to low-code platforms to help create some of these yourself.
It’s important to acknowledge the human factors involved with using systems such as these. In most organizations, software development is owned by some part of IT. It’s not unusual for people who work in that area to feel threatened by technologies which are seen as a replacement for their skills. It’s not unlike the fear a production-line worker might have when someone starts talking about robotics.
The truth is that low-code platforms aren’t a replacement for skilled software developers; they are a complementary tool which can be leveraged for the right types of work. Identifying those types can be a boon to both parts of the organizations. You get the functionality you need, and IT gets to focus on core objectives.
In using these platforms, it’s important to keep in mind that writing code is only one part of software development. In fact, most software developers would tell you it’s the smallest part. Some examples of other tasks involved in software development would be:
- Planning and managing the infrastructure and deployment of software
- Ensuring its test coverage is adequate
- Providing customer support by investigating issues
- Managing security and privacy concerns
- Ensuring compliance with things like GDPR
- etc.
Someone who isn’t a software developer can learn some of these things over time — what some would call a citizen developer. While there isn’t anything inherently wrong with that, citizen developers can’t replace professional software developers when contributing to enterprise-wide or mission critical systems — in fact, your low-code consultant most likely has a computer science degree.
A good analogy would be the difference between a handyman and an electrician. Handymen are cheaper, and can handle various jobs. But there are some tasks where not getting an electrician would be disastrous.
Low-code platforms are perfect for constrained, simple projects, and software developers don’t necessarily need to be involved in the development process. On the other hand, mission-critical apps require the depth of expertise supplied by professionals software developers. The middle ground is where things become less clear, and projects can grow in complexity and criticality. As we’ll talk about at the end of this article, it’s vital that you work with IT to navigate this middle ground.
IT ownership
Traditional software development is almost entirely an IT department endeavour. Low-code platforms claim that this can be circumvented through their platform by enabling the creation of shadow IT departments. The degree to which this is true is debatable. Regardless, we believe that IT must still play a role when using a low-code platform. Furthermore, we believe that the success of the platform should be IT’s responsibility, and IT should be accountable for it.
IT taking ownership of the success of the platform isn’t just about managing the platform itself. It’s about being a guardian of how the platform is being used. Being a guardian of the platform takes on many forms, but there are two primary obligations.
The first is IT keeping its finger on the pulse of how the platform is being used. IT needs to ensure that only apps that meet the internal policies are being built and hosted on the platform. This includes things like regulatory compliance, data retention and backup policies, etc. It’s unreasonable to expect somebody from, for example, the finance department to have the knowledge and skills to make their departmental app meet the internal security standards or privacy policy.
The second obligation is to facilitate the transition of software away from the low-code platform when it becomes prudent or necessary. This facilitation means helping teams recognize when the platform is no longer suitable for a task, advocating for the transition, and effectively enabling the transition and software delivery lifecycle for enhanced business outcomes.
There could be any number of reasons a project needs to transition away from the platform, and IT’s insight into software development is necessary for knowing when to transition. Key indicators to look out for would be the progress of a project’s complexity and criticality. Other indicators would be things like growing costs, security needs, scope creep, and compliance requirements to name a few.
Business and IT coming together for success
Business and IT coming together is vital to the success of utilizing a low-code platform. In fact, although it’s largely a byproduct, we believe that one of the key benefits of low-code platforms can be the bringing together of the two. When business and IT collaborate, they can leverage their respective expertise to reach the best possible outcome in both a business and technology sense. We believe that this is fundamental to making low code successful for your business.
Probably the most vital task that IT and the business need to collaborate on is the creation of a policy detailing clear usage guardrails. These guardrails should outline what kinds of apps are appropriate for the platform, and what kind of team structures are appropriate for different types of apps in development. Then follow and evolve those guardrails, together. These guardrails will help mitigate damage, e.g. security breaches, while also being supportive of the creativity of your employees. This is where business and architecture teams co-create solutions. What business problems are you trying to solve, what trade-offs will you make, and why?
Coming together and forming a united front will allow the business to get the value it needs from the low-code platform while still addressing the concerns of IT. It’s like a merchant ship. The merchant ensures that the venture is profitable, and the sailors make sure that you reach your destination without sinking. In the case of low code, the merchants are the business, the sailors, IT. Just like the merchant ship realistic expectations, mutual understanding, and cooperation are required to ensure the smooth sailing of your low-code venture.