TL;DR

Enterprise low code enables analysts to deliver in 1 hour what might take weeks or more for traditional teams to deliver - and is achieved with:

no meetings
no miscommunication
100% code predictability
0 technical debt

This revolutionises enterprise IT delivery, allowing a small number of your best software engineers to focus on new and improved software patterns, whilst stimulating rapid delivery and iteration by analysts working directly with users and stakeholders.

Imagine the agility in an enterprise like that!

Traditional Software Delivery

In an enterprise software delivery is traditionally undertaken by a software engineer / programmer / developer who will hand craft each program based upon:

A design specification from an analyst
Discussions with the designer
Their own experience of the language or platform
Their own understanding of the enterprise
Interpretation and application of a code pattern and enterprise standards

And may iterate the output a number of times based on:

Evolving requirements
Quality issues identified through a technical QA process
Defects or gaps identified by a test team or users

Once the engineer is finished an artefact they may start another of the same family, or potentially of a different family altogether.

Each time the engineer undertakes delivery of a new artefact they will improve their delivery a little from familiarity and from learning.

Inconsistencies within a code family arise because:

Improvements by a software engineer typically won't be retrofitted to previous examples of a pattern
If two software engineers deliver different instances from the same family there will be limited fidelity between them.

So consistency is limited by the nature of this delivery approach and the engineers who specialise in it.

Enterprises will implement code patterns QA processes to various degrees to mitigate these risks, however pattern evolution and innovation is impeded because the expense of retrofitting innovation typically cannot be justified through either cost or priority.

How does Enterprise Low Code differ?

Taking a Code Printing approach with Enterprise Low Code means focussing on any code artefact as being a representative of a family.

The family is represented by a rigorous code pattern and a formalised design specification template. For any member of the family the two are combined via a transformation algorithm to deliver a code artefact with 100% predictability and fidelity.

That means analysts can fill out the design template as a predictable process with only the information required specifically for the task. They can also be assisted by information merged in from other sources such as data structure definitions and API or micros service contracts rather than spending time on wordy descriptions of the requirements which may be misinterpreted.

Once a module is specified the analyst can immediately print and test the code artefact(s) arising from it without the handover and delivery delays associated with hand crafted delivery by a software engineer.

This approach encourages the best software engineers to place their whole focus on evolving and improving code patterns i.e. on hardening and innovating the code structure because:

Software engineers have the bandwidth because are no longer involved in delivery of individual code artefacts
Each improvement they make to a code pattern can be automatically applied to the whole family

And the delivery approach changes from:

A few analysts bottle necked as they document, evolve and explain requirements to
a number of software engineers who slowly iterate through the SDLC process and associated meetings and reviews
with each set of requirements repetitively delivering different code that broadly addresses the same problem
When a pattern change evolves for a module it results in inconsistencies and technical debt

Instead:

Each analyst can rapidly specify, deliver and iterate their own code based on a best practice pattern
There is no need for extended delivery timeframes and the possibility for different interpretations between analyst, engineer and test analyst
Patterns are expected to evolve and improve so they can improve the whole family of code

This approach allows an IT organisation to always be working on what is important, on delivery and innovation, without constraint from a legacy code base.

It also facilitates speed, agility and flexibility in the enterprise.

Transitioning Enterprise Delivery to Low Code

Follow these steps to transition pattern based delivery for an existing code pattern to Enterprise Low Code:

Step 1. Identify key delivery patterns, prioritised by total delivery effort (i.e. # modules* delivery effort per module)

Step 2. From sample specs and code define a Design Configuration Template and a Code Printing transformation Algorithm

Step 3. Specify structured configs for target modules using the Design Configuration Template, replacing place of unstructured design specs, and generate the code

Code Printing Workflow Diagram - Design Specs to Code Deliverables

Transitioning to Code Printing

Step 4. Identify test automation patterns and transition those also to printed code

How do we get started with Enterprise Low Code for in-house patterns?

elfware is an IT automation company specialising in using enterprise low code to accelerate delivery for enterprise clients in their own code patterns.

We leverage mojoh.io to rapidly print code artefacts consistent with client specific code patterns - a truly Enterprise Low Code platform.

We have headquarters in Sydney and clients across the globe.

If you'd like to learn more, visit www.elfware.com or contact us for:

Technical platform replacement
Project rescue
IT delivery acceleration

View all articles

Insights

TL;DR

Traditional Software Delivery

How does Enterprise Low Code differ?

Transitioning Enterprise Delivery to Low Code

How do we get started with Enterprise Low Code for in-house patterns?

Related Articles

What is Code Printing?

Why has In-house Low Code now become feasible for an enterprise?

How much complexity can Enterprise Low Code support?