For a long time, my relationship with digital design was simple. I lived comfortably inside the Figma bubble. I focused on what I did best: perfecting responsive grids, maintaining typography variables, and building clean component states. To me, the handoff process was a clear line in the sand—I delivered the visuals, and developers turned them into code.

But as I began working on larger, more complex web redesign projects, I hit a profound structural realization: A website is only as flexible as the Content Management System (CMS) powering it.

When design is built completely separate from the underlying backend code, a massive friction point emerges. You can design an incredibly optimized user experience in Figma, only to discover later that the existing components or templates built into the backend cannot support your layout without significant engineering rewrites.

Faced with this bottleneck, I decided to look past the Figma canvas and understand how the design community actually perceives content architecture. What I found is that designers generally fall into three distinct camps:

1. The Skeptics: These designers often feel restricted by legacy, traditional CMS templates. They view the CMS as a creative straightjacket that forces them to design for the system’s historical technical limitations rather than the user's actual needs.

2. The Enthusiasts: These are the creators who lean heavily into visual no-code builders (like Webflow or Framer). They love the total creative autonomy of visually programming layouts and animations independently, though they acknowledge these platforms face strict scaling limitations for complex data.

3. The Systems Thinkers: This is where I found my own design philosophy. Systems thinkers don’t look at websites as a collection of static pages; we look at them as a unified ecosystem of reusable, elastic components. We value scalability, structured data, and long-term brand guardrails.

My Real-World Solution: The Component Audit

When you are a Systems Thinker dealing with a pre-existing technical architecture, your goal isn't to fight the system or demand a total rebuild. Your goal is to map your visual system to the developer's data system.

To solve this friction point on a recent redesign, I initiated a collaborative framework called a Component Audit:

• Step 1: Structural Mapping. Instead of handing off finished page mockups, I broke my Figma designs down into their raw, atomic elements (Hero sections, Card variants, Form layouts).

• Step 2: Gaps and Extensions. I sat down with engineering to map my new UI components directly against the existing CMS blocks. Where there was a perfect structure match, we simply applied the new visual styling (colors, corner radiuses, typography variables).

• Step 3: Engineering Conditional Fields. Where my design required a layout modification that the current CMS didn't support, we didn't scrap the system. Instead, we worked together to add conditional field extensions into the backend data structure, giving the layout the necessary elasticity without breaking the database foundation.

A CMS should never be a mystery to a design team, nor should it be an afterthought. By treating content architecture as an extension of your Figma design system, you can respect existing engineering frameworks while protecting your creative intent. When designers and developers co-author the system, the final product is always stronger.