About The Playbook
Korio is a group of professionals who came together to help companies re-platform and become agile and fast. We prefer to work with established companies in the mid-market who might be struggling with the transformation to digital. Collectively, we have gone through dozens of transformations. We have witnessed successes and failures.
Based on what we have learned, we have become quite opinionated on what works and what doesn't. This short post is part of a larger Playbook that we have assembled based on what we have learned.
For tactics that should guide how you think about your digital platform, explore the links below.
As we learn more from our clients and if we think that the learning is: A) actionable, B) validated and C) doesn't state the obvious, then we will add it to our Playbook.
Remember, everything we propose can be done incrementally and with very little lead-time. If you want to adopt the plays in a more gradual manner, go ahead but consider setting each up as an experiment: have a hypothesis, measure the impact and act on what you learn.
The Play: Select A Low-Code Platform (Carefully)
Most low-code solutions on the market are black boxes that provide limited visibility into the inner workings of a critical capability for your business. Avoid these at all costs.
Instead, select low-code solutions that generate quality code that can be inspected by your developer team. The Korio Platform leverages a code generation approach that ensures critical features, like access and authorization policies, are visible to the teams accountable for the integrity of these features.
At Korio we are a strong proponent of low-code solutions because we believe in the DRY principle: Don't Repeat Yourself. As technologists, we have enough on our plates and we don't need to spend countless hours writing and rewriting boilerplate code and configuration.
Not all code can be (or should be) generated. In fact, the code that is usually more interesting to your engineers is the code that ought to be written and optimized by hand. If your technology platform is ambitious - and if you plan on beating the competition - you need to be creating differentiating services that handle complex logic that is unique to your company. This is the hand-coded work that still needs to be undertaken by developers and should be the focus of your expensive technical teams. Writing boilerplate code, on the other hand, that simply presents forms or content to end users is not a good use of developer time.
Also - and this is an unfortunate reality we have witnessed - without a good low-code solution, the typical cycle time and cost to get new experiences deployed can balloon. In our experience, a good low-code platform can shorten cycle times and shrink costs by 10 times.
As developers, we love the flexibility that our development tools and frameworks provide us. Having said that, if you are like Korio, you probably work in a domain that is moderately mature and patterned. In this context the flexibility afforded by typical tools and frameworks is not needed and can even become a significant cause of problems. In comparison, a good low-code platform enforces better governance and consistency because it elevates "patterns" in your architecture for careful design and optimization and then locks them in through templated generators.
Korio consultants have been able to extract these patterns over dozens of transformation projects so that our clients don't need to re-invent them each time they are applied. The types of patterns we have captured in our code generators are heavily focused on front-end interactions. For example, when a form needs to capture an address and send the data into the data pipeline, we don't think developers should be hand coding this kind of feature - so we build it with generators. By generating this kind of code we increase velocity, consistency and, ultimately, code quality.
The generators that target user interactions represent an implementation of a Design System. We believe Design Systems are critical to brand consistency, effective user experiences and velocity. Within the Korio low-code platform, the Design System is a set of UX widgets or components that, when tied to code generation, produce quality code tied to a front-end framework that our client knows and trusts.
Finally, make sure the generator-based low-code solution you adopt will allow your developers to create new generators with ease. While the patterns that your generator models use may rarely change in most established industries, the technical features of the front-end and back-end frameworks will likely be optimized by the framework's owners - so make sure your generators can be adapted by your teams.
How
- When it comes to software code, commit to DRY (don't repeat yourself).
- Acknowledge and agree on "patterns" that exist in a differentiating platform.
- For the front-end, extract these patterns into a Design System.
- Create a generator for the front-end framework (Korio currently has generators for Angular and WebComponents, but other generators can be added with minimal effort)
- Create a generator for State Management and the services that manage data flow to the backend (Currently, our generators support the Redux pattern and event streaming to a Kafka "data pipeline")
- Create a generator for service orchestration (currently, our generators support the Camunda Process Execution Engine, hosted in Kubernetes)
- Working in Small Autonomous Teams, in design sessions, create models of customer journeys and business logic in Journey Mapper and then generate code from these models right in the design session. This is possible with low-code and is one of its primary advantages. Getting immediate feedback from stakeholders will significantly reduce cycle time.
Why Bother
- Patterns matter in software development. We need to recognize them and ensure that whatever code is deployed to satisfy the pattern is robust and applied consistently between teams and over time.
- Most languages and frameworks use code generation internally to save you from writing repetitive code by hand. Korio's generators work the same way but for higher level patterns that we have observed in businesses with complex business logic, multiple customer touchpoints and long-running journeys or processes.
- Turnover on technical teams is not uncommon and, despite attempts at documentation, the code of now-departed developers can be very hard to understand. Generator-based patterns reduces this risk signficantly.
- Implementing common user interactions differently from page to page based on hand code is not good for the user experience. Our users come to us to transact with us or self-serve in some way, they do not come to us to be confronted with a new way to interact with our platform that is non-standard and unfamiliar. Templated generators address this problem directly.
- In most organizations that aren't a digital startup, cycle times tend to be a real problem. Low-code combined with Small Autonomous Teams can compress cycle times ten-fold. By not having to write repetitive boilerplate code by hand, we can gain velocity. Velocity not only means fewer resources to achieve the same outcome, it also means that software can be tested and released faster so that real world data can be accumulated earlier which, in turn, means a shorter time to optimization.
What To Avoid
- Don't buy into Citizen Development as the rationale for low-code. Citizen Developmment gives non-technical folks the latitude to create applications. While this may have its place in some low-code frameworks, to us, it is not a good idea for applications that tie into your core platform. Our approach keeps trained technical staff in the loop while making them significantly more productive.
- Avoid "black box" low-code products. These solutions tend to hide their logic in closed-source solutions where the code isn't made available to your developers and infrastructure teams. This is definitely not good. This approach hides critical logic like security (access/authorization), data flow, data governance and financial controls. Korio's approach is based on code generation - and the templates and the generated code are available to developers for full inspection.
The Fallback
If you prefer to avoid low-code, at the very least, adopt a Design System. We have had the priveledge of working with some of the best User Experience talent available in our market and if we have learned one thing it is that gratuitous or inconsistent design of interaction patterns should be avoided at all costs. Design Systems, even in the absence of code generation, can lock-in the patterns that work.