Low code: understanding the real promises and the real pitfalls
What low code is really changing
Low code consists of use visual interfaces in order to create applications, while having as little code as possible to write: you assemble components by drag and drop, configure rules in menus, define workflows graphically. This approach is different from no-code (no line of code) and classical development (everything manually coded).
In the Microsoft ecosystem, low-code comes next Power Platform which includes in particular:
- Power Apps to create applications;
- Power Automate to automate processes;
- Dataverse as a business database.
Thus, Power Platform is not just a simple prototyping tool but a mature platform with integrated governance based on Microsoft security (authentication via Entra ID, data flow control, integrated audit).
Used wisely, low code keeps its promises. The speed of development comes from pre-built components and native connectors that avoid weeks of integration. Empowering businesses allows “citizen developers” to create their own solutions. This democratization frees IT teams to focus on projects with high added value. For example, an expense report management application takes 2 weeks for a functional version with Power Apps, while it would take several months if you coded it entirely by hand.
The “anyone can code” myth: why skills are still essential
Be careful, however, because although to a certain extent, it is true that almost “anyone can create business applications without coding”, this does not mean that anyone can create any application without coding.
In other words, A simple application is not necessarily robust, secure, and scalable. Just because it works for 5 users does not mean that an application developed in low-code is viable for 500 users with sensitive data.
As soon as we change the scope, certain skills are indispensable, among which we can mention:
- Algorithmic logic to properly structure your processes;
- data architecture to model effectively;
- UX principles for creating usable interfaces;
- basic security best practices: do not store secrets in the clear, understand permissions, protect sensitive data.
When business users develop their own applications, we speak of citizen development; if the latter is not supervised then you fall into shadow IT whose risks can be illustrated through the following typical scenario: A Power Apps application created to manage hardware requests, adopted by 50 colleagues, has become critical. However, its creator leaves the company and the application then becomes an orphan. That is to say, its logic is buried in formulas without documentation and no one dares to change it anymore.
Low code lowers the technical barrier but does not eliminate the need for skills and governance.
Identify precisely when low code is enough and when expertise becomes essential
Use cases where pure low code excels
Low code works perfectly when complexity is manageable. Think of daily management applications: entry forms, approval workflows, monitoring dashboards. What do they have in common? Relatively linear business logic without sophisticated calculations or massive volumes of data.
Simple automations are also ideal terrain. Synchronize data between SharePoint and your CRM, send notifications when certain conditions are met, automatically create folders and tasks: Power Automate excels in these scenarios thanks to its hundreds of connectors.
From experience, the limit is around 50 users, around 100,000 records and a logic that consists of a few dozen understandable rules. Beyond that, warning signs start to appear.
Warning signs that require technical expertise
There are three types:
- First of all, the technical signals : the application is gradually slowing down, you are running up against Dataverse API limits, your formulas become incomprehensible even to you.
- Then, the organizational signals : your small department application has become critical for 200 people, it now manipulates sensitive financial data and each bug causes an operational outage.
- Finally, the maintenance signals : no one understands how it works anymore, each change creates three new bugs, the documentation does not exist.
If you spot 3 or more warning signs — of any type (s) — stop everything and call in an architectural expert.

