Low/No-Code platforms often like to advertise that you will build and deliver valuable business applications without traditional programming knowledge. While there is some truth to that statement, we've dug a little deeper to highlight and discuss any issues faced by a citizen developer building and maintaining a custom solution on a no-code platform.
1) Traditional programming style "Problem solving" still needs to be utilized.
Often the most significant selling point that no-code platforms like to advertise is that you can put together applications without any coding knowledge, thus enabling citizen developers to create apps without the help of a qualified software developer. While it is true that you do not have to know how to write code, I believe you will still need to understand coding basics and the way code works and executes, in general, to put together a custom no-code solution. You may not be writing literal code to provide a solution, but you will still have to structure your no-code solution a certain way to solve a problem the same way you might structure a code-based solution to solve that same problem. In my opinion, some basic coding knowledge and experience is the least one would require to build and maintain quality systems using no-code platforms.
2) Knowledge of common coding patterns will make no-code development much easier
Your no-code solutions will often end up implementing common coding patterns used in custom code solutions (e.g., loops, recursion, and linked lists). Knowing about these patterns can often be crucial to whether your solution is viable or not and can often mean the difference between "We can do that" and "We can't do that".
3) No-code platforms are much more constrained in comparison to custom code solutions
No-code solutions take a regular coding base and make it more user friendly and understandable to the developer working on it, by giving them a user-friendly GUI rather than writing code line-by-line. While this makes some more mundane development tasks less tedious and more manageable, it will introduce limitations and prevent using a particular feature/pattern that might otherwise be relatively easy to implement using a custom development platform. These limitations can sometimes require integration with a custom-built API, so that the low code platform can pass data to a custom code solution to have it perform certain functions that are not viable in the low code platform itself (Which will require knowledge of custom code solutions).
4) Low code platforms can be good at providing functionality quickly but can be a bit lacking in the UI/UX customization options.
Low code platforms usually provide basic UI/UX based customization, using themes that apply specific colours and styles to elements and allow consistency between forms and controls. When the themes provided to you by the low code platform do not cut it, it can end up being quite tricky and messy to implement your own custom styling/functionality. Implementing this custom styling is not usually very straightforward, and depending on how customized it is, it could make maintenance of the system quite challenging. While low-code platforms can be used to deliver a functional system quite quickly, they may not offer the best UI/UX experience to the end-user without some custom tweaking and workarounds.
5) Too much customization of a no-code solution can make maintenance difficult
Systems in general, usually stick around longer than the developers who made them, which means a handover is done at some point in the systems life span. While a skilled developer with custom code knowledge may have made a solution on a low code platform and customized it extensively, it could get handed down to a less experienced developer who does not understand the various customizations that the experienced developer has already implemented. This can cause even the most superficial changes to become quite difficult for a less skilled developer without knowledge of the customizations made by the more skilled developer.
In conclusion, we can see that a citizen developer without traditional programming knowledge can build and maintain basic business apps. When the project requirements call for a more of a customized solution, it may not be viable to leave the building of that solution in the hands of a citizen developer who does not have the required knowledge of common coding patterns and structure.