Is frictionless software delivery just a tech utopia? Debunking the Myth.

At Webtonic, we believe in the Theory Y management style when dealing with our people, in that we trust our people to make the right decisions. Further to this, we aim to make the delivery of software as frictionless as possible.  However, we cannot be reckless in our delivery methodology, and we understand that people make mistakes, so we have the necessary automated systems to support our developers in delivering quality, bug-free code.

To this end, we have an internal application we are building that allows us to practise our craft and teach new developers coming into our world what to expect when delivering code according to our expectations.

Below, we outline how we deliver software in a frictionless manner while maintaining our standards.

Agile and Scrum

Planning is the first step in the process. We firmly believe in an agile process and make sure that we follow the scrum methodology when managing our delivery. This means our tasks are small, with input and oversight from the entire team, giving a degree of assurance that we have covered all aspects of the requirement.

Trunk Based Development

When a developer is working on a task and creating a piece of software, we want to minimise friction when delivering it into an environment. This allows the feature, whether complete or not, to be assessed very early in the delivery cycle. Whenever code is committed, it is run through our pipeline and deployed into an environment for visibility.

To ensure incomplete features are not deployed to production we follow trunk based development with feature toggles. Because of the trunk based development all of the features are toggled and the can be switched on or off at any time. Essentially allowing us to dark launch features into production.

Software Architecture

Trunk based development is impossible without a solid software architecture allowing for loose coupling of components with the correct abstractions and separation of concerns. As a result, we start slow to go fast.

We focus on our software architecture at the start to ensure we have the appropriate points to inject our toggles in order to have confidence in what are delivering is not breaking the existing functionality.

A positive side effect of well architected code is that it is easily unit tested allowing us to test business logic without reliance on any external aspects of the infrastructure.

Code quality

We believe that a code review is an anti-pattern, and we don’t believe that a review by a senior or peer, once the code is complete, adds value to the process of delivering software. Firstly, it delays the completed code from being made visible. Secondly, it is too late; the code is written. I would rather two developers pair on a piece of code so that they both have the same understanding of the context and any problems can be fixed in the moment.

We also ensure we have the necessary metrics in place to make sure our code is of sufficient quality. This means we have pipelines to make sure we have sufficient test coverage, and static code analysis to ensure we aren’t introducing any bad coding practices or inadvertently introducing security problems.

Automated Testing

We have automated testing at a number of levels to enable confidence. We insist on an 80% unit test coverage on all new code. And should this not be met, the code will not be deployed. This coverage is expected on the backend and frontend unit tests.

Further to this, we invest heavily in automation testing to cover our regression tests. Thus, freeing up our people to add value in the process of delivering software, and not manually having to run a regression test pack. This becomes impossible when we aim to deliver features at least daily into our production environment.

Continuous Delivery

Once our end-to-end automated regression has run successfully, the software is automatically delivered into our production environment once a day. This allows to be delivering, in most instances, no more than a days work into production thus reducing the risk of change because we are deploying in small increments.

In summary, Webtonic’s frictionless software delivery highlights a balance between agility, quality assurance, and continuous improvement, aiming to deliver high-quality software predictably and consistently. Checkout our success stories!