In software engineering, complexity is often seen as a sign of competence: a simple system looks suspicious, while a complex system looks serious.
I experienced it for ten years with the platform of a cybersecurity competition. This article starts from that story to try to understand why.
Ten years without a major incident
In my final year of engineering school, I built a CTF platform. At the time, no software like CTFd existed, so everything had to be built from scratch.
It took me a lot of thinking to arrive at an architecture that looks simple in hindsight. It served static files, generated when needed, in order to reduce the attack surface. Standard Unix services glued the components together, while low-level containers isolated the services from one another.
The first year was a bit chaotic, as any first attempt tends to be. Improvement after improvement, I stabilized the system, and a few well-scoped “micro-services” came to structure the critical parts. For ten years, the whole thing ran like clockwork: no major incident, no outage caused by a poorly understood service going down.
Yet every time I presented the architecture, I heard the same questions, asked in a skeptical tone:
- Why isn’t there Kubernetes?
- Why use the filesystem that way?
- Why not a simple REST API?
I never managed to convince anyone: a decade without incident was not enough. When I left, my work was thrown away.
The new solution is built on CTFd. In other words, a generic product that requires more computing power, offers fewer features, displays an austere interface and runs, of course, on Kubernetes.
Since then, I have been wondering why the software industry values complexity over simplicity.
Adding has become the default reaction
Today, faced with a technical difficulty, the reaction is almost always the same: add machines, software layers, cloud, abstractions. The processor is at 100%? Add processors. The system is slow? Move everything to the cloud. The architecture doesn’t suit anyone? Switch to micro-services.
From what I observe, these decisions are often made before anyone has understood the problem. When a system becomes slow, the instinctive reaction is to add servers and resources, whereas an engineer’s reaction should be to ask why.
Saying “it’s slow” is not a diagnosis: it is admitting that you have lost control of your system.
A simple system is a mastered system
There is one phrase that now sets off alarm bells for me, and that I encourage you to spot whenever you hear it: “let’s keep it simple!”. Whoever says it often confuses “simple” with “simplistic” and, in general, is not from the field.
That does not mean I advocate for a lack of technology. A simple system is not rudimentary: every one of its elements has a reason to exist. This is what makes it a mastered system, that is to say a system where:
- you know why the processor is saturated;
- you know why a network card should be added;
- you know why a faster disk is necessary;
- you understand the details of the costs, beyond a “10% less than last month” obtained by chance.
Does that seem obvious? Yet I see the opposite in many companies, starting with the interfaces of cloud providers: they are supposed to represent the state of the art, and they are frustratingly slow. When those who sell performance are not performant themselves, it should make us suspicious.
Complexity as a marker of seriousness
In many organizations, complexity has become a marker of seriousness. I experienced this firsthand: my Unix architecture, my static files and my lightweight micro-services were perceived as tinkering. Meanwhile, the other organizers of the event were struggling with their servers and with CTFd, while my system ran like clockwork.
Seen from the outside, “engineer’s tinkering” that works for ten years can’t have been that complicated to design! Conversely, a stack built on Kubernetes, Kafka and a service mesh will immediately be seen as “a real architecture”, even if those who truly understand it are rare.
I have identified several roots to this phenomenon, and there are probably more:
- mimicry: we copy the architectures of Netflix and Google without considering their constraints, which amounts to building a three-star restaurant kitchen to cook pasta;
- fear of blame: if the system breaks while you are using “industry standards”, no one will be pointed at;
- the résumé effect: working with Kubernetes and Kafka boosts a career, PostgreSQL and a monolith much less so;
- the abundance of cheap resources: why save on storage, memory or computing power, when adding more only costs a few dozen euros?
On this last point, it must be acknowledged that keeping things simple has a price: it requires time from skilled people, who are rare and expensive.
The custom doesn’t disappear, it moves
My successors replaced my system with CTFd in order to standardize. The specific code did not disappear, though: it changed location.
Admittedly, the core of the system became generic software. But everything that completes it (the orchestration, the scripts, the duct tape, the adaptations) became the new custom. That code is often worse, because it is less coherent, more scattered and less thought through as a whole. A system designed as a whole was replaced with an accumulation of workaround layers.
This case is common with modern architectures: complexity is not removed, it is moved to less visible and less controlled places. On top of that, you constantly have to keep up with the evolution of the “standard” software, adapt your customizations, fight structural changes and pray for the goodwill of others.
The cloud, the main lazy solution
The cloud is the logical continuation of this trend. It is legitimate for certain uses, but above all it allows problems to be masked instead of solved.
Faced with a technical problem, I see two paths. The first is to measure, understand and analyze. The second is to add resources, pile up abstractions and move the problem elsewhere. This second path has become the norm, because adding machines is often easier than understanding a program.
The laziness lies here: not in choosing simple hosting or a lightweight architecture, but in the unwillingness to understand how the whole thing works and what is happening inside the system.
Keeping the indispensable complexity
Some systems are complex, and that is normal. Google’s search engine or Criteo’s real-time ad auctions are surgical systems, where every element is justified, sometimes several times over. Minimalism in engineering is precisely about keeping only the complexity that is indispensable.
A company just starting out, with a few thousand users and a team of five developers, does not face the same constraints as Netflix. Yet many deploy the same architectures.
Artificial intelligence speeds things up
Artificial intelligence software can now produce code and architectures at an unprecedented pace. I can generate an entire system in a few hours: producing complexity has never been easier.
In this context, the skill is shifting. Knowing how to code matters less than knowing how to contain the complexity that gets produced, which means forcing yourself to think rather than rushing headlong toward the first solution proposed. Artificial intelligence is a great tool to pivot quickly toward alternative solutions or to explore different approaches, provided you have the perspective required to choose the right one.
The role of the engineer
An engineer is not just a producer of code. Their role is to understand systems, to master resources and costs, and to eliminate unnecessary complexity. A good engineer, by the way, often builds less.
A well-designed system looks almost too simple, and this is probably why it goes unrecognized: when everything works, nobody perceives the difficulty anymore.
Simplicity therefore has nothing to do with an absence of technology. It results from demanding engineering work, which requires measurement, observation, reflection and sometimes resisting the social pressure that pushes toward complexity.
For a concrete example of what this looks like, I described the architecture of my production projects.