How I’ve watched the designer-developer relationship evolve over three decades—and what it means for today’s visual designers
Introduction: When Design and Dev Were One
When I started, web design and web development were combined… People who made websites did the designing, too.
Back then, you couldn’t rely on books—there weren’t any for HTML or CSS. You learned by looking at other people’s code and figuring out what worked.
Microsoft Internet Explorer dominated, but since people had to manually update it (and most didn’t), we were stuck using outdated code to please the majority. It was a frustrating but incredibly revealing era—you understood the medium because you had to.
1. The Combined Era: We Built in the Browser
In the early web, the designer and developer were the same person. You didn’t just design—you built.
I remember Microsoft FrontPage and Netscape’s WYSIWYG tools. Adobe Fireworks—built specifically for web designers—let us slice images and create interactive prototypes. But we still laid out everything using HTML tables, a hack everyone used despite tables being meant for data, not design.
The advantage? You understood systemic consequences immediately. Change a heading style, and you saw it update everywhere. You worked within the browser’s natural flow because you had to.
2. The Communication Breakdown: The PSD Layerpocalypse
Then the roles split. Designers moved into layered Photoshop files while developers handled the code.
I watched designers create beautiful comps without realizing that changing an <h2> size would affect every page.
The Flash era brought ActionScript and plug-in nightmares—sites looked amazing until users hadn’t updated their Flash players.
WordPress arrived in 2003, making sites accessible but often crude. To customize anything, you needed PHP. Then page builders emerged, creating “div soup”—millions of nested elements where hunting down a simple 10px padding became an hour-long treasure hunt.
The result? Handoffs replaced collaboration. Designers and developers spoke different languages.
3. The Illusion of Connection: The Figma Bridge
Modern tools promised to bridge the gap but often created new silos.
When Figma launched in 2016, everything used absolute positioning—a nightmare if you’ve ever tried it. Early exported code was completely non-responsive: no rem, no vh/vw. Even now, with auto-layouts mimicking Flexbox, it’s possible to design in Figma without understanding HTML’s natural flow.
The pattern continues: Each new tool aims to eliminate code, but ends up abstracting designers further from the medium.
The rapid evolution of tools tells the story itself:
1994 → Netscape Navigator launches
1995–2006 → Microsoft FrontPage
1996–2011 → Macromedia / Adobe Flash era
1997–present → Adobe Dreamweaver
1998–2013 → Adobe Fireworks
2003 → WordPress revolution
2003 → Safari 1.0 launches
2004 → Squarespace launches
2004 → Firefox 1.0 launches
2006 → Wix founded
2006 → Shopify founded
2007 → iPhone launches
2008 → Google Chrome launch
2010 → Google Fonts launch
2010 → Ethan Marcotte coins “Responsive Web Design”
2013 → Webflow launches
2016–present → Figma era
2020 → Framer pivots to no-code web design
Between 2005-2010, the standard toolkit was Dreamweaver for hand-coded sites, WordPress for content-driven projects, Photoshop for visuals, and Flash for interactivity. Each solved immediate problems but deepened the divide by isolating design decisions from their technical implementation. A decade later, 2013-present, no-code tools represent the latest iteration of this cycle—new solutions, familiar silos.
4. The Path Forward: Reunification Through Systems Thinking
The solution isn’t going backward—it’s moving forward with wisdom from the past.
Learning HTML & CSS isn’t about becoming a developer. It’s about understanding the medium you design for. When you comprehend the box model, component architecture, and responsive principles:
- You design realistic, buildable interfaces
- You communicate effectively with developers
- You create scalable systems rather than one-off layouts
- You gain creative independence and control
The modern “combined” role isn’t one person doing everything—it’s both sides speaking the same language of components, variables, and systems.
Conclusion: Breaking the Cycle
In over 30 years, I’ve seen the same pattern repeat: new tools promise simplicity but often isolate designers from systemic understanding.
History shows what we lost when design and development diverged. Now, it’s your turn to reunify them—not by mastering every tool, but by understanding the principles that transcend them.
The designers who thrive today aren’t those who avoid code, but those who understand the systems behind their designs.