Choosing the right code for the job

Low-code and no-code solutions have been part of the IT toolbox for over 20 years, although the current technology and terminology are newer. No-code allows users to define software behavior through a visual interface. The simplicity is appealing and certainly has its uses, often making it the right tool for the job.

Today’s no-code platforms have learned much from their predecessors. Instead of trying to do everything, most platforms specialize in simplifying configuration around standard repeatable functions like workflow, data intake, data standardization and data analysis.

Low-code platforms, on the other hand, require more software knowledge but have vast libraries of already-written and standardized modules ready to be configured and linked together with custom code.  Some believe low-code/no-code is more powerful than it really is, while others discount it as a means to do much of anything. Which of those views is in favor depends on where the technology sits in its popularity cycle.

Right now, low-code/no-code is in vogue, perhaps partially because of the difficulty many agencies have in recruiting talented software developers from the relatively small labor pool.

There are indeed some very strong use cases for low-code/no-code, but other settings where it should be a non-starter. For those, the realistic choice is between a commercial off-the-shelf (COTS) solution, perhaps with some customization, or custom code from the ground up.

In many cases, it takes an expert’s assessment to reach the right conclusions on the proper tool to use. It is important government IT leaders avoid simply picking a solution without really evaluating the problem, and just as important they avoid letting the analysis serve as an excuse for inaction.

Remember that despite the name, low-code/no-code solutions all boil down to code someone has written just below the user interface. Low-code solutions offer a mix of flexibility with some interaction with the underlying code, while no-code solutions make the code invisible to the user.

When low-code/no-code might work

Low-code/no-code is best suited for cases where repeated functions do not need heavy customization and high performance is not necessary. Some low-code/no-code platforms scale fairly well, but many do not, and it is not something users should expect of the platform.

Consider low-code/no-code for low-performance applications. In government agencies, processing standard forms is an ideal use case. The federal government uses many such forms, designated SF-and a number. SF-50, for example, is a Notice of Personnel Action, a documentation of an action that affects an individual employee’s position or pay, such as promotion. Processing these forms requires no high-end computation power, and while a large number of people might need to interact with the system, scale is not an issue. The SF-50 is an example of simple data collection, secure storage and workflow with routing, notification and basic data analytics: A highly repetitive set of well-known and well-defined user interactions. 

Low-code/no-code solutions are quite agile. During the early days of the COVID pandemic, agencies that had built low-code/no-code solutions were able to retool them quickly to adapt to remote employees and other changes to work patterns caused by the pandemic. These products offer great flexibility within their scope. However, as the environment evolves and the configuration becomes more complicated, low-code/no-code solutions can quickly outgrow their benefits and become difficult to maintain or manage. 

The place of custom development

Many government  applications need high-speed custom processing to manage large volumes of data in a unique way, so they should not try to cram a custom solution into an already-made box.  Not only will low-code/no-code likely fail in these situations, COTS products are often inadequate as well.

When I was CIO at the U.S. Patent and Trademark Office, I came in thinking I could improve the Patent Search System, which was, at the time, inadequate to the task. I had friends who worked at Google and brought them in to help.

I can still remember how they looked at me with pity as they explained how Google’s search engine served a very different purpose and that their algorithms were built for speed but not completeness -- offering nothing to help solve my problem. PTO held multiple petabytes of data and the number was constantly growing. A typical PTO search was complex:  “When someone says, ‘I need to find any sentence that contains the words cat and dog, within four words of one another, and I need to find ALL occurrences and I need it in under a minute’ -- that’s a different problem set,” my friends explained.  

What I had at PTO was a different problem, one that even an innovative industry giant like Google had not confronted before. This is a frequent situation at government agencies, and in these situations, custom development still reigns. It gives agencies the flexibility to adjust things down to the most minute detail while providing the greatest flexibility for scalability and performance. 

Landing in the middle: The power of COTS

Of course, the complexity of the above scenario is self-evident, and so is the simplicity of the SF-50 example above. What about situations that fall somewhere in between?

Highly configurable COTS software is an ideal solution in cases that need more power and flexibility than low-code/no-code can provide but do not demand the innovation and unique capabilities of expensive custom development.

Note the “highly configurable” part. Government agencies are complex and regulated, and in many cases they demand capabilities that private-sector solutions can’t deliver. Vendors who are willing to turn agency requirements into software enhancements are often the best choice. Enhancements can be built into the core product, available in future product releases and maintained by the product vendor, thus reducing the overall cost, complexity and risk of implementing upgrades and improving the next criteria -- auditability.

Conclusion

In government agencies, as in other large organizations, low-code/no-code, COTS and custom development all have a place. I recommend agencies engage experts to help them assess their agency’s needs and select the right solution that balances cost, features, time and performance. It might or might not be the solution expected, but with the help of experienced partners agencies can find the solution most likely to succeed.  That, in the end, is what every CIO wants.