The hybrid approach: the right balance
Rather than redoing everything in classical development, the hybrid approach Keep low code where it adds value. Thus, the user interface remains in Power Apps for its rapid evolution while the complex business logic switches to Azure Functions developed in C#, which are unit testable and efficient.
Let's take the example of an industrial product configurator. Sales reps use an intuitive Power Apps interface to select options and visualize the product. But behind it, a C# engine manages thousands of compatibility rules, calculates prices according to complex price grids and queries the ERP for stocks. The salesperson sees simplicity but the architecture of the product guarantees its robustness.
This approach requires a real expertise to help you decide what should stay in low code and what should switch to professional code. It is precisely in this type of situation that an integrator like Askware brings value.
Governance: transforming anarchic low code into strategic low code
The Center of Excellence (CoE) as a pillar of governance
Orphan applications, shadow IT, duplication of efforts, without governance, low-code is a source of chaos. The Center of Excellence solves this problem by creating a framework that unleashes innovation while controlling risks.
Concretely, the CoE is a small transversal team that defines the rules of the game : who can create what, with what tools, according to what approval process. But that's not all:
- It maintains a library of reusable components to prevent anyone from having to try to reinvent the wheel.
- It trains citizen developers in best practices.
- It reviews applications created to detect problems before they explode in production.
Microsoft provides the CoE Starter Kit with dashboards that give immediate visibility: how many apps exist, which ones are used, which ones are orphaned. Organizations that deploy CoE are seeing a significant reduction in orphan applications and a significant improvement in the reuse of components.

Training and coaching citizen developers
A motivated but untrained citizen developer will tend to create applications that work on the surface but hide real time bombs (which will have to be fixed several months later). Be careful, training does not mean showing an employee where to click in Power Apps. To train is to give all the details On:
- data architecture (how to model properly);
- UX;
- safety;
- documentation.
Effective training combines Microsoft certification (PL-900 for the basics, PL-100 for a more advanced level), mentoring by an experienced developer during the first projects and systematic code review before going into production.
Governance policy: unleashing innovation without creating chaos
As mentioned above, good governance seeks above all to provide a framework without hampering innovation. To do this, it is thanks to DLP policies that you prevent accidental data leaks by blocking certain combinations of risky connectors (no automatic copy of the CRM to personal Dropbox). Likewise, by separating development environments, you're giving free rein to sandbox experimentation while protecting production.
Furthermore, in order to avoid both the pitfalls of laxity and that of bureaucracy, make your approval processes proportionate to the challenges :
- Personal application? Self-approved.
- Departmental application? CoE lightweight review.
- Critical application? Complete architecture validated by IT.
Power Platform: Microsoft's extensible low-code ecosystem
Power Apps and Power Automate: creation and automation
As a mature business platform, Power Apps offers two approaches: Canvas Apps offer total design freedom for tailor-made interfaces, while Model-Driven Apps rely on your Dataverse data model to automatically generate management interfaces. Native integration with Microsoft 365, Dynamics 365, and Azure works without complex configuration.
For its part, Power Automate orchestrate automations with several hundred connectors. Thanks to this tool, workflows can be sophisticated: conditions, loops, error management, parallel branches. So, when an opportunity is created in Dynamics 365, Power Automate creates the structured SharePoint folder, notifies the team on Teams, generates follow-up tasks, and sends the email to the prospect.
Note, however, that for very large volumes or complex integration orchestrations, Azure Logic Apps will be more appropriate than Power Automate.
Extensibility: when low code is not enough, extend with code

Power Platform escapes the trap of confinement thanks to its scalability. Need a sophisticated visual component that doesn't exist? Develop it in TypeScript like PCF Control (custom visual components) and integrate it by drag and drop. Business logic too complex? Create a Dataverse plugin (business code that runs on the server side) in C#. Internal system without a connector? Create your custom connector.
And above all, Power Platform integrates deeply with Azure. Your applications call Azure Functions for complex calculations, Azure Cognitive Services for AI, Azure API Management for enterprise integrations.
You start with pure low code to deliver quickly. Then you gradually expand with Custom code when the needs justify it. That way, the initial investment is never lost.
Low code is a tool powerful that requires expertise and governance to deliver its full value. Successful IT decision makers clearly identify appropriate use cases, implement governance through a CoE, train their citizen developers, and adopt hybrid approaches when needed.
Askware supports organizations in the integration of low-code practices by combining technical expertise in the Microsoft ecosystem and understanding of business issues. Contact us for a diagnosis of your needs and discover how Power Platform can accelerate your digital transformation.



