Figma Sites vs. Figma Make

In our company, one recurring challenge has been finding front-end developers willing to take on short-lived marketing landing pages. These pages are important, but they're also fast-turnaround, low-impact tasks that often pull developers away from higher-value work. We wanted a tool that would let our design and marketing teams ship these pages independently, without waiting on engineering bandwidth.

After a bit of R&D — and conversations with our design team — the obvious direction was to stay inside Figma, since all our flows, layouts, and prototypes already start there. That led us to evaluate two emerging options built directly into the Figma ecosystem:

• Figma Make
• Figma Sites

Below is how we see them for simple, fast, marketing-focused landing pages.

Figma Make is an AI-powered "prompt-to-app / code generation" tool inside Figma. The idea is that instead of manually building HTML/CSS or wiring interactions, you can describe what you need — layout, behavior, data connections — and Make will generate a working prototype or application.

Key characteristics of Figma Make:

• You work inside Figma, but Make can generate actual code (or at least a code- scaffold) for a web app or UI.
• It supports backend integration: for instance, you can connect a project to Supabase (or other tools via connector protocols) to simulate data, secrets, or API calls — useful if your landing page needs dynamic behavior, forms, or data-driven content.
• It's more than a static design tool — it's meant for interactive prototypes or small apps. You get layout, behavior, and data integration in one.

In short: Figma Make is like asking Figma to build an app for you — from high-level prompt to a working UI (with optional backend hook-up).

Figma Sites is Figma's new built-in website builder — a way to design, build, and publish websites directly within Figma, without needing to write code manually.

Important aspects of Figma Sites:

• You can paste your existing Figma design frames (layout, typography, components) into Sites and get them turned into responsive web pages using auto-layout, breakpoints, and Figma's layout tools.
• Sites supports interactive effects (hover states, simple animations, scroll effects, etc.), so you can add some behavior without code.
• It includes a built-in CMS: you can define "collections" (structured content like blog posts, product listings, case studies), then link collection data to design elements — establishing lists and template pages. Great for landing pages, catalogs, blogs, or content that changes over time.
• Publishing is integrated: you can publish your site directly from Figma (on a figma.site subdomain, or a custom domain depending on plan & beta features) — cutting out the traditional "export → deploy" workflow.

In short: Figma Sites is for designers who want to go from design → live site with minimal friction, ideal for marketing pages, simple sites, blogs or static-ish content.

Warning

Both Figma Sites and Figma Make rely heavily on AI to interpret designs, so using Auto Layout, consistent layer naming, and clean structure dramatically improves the output quality for both tools.

Here's a side-by-side view of how they differ — and when one might suit you better than the other.

• You need a quick landing page, marketing page or small site that will be live for a short time.
• You want non-technical team members (marketing/designer) to be able to edit content, update copy or images without developer help (CMS + visual layout tools).
• You prefer minimal handoffs: design → publish in one flow inside Figma.
• You don't need complex interactions, backend logic or dynamic data beyond simple content.

• You need a prototype or a small app — something with logic, data, forms, or dynamic behavior.
• You expect the page might need backend integration (database, API, auth, data storage) rather than only static content.
• You're comfortable exporting code and self-hosting (or integrating with backend hosting).
• You want to build something more "web-app-like" than a simple static site.

• The CMS in Figma Sites is internal only — you cannot (currently) connect external CMS or headless-CMS platforms (e.g. Strapi, Supabase as CMS, or similar) directly via Sites. That limits flexibility if you prefer a headless or external content backend.
• If you need truly custom backend behavior (database, auth, dynamic data) Sites alone won't suffice — you'll need a solution like Figma Make + exported code + hosting.
• Because both tools are still relatively new (beta for Sites, evolving for Make), you may run into limitations depending on your domain, hosting needs, or content complexity.
• For a fully self-hosted, maintainable site with long-term control (e.g. custom domain + version control + backend), you may still need a developer handoff — especially if using Make → code export.

When evaluating landing pages, it's important to consider web accessibility (WCAG 2.1). Here's how the two tools compare:

Summary:

• Figma Sites works for quick, “accessible-ish” landing pages but may require developer review for full compliance.
• Figma Make offers full flexibility to integrate accessibility during code export, giving complete control over standards compliance.

After evaluating both options, Figma Make is the better fit for our real workflow. We already have a mature CMS and a deployment setup that lets us publish landing pages on our own domains — not on a hosted figma.site environment. That alone rules out Figma Sites as a long-term solution, since its publishing flow funnels you into Figma's hosting and its CMS is fully internal with no external integrations. For live, public-facing pages that must connect to our stack and run on the domains we choose, Make gives us far more control.

Figma Make lets us generate layouts, page structures, and even frontend scaffolding directly from prompts or designs, then integrate it into our existing codebase and CMS just like any other project. This means we keep ownership of the code, self-host on our infrastructure, and avoid introducing another publishing surface.

That said, Figma Sites still has a role for us: it's excellent for quickly turning a design into a realistic, interactive prototype. For usability tests, user interviews, internal reviews, or validating layout and content before development starts, Sites is fast and frictionless. As a prototyping layer, it fits neatly into our design process.

But for anything that needs to go live under our brand domain, integrate with our CMS, or remain maintainable inside our own codebase, Figma Make is the clear choice.

I'll talk more about Figma Make in Generating Landing Pages in Figma Make post.