<?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 Aparna Rajan on Medium]]></title>
        <description><![CDATA[Stories by Aparna Rajan on Medium]]></description>
        <link>https://medium.com/@aparnaabbe?source=rss-00bf039e37da------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*c7QHVRKcGFjaCZTh</url>
            <title>Stories by Aparna Rajan on Medium</title>
            <link>https://medium.com/@aparnaabbe?source=rss-00bf039e37da------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 14:04:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@aparnaabbe/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[NEXT.JS + NESTJS Structuring a Full-Stack TypeScript Project]]></title>
            <link>https://medium.com/@aparnaabbe/next-js-nestjs-structuring-a-full-stack-typescript-project-b84902edf672?source=rss-00bf039e37da------2</link>
            <guid isPermaLink="false">https://medium.com/p/b84902edf672</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[full-stack-development]]></category>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[nestjs-typescript]]></category>
            <dc:creator><![CDATA[Aparna Rajan]]></dc:creator>
            <pubDate>Tue, 03 Nov 2026 07:05:30 GMT</pubDate>
            <atom:updated>2026-11-03T07:05:30.567Z</atom:updated>
            <content:encoded><![CDATA[<p>A practical approach to building a clean, scalable architecture with Next.js, NestJS, Nx, and PostgreSQL</p><p><strong>Building a full-stack TypeScript application is straightforward. </strong>Keeping it maintainable as features, integrations, and teams grow is where architecture really matters.</p><p>Next.js and NestJS complement each other particularly well. Next.js provides the frontend experience, while NestJS gives the backend a structured home for APIs, business logic, validation, authorization, and data access.</p><p>But choosing the right frameworks is only part of the solution.</p><h3>Start With Clear Boundaries</h3><p>Before thinking about folders, define responsibilities.</p><pre>┌─────────────────────────┐<br>│        Next.js          │<br>│    Frontend / UI        │<br>└────────────┬────────────┘<br>             │  REST API<br>             ▼<br>┌─────────────────────────┐<br>│        NestJS           │<br>│  Business / API Layer   │<br>└────────────┬────────────┘<br>             ▼<br>┌─────────────────────────┐<br>│      PostgreSQL         │<br>│       Data Layer        │<br>└─────────────────────────┘</pre><h3>Next.js owns the user experience</h3><p>· Pages and layouts</p><p>· React components and user interactions</p><p>· Forms and frontend state</p><p>· Rendering and communication with backend APIs</p><h3>NestJS owns backend behavior</h3><p>· REST APIs and business rules</p><p>· Request validation</p><p>· Authentication and authorization</p><p>· Database access and external integrations</p><p>· Error handling</p><p>The frontend should know how to present a feature. The backend should know how that feature behaves.</p><h3>Organize the Project as a Monorepo</h3><p>When frontend and backend applications evolve together, a monorepo can provide a clean development experience. With Nx, separate deployable applications from reusable libraries:</p><pre>my-project/<br>├── apps/<br>│   ├── web/          # Next.js<br>│   ├── admin/        # Next.js<br>│   └── api/          # NestJS<br>├── libs/<br>│   ├── frontend/<br>│   ├── backend/<br>│   └── shared/<br>├── package.json<br>├── nx.json<br>└── tsconfig.base.json</pre><p>This structure makes it easier to introduce another frontend, backend service, or shared capability later without reorganizing the entire repository.</p><h3>Keep the Next.js Application Focused</h3><p>The frontend should remain centered around presentation, user interaction, and communication with the backend.</p><pre>apps/web/<br>├── app/<br>├── components/<br>├── hooks/<br>├── services/<br>└── styles/</pre><p><strong>app/ </strong>Routes, layouts, pages, and route-level functionality.</p><p><strong>components/ </strong>Reusable UI elements.</p><p><strong>hooks/ </strong>Reusable React behavior and data hooks.</p><p><strong>services/ </strong>Communication with backend APIs.</p><p><strong>styles/ </strong>Shared application styling.</p><p>For example, API communication can remain outside UI components:</p><pre>export const getCustomers = () =&gt;<br>  fetch(`${API_URL}/customers`).then(res =&gt; res.json());</pre><p>This keeps components focused on what they should do best: rendering and interaction.</p><h3>Separate Server State From Client State</h3><p>As a frontend application grows, state management can quickly become confusing. A useful distinction is:</p><pre>Server state  →  TanStack Query<br>Client / UI state  →  Zustand</pre><p>TanStack Query is a natural choice for data coming from the backend, including fetching, caching, mutations, and refetching. Zustand can be useful for application-specific state such as multi-step workflows, temporary selections, UI preferences, or shared client state.</p><p>The architectural goal is to avoid maintaining multiple copies of the same server data unnecessarily.</p><h3>Structure NestJS Around Business Features</h3><p>Instead of grouping everything by file type, organize NestJS around business capabilities:</p><pre>apps/api/src/modules/<br>├── customers/<br>│   ├── customers.controller.ts<br>│   ├── customers.service.ts<br>│   ├── customers.repository.ts<br>│   ├── dto/<br>│   └── entities/<br>├── users/<br>├── invoices/<br>└── documents/</pre><p>Everything related to customers lives together. The same applies to invoices, users, documents, or other business areas.</p><h3>Keep Backend Responsibilities Predictable</h3><p>Within each feature, maintain a clear flow:</p><pre>Request  →  Controller  →  Service  →  Repository  →  Database</pre><p><strong>Controller: </strong>Handles the HTTP boundary.</p><p><strong>Service: </strong>Contains business behavior.</p><p><strong>Repository: </strong>Handles persistence.</p><p>The goal is not to create layers for their own sake. It is to ensure each part of the application has one clear responsibility.</p><h3><strong>Define Clear API Contracts</strong></h3><p>The boundary between frontend and backend deserves special attention. NestJS DTOs provide a clear definition of what an API accepts.</p><pre>Request  →  DTO  →  Business Logic  →  Entity  →  Database</pre><p>Your API contract and database entity may look similar, especially early in a project, but they represent different concerns. Avoid making the database schema your API contract by default.</p><h3>Share Contracts, Not Implementations</h3><p>Having TypeScript across the entire stack creates an excellent opportunity for code sharing. But sharing everything is not necessarily good architecture.</p><pre>libs/shared/<br>├── contracts/<br>├── validation/<br>└── utils/</pre><p>Good candidates for shared libraries include:</p><p>· API contracts</p><p>· Enums</p><p>· Validation schemas</p><p>· Common constants</p><p>· Framework-independent utilities</p><p>Backend repositories, ORM entities, NestJS services, and React-specific state should usually remain within their respective layers.</p><h3>Keep the Database Behind the Backend</h3><pre>Next.js  →  REST API  →  NestJS  →  ORM  →  PostgreSQL</pre><p>NestJS becomes the controlled boundary around the application’s data. This provides a centralized place for validation, authorization, business rules, persistence, error handling, and auditing.</p><p>More importantly, the frontend does not need to understand how data is physically stored. That separation gives both sides room to evolve.</p><h3>Treat Authentication and Authorization Differently</h3><h3>Next.js handles the experience</h3><p>· Whether a user sees a particular page</p><p>· Whether an action is displayed</p><p>· Which navigation options are available</p><p>· How authentication states appear</p><h3>NestJS enforces access</h3><p>The backend should independently verify whether a request is actually allowed. Hiding a button is a UX decision. Rejecting an unauthorized API request is a security decision. Never rely on the frontend alone to protect sensitive operations.</p><h3>Let Testing Follow the Architecture</h3><pre>Frontend  →  Components, hooks, user interactions<br>Backend   →  Services, controllers, business rules, API integration<br>End-to-end → Critical user journeys</pre><p>For the frontend, React Testing Library with Jest or Vitest works naturally for component and interaction testing. On the backend, tests can focus on NestJS services, controllers, validation, and business behavior. End-to-end tests can then verify the workflows that matter most to users.</p><h3>Putting It All Together</h3><p>A typical request follows a predictable path:</p><pre>User<br>  ↓<br>Next.js<br>  ↓<br>Component<br>  ↓<br>Hook / API Service<br>  ↓<br>NestJS Controller<br>  ↓<br>Validation<br>  ↓<br>Business Service<br>  ↓<br>Repository<br>  ↓<br>PostgreSQL</pre><p>Every layer exists for a reason. When something goes wrong, developers have a much clearer idea of where to start looking.</p><h3>A Scalable Final Structure</h3><pre>my-project/<br>├── apps/<br>│   ├── web/<br>│   ├── admin/<br>│   └── api/<br>├── libs/<br>│   ├── frontend/<br>│   │   ├── ui/<br>│   │   ├── hooks/<br>│   │   └── features/<br>│   ├── backend/<br>│   │   ├── auth/<br>│   │   ├── database/<br>│   │   └── common/<br>│   └── shared/<br>│       ├── contracts/<br>│       ├── validation/<br>│       └── utils/<br>├── package.json<br>├── nx.json<br>└── tsconfig.base.json</pre><pre>frontend/*  →  UI and browser concerns<br>backend/*   →  API and server concerns<br>shared/*    →  Framework-independent TypeScript</pre><h3>Common Mistakes to Avoid</h3><h3>1. Putting business logic in React components</h3><p>Components should primarily handle presentation and interaction. Keep business rules in their appropriate domain.</p><h3>2. Building giant NestJS services</h3><p>If a service starts coordinating several unrelated workflows, split those responsibilities before it becomes difficult to test and maintain.</p><h3>3. Exposing database entities to the frontend</h3><p>Persistence models and API contracts solve different problems. Keep them separate.</p><h3>4. Overusing any</h3><p>If everything eventually becomes any, much of TypeScript’s value disappears. Prefer explicit domain types whenever possible.</p><h3>5. Turning utils/ into a dumping ground</h3><p>A generic utilities folder tends to collect unrelated functionality. Prefer meaningful, domain-specific libraries when ownership is clear.</p><h3>Final Thoughts</h3><p>Good architecture is not about creating as many folders, layers, or abstractions as possible. It is about making responsibilities clear, predictable, and difficult to misuse.</p><pre>Next.js  →  API Services  →  NestJS  →  Business Services  →  Repositories  →  PostgreSQL</pre><p>Use Nx to organize deployable applications and reusable libraries. Keep server state and client state conceptually separate. Share TypeScript contracts where they add value, but avoid coupling frontend code to backend implementation details.</p><p>Organize your codebase around responsibilities and business capabilities, not simply frameworks and file extensions.</p><p>A good project structure should make one question surprisingly easy to answer:</p><p><strong>Where should this code go?</strong></p><p>When a developer can open the repository and answer that almost immediately, the architecture is doing its job.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b84902edf672" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Figma to Code: Building Pixel-Consistent Web Pages with Design Tokens and GitHub Copilot]]></title>
            <link>https://medium.com/@aparnaabbe/from-figma-to-code-building-pixel-consistent-web-pages-with-design-tokens-and-github-copilot-9eb5e139233f?source=rss-00bf039e37da------2</link>
            <guid isPermaLink="false">https://medium.com/p/9eb5e139233f</guid>
            <category><![CDATA[figma-design-system]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[react-development]]></category>
            <category><![CDATA[import-figma]]></category>
            <dc:creator><![CDATA[Aparna Rajan]]></dc:creator>
            <pubDate>Thu, 29 Oct 2026 16:28:11 GMT</pubDate>
            <atom:updated>2026-10-29T16:28:11.698Z</atom:updated>
            <content:encoded><![CDATA[<p>A practical, end-to-end workflow for transforming Figma designs into maintainable React interfaces using design tokens, Figma Variables, and GitHub Copilot.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YGoJgk9e5XS3kC07RDL_vg.png" /><figcaption>Figma to Live Website</figcaption></figure><h3>Introduction</h3><p>Turning a Figma design into a production-ready web page is rarely as simple as copying colors, spacing, and typography into CSS.</p><p>A design may look perfect in Figma, but during implementation subtle inconsistencies can quickly appear:</p><ul><li>A developer uses #0067B8 instead of the design-system color.</li><li>A button receives 12px padding instead of the approved spacing.</li><li>Border radius differs between screens.</li><li>Typography becomes inconsistent across components.</li><li>Dark-mode values are duplicated throughout the application.</li><li>A future design-system update requires developers to search through dozens of CSS files.</li></ul><p>The real challenge, therefore, is not just converting <strong>Figma into code</strong>.</p><p>The challenge is preserving the <strong>design system behind the Figma design</strong> while accelerating development.</p><p>This is where <strong>Figma Variables, design tokens, and GitHub Copilot</strong> can work together.</p><p>Figma’s Variables REST API supports querying, creating, updating, and deleting variables and is specifically designed to support scenarios such as integrating Figma with CI systems and synchronizing a design system between Figma and code.</p><p>Instead of asking GitHub Copilot to guess every color, margin, font size, and border radius from a screenshot, we can provide the application’s design tokens as structured context and use Copilot to implement components against those definitions.</p><h3>1. Start with the Design System, Not the Screenshot</h3><p>Consider a simple Figma landing page containing:</p><ul><li>Header</li><li>Navigation</li><li>Hero section</li><li>Primary and secondary buttons</li><li>Cards</li><li>Form elements</li><li>Footer</li></ul><p>A common implementation approach is to inspect each Figma element and manually reproduce it:</p><p>CSS</p><p>.hero-button {</p><p>background: #005ea8;</p><p>color: #ffffff;</p><p>border-radius: 8px;</p><p>padding: 12px 24px;</p><p>}</p><p>The page may initially look correct.</p><p>However, these values have now become implementation details hidden inside individual components.</p><p>A better approach is:</p><p>CSS</p><p>.hero-button {</p><p>background: var( — color-action-primary);</p><p>color: var( — color-text-on-primary);</p><p>border-radius: var( — radius-medium);</p><p>padding: var( — spacing-3) var( — spacing-6);</p><p>}</p><p>Now the component expresses <strong>design intent</strong> rather than just visual values.</p><p>That is the role of design tokens.</p><h3>2. What Are Design Tokens?</h3><p>A design token is a named representation of a visual design decision.</p><p>Instead of #005EA8 we might define color.action.primary.</p><p>Typical token categories include:</p><p>Colors</p><p>Typography</p><p>Spacing</p><p>Border radius</p><p>Shadows</p><p>Breakpoints</p><p>Motion</p><p>Component states</p><p>The important distinction is that developers work with the <strong>meaning of a value</strong>, rather than repeatedly copying its raw representation.</p><p>For example:</p><p>JSON</p><p>{</p><p>“color”: {</p><p>“brand”: {</p><p>“primary”: “#005EA8”,</p><p>“secondary”: “#003B70”</p><p>}</p><p>},</p><p>“spacing”: {</p><p>“small”: “8px”,</p><p>“medium”: “16px”,</p><p>“large”: “24px”</p><p>},</p><p>“radius”: {</p><p>“small”: “4px”,</p><p>“medium”: “8px”</p><p>}</p><p>}</p><p>The real token structure should, of course, reflect your organization’s design system rather than an arbitrary example.</p><h3>3. Define Variables Correctly in Figma</h3><p>Before asking Copilot to build anything, create a clean token structure in Figma.</p><p>For example:</p><p>Primitive Tokens<br>│<br>├── Color<br>│ ├── Blue/100<br>│ ├── Blue/500<br>│ ├── Blue/700<br>│ ├── Grey/100<br>│ └── Grey/900<br>│<br>├── Spacing<br>│ ├── 4<br>│ ├── 8<br>│ ├── 12<br>│ ├── 16<br>│ └── 24<br>│<br>└── Radius<br> ├── Small<br> ├── Medium<br> └── Large</p><p>We can then create semantic variables:</p><p>Semantic Tokens<br>│<br>├── Background<br>│ ├── Primary<br>│ └── Secondary<br>│<br>├── Text<br>│ ├── Primary<br>│ ├── Secondary<br>│ └── Disabled<br>│<br>├── Action<br>│ ├── Primary<br>│ └── Primary-Hover<br>│<br>└── Border<br> ├── Default<br> └── Focus</p><p>This separation is important.</p><p>The UI should preferably consume color.action.primary rather than blue.500</p><p>That makes future redesigns much easier.</p><h3>4. Export the Variables from Figma</h3><p>Once those variables exist, the next step is bringing them into the development workflow.</p><p>Figma provides a Variables REST API specifically for interacting with variables programmatically, including design-system synchronization and CI integrations.</p><p>A Figma-maintained example repository demonstrates workflows for both:</p><ul><li>synchronizing Figma variables into codebase tokens; and</li><li>synchronizing codebase tokens back into Figma.</li></ul><p>A simplified exported representation could look like:</p><p>{<br> “colors”: {<br> “background”: {<br> “primary”: “#FFFFFF”,<br> “secondary”: “#F5F7FA”<br> },<br> “text”: {<br> “primary”: “#1A1A1A”,<br> “secondary”: “#5F6368”<br> },<br> “action”: {<br> “primary”: “#005EA8”,<br> “hover”: “#004578”<br> }<br> },<br> “spacing”: {<br> “xs”: “4px”,<br> “sm”: “8px”,<br> “md”: “16px”,<br> “lg”: “24px”,<br> “xl”: “32px”<br> },<br> “radius”: {<br> “sm”: “4px”,<br> “md”: “8px”,<br> “lg”: “16px”<br> }<br>}</p><p>Treat this JSON as part of the design-system contract rather than as a temporary file.</p><h3>5. Add Tokens to the Application Repository</h3><p>A clean project structure might look like:</p><p>src/<br>│<br>├── components/<br>│ ├── Button/<br>│ ├── Card/<br>│ ├── Header/<br>│ └── Input/<br>│<br>├── pages/<br>│<br>├── styles/<br>│ ├── globals.css<br>│ └── tokens.css<br>│<br>├── design-system/<br>│ └── tokens.json<br>│<br>└── app/</p><p>The important part is: design-system/tokens.json</p><p>Now the design source and implementation source have a structured bridge.</p><h3>6. Convert Tokens into Application-Friendly Styles</h3><p>Depending on the frontend architecture, tokens can be mapped into:</p><ul><li>CSS custom properties</li><li>Tailwind configuration</li><li>JavaScript/TypeScript constants</li><li>CSS-in-JS themes</li><li>component-library themes</li></ul><p>For a CSS-variable approach:</p><p>:root {</p><p>— color-bg-primary: #ffffff;</p><p>— color-bg-secondary: #f5f7fa;</p><p>— color-text-primary: #1a1a1a;</p><p>— color-text-secondary: #5f6368;</p><p>— color-action-primary: #005ea8;</p><p>— color-action-hover: #004578;</p><p>— spacing-xs: 4px;</p><p>— spacing-sm: 8px;</p><p>— spacing-md: 16px;</p><p>— spacing-lg: 24px;</p><p>— spacing-xl: 32px;</p><p>— radius-sm: 4px;</p><p>— radius-md: 8px;</p><p>— radius-lg: 16px;</p><p>}</p><p>A button can then become:</p><p>.button-primary {<br> background-color: var( — color-action-primary);<br> color: var( — color-bg-primary);<br> padding: var( — spacing-sm) var( — spacing-md);<br> border-radius: var( — radius-md);<br>}</p><p>If the design-system values change, components using those variables generally do not need their individual styles rewritten.</p><h3>8. Now Bring GitHub Copilot into the Workflow</h3><p>This is the point where GitHub Copilot becomes especially useful.</p><p>Instead of asking: <em>Create this Figma page. W</em>e can provide Copilot with much better implementation context.</p><p>For example:</p><p>Implement the landing page represented by the provided Figma design.</p><p>Before generating code:</p><p>1. Review src/design-system/tokens.json.</p><p>2. Review the existing components under src/components.</p><p>3. Reuse existing components wherever possible.</p><p>4. Use design-system tokens for colors, spacing,</p><p>typography and border radius.</p><p>5. Do not hardcode values when an equivalent token exists.</p><p>6. Follow the application’s existing React and</p><p>TypeScript conventions.</p><p>7. Use responsive layouts.</p><p>8. Preserve accessibility semantics.</p><p>This difference matters. We are no longer asking AI to merely <strong>reproduce an image</strong>. We are asking it to <strong>implement a design using our engineering system</strong>.</p><h3>10. Generate Components, Not One Giant Page</h3><p>Avoid prompting Copilot to place the entire design into a single component.</p><p>A useful Copilot prompt is:</p><p>Implement the Hero section from the design.</p><p>Requirements:</p><p>- React + TypeScript.</p><p>- Reuse the existing Button component.</p><p>- Use tokens from our design system.</p><p>- Do not introduce hardcoded colors or spacing if a corresponding token exists.</p><p>- Preserve the responsive behavior represented by the design.</p><p>Follow existing project conventions.</p><p>Then move section by section through the design.</p><h3>11. Let Copilot Reuse Existing Components</h3><p>This step is critical for enterprise applications.</p><p>Imagine the repository already contains:</p><p>Button</p><p>Input</p><p>Select</p><p>Modal</p><p>Card</p><p>Typography</p><p>Checkbox</p><p>DatePicker</p><p>We do not want an AI-generated page to reinvent all of them.</p><p>Tell Copilot explicitly:</p><p>Before creating a new UI component, search the existing component library.</p><p>If an appropriate component already exists, reuse it.</p><p>Do not recreate Button, Input, Card or Typography components</p><p>unless the existing API cannot satisfy the design.</p><h3>12. Generate the Page Using the Components</h3><p>Once individual parts are ready, assemble them.</p><p>At this point, Copilot has helped with the repetitive implementation work, while the design system continues to control the visual vocabulary.</p><p>An internal engineering example similarly describes GitHub Copilot being used to propose HTML, CSS, and React structure during Figma-to-code work, allowing engineers to refine generated drafts around reuse and consistency.</p><h3>13. Don’t Stop at Code Generation: Validate Against Figma</h3><p>AI-generated code should never automatically be considered finished.</p><p>Run the application and compare it with the Figma reference.</p><p>Validate the Layout, Typography, Colors, Components, Responsive behavior.</p><p>Then feed specific discrepancies back into Copilot rather than simply saying: <em>Make it look more like Figma.</em></p><p>Compare this implementation against these design requirements:</p><p>Hero container max width: use the corresponding layout token</p><p>Card gap: use the matching spacing token</p><p>CTA: use the existing Button primary variant</p><p>Update the implementation without introducing hardcoded design values.</p><p>This keeps corrections systematic.</p><h3>14. Add Automated Checks</h3><p>The workflow becomes much stronger when implementation validation is also included.</p><p>Ask Copilot to help generate tests for:</p><p>Component rendering</p><p>Navigation</p><p>Button interactions</p><p>Forms</p><p>Validation</p><p>Responsive behavior</p><p>Accessibility</p><p>Component rendering</p><p>Navigation</p><p>Button interactions</p><p>Forms</p><p>Validation</p><p>Responsive behavior</p><p>Accessibility</p><h3>15. The End-to-End Development Workflow</h3><p>Putting everything together:</p><p>STEP 1 — Create the UI in Figma</p><p>STEP 2 — Define reusable Figma Variables</p><p>STEP 3 — Separate primitive and semantic tokens</p><p>STEP 4 — Export/sync variables</p><p>STEP 5 — Store token definitions in the repository</p><p>STEP 6 — Transform tokens into CSS/Tailwind/theme configuration</p><p>STEP 7 — Give GitHub Copilot the design-system and repository context</p><p>STEP 8 — Ask Copilot to analyze the design</p><p>STEP 9 — Identify reusable application components</p><p>STEP 10 — Generate components incrementally</p><p>STEP 11 — Assemble the page</p><p>STEP 12 — Run the application</p><p>STEP 13 — Compare implementation with Figma</p><p>STEP 14 — Correct discrepancies using tokens</p><p>STEP 15 — Generate/refine tests</p><p>STEP 16 — Perform human review</p><p>STEP 17 — Merge through the normal CI/CD process</p><h3>Conclusion</h3><p>The interesting opportunity in Figma-to-code is not simply asking an AI tool to generate HTML from a picture.</p><p>The more scalable approach is to establish a <strong>structured contract between design and engineering</strong>.</p><p>Figma manages the design language through reusable variables.<br> Design tokens make those decisions machine-readable.<br> The application design system turns the tokens into implementation primitives.<br> GitHub Copilot accelerates the work of converting those primitives and design requirements into reusable components.</p><p>With that architecture, the workflow moves from:<strong><em>“Look at this design and try to reproduce it.”</em></strong></p><p>toward:</p><p><strong><em>“Here is the design, here is our design system, here are our existing components and engineering conventions. Implement the page within those constraints.”</em></strong></p><p>That is a much more powerful use of AI-assisted development.</p><p>The goal is not <strong>Figma → generated code</strong>.</p><p>The goal is:</p><p><strong>Figma → structured design system → AI-assisted implementation → validated production UI.</strong></p><p>And that is where design tokens and GitHub Copilot can create a meaningful bridge between design and engineering.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9eb5e139233f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>