For many years, the debate has raged. Code, or no-code? Proponents of both camps have discussed to no end which one of the two approaches could provide the definitive solution to the challenges of building software. Like many things in life, this contrast between code and no-code cannot just be resolved in a straightforward manner, but here's the best part: it's actually great news for all parties involved. Indeed, while code and no-code have different tradeoffs, we can combine them into a rich architecture that leverages the advantages of both approaches while not suffering from any of their disadvantages.
Let's start with plain, old-school code. Programming languages are incredibly expressive tools. A modern programming language is very rich, and for a reason: we use it to encode all sorts of human concepts and taxonomies. Programming also has a stylistic element: the same result can be achieved with different code and algorithms, depending on what other secondary aspects we want to express: performance, concurrency, extra security, modularity, just to name a few. This is what makes code uniquely useful. Code in a modern programming language such as .Net/C# will not just allow a developer to reach the desired result, but it will also offer absolute freedom to meet all necessary functional and non-functional requirements. For example, we could connect with APIs towards all sorts of external systems, legacy (Navision/Axapta) and modern (Dynamics/SalesForce/HubSpot). Or we could structure a modular software architecture where we can start with a payment system such as Buckaroo but later extend the system to Mollie and Adyen as well because we already know that future requirements will need the extra flexibility. We can use advanced permanent open source storage solutions such as a Postgres database, synchronize it with ElasticSearch, and perhaps even load data into them from SharePoint Online or some other cloud solution. In short, the possibilities are endless.
Building a responsive, progressive frontend with modern programming tools such as TypeScript and React offers equally rich possibilities. We can build an interface which is capable of adjusting dynamically to the role of the logged in user, offer assistance and contextual visual hints in realtime, call APIs automatically on the background, all while offering a pixel-perfect, beautiful and appealing responsive and progressive user experience.
Code comes with some disadvantages though. The biggest being complexity. Developers are hard to find, and good developers (and software architects!) who can build code that can be maintained for many years without exploding maintenance costs are even harder to find. Moreover, the complexity of code usually means that achieving results simply takes time, because the huge freedom of programming languages means a myriad of tiny choices along the way about all sorts of detailed minutiae.
In short, code allows huge freedom but is expensive to wield.
No-code is sort of the opposite. No-code usually allows one single way to achieve a result, and this single way tends to be the simplest, which will be more than enough in many cases. No-code allows a developer to design their data structures and connect them to UI elements right away by means of drag and drop. No-code gets us to some pretty good results very quickly and with very little effort. We can define linear data flows that move data around through simple APIs, send notifications, manage approval flows, and more.
No-code might seem like a dream, but there are some serious caveats here. In particular, no-code allows very limited opportunity for customization. If the solutions that come out of the box do not match the specific (non functional) requirements, all of the speed and ease of building no-code applications will grind to a halt, and that's where "the fight" to tame no-code begins. Trying to get a no-code platform to behave exactly as the developer wants instead of following its assumptions is a lot of work. This means that writing no-code applications requires a good dose of pragmatism, coupled with the willingness to give up on some specific requirements.
Something that we should also not forget about is the complexity of data design. Designing databases and data structures is something that takes a fair bit of knowledge and experience. The principle of "garbage in - garbage out" applies particularly to the value of a good database design. While no-code platforms offer very appealing and intuitive data model designers, not taking the appropriate time to make sure that the data foundation properly models the application domain can be a very costly mistake. Restructuring data structures is akin to rebuilding a foundation after the house has been completed: an expensive and avoidable mistake.
In short, no-code offers great speed, but requires giving up some flexibility. And it does not make all complexity of technical design disappear as one might hope.
One might even notice that there are domains of applicability where code and no-code shine. For example, customer facing applications where a pixel-perfect UX will make a big difference in conversions and bottom line, will benefit from the freedom of frontend code such as TypeScript and React. Tweaking algorithms in order to squeeze the best SEO performance, lightning-fast application reactions, and ease of use cannot be achieved at the same level with no-code (and in the rare cases when they can, no-code will be a nightmare of costs and maintenance). A custom code middleware will also provide the ideal complement to a custom frontend: .Net and C# would allow us to provide the tailor-made fast, secure and reliable APIs that can power the UX at the frontend.
The power of no-code is best leveraged at the backend. Building multiple Power Apps that allow employees with each role within the organization to monitor running processes and even intervene when needed does not require the same level of visual sophistication of the custom frontend. Moreover, no-code will allow us to quickly build many different specialized interfaces for all sorts of different scenarios in no time, providing a great aid to the backoffice of the organization while also allowing employees freedom and effectiveness. All while reducing errors and increasing the speed and quality of backoffice processes to the advantage of internal stakeholders as well as end customers. And with Power Query/Power BI we can also connect the same data used by Power Apps and the rest of the digital platform in order to offer rich dashboards that provide the necessary insights that lead to quick and useful action to help end users achieve what they need.
In short, we can build a hybrid architecture where the advantages of code and no-code are perfectly integrated. By doing so we will build applications where no compromise is needed in order to give form to a perfect user experience on the frontend thanks to custom code, while supporting backoffice processes with little cost and high development velocity thanks to no code.
The final result: happier customers, faster processes, less mistakes, and much less effort from the backoffice.
Would you like to achieve a digital transformation that touches your whole organization, from front- to back-office? Get in touch with me at firstname.lastname@example.org or contact me via LinkedIn, I am always more than happy to help!