WordPress 8 min read

Hire a WordPress developer: what to check before you sign

How to hire a WordPress developer with confidence: match skills to the job, review real code, run a paid trial task, agree ownership and access, and fix the problems that derail new hires.

Crest Design
Cover for a guide on how to hire a WordPress developer by checking code, running a trial and agreeing ownership.

If you need to hire a WordPress developer for a new site, a WooCommerce store or a rescue job on an existing build, this guide is for you. It explains what separates careful WordPress work from work that only looks finished, and gives you a practical way to check a developer's skills, run a fair trial and sign an agreement that protects your site.

Why hiring for WordPress goes wrong so often

The usual story goes like this. You find a developer with a strong portfolio, agree a price, and the site launches on time. A few months later a plugin update breaks the checkout, the site is slow on phones, and nobody can explain how the custom features were built. The next developer quotes for a rebuild.

The problem isn't that WordPress is hard to hire for. It's that WordPress is easy to assemble. A page builder, a premium theme and a stack of plugins can produce a polished front end without much engineering underneath. A portfolio shows you that front end. It doesn't show you the code, the plugin choices, or how the developer works when something breaks.

So the job of a buyer is to look past the screenshots and check three things: the right specialty, the quality of the code, and the way the person works with you.

How WordPress development actually works

"WordPress developer" covers several different jobs. Knowing which one you need is the fastest way to narrow a shortlist.

  • Theme and block development. Building block themes, custom blocks and patterns so your team can edit pages in the Site Editor without breaking the design. Since WordPress 7.1 added responsive controls and hover and focus styling in the editor, a good theme developer can hand over far more control to editors safely.
  • Plugin development. Custom features: booking logic, member areas, integrations with a CRM or ERP. This is PHP and JavaScript engineering, and it's where security mistakes live.
  • WooCommerce. Products, checkout, payment gateways, shipping and the hooks that change them. Store work needs someone who has dealt with order data and payment testing before.
  • Performance and hosting. Caching, image handling, database clean-up and Core Web Vitals. This overlaps with server work and often needs access to hosting, not just the WordPress admin.

Most real projects need two or three of these. A small agency can usually cover them as a team; a single freelancer may be strong in one and adequate in the rest. Neither is wrong, but you should know which you're getting.

Underneath every specialty sits the same foundation. WordPress gives developers hooks (actions and filters) to change behavior without editing core files, and a set of functions for checking who the user is, confirming a request is genuine, cleaning input and escaping output. Developers who use these consistently produce sites that survive updates. Developers who skip them produce sites that work until they don't.

How to hire a WordPress developer, step by step

A six-step process for hiring a WordPress developer: write the brief, shortlist, review real code, run a paid trial task, agree the contract and access, then plan the handover.
The hiring path we recommend, from brief to handover.

1. Write a short, specific brief

List the pages and templates, the features, the plugins you already rely on, the integrations, who will edit the site and where it's hosted. Our guide to writing a website brief for an agency has a template you can copy. A clear brief also makes quotes comparable.

2. Shortlist on fit, not volume

Ask each candidate which of the specialties above they'd own, and which they'd bring someone in for. Ask them to name the plugins they'd use for your forms, SEO and caching, and why. Vague answers ("whatever works") are a signal.

3. Review real code

Ask for a link to a repository, a plugin they've published, or a sanitized sample from a past project. You don't need to read PHP fluently to spot the patterns below. If they can't share any code at all, ask them to talk you through a feature they built and how they tested it.

Four things to look for when reviewing a WordPress developer's code: permission checks, nonces, sanitized input and escaped output, plus version control and coding standards.
What we look for first when reviewing a candidate's WordPress code.

Here's a small form handler of the kind we'd expect in a custom plugin. It checks the user's permission, verifies the nonce, cleans the input before saving and escapes it on output. If a candidate's code never contains functions like these, ask why.

// In a custom plugin file. Change 'acme' to your plugin prefix.
add_action( 'admin_post_acme_save_note', function () {
    if ( ! current_user_can( 'manage_options' ) ) {
        wp_die( esc_html__( 'You are not allowed to do this.', 'acme' ), 403 );
    }
    check_admin_referer( 'acme_save_note' );

    $note = isset( $_POST['note'] )
        ? sanitize_textarea_field( wp_unslash( $_POST['note'] ) )
        : '';
    update_option( 'acme_note', $note );

    wp_safe_redirect( admin_url( 'options-general.php?page=acme-note&saved=1' ) );
    exit;
} );

// Wherever the note is displayed: escape at the point of output.
echo esc_html( get_option( 'acme_note', '' ) );

The form that posts to it would include wp_nonce_field( 'acme_save_note' ) and a hidden action field set to acme_save_note. You can also ask a developer to run the WordPress Coding Standards against their own work. With Composer, that's:

composer config allow-plugins.dealerdirect/phpcodesniffer-composer-installer true
composer require --dev wp-coding-standards/wpcs:"^3.0"
vendor/bin/phpcs --standard=WordPress wp-content/plugins/your-plugin

A handful of warnings is normal. A developer who has never heard of the tool, or a wall of security errors, tells you more.

4. Run a small paid trial

Pick a real task from your backlog: a new block, a template change, a plugin conflict. Give access to a staging copy, never production, and pay for the time. You're watching how they ask questions, how they report progress, whether the work arrives in Git with a clear note, and whether it still works after you update plugins.

5. Agree the contract and access

Put scope, change requests, payment milestones and code ownership in writing. Give the developer their own named WordPress, hosting and Git accounts rather than sharing yours, so access can be removed cleanly later. Our post on what you should own when you hire an agency lists the accounts to keep in your name. Have a qualified adviser review any contract terms you're unsure about.

6. Plan the handover before day one

Agree now what you'll receive at the end: the repository, a list of plugins and licenses in your name, admin notes for editors, and who handles updates afterwards.

What we've learned from rescuing WordPress builds

When we take over a WordPress site that someone else built, the same patterns tend to come up.

  • Too many plugins doing small jobs. Each one is another update and another possible conflict. We'd rather see a few well-maintained plugins and a little custom code than dozens of single-purpose add-ons.
  • Edits to a parent theme or plugin files. These vanish on the next update. Changes belong in a child theme, a custom plugin or hooks.
  • No staging site. Without one, every change is tested on customers.
  • Old PHP. Sites left on unsupported PHP versions miss security fixes. Ask what PHP version the developer targets; our note on which PHP version WordPress should run explains the current position.

Our recommendation: for a brochure site with light editing needs, a solid freelancer who builds with blocks is often enough. For WooCommerce, custom integrations or a site the business depends on daily, we'd lean toward a small team, because you need cover for holidays, emergencies and the skills one person rarely has all of. The trade-off is cost and a little more process.

Troubleshooting a new developer relationship

Symptom Likely cause Fix
The site breaks after every plugin update Custom changes were made inside theme or plugin files Move changes into a child theme or custom plugin, and test updates on staging first
Pages look right on desktop but slow and jumpy on phones Heavy page builder output, unoptimized images, no caching Ask for a performance pass; see our guide to fixing a slow WordPress site
Nobody can explain how a feature works No version control or documentation Make a Git repository and a short README part of every milestone
You can't remove a former developer's access Shared admin and hosting logins Create named accounts, rotate passwords and turn on two-factor sign-in
Quotes vary wildly for the same job The brief is too loose, so each developer guessed a different scope Tighten the brief and ask everyone to quote the same feature list

Questions people ask

Should I hire a freelancer or an agency for WordPress?

It depends on what the site does for the business. A freelancer suits a focused, well-defined build. An agency suits sites with several specialties, ongoing changes or a need for cover when someone is away.

Do I need a developer if I use a page builder?

For small content changes, often not. You'll want one for custom features, integrations, performance work and anything that touches checkout or user data.

How do I check a developer's work if I'm not technical?

Use the trial task and ask a second developer to review it. Look for Git history, a staging site and clear written notes. How they explain their choices to you matters as much as the code.

Why it matters for your business

Your WordPress site is where leads arrive and orders are placed. Hiring the right developer decides whether it stays fast, secure and easy to edit for years, or needs rebuilding the next time something changes. Checking code, running a trial and agreeing ownership up front costs a little time and helps you avoid the most common and painful outcomes.

A quick checklist before you sign:

  • Brief written and shared with every candidate
  • Specialty matched to the job
  • Real code reviewed, with permission checks, nonces and escaping in place
  • Paid trial completed on staging
  • Ownership, named accounts and handover agreed in writing

If you'd like a team that works this way, our WordPress development service covers builds, rescues and ongoing care, and you can tell us about your project whenever you're ready.

(over to you)

Planning a build like this?

Tell us what you're building and we'll come back with ideas and next steps.