Skip to content
Tutorials Center
My learning

Topics

Lesson 35 of 36 ยท Projects and Practice

Project: Responsive Landing Page

Design a responsive landing page in Figma for desktop, tablet and mobile using grids, auto layout, variable modes for breakpoints and a clean handoff.

Landing pages must look good on a phone, a tablet and a wide monitor. In this project you design one for a fictional product, "Pocket Pantry", an app that suggests recipes from ingredients you already have. You will create the page once and adapt it to three breakpoints using layout grids, auto layout and variable modes.

Figma cannot run on this site, so you do the design in Figma. The code blocks are labelled JavaScript stand-ins for the arithmetic of grids and breakpoints. Menu names can vary by Figma version.

The brief

  • Goal: get visitors to join a waitlist.
  • Sections: header with logo and call-to-action button, hero (headline, subtitle, email form, product image), three feature cards, a "how it works" step list, a testimonial, and a footer.
  • Breakpoints: Mobile 390, Tablet 768, Desktop 1440.
  • Assets: original shapes and icons only; no copyrighted photos.

Step 1: grids and breakpoints

Create three frames, one per breakpoint, and add a layout grid to each (the + next to Layout grid in the Design tab):

Breakpoint Frame width Columns Gutter Margin
Mobile 390 4 16 16
Tablet 768 8 24 32
Desktop 1440 12 24 120 (or a max-width container)

Compute the width of a single column from the numbers: (width - 2 * margin - (columns - 1) * gutter) / columns.

JS Stand-in: column width calculator

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Real designs often cap content at a maximum width (for example 1200 px) and center it, so very wide screens do not stretch text lines. In Figma, create a content frame with a fixed max width in a full-width parent, aligned center.

Step 2: foundations as variables

Create a collection Layout with modes Mobile, Tablet, Desktop:

Variable Mobile Tablet Desktop
font/display 36 48 64
font/body 16 17 18
space/section 48 72 112
columns/features 1 2 3

Bind text sizes and section padding to these variables (number variables can be bound to font size, padding and gap). Now switching a frame's mode changes the scale in one click. Put your color variables, tokens and styles in separate collections, so breakpoints do not clutter them.

Step 3: build with auto layout

Use one vertical auto layout frame per breakpoint as the page, and one auto layout frame per section. Key patterns:

  • Header: horizontal; logo left, nav center, button right (Fill container spacer between). On mobile, replace nav with a menu icon (swap via a variant Device = Mobile | Desktop).
  • Hero: horizontal wrap or two columns on desktop; vertical stack on mobile (text above image). Use a component variant or change the frame direction per breakpoint.
  • Feature cards: a horizontal frame with wrap enabled; each card Fill container with a minimum width, so cards flow from three across to one.
  • Steps: numbered list with a repeating card component using a text property for the step title.
  • Footer: links in columns that stack on mobile.

Set images to Fill with a fixed aspect ratio, and clip them with a radius from radius/md.

Make a CTA form component: an input and a button, horizontal on desktop, vertical on mobile (variants). Give the input a visible label or placeholder, and an error state.

Step 4: pick breakpoints from content, not devices

Devices change. A better approach is to choose the width where the layout starts to look bad. The stand-in picks a feature-card column count from available width, mirroring a "wrap" layout.

JS Stand-in: how many cards fit per row?

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Step 5: type and readability

Limit body line length to about 45 to 75 characters. At 18 px, that is roughly 600 to 720 px wide. The stand-in estimates the characters per line for a width; it uses an average character width of 0.5 em, a rough approximation.

JS Stand-in: characters per line estimate

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Step 6: prototype and states

Add small interactions: header menu opens as an overlay on mobile, nav links Scroll to sections, the form button shows Default, Hover, Loading and Success variants (use After delay to simulate submission), and the sticky header uses Fix position when scrolling. Do not wire what you will not test.

Step 7: handoff

  1. Name layers semantically (hero, feature-card, cta-form).
  2. Mark frames Ready for dev and add annotations for behavior ("Cards wrap below 640 px").
  3. Export the logo and illustrations as SVG, hero image as WEBP/PNG at 1x and 2x.
  4. Write handoff notes: breakpoints, max width, image ratios, heading levels (one H1), focus states and alt text for images.
  5. Check Dev Mode shows variable names for the spacing and type.

Quality checklist

  • All text meets 4.5:1 contrast on its background, including text over the hero image.
  • Tap targets at least 44 pt on mobile; links not tiny.
  • The heading hierarchy makes sense (H1 once, H2 for sections).
  • Empty and error states exist for the form.
  • Long text and translated text do not break the layout (test a very long headline).

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. How do you compute one column's width in a grid?

    Subtract the margins and all gutters, then divide by the number of columns.
  2. 2. What lets one variable set change font sizes for Mobile, Tablet and Desktop?

    A collection with a mode per breakpoint stores different values for each.
  3. 3. Why cap the content width on desktop?

    Very long lines are hard to read, so content gets a maximum width.
  4. 4. Which auto layout feature makes cards flow onto new rows?

    Wrapping auto layout moves items onto new rows when space runs out.

Summary

  • Use grids per breakpoint and compute columns from width, margin and gutter.
  • Store breakpoint-dependent sizes in a variable collection with modes.
  • Build sections with auto layout, wrapping rows and variant components.
  • Design for content, readable line length and accessibility.
  • Prepare handoff with names, annotations and exports.

Next: Project: Design System Audit