Backend Software Engineers are Designers Too
We typically associate 'design' with visual aesthetics, but it's more than that. Backend engineers are masters of System Design, meticulously crafting the architecture, dependencies, and data structures that influence user experiences. This post explores the hidden artistry in their work.
The internet is overflowing with memes of “dev vs designer”, and it’s undeniable that it’s a collaboration that can yield both spectacular and hilarious results.
“Designer” is a term we often - and sometimes exclusively - associate with roles related to “interface design” like Web Designer, UI/UX Designer, Product Designer, etc. Maybe, even unconsciously, we associate it with someone artistic, creative and with a focus on building beautiful and intuitive products with carefully cultivated aesthetics.
However, the focus on the artistry of “design” often leads us to forget the pragmatism of it. Designing ultimately means making decisions about how things should look, function, and operate to meet specific objectives.
That’s why backend software engineers are designers too: “system design” is also a category of design.
Beyond the fact that backend engineers can contribute to the design of the product with feedback and ideas - which is a whole conversation in itself - they have to consistently decide and shape the design of the software. From the whole architecture of a system, to its individual dependencies and data structure, developers need to make hundreds of decisions that impact the end user experience and the usability and maintainability of the software.
In this blog post we aim to highlight that design has always been an intrinsic part of the backend engineer’s role and that “devs and designers” are more similar than we often assume.
The Pragmatic Side of Design
Any run-of-the-mill engineer can design something which is elegant. A good engineer designs systems to be efficient. A great engineer designs them to be effective. - Akin's Laws of Spacecraft Design
Design is a two sided coin with aesthetics and creativity on one side and pragmatism on the other. Both coexist and are essential to delivering a product that meets user expectations and requirements, but the artistic side is often more visible: it prioritizes things like an appealing and intuitive interface, which is what users immediately notice and appreciate.
However, the pragmatic side is just as important in steering choices toward solutions that are performant, scalable, and maintainable … however these aspects are not always as visibly evident to users.
In software engineering, design choices permeate every layer of the tech stack and both frontend and backend engineers grapple with them daily. However, the design choices of backend engineers isn’t always immediately visible to users. These are things like:
- Defining the system architecture
- Adding a new microservices
- Bringing on a new SaaS provider
- Changing an API
- Editing the data structure
It’s a misconception to think that backend developers just “churn out code”: the design decisions made in building the backend of an application shape the user experience indirectly and they matter as much as the front-end decisions. For example, think of the loading time of an application, how fast you can search the data, how seamless the user experience is in any location, etc.
Reliability, scalability, performance, and efficiency are aspects of an application that we take for granted most of the time, but it is painfully obvious when they are missing and something has gone wrong - i.e. when we make poor backend system design decisions.
The Artistry of Backend Engineers
There is never a single right solution. There are always multiple wrong ones, though. - Akin's Laws of Spacecraft Design
Calling Backend Engineers “artists” seems an exaggeration until you realize the amount of creativity, intuition, adaptability, and problem solving needed to build the backend of a complex distributed system. Among the many possible approaches to achieve any given objective, the backend engineer needs to select the design that perfectly meets the requirements while also being able to gracefully evolve over time.
From a macro perspective, backend engineers need to evolve their approach based on industry wide shifts in technology.
Think for example of how programming used to require writing code from scratch, line by line. Now it's an assembly-like approach, where backend engineers need to meticulously select and combine components, libraries, and frameworks to create a complete system where each piece fits seamlessly.
Or, consider having to embrace new types of software architectures, programming paradigms, etc. to meet the requirements imposed with the shift toward distributed systems and cloud-native applications.
At the business problems level, they may need to craft designs that deliberately change over time (i.e. succession design and evolutionary architecture) because of known or unknown future product requirements. Or they may need to revisit their technology choices and evolve their tech stack choices to leverage new technologies (e.g. LLMs)
Software engineering is a vast and complex discipline, made even more complex thanks to the continuous evolutions in the tech landscape.
The artistry of backend engineers is evident in the way they meticulously design system architectures, selecting the most elegant coding solution, and sculpting data structures to create software that operates seamlessly.
On a personal side note, throughout my years in tech I’ve met a large number of engineers who are also talented visual artists or musicians. While I couldn’t find any official study to corroborate this observation, I wouldn’t be surprised to learn that there is a correlation between being a great developer and being a great musician or artist.
Why Every Developer Should Learn System Design
If you want to have a maximum effect on the design of a new engineering system, learn to draw. Engineers always wind up designing the vehicle to look like the initial artist's concept. - Akin's Laws of Spacecraft Design
System Design is becoming a non-negotiable skill set for developers in a world where most modern software systems are distributed systems. The scalability, resiliency, and consistency requirements, the number of components and interactions between them, the distribution, partition, replication of data, etc. produce a system that is many number of times more complex than a single-server or monolithic system.
Coordinating these requirements and components is a complex challenge, and software design is a critical tool to avoid issues like poor performance, data inconsistency, security vulnerabilities, and system failures.
Attention to System Design is also a differentiator for high performing software engineering organizations. As argued in the book “Accelerate” by Dr. Nicole Forsgren, Jez Humble, and Gene Kim, there is a link between a well-designed, loosely-coupled architecture and more frequent software delivery.
In fact, software design - how things are named, structured, organized, etc. - is a fundamental part of internal quality. And the latter enables new features and improvements to be delivered more sustainably (see also this argument by Martin Fowler).
Lastly, it’s worth pointing out that many engineers perform logical/functional design implicitly, without realizing it (for example when they break down a User Story). However, fully embracing the need for System Design and applying it in your daily work becomes a huge competitive advantage, even just for its ability to prevent technical debt -i.e. identify “high-cohesion” areas and highlight potentially “high-coupling” dependencies which should be avoided.
A Collaborative & Iterative Approach to Design
Design is an iterative process. The necessary number of iterations is one more than the number you have currently done. This is true at any point in time. - Akin's Laws of Spacecraft Design
In the ever-evolving landscape of software development, the lines between the roles of 'dev' and 'designer' continue to blur.
Nowhere is this more evident than in the realm of backend engineering, where design is critical but often underestimated. The beauty of a modern digital product lies not just in its visual elegance, but in the seamless functionality that underlies it, hidden from the user's view.
Breaking down the barriers between roles and encouraging more collaborative work across teams leads to benefits on every level of the tech stack and, in particular, at an architectural level where decisions are more costly and harder to reverse.
It's an iterative journey where creativity and pragmatism dance together, constantly refining and optimizing the end product.
When choosing how to make your team successful, you want to select software that is natively built for visual collaboration, fosters effective teamwork across every phase of development, and emphasizes communication and documentation.
Multiplayer is working on a platform that will improve how backend developers design, develop, and manage distributed software, and ultimately drive innovation, productivity, and success in tech companies. If you’re interested in checking it out, sign up for free.