Could new software tools make anyone a programmer?

In today’s world, new enter­prise soft­ware require­ments sur­face on a con­tin­u­ous basis, dri­ven by cor­po­rate realign­ments, reg­u­la­to­ry shifts, new types of devices and more. We always seem to need more soft­ware – but this can pose chal­lenges. 

Soft­ware devel­op­ment can be expen­sive, labour-inten­sive, archi­tec­tural­ly com­plex and time-con­sum­ing. It’s tra­di­tion­al­ly been a one-sided coin: pro­gram­mers take ‘require­ments’ from their user base, then hap­pi­ly dis­ap­pear off to cut code accord­ing to their pre­ferred and per­ceived vision of the solu­tion need­ed.

This mod­el of soft­ware cre­ation is effec­tive enough, but it risks cut­ting out user input: feed­back from those who can solve par­tic­u­lar busi­ness prob­lems but mightn’t under­stand how to build the soft­ware required. This dynam­ic has paved the way for ‘no-code’ and ‘low-code’ soft­ware plat­forms and tools.

Different approaches

There’s a pro­nounced dif­fer­ence between the two approach­es, with the clue quite def­i­nite­ly in the name.

No-code soft­ware suites offer users a visu­al­i­sa­tion lay­er that effec­tive­ly abstracts all the low­er-lev­el cod­ing mechan­ics and func­tion­al­i­ty into a drag-and-drop inter­face. Intend­ed to be used by busi­ness­peo­ple to cre­ate work­flows and even quite sophis­ti­cat­ed new appli­ca­tion func­tion­al­i­ties, no-code cor­rals a giv­en set of soft­ware process­es and offers them to users in a sort of intel­li­gent Lego box that spec­i­fies how the pieces can be con­nect­ed, poten­tial­ly encour­ag­ing them in a cer­tain direc­tion.

Low-code soft­ware oper­ates one fair­ly sig­nif­i­cant step high­er than no-code. Intend­ed to be used by trained devel­op­ers with sci­en­tif­ic knowl­edge of pro­gram­ming, it offers short­cuts, pre-tem­plat­ed func­tions, com­po­nen­tised accel­er­a­tors and ref­er­ence archi­tec­tures against which pro­gram­mers can craft their next appli­ca­tions or data ser­vices. 

Whether it’s low-code or no-code, any sys­tem of soft­ware short­cut­ting must have process con­trols to ensure appli­ca­tions stay with­in the realm of estab­lished gov­er­nance and com­pli­ance reg­u­la­tions.

“Organ­i­sa­tions must ensure their low-code plat­form has con­trols and stan­dards baked into it,” says Mal­colm Ross, VP of prod­uct strat­e­gy and deputy CTO at Appi­an, which offers a com­pre­hen­sive low-code plat­form and cor­re­spond­ing soft­ware tools. “Whether it is health data, finan­cial records or per­son­al infor­ma­tion in ques­tion, you need to make sure your provider adheres to glob­al reg­u­la­to­ry stan­dards. Oth­er­wise you risk staff devel­op­ing solu­tions that fail to com­ply with your IT gov­er­nance.” 

By bak­ing con­trols into their low-code plat­form of choice, organ­i­sa­tions can avoid the spec­tre of dan­ger­ous ‘shad­ow IT’, where apps are built out­side of cen­tral IT management’s view, Ross says. He insists that plat­forms in this space should adhere to indus­try stan­dards when it comes to reg­u­la­tions like the EU’s Gen­er­al Data Pro­tec­tion Reg­u­la­tion (GDPR) or the US Health Insur­ance Porta­bil­i­ty and Account­abil­i­ty Act (HIPAA). 

“Teams across an organ­i­sa­tion can then build the solu­tions they need, whilst IT lead­ers rest easy know­ing their stan­dards are being met. We know data can some­times sit in silos. But with low-code exe­cut­ed dili­gent­ly, an enter­prise has the option of gain­ing a uni­fied view of its data in a sin­gle, acces­si­ble and com­pli­ant solu­tion,” adds Ross.

Two toolsets

In the low-code soft­ware mar­ket, two core types of tech­nol­o­gy plat­forms are com­ing to the fore. First, there are ded­i­cat­ed low-code spe­cial­ists that devel­op tools to accel­er­ate pro­gram­ming, includ­ing Appi­an, Men­dix and Out­Sys­tems. Sec­ond, there is a new breed of low-code plat­forms that are attached to exist­ing cloud soft­ware com­pa­nies: Ser­vi­ceNow, Sales­force and Microsoft are not pure-play low-code com­pa­nies, but these firm’s low-code tools offer cus­tomers an addi­tion­al tier of free­dom to inno­vate, self-cus­tomise and pro­to­type as they work to try and solve their own prob­lems. 

The wider ben­e­fit with tech­nolo­gies like Ser­vi­ceNow Cre­ator Work­flows, Salesforce’s low-code offer­ing and Microsoft Pow­er Apps is that these ven­dors won’t nec­es­sar­i­ly need to sup­port every con­ceiv­able fea­ture that users build. That helps cus­tomers, too, because they don’t have to draw on the ven­dors for main­te­nance and sup­port. 

“No-code tools can elim­i­nate a lot of tedi­um from soft­ware devel­op­ment. They also make it far more acces­si­ble,” says Dr Hol­ly Cum­mins, senior prin­ci­pal soft­ware engi­neer at Red Hat, a soft­ware devel­op­er found­ed on the prin­ci­ples of open source, which is now part of IBM.  “With the right tools, any­one can cre­ate soft­ware and cre­ate it quick­ly. The catch is that these kinds of tools are most suit­ed to cer­tain kinds of sim­ple tasks, like fill­ing in forms and sim­ple approval work­flows.” 

While no-code tools make the easy things eas­i­er, they can also make hard things hard­er. Although no-code sys­tems are more acces­si­ble to peo­ple who aren’t soft­ware engi­neers, Cum­mins notes that in some ways they’re less acces­si­ble to soft­ware engi­neers, who may find their usu­al tools and pro­fes­sion­al prac­tices don’t work when they must dove­tail with the no-code offer­ing.

“Most devel­op­ers will tell you that typ­ing out code is only a small part of their skillset. Man­ag­ing inter­ac­tions with oth­er soft­ware, mak­ing updates seam­less and catch­ing weird bugs is where the intel­lec­tu­al heavy lift­ing hap­pens,” explains Cum­mins.

Development drawbacks

But there are always poten­tial weak­ness­es. All soft­ware is prone to becom­ing frag­ile over time, Cum­mins notes. That’s par­tic­u­lar­ly true for some short­cut low-code and no-code sys­tems, which are typ­i­cal­ly tight­ly locked to the par­ent plat­form. 

“This can make the result­ing appli­ca­tions hard­er to main­tain and hard­er to inte­grate with oth­er, new­er sys­tems. It also makes them hard­er to under­stand and mon­i­tor. As it matures, the soft­ware indus­try is start­ing to feel the weight of its past,” says Cum­mins.   

The bot­tom line is that no-code and low-code soft­ware will always come down to the trade-off between per­for­mance and flex­i­bil­i­ty ver­sus sim­plic­i­ty. As we now embrace the lay­ers of abstrac­tion in these soft­ware devel­op­ment tools, it’s impor­tant to remem­ber that appli­ca­tion flex­i­bil­i­ty itself is not a fac­tor of soft­ware code. It depends on how well we can under­stand, inter­pret and man­age the code blocks we work and cre­ate with. 

With the right enabling con­straints, we can use no-code and low-code for a bet­ter com­pet­i­tive advan­tage for all. As for the hard­core pro­gram­mers, they can focus on build­ing even more com­plex mod­el solv­ing, all of which they can ulti­mate­ly com­part­men­talise fur­ther into abstract­ed toolsets. Order a big­ger piz­za, dear soft­ware team – you’re going to need it.