How I turn a Figma design into a pixel-perfect WordPress theme

The process I follow to build a Figma design as a WordPress website: reading the file, deciding what the client edits, choosing a custom theme or page builder, and matching the design on every screen.

Most of the WordPress sites I build start as a Figma file. A designer has spent weeks on it, the client has signed it off, and now it needs to become a real website that looks the same and that the marketing team can update without calling a developer.

That second part is where many builds go wrong. A site can match the design perfectly on launch day and still be painful to edit a month later. Here’s the process I use to get both right, based on projects like FirmPilot, WorldFirst and TEG.

Read the whole design before writing any code

I go through every page in the Figma file before I estimate anything. I’m looking for three things:

  • Repeated patterns. If the same card or banner shows up on six pages, it becomes one reusable component instead of six separate layouts.
  • Missing states. Designs usually show the happy path. What does the form look like with an error? What happens when a post has no featured image, or a title runs to three lines?
  • Mobile frames. If a section has no mobile design, I work out how it should stack and check with the designer before building it.

I send these questions in one list at the start. It saves days of back-and-forth later, and designers tend to appreciate that someone read their file properly.

Decide what the client will edit

This is the most important step and the one most often skipped. Before I set up the theme, I agree with the client which parts of each page they’ll change themselves, and how often.

A headline they update every week needs to be a simple text field. A section that never changes can be part of the template. A layout the marketing team wants to rearrange for every campaign works better as a set of Gutenberg blocks or Elementor templates.

Getting this wrong in either direction causes problems. Lock everything down and the client needs a developer for every typo. Make everything editable and sooner or later someone breaks the layout by accident.

Choose between a custom theme and a page builder

There’s no single right answer, so I decide project by project.

For FirmPilot, an AI marketing platform for law firms, I built a custom theme from scratch. The design relied on GSAP animations across several pages, and a custom theme kept the front end light and gave me full control over how those animations loaded.

For WorldFirst and TEG, I built the pages in Elementor from the Figma files. Elementor works well when a team wants to add and edit pages on its own, and templates built from the Figma components keep new pages consistent with the design.

My rule of thumb: if the team will create new pages often, use a page builder with well-built templates. If the site has a distinctive design, heavy traffic or complex interactions, write a custom theme.

Set up the design system first

Before building any page, I take the styles out of Figma and turn them into a small design system in code: colours, font sizes, spacing, buttons, form fields and the grid.

In a custom theme these become CSS variables and a handful of shared classes. In Elementor they go into the global colours and fonts, so a change in one place updates every page.

This step feels slow, but it’s the reason the finished site stays consistent. When every page uses the same spacing and the same button styles, the site still looks like the design in places the designer never drew.

Build components, then pages

With the system in place, I build each repeated pattern as a component: the hero, card grids, testimonials, call-to-action bands and so on. In a custom theme that usually means ACF field groups or custom Gutenberg blocks. In Elementor it means saved templates and global widgets.

Pages then become a matter of putting components together. By the fifth or sixth page most of the work is already done, and new pages after launch are just as quick for the client.

Match the design at every screen size

“Pixel-perfect” gets used loosely, so here’s what I actually check. I compare each page against Figma at the designer’s desktop and mobile widths, lining up spacing, font sizes and alignment. Then I check the sizes in between, like a 13-inch laptop or a tablet held upright, because that’s where layouts usually break.

I also test with real content. Long names, long headlines and images with awkward proportions all turn up eventually, and I’d rather find those problems before the client does.

Keep it fast

A site can match the design and still feel slow. Before launch I resize and compress images, using WebP where possible, load fonts carefully, defer scripts that aren’t needed straight away and check the result against Core Web Vitals. Animations are a common cause of slow pages, so I make sure they only load where they’re used.

Hand over a site the team can use

The last step is a walkthrough showing the client how to edit each type of page. I also leave notes on anything unusual in the build, so the next developer, whether that’s me or someone else, doesn’t have to guess.

A quick checklist

  • Every page and mobile frame reviewed before estimating
  • Questions about missing states sent in one list
  • Editable areas agreed with the client
  • Custom theme or page builder chosen for a reason
  • Colours, type and spacing set up as a design system
  • Repeated sections built as reusable components
  • Pages checked against Figma at desktop, mobile and the sizes in between
  • Images, fonts and scripts optimised before launch
  • A walkthrough and build notes handed over

If you have a Figma design ready and need it built in WordPress, take a look at my Figma to WordPress service, or read the FirmPilot case study to see this process on a real project.

Related serviceFigma to WordPress Case studyFirmPilot

Need a developer for a project like this?