In my experience, one of the most common challenges companies face when implementing low code is establishing governance to manage how it’s used. I frequently see companies adopt low code with no governance at all—or, in some cases, heavy-handed governance processes that lead to shadow IT development.
However, when implemented correctly, low code governance can help companies build and innovate faster while also ensuring that software is scalable and future-proof.
In this guide, I’ll take a closer look at low code governance and explain how to balance flexibility and control within your organization.
Low Code, Mission-Critical Systems, and Governance
While good governance has long been essential for low code, it’s more important today than ever before. That’s because low code is increasingly being used in mission-critical systems.
It’s easy to miss this trend because most companies haven’t yet adopted low code for their systems of record, such as their enterprise resource planning (ERP) or customer relationship management (CRM) systems. However, they’re increasingly using it for their systems of differentiation, including customer portals—and customer-facing software like this should be considered just as mission-critical as more complex back-end systems.
Incorporating low code into these applications is very beneficial for companies, especially those with complex IT landscapes. It enables them to reduce time to market for new features, optimize internal processes, and scale more readily.
At the same time, though, it underscores the need for low code governance. As low code is used more widely throughout organizations for a broader range of systems, both the benefits of good governance and the consequences of poor governance become more pronounced.
Why Does Low Code Governance Matter?
Good governance is crucial to realizing the full benefits of low code and preventing potential downsides that can come from a disorganized IT environment. Let’s take a closer look at some of the key reasons why every organization using low code needs to think carefully about governance.
Boosts development speed
Companies I’ve worked with are afraid that implementing low code governance will slow them down. But actually, the opposite is true. When executed well, governance can actually speed up development.
That’s because it’s cheaper and faster to fix errors before they’re written into an application or propagate across systems. So, if your governance process includes a design phase, you can catch problems before they get baked into new software.
This approach might require a few extra steps in your development process, but it ultimately saves time and doesn’t impede your organization’s flexibility or agility.
Prevents shadow IT
Another benefit to having governance processes in place is that they prevent shadow IT—that is a situation where business users create their own low code apps and tools without consulting IT. Shadow IT can result in isolated apps that don’t play well with the rest of your IT infrastructure, creating confusion and inflating future development costs.
Governance prevents this by putting IT users in control of development processes while keeping them closely in touch with the needs of business users. For example, you can create guidelines for proposing new development needs to IT and establish a regular schedule for IT to publish software updates.
Ensures quality and cost control
Enterprise-scale apps need to meet strict quality standards. They must perform well, offer low downtime, scale with your business, and be relatively future-proof.
At the same time, they also need to be on budget—even if your organization uses an agile workflow that deemphasizes concerns about cost.
Achieving all these different requirements depends on using governance processes, such as performance testing and codebase management, to control quality and cost. Otherwise, it’s nearly impossible to make sure you’re checking all the boxes and still meeting tight deadlines to push new software to market.
Our Hybrid Approach to Governance
At CLEVR, we use a hybrid approach for low code governance that blends agile and waterfall methodologies.
The agile methodology brings speed and flexibility, which is especially helpful when the solution to a complex problem isn’t immediately clear. It allows us to experiment, iterate quickly, and explore different solutions before determining what we need to build.
The waterfall methodology brings structure and precision. Once we’ve identified the right solution through agile exploration, this methodology enables us to deliver it efficiently: on time, within budget, and with a strong focus on quality.
This hybrid methodology is fundamental to our success in helping enterprise-scale companies across industries implement and govern low code. It balances speed and quality in low code governance while also giving organizations a new way to approach future development.
5 Tips for Balancing Flexibility and Control
So, how can your business achieve a similar hybrid approach and balance flexibility and control in low code governance? Here are four top tips based on my experience at CLEVR:
1. Get business and IT users on the same page
Business and IT users can often be at odds when it comes to low code development because they’re looking at different parts of the same puzzle.
Business users are concerned about getting functional products to market as quickly as possible, while IT users often focus on software architecture and security. Both speed and quality are important, but any software development effort represents a trade-off between the two.
To address this, it’s essential to ensure that IT users and business users of low code understand each other’s needs and concerns. IT users need to understand the end-goals that business users are trying to achieve, and business users need to understand what it takes to deliver that solution from an IT perspective.
This understanding can be framed in terms of the ultimate goal of serving the same customer from different parts of your organization. That way, business and IT users can ask how they can work together and focus on what each needs from the other to be successful.
The net result is greater synchrony within your organization and a clearer understanding of the importance of governance for everyone involved.
2. Manage expectations around continuous development
What I often see when I’m working with IT to launch a new application is that everyone in the organization, at first, is excited. There’s a lot of attention, a lot of support, and a lot of patience to ensure the product gets off the ground.
However, once that application is live, expectations from business users change dramatically. They frequently assume that adding a small feature to an existing application or updating its functionality is an easy and quick change.
That’s hardly the case. In my experience, modifying an existing app is often more complex than building a new one, as it introduces risk to existing dependencies and functionality. And, as I said earlier, low code apps are increasingly used in mission-critical systems—where failure isn’t an option. Yet, if business users feel like updates are taking too long, they’re more likely to go around IT and your organization’s governance processes.
So, it’s crucial to manage expectations around how apps are continuously developed, improved, and scaled after launch. I recommend clearly communicating that updates can take longer than expected and that access to modify existing low code apps is strictly limited to IT users who understand the stakes of making changes.
3. Use timeboxing as a form of governance
One of my favorite approaches to low code governance is to use timeboxing to break complex projects into smaller pieces. Timeboxing ensures speedy delivery of milestones while leaving time for essential quality checks.
For example, I once worked with a product manager who told me that the software he wanted was too complex to document. Of course, if it was too complex to explain, it was certainly too complex to build.
I worked with the product manager to break the app he wanted into bite-sized pieces, each scoped to a timebox of several weeks for manageable, focused delivery.
Each timebox gave the IT team the flexibility to complete the design, building, and testing phases, ensuring they could find the appropriate solution to the problem the business team had identified. At the same time, delivering updates at the end of each timebox showed business users we were making real progress and gave them a chance to share feedback along the way.
This timeboxing method can be used for many low code projects and works well within the context of the hybrid agile-waterfall governance approach I discussed earlier.
4. Focus on building smaller, more manageable apps
Your governance process can also benefit from focusing on building smaller, connected apps instead of a single “super-app” that tries to solve all business problems at once.
Smaller apps are easier to manage and update, with less risk to mission-critical systems. They’re also more future-proof since you can replace or upgrade them without overhauling large parts of your IT infrastructure.
This approach should start during the design phase of your governance process. IT teams should look for opportunities to break down solutions into multiple interconnected parts, especially when each part aligns with a distinct business function or goal.
5. Make sure your organization is ready for low code
Last but not least, it’s essential to ensure your organization has the foundations in place to adopt low code. These include having the right people, the right projects, the right development processes, and the right low code platform.
CLEVR has created an online tool to help you assess your organization’s low code maturity. I highly recommend using this to identify gaps in your low code readiness, including potential improvements you can make to your existing software development governance processes.
Strong Governance Enhances Low Code’s Potential
I can’t overstate how essential strong governance is to experiencing the full benefits of low code—from faster product delivery and greater innovation to future-proofing your organization’s IT infrastructure. To get started, focus on better aligning business and IT users, managing expectations around continuous software development, implementing timeboxing, and focusing on building smaller connected apps.
Lastly, consider conducting a low-code maturity assessment with CLEVR to ensure your business has the necessary foundations for successful low code adoption. With these steps, your business can confidently leverage low code to thrive in a rapidly evolving digital landscape.
Get in touch
