Low-code versus traditional development: A primer for independent software vendors
Independent software vendors take pride in having talented developers, but that doesn’t mean they can’t benefit from the low-code revolution.
Independent software vendors (ISVs) face constantly increasing pressure to deliver innovative software solutions to their customers in as little time as possible while maintaining the level of quality they expect.
Unfortunately, this also means that even though their solutions may be functionally complete, the speed at which they need to be rolled out usually means making some sacrifices. Often, issues with the underlying code present themselves soon after delivery, necessitating rework. Thus, technical debt remains a serious and growing problem for ISVs faced with ever-growing demand.
Low-code development platforms (LCDPs) offer an increasingly viable alternative to traditional software development thanks to their ease of use and faster delivery times. That said, software vendors often still view low-code with a degree of skepticism, assuming it to be only suitable for small projects and citizen developers.
In reality, nothing could be further from the truth. Low-code is already transforming the world of software development and delivery, with the low-code market size increasing by 22.6% in 2021 alone. Indeed, low-code is fast becoming the new standard in software development to the point it is outpacing traditional software development in many sectors. Already, 84% of enterprises are using low-code to reduce the strain on their IT departments and involve the wider business in the development of mission-critical digital assets.
ISVs need to keep up if they are to remain relevant in the years to come, and the adoption of low-code will undoubtedly prove essential in that endeavor. However, that is not to suggest that traditional software development will become obsolete – after all, low-code is not quite the same as no code. Rather, it presents a compromise between the two, whereby applications can be developed quickly and, in the rare cases where an LCDP cannot accommodate certain advanced use cases, skilled developers can still rely on coding.
In this blog, we will explore the differences, as well as the commonalities, of both low-code and traditional software development and how they concern ISVs wanting to increase their speed to market while continuing to uphold rigid quality control standards.
1. Required coding knowledge
Programming languages often evoke thoughts of complicated syntax and numerous lines of code. Even popular modern languages like Python and Java are far from intuitive to laypeople, hence the continuing shift towards visual workflow designers and drag-and-drop features. By contrast, traditional development requires extensive knowledge of coding methodologies and standards, web frameworks, and various other tools.
Low-code primarily exists to make programming easier and more accessible, while traditional software development requires a very specific set of skills. Furthermore, the variation between programming languages also means that someone who is well-versed in one language may still have a lot of learning to do in order to become sufficiently familiar with another. In other words, programming skills are not nearly as portable as some might assume.
Coding knowledge and experience, or lack thereof, might not seem like an issue for ISVs, who often pride themselves on having talented developers. However, just like anyone else in the IT space, ISVs also struggle to fill skills gaps.
While any ISV will understandably want and need to retain its traditional software development team, the adoption of low-code solutions can help bridge the skills gap by easing the burden on their top developers.
2. Control and ownership
Ownership of source code is one of the most important considerations for any ISV choosing a software development platform. This is also one of the main reasons why traditional software development remains the most common approach. After all, a software vendor cannot expect to freely develop and sell applications to their clients if they do not have ownership of the code, unless they have the necessary legal agreements with those who do.
However, even traditional development can come with ownership caveats. Copyright law says that, unless agreed otherwise beforehand, every line of code is the intellectual property of the person or company that wrote it. This can be problematic for ISVs who outsource work to third-party developers. In these cases, if the developer retains ownership of the source code, the client is forever tied to that developer when it comes to updates, changes, patches, or anything else.
Unsurprisingly, most low-code platforms are even more restrictive, as users do not generally have access to the source code that their platform is built on – let alone ownership of it. Many LCDPs do support ISVs who want to develop solutions that they can sell on to their own clients, but usually only via official partner programs and if they sell exclusively through the vendor’s online marketplace.
Fortunately, there are other options for ISVs wanting to benefit from low-code. Open-source LCDPs, such as Corteza, make the source code freely available. This means that ISVs retain full control and ownership of anything they build using the platform.
3. Software delivery speed
Traditional software development requires advanced coding expertise and extensive testing, even in cases where it might be possible to reuse existing snippets of code. Because of this, more complex applications can easily take several months to develop.
The most commonly cited and greatest value of low-code is that it enables much faster delivery speed. The holy grail of rapid application development, low-code allows developers to create working apps in just days or weeks.
Since software development is what ISVs do, it stands to reason that they need to keep their development times to a minimum. Unfortunately, this often means placing a huge burden on their development teams as they find themselves struggling to meet ever-tighter deadlines.
Incorporating low-code software development can help ISVs reduce that burden and free up time for their professional developers to work on more complex and demanding projects. Low-code is not all about replacing traditional development – it should also be viewed as a way to augment the capabilities and capacities of skilled developers.
By enabling rapid development, especially in the case of common client use cases, ISVs can take on more clients, and that means increased revenue.
4. Cross-platform compatibility
From an end user perspective, low-code applications are inherently multi-device compatible, since most are entirely web-based. This means they run in the cloud and are accessible via any widely supported browser on any internet-connected device. Many LCDPs also support the development of native desktop and mobile apps. By contrast, traditional development requires applications to be built separately for each platform the developer wants to support.
That being said, deployment is quite another matter, and one where traditional development is often the clear winner. While deploying low-code apps is certainly fast, deployment options are entirely dictated by the vendor. This can be problematic for ISVs, who typically need the freedom to deploy their solutions across a wide variation of computing architectures. Given a significant lack of deployment and compatibility options, this may translate into the inability to support the needs of certain clients.
Fortunately, there are exceptions. For example, Corteza runs on open-source containerization platform Docker. Docker allows developers to package their applications into containers along with the operating system libraries and any other dependencies required to run the application in a particular environment. This means it is possible to run the LCDP, as well as any software built with it, in any operating environment. Moreover, unlike traditional software development, software only needs to be built once for all platforms instead of from scratch for each platform the ISV wants to support.
5. Support and maintenance
Vendors sell LCDPs rather like IKEA sells flat-packed furniture, in that they provide the building blocks that almost anyone can put together. The fundamental difference is that all software requires maintenance to ensure it works with other software and remains fit for purpose. Fortunately, maintaining low-code apps is typically something citizen developers can do, while the vendor supports and maintains the source code and the underlying platform.
With traditional software development, by contrast, maintenance generally falls to professional developers. This can place an especially significant burden on ISVs, since they are typically contractually obligated to support the software solutions they sell to their clients for the entire predefined lifecycle. Given that software lifecycles can last several years, this might result in long-term technical debt. Of course, this applies with low-code apps as well, although the far lower maintenance burden means reduced technical debt and easier support lifecycles.
In light of such support and maintenance needs, it may seem counterintuitive to instead adopt an open-source LCDP, as the responsibility to maintain the code partially falls to the ISV as a member of the broader development community. However, even open-source solutions have paid support contracts available, which allow ISVs to shift the operational risk to a third-party while still retaining full control and ownership over their software.
6. Agility and functionality
Low-code applications are more agile, because it is easy and quicker to make changes. Most issues can be resolved almost immediately, which translates into higher customer satisfaction in the case of ISVs. With traditional software development, releasing patches can be a lengthy process that sometimes even ends up introducing new problems that did not exist before. It is possible to mitigate these risks by following an agile software development methodology, but the inherent limitations of traditional development mean it will never be as agile as low-code.
It is also easy to add new functions to a low-code application. Often, it is as simple as dragging and dropping a new feature element into the low-code workflow, performing a few tweaks and customizations, and then recompiling the application. On the other hand, which functions and features are available are limited to those provided by the vendor – many of which are unable to support advanced business logic and very specific use cases. This takes us onto the most contested area of the whole debate – customization.
With traditional software development, ISVs are free to create any solution for any use case they want. They can support any platform, add any number or variety of features, and use any programming languages they want. Thus, the only limits to customizability are the availability of the necessary skills and the time required to complete development projects.
In practice, those limitations mean that the perceived lack of customization in low-code is often a moot point anyway. Furthermore, the more inclusive nature of low-code can offset its relative lack of customizability. In addition, LCDPs have advanced to a point where they are perfectly capable of handling advanced business logic and less common use cases.
Customization is another area where an open-source LCDP presents the best of both options. Because the source code is freely available, professional software developers can still create new functions and features from scratch if and when they need to. On the other hand, they do not need to reinvent the wheel every time they need to create a similar application for another client. That way, ISVs do not have to worry about trading off customization for ease of use.
Which method is best for ISVs?
Low-code presents enormous value to ISVs looking to ease the burden on their development teams and take on more clients. It simplifies and streamlines routine development processes, facilitates support and, in the case of open-source LCDPs, allows ISVs to retain full ownership of the intellectual property of everything they build.
This is not to say that traditional software development is going to become irrelevant for ISVs any time soon. Rather than completely replace traditional development, low-code empowers talented developers to work smarter, faster, and more agilely. By incorporating open-source low-code into their projects, ISVs can enjoy almost all the benefits of both worlds.
Planet Crust is the creator and driving force behind Corteza, a 100% open-source low-code software development platform that lets you import data from any source and use intuitive drag-and-drop tools to create custom applications for your unique business needs. Get started for free today.
Leave a ReplyWant to join the discussion?
Feel free to contribute!