Short notes on how software stays easy to change for years: the ideas we work by, the sources we learned them from, and one project where they were put to the test.
Mastering Software Architecture: The Knowledge You Can’t Afford to Miss
Great software is not luck. It stands on its architecture. When the foundation is weak, even a promising application stops scaling, gets harder to maintain with every release and, in the end, has to be rebuilt.
Nobody becomes an architect by reading alone. Still, two sources have shaped how our teams think, and we recommend them to every developer. They sit behind many of our core concepts.
A book: Clean Architecture, by Robert C. Martin
Clean Architecture shows how to design systems that are modular, flexible and maintainable, so they survive years of change. Its principles do not depend on a framework or a technology, which is why they apply to almost any project. We have built them into the way we work.
A video series: Software Architecture Fundamentals, by Neal Ford and Mark Richards
For people who learn by doing, this series connects theory with practice. It gives you three things:
Architectural styles: monolith, microservices, event-driven and others, and when each one fits.
Common mistakes: the antipatterns that lead to systems which do not scale, perform badly or turn into a tangle.
Practical insight: what two industry veterans have seen work, and fail.
Above all it teaches you to think about architecture, not to follow rules.
Eight ways to put it to work
Knowledge stays only when it is used on real projects. We encourage our teams to try new patterns while respecting the fundamentals. A good place to start:
Think before you code. Plan the architecture before development starts.
Prioritise modularity. Keep components independent and loosely coupled.
Avoid complexity. A simple, well-structured system beats an over-engineered one.
Learn from mistakes. Study real architectural failures and why they happened.
Document your design. Others must be able to understand and maintain it.
Test early. Build testing into development, not after it.
Prepare for security. Consider it from the first day.
Stay current. Keep learning new technologies and patterns.
Architecture is a way of thinking, not only a technical skill. Time spent on the fundamentals pays back for a whole career.
12 April 2024 · case study · 3 min read
Sales and Marketing Tool Case Study
Client
a large multinational telecom company
Users
sales and marketing managers and agents
Team
6 engineers, plus testers and operations
First version
8 to 9 months
Method
Scrum · 2-week sprints
Test feedback
under 20 minutes
The challenge
The client's business-to-business sales team ran a complex sales process and wanted real insight into its activity and its expected results, from the first marketing lead to the closed opportunity. Several ready-made sales tools were evaluated. None fitted the process the client regards as a competitive advantage, so we were asked to build one that does.
What we built
A sales management tool that carries the whole sales process and tracks the activity and results of every salesperson. Our engineers worked with the client's product owner and business analyst, in two-week sprints, and delivered the first version in eight to nine months.
Years later a team of similar size still develops the product. New features and changes to the process go live with a low risk of surprises. We are responsible for the whole life cycle: requirements analysis, development, testing, level 2 support and fixing production incidents.
Why it is still easy to change
The product stayed flexible because design and code quality were never put aside: clean architecture, domain-driven design, modularity and low coupling on one side; SOLID principles, object-oriented design and patterns on the other. Architecture is not a decision taken once. It emerges from the code every developer writes every day, so each person on the team has to know their part in keeping it understandable while delivering the sprint.
The system follows the hexagonal style (ports and adapters) together with domain-driven design: a rich domain model holds the business logic and is kept apart from infrastructure details.
Thousands of automated tests (unit, integration and API) run on every commit, and the acceptance pipeline answers in under twenty minutes. You can watch such a pipeline run in the Engineering section.
What made it work
Autonomy. The team chose its tools, technologies and ways of working to reach the client's goals.
Domain knowledge. The engineers learned the client's sales and marketing processes until they could speak the users' language and advise on the business, not only on the code.
Continuous improvement of how the team works, with the client and inside the team.
Professional growth. Books, conferences, training and sharing inside the team, with the aim of being among the best anywhere, not only locally.
6 February 2023 · quality · 3 min read
Quality in Software
"Quality" may be the most used word in our industry. Almost every company claims it. In reality most projects lack it, and many practitioners cannot say convincingly what it is. Projects look good while they are new and then age badly: development slows down, and a change in one place breaks something in another, sometimes at great cost.
How it is built matters as much as what it does
Following Robert C. Martin, software has two values. The first is what it does: the reason the client hired the team. The second is how easily it can change. The second is less visible and, over time, more important: if flexibility is traded away to meet the first requirements, the first value erodes quickly and the product may have to be built again.
Projects still concentrate on the "what", partly because the "how" is hard to measure, above all for a client who is not a specialist in architecture and clean code.
Illustration · not measured dataTwo projects, the same start
year 1year 2year 3year 4year 5
kept clean: change stays cheapquality neglected: every change costs morespeed of change ↑
How quality is achieved
Keeping software easy and safe to change takes deliberate care from the first day of a project to the last. Following Dave Farley's Modern Software Engineering, it comes down to becoming expert at two things.
Learning
Find out what to build, and how
Software development is exploration: we keep discovering what users need and how to solve it better. Five habits make a team good at it.
Work iteratively
Use fast, high-quality feedback
Work incrementally
Be experimental
Be empirical
Managing complexity
Keep it within what people can hold
Enterprise systems live for years, keep changing and connect to many others. No engineer can keep one entirely in mind, so complexity has to be managed.
Modularity
Cohesion
Separation of concerns
Information hiding and abstraction
Low coupling
Keeping it flexible
One way to keep an architecture flexible in the long run is the one we use: a hexagonal structure with domain-driven design, where a rich domain model carries the business logic and stays independent of infrastructure. How we check this in daily work is on the Technical excellence page.
Have a platform in mind? Tell Scout.
Scout, our project agent, writes your brief in about a minute. A person on our team replies.