The Mess That Made Design Systems Inevitable
The history of how digital products got complicated enough to need a system.
There’s probably a parallel universe where we saw all of this coming. Where we understood early on that digital products would become complex, multi-device, multi-team organisms, and we prepared accordingly.
Not in this universe.
The Tools Were Great. The Future Had Other Plans.
I finished my degree in Graphic Design in 2001. The course was full of rules: composition, typography, colour theory, print production. Then I stepped into the web, and it felt like the opposite of all that. A new world, almost without constraints. No production costs. No print runs. No physical limits.
The tool that captured that spirit best was Macromedia Flash. You could make things move, respond, surprise. We believed — genuinely believed — that the web would evolve towards something closer to animation and advertising than to editorial design. Full-screen experiences distributed on auto-executable CDs. Microsites. Banners that took over the page.
Clients weren’t asking for anything different. Brands saw the internet as a place for identity, not for products.
This wasn’t a minority position. Design schools were teaching websites as a form of creative expression, free of the constraints that governed everything else. And there was a reasonable argument for it: unlike a newspaper or a car, digital could be corrected after delivery. You could fix things. Ship, then iterate.
That flexibility, it turned out, had a cost. We just couldn’t see it yet.
The Web Grew Up Faster Than We Did
Screens started multiplying. Speeds increased. Interactions became richer. And then smartphones arrived, and everything we thought we understood about designing for a screen had to be rethought.
Suddenly one product needed to work on a 320px phone, a 768px tablet, a 1440px desktop, and a TV. Each at different resolutions, in different orientations, for different contexts. A user on the subway needed something different from a user at a desk. “Multi-device” wasn’t a feature request. It was the new baseline.
We reacted by going granular. Design every state. Every breakpoint. Every micro-interaction. Control everything. The pixel-perfect mentality, which made sense when a single screen was the canvas, became an obsession that didn’t scale. You cannot hand-craft every combination of every component across every device for every team working in parallel. The maths don’t work.
And the tools were still catching up. Many of us had moved from Flash to Fireworks, then to Photoshop for UI work, tools built for retouching and illustration, not for designing systems of reusable parts. Sketch arrived and felt like a revelation. Then Figma. But by the time the tools were right, the products had already grown far beyond what any individual designer could hold in their head.
The Code Side Got Complicated Too
On the development side, something significant was shifting.
In the early days, a web page was mostly a static template that the back-end would fill with content. Your computer received a finished page from a server. Each interaction triggered a round trip: request sent, page returned, page rendered. The front-end was largely decorative. It coloured and animated what the server sent back.
That changed. The front-end started carrying real logic. Frameworks like React and Vue made it possible to build genuinely complex behaviour in the browser without a constant back-end round trip. Filters, dynamic content, real-time updates, personalisation: all of it running in the client. The front-end became a product in its own right, not a skin over a server response.
This meant components were no longer just visual elements. They had state. They had behaviour. They had data flowing through them. The same button could appear in ten different contexts, each with slightly different requirements. The same form could be used across six products with different validation rules.
And the environment kept adding complexity. Third-party services, payment gateways, chat widgets, analytics scripts: each one integrated into the product but built by a different team with different rules. Cloud infrastructure introduced real costs around traffic and data. SEO requirements meant the code had to be semantically correct, not just functional. Accessibility went from an afterthought to a legal consideration in many markets.
Each new requirement was reasonable on its own. Together, they produced something almost unmanageable.
The Debt Nobody Talked About
All of that complexity left a residue.
Technical debt accumulated quietly. The same solution programmed five different ways by five different developers, each one technically correct, none of them consistent with the others. Style rules written inline because there wasn’t time to do it properly. A design decision made in a rush that got locked in because too many things depended on it.
Design debt piled up alongside it. Colours that drifted slightly between products. Spacing that was eyeballed rather than defined. Typography choices made by a designer who left two years ago, now replicated by everyone who came after because it was already there and changing it seemed risky.
The worst part wasn’t the inconsistency. It was where the decisions lived. In someone’s head. In a Slack message from 2019. In a Confluence page that nobody had updated since the team restructure. When the person who made the original call left the company, the reasoning left with them. What remained was the output, stripped of its context.
Adjusting something “2px to the left because it looks better” was a normal design review comment for years. Not because designers were being precious. But because there was no shared reference point. No system to appeal to. Every decision had to be argued from scratch.
The Complexity Was the Signal
Looking back, it would be easy to frame all of this as a series of mistakes. We used the wrong tools. We moved too fast. We didn’t plan for scale.
But that’s not quite right either.
The web genuinely was a new medium, and we were figuring it out as it grew. The Flash era produced real creativity. The pixel-perfect obsession came from caring about quality. The technical debt was often the cost of shipping quickly in a competitive market, which is sometimes the right call.
What changed wasn’t that the industry got careless. What changed was that the medium matured, and the old ways of working stopped being adequate for what the products had become.
A single designer can hold a single product in their head. Two designers can negotiate. Ten designers across five teams building for eight platforms under three brands cannot operate on negotiation and goodwill alone. The coordination cost becomes the product cost. The inconsistency becomes the user experience.
Design Systems didn’t emerge because someone had a clever idea about atoms and molecules. They emerged because the alternative, continuing to design and build digital products as if they were independent artefacts, stopped being viable. The mess was the signal. The system was the response.
The question was never whether to build one. It was whether to build it deliberately, or let it build itself out of accumulated habit, technical debt, and design debt.
Turo López Sanabria has over 20 years of experience in Design, and nearly a decade building the infrastructure that makes digital products coherent at scale. Five Design Systems. Several companies. Today, he works at the frontier where the line between building for humans and building for machines has started to blur.
Read the companion pieces: