Maintenance

That means treating it as something to look after, not just launch and forget: ongoing care, regular updates, and close attention are what keep it running smoothly long after the initial implementation. This is what keeps your users happy for a long time to come.

Beyond keeping things running well, we make sure your customers are safe. That starts with robust engineering: clean, well-structured code built on a solid foundation. The software underpinning web products is continually being tested and improved upon to fix any bugs, and with regular updates to your codebase, we can ensure that your customers enjoy a product that never lets them down.

That's why the groundwork for efficient maintenance should happen long before any issues arise. With clean coding practices, good documentation, and the integration of external tools, we make it as easy as possible to get an overview of the application's state and to investigate problems.

As a result of this groundwork, fewer bugs are in the code. Any bugs that do surface can be caught early on, ideally before the code is even in production use.

Documentation

From the very beginning, we document the app’s architecture in detail, including visualisations such as data models, state machines, and user flows.

This documentation isn’t just a one-time task. It’s a critical asset that evolves alongside your product. It empowers your team to plan and implement new features seamlessly while serving as a reliable reference for troubleshooting unexpected issues. With clear, up-to-date documentation, developers can resolve problems faster, make well-informed decisions, and maintain a high-performing system with confidence.

Test coverage

We write tests for any code we add. Tests operate on multiple levels: from unit tests, which check individual functions on a fine-grained level, to integration tests and full browser-based end-to-end tests, which simulate complete user flows and confirm that all parts work together as expected.

Tests don't just confirm the code works as expected, they also serve as documentation, showing exactly what the code is supposed to do. Just as importantly, they give us the confidence to change and refactor code without fear of breaking something elsewhere.

Automated code checks

Before any new code is added, we run it through automated checks to make sure code quality doesn't deteriorate. This Continuous Integration (CI) pipeline confirms for example that the code passes all tests, that the code style matches our conventions, and that all extras needed for your app, such as translations to other languages, are present. Depending on the codebase, we may add further checks to ensure the new code meets all formal requirements.

With this approach, we catch most accidental behavioral changes before they can surface later on as bugs, minimizing the maintenance work required down the line.

Human code review

On top of the automated checks, all new code is reviewed by another of our developers. A second pair of eyes helps catch unclear or risky changes early, and ensures the code stays readable and maintainable for the whole team.

Automated dependency checks

Keeping dependencies up to date is another important piece of the puzzle. We use tools like Dependabot to automatically check for outdated or vulnerable dependencies, and open pull requests to update them. This means security patches and bug fixes land quickly, rather than piling up until a major, riskier upgrade becomes necessary.

Combined with our automated checks and human review, these updates go through the same rigorous quality assurance process as any other change.

Tracking errors and monitoring performance

Using tools like Appsignal, we can track errors that happen in the live app and any other deployments. We also use it to monitor the app's performance and keep an eye on inefficient database queries.

Beyond errors, we can track other events too, wherever it's helpful to know if and how often they occur. Errors are reported to us in real time, so we can address them quickly.

All of the above means that when an error is reported or a performance issue is flagged, we're rarely starting from scratch. We can lean on the documentation, tests, and monitoring data already in place to quickly understand what's happening and why.

We treat maintenance as an ongoing responsibility, we don’t just react to problems.

• Monitor code health
• Regularly revisit and refactor older parts of the codebase
• Address issues proactively

Rather than letting small code issues pile up, we clean up as we go. This keeps the codebase easier to reason about, and means new features can be built without first having to untangle old ones.