<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Jesica Alvarez on Medium]]></title>
        <description><![CDATA[Stories by Jesica Alvarez on Medium]]></description>
        <link>https://medium.com/@jesicaalvarez?source=rss-01be78ebd2a0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*zXRXj5gMKiF80QdGGq3JYQ.png</url>
            <title>Stories by Jesica Alvarez on Medium</title>
            <link>https://medium.com/@jesicaalvarez?source=rss-01be78ebd2a0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 00:15:23 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jesicaalvarez/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Beyond Figma: How Learning CSS Changed the Way I Design]]></title>
            <link>https://medium.com/@jesicaalvarez/beyond-figma-how-learning-css-changed-the-way-i-design-26edcb71f858?source=rss-01be78ebd2a0------2</link>
            <guid isPermaLink="false">https://medium.com/p/26edcb71f858</guid>
            <category><![CDATA[css]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[design-engineer]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Jesica Alvarez]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 20:08:34 GMT</pubDate>
            <atom:updated>2026-11-17T20:09:37.610Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tJq_s3hZKEzKeTcVkcsDtQ.png" /></figure><h3>Introduction: Shifting Away from the “Handoff” Wall</h3><p>For years, the standard product design workflow has operated like a quiet game of telephone. We spend hours refining components in Figma, sweating over pixel perfection, crafting the ideal “happy path,” and organizing layers into immaculate design systems. Then comes the final ritual: we click “Share,” pass the link over an imaginary wall, and call it a <em>handoff</em>.</p><p>What happens next is a familiar friction. Developers are left to reverse-engineer intent, guessing how a component should collapse on a tablet viewport, how a data-dense table handles text overflow, or whether a micro-interaction is a subtle state change or an expensive performance bottleneck. The result? Endless clarification loops, back-and-forth Slack threads, and compromises made under the pressure of shipping deadlines.</p><p>The root cause isn’t a lack of talent or communication on either side. It’s the medium itself. Purely visual tools allow us to design states that are fragile, inconsistent with DOM architecture, or practically impossible to build efficiently in a real codebase.</p><p>When you cross the boundary and learn the fundamentals of HTML, CSS, and layout systems, something shifts. You don’t become a frontend developer — that’s not your job. Instead, you become a <strong>bilingual designer</strong>. You start thinking in <em>Flexbox</em>, <em>CSS Grid</em>, and responsive tokens from the moment you draw your first frame. And the moment you design with the actual constraints and logic of the web in mind, everything changes: you stop being a bottleneck and finally become a true engineering partner.</p><h3>The Developer’s Mental Model: Designing with Constraints</h3><p>When designing in Figma, it’s easy to focus on how an interface looks at a specific screen size. Even with Auto Layout and responsive constraints, a design file can’t fully replicate the fluid behavior of a browser, where content, viewport dimensions, and DOM structure continuously influence layout.</p><p>Understanding how CSS layout systems work changes how you approach your designs long before a developer opens the file.</p><h4>Thinking in Layout Systems, Not Floating Pixels</h4><p>Modern CSS relies on layout systems like <strong>Flexbox and CSS Grid</strong>, which share many principles with Figma’s Auto Layout, including alignment, spacing, and content-driven sizing. Understanding how these systems behave helps designers build interfaces that are more adaptable, predictable, and easier to implement.</p><ul><li><strong>Direction and Flow:</strong> Instead of guessing coordinates, you design with container behavior in mind — knowing how items will stack, grow, or shrink as the viewport changes.</li><li><strong>Intrinsic Sizing:</strong> You stop hardcoding fixed widths for text containers and instead design for content-driven layouts that scale gracefully.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E6EG3-dal8KXmwdMgtclmA.png" /><figcaption>From visual design to implementation: an illustrative example of how component structure, layout rules, and design tokens can create a shared language between designers and developers.</figcaption></figure><h4>Designing for the Real DOM</h4><p>Data-dense enterprise software and SaaS platforms rarely break on the “happy path.” They break in the messy edges of real-world usage. Knowing how the browser renders elements forces you to design for runtime realities:</p><ul><li><strong>Text Truncation and Wrapping:</strong> In tables and dense data grids, what happens when a user’s name or product title is three times longer than expected? Designing with CSS text-overflow and flex-wrap constraints in mind prevents ugly UI breakage during implementation.</li><li><strong>Empty, Loading, and Error States:</strong> You begin treating states not as afterthoughts, but as structural components that must fit seamlessly into the same layout grid without throwing off vertical rhythm.</li></ul><h4>Tokens and Scalability</h4><p>Codebases rely on design tokens — systematic variables for spacing, typography, and color that map directly to CSS custom properties (e.g., --spacing-md, --color-surface-primary). When you structure your Figma variables to mirror these exact token names, handoff ceases to be a translation problem. You speak engineering fluently because your design system&#39;s architecture matches theirs.</p><h3>From Screen to Production: Practical Collaboration Wins</h3><p>When you stop treating engineering as a black box and start understanding how code translates your intent, the day-to-day dynamic of building software undergoes a quiet transformation. Collaboration shifts from defensive status updates to active, peer-level problem solving.</p><h4>Speaking the Same Vocabulary</h4><p>One of the most immediate benefits of crossing the design-code boundary is the elimination of subjective translation friction.</p><ul><li><strong>Precision over Ambiguity:</strong> Instead of leaving feedback comments like <em>“can you make this spacing feel a bit lighter?”</em> or <em>“this layout feels off on mobile,”</em> you begin communicating in precise technical terms.</li><li><strong>Shared Reference Points:</strong> Discussing layouts using terms like flex-wrap, spacing tokens, box-sizing, or explicit padding values gives designers and developers a common technical language. It reduces ambiguity, makes conversations more productive, and helps teams reach implementation decisions faster.</li></ul><h4>Prototyping with Reality in Mind</h4><p>Purely visual prototyping tools can easily trick you into designing animations, transitions, or state changes that look slick in a prototype but are nightmares to render efficiently in a live browser.</p><ul><li>When you understand performance budgets, DOM reflows, and basic CSS transitions, your prototypes become inherently more realistic.</li><li>You start designing micro-interactions that respect actual browser rendering capabilities — meaning your designs don’t just look good in a static presentation; they survive the transition to production smoothly.</li></ul><h4>Earning Engineering Trust</h4><p>Perhaps the most valuable win is earned trust. Developers spend a lot of time cleaning up messy, structurally unsound design files where layers are ungrouped, autolayout is broken, and responsive constraints are ignored.</p><ul><li>When an engineer opens your Figma file and sees a clean, modular component tree that mirrors DOM hierarchy and uses systematic spacing tokens, the dynamic changes instantly.</li><li>When developers encounter well-structured design files, reusable components, consistent spacing, and clearly defined responsive behavior, collaboration becomes easier. It demonstrates an understanding of implementation constraints and creates opportunities for designers to contribute earlier to technical discussions and product decisions.</li></ul><h3>Design QA: From a Policing Checklist to a Collaborative Dialog</h3><p>Every designer knows the sinking feeling of opening a staging environment for the first time and seeing that the padding is uneven, the font weight defaulted to regular instead of medium, and the icon alignment is slightly off.</p><p>Traditionally, <strong>Design QA</strong> has been treated like a red-pen audit — a tedious game of ping-pong where the designer logs dozens of micro-tickets (<em>“this is 2px off”, “wrong border-radius”</em>), and developers sigh, viewing design review as an exercise in policing rather than problem-solving.</p><p>When you understand how styles cascade and how elements sit in the DOM, Design QA transforms entirely:</p><ul><li><strong>Debugging Together, Not Apart:</strong> Instead of tossing tickets over the fence, you sit down with a developer, open browser <em>DevTools</em>, and inspect the element together. Because you speak CSS, you can say, <em>“Ah, the flex-direction on this wrapper container is set to column instead of row,”</em> or <em>“We just need to adjust the flex-shrink property here.”</em></li><li><strong>Live Problem Solving:</strong> You can tweak properties right there in the browser to test a fix instantly, rather than guessing what went wrong and waiting another sprint cycle for a rebuild.</li><li><strong>Better Decisions, Better Polish:</strong> Understanding the technical reasons behind visual inconsistencies helps designers and developers evaluate solutions together, balancing visual quality with accessibility, performance, and implementation constraints. Design QA becomes a shared effort to improve the product rather than a checklist of isolated corrections.</li></ul><h3>Conclusion: The Value of the Bilingual Designer</h3><p>Bridging the gap between design and engineering isn’t about doing someone else’s job. A product designer’s core responsibility remains what it has always been: understanding user needs, defining intuitive flows, and crafting products that solve real business problems.</p><p>However, learning the fundamentals of code — understanding how a layout wraps, how design tokens map to CSS variables, and how the browser renders structure — changes your mindset. It stops you from designing in a vacuum.</p><p>Understanding code doesn’t automatically make someone a better designer. What it does is expand the way we think about problems, communicate decisions, and collaborate with engineering. When our design files reflect the logic of the web, we reduce ambiguity, build stronger partnerships, and contribute to more thoughtful, scalable product solutions.</p><p>You don’t need to write production code every day. You just need to speak the language. And once you do, building great software becomes a lot less about friction, and a lot more about creation.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=26edcb71f858" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>