Why a Drupal SEO audit checklist starts with the site you already run
A Drupal SEO audit checklist starts with the site as it is served today, not with the site the team remembers building. If search visibility has become unclear or has slipped, the first step is a repeatable review of what Drupal actually outputs: rendered HTML, HTTP responses and sitemap files. Only after those are recorded should anyone change metadata, aliases, redirects or templates. The audit inspects those artifacts directly, so findings do not depend on whether an editor believes a title tag or canonical URL is correct. A page can look right in the editor and still send a different title, a duplicate path or a 404 to a crawler.
Start by capturing a baseline that the team can rerun. For a sample of each content type, record the response status, the canonical link, the robots meta tag, the title and description, the Open Graph tags, the JSON-LD blocks and the URL alias. Pull the XML sitemap and compare it with the published nodes and aliases. Then list the redirect entries, the paths that return 404, and the paths that answer on more than one URL, such as with and without a trailing slash or on both an HTTP and HTTPS host. Confirm which of these checks your team can run with its current tooling and which need a crawler or a script, because that decides who does the work and how long it takes.
The site is also code and configuration that your organization owns. Drupal core and contributed modules are licensed under GPL-2.0-or-later, and there is no paid edition of Drupal itself, so the audit does not depend on a vendor license that could be withdrawn. The fixes will live in your modules, themes, configuration exports and hosting setup. DeployOpen can prepare the findings, the prioritized fix list and the implementation work under a written scope. It does not issue audit reports, certifications or search engine approvals, so ask upfront what evidence you need to keep and who will review it.
Which checks belong in a Drupal SEO audit
A Drupal SEO audit works best when each area produces its own evidence, so findings can be traced to a template, a setting or a content rule. The six areas below cover what search engines see, how URLs multiply, where traffic lands after a redirect, what the sitemap advertises, what structured data claims, and how the page performs and reads for assistive technology.
Metadata defaults and overrides
Review the site-wide default titles and descriptions, then sample rendered HTML from each content type, taxonomy term and view to confirm which values actually reach the page. Look for empty descriptions, identical titles across templates, and token patterns that output blank strings when a field is missing. Ask the content team which entities have manual overrides, because those often drift from the defaults. The evidence is an HTML sample per template plus a crawl export listing titles and descriptions. Editors and the site builder should supply the sample URLs.
Duplicate and parameterized URLs
Crawl the site with query strings, trailing slashes, uppercase paths and pager parameters enabled, then group responses that return the same content. Confirm each duplicate points to one canonical URL and that faceted or sorted views are either blocked, canonicalized or noindexed by an explicit rule. A common failure is a view that exposes dozens of filter combinations with no canonical tag. The evidence is a crawl export grouped by content hash, supplied by the platform engineer who controls the web server and the view configuration.
Aliases and redirect coverage
Compare the URL alias table with the live paths in the crawl, then check that every alias change since launch left a redirect behind. Pathauto patterns that changed on a live site can silently orphan old paths, so test a sample of retired URLs for a single 301 to the current page rather than a chain. Also review 404 logs for paths that real visitors and external links still request. The evidence is a redirect map compared against a log extract of 404 responses, supplied by whoever administers the Redirect module and the web server logs.
Sitemap content and status codes
Fetch the XML sitemap and request every listed URL, then flag entries that return redirects, 404s, 403s or noindex pages. Check that the sitemap excludes unpublished content, filtered views and language variants that are not meant to rank. On large sites, confirm the sitemap is split into indexed files and that the lastmod values reflect real content changes. The evidence is a status-code report for sitemap entries, supplied by the team that configures the sitemap module and has access to the search console property.
Structured data validity
Extract the JSON-LD from a representative set of articles, organizations, events and products, then validate it against the schema types the site claims to use. Verify that required properties are populated from real fields and not from placeholder tokens, and that the markup matches visible page content. Compare the markup after a theme or Metatag change, since template edits often remove properties silently. The evidence is a validation report per template and the raw JSON-LD sample, supplied by the developer who maintains the Schema.org Metatag configuration.
Rendered performance and accessibility
Measure rendered pages on mobile and desktop, recording largest contentful paint, layout shift and total page weight, then review heading order, image alternative text and link names in the rendered DOM. Slow templates often trace to unoptimized images, blocking scripts or cache misses on the template, so record which pages were tested against cached and uncached requests. The evidence is a performance trace and an accessibility scan per template, supplied by the front-end developer and checked by the accessibility lead.
Which Drupal SEO tooling fits which audit depth
A lightweight review examines one content type, such as articles or product pages, using the configuration that governs it. The reviewer reads the Metatag defaults and per-entity overrides, the Pathauto pattern for that bundle, and the Schema.org Metatag output on a sample of nodes. This depth is useful when an editorial team asks why one section underperforms or when a single template changed.
- Metatag configuration: Check whether titles and descriptions fall back to tokens that produce empty or duplicated values for this bundle.
- Pathauto pattern: Confirm the alias pattern is stable, lowercase, and free of stray tokens or repeated segments.
- Schema.org Metatag output: Inspect the rendered JSON-LD on sampled nodes rather than trusting the configuration screen.
- Sample rendering: Compare the HTML head of a few published nodes with the configured values, since overrides often hide defaults.
- Scope limit: This view does not show crawl-wide duplicates, broken internal links, or sitemap coverage.
Before closing the review, confirm that the sample covers both old and recently edited nodes, because configuration changes do not always reach content created earlier.
A full site crawl follows internal links and sitemap entries across every content type, taxonomy page, and listing, and compares what the crawler finds with what Drupal is configured to publish. It reveals duplicate URLs, redirect chains, orphaned pages, and sitemap gaps. The Redirect module, the XML sitemap options (Simple XML sitemap or XML sitemap), and the Pathauto alias table are the usual inspection points.
- Duplicate URLs: Find the same content reachable under several aliases, query strings, or trailing-slash variants.
- Redirect module entries: Look for chains, loops, and redirects that point at pages now returning 404.
- Sitemap comparison: Compare sitemap entries with crawled, indexable URLs to find excluded or missing pages.
- Alias collisions: Identify paths shared by a node and a taxonomy term or view.
- Scope limit: A crawl sees only what is linked or listed, so it can miss unlinked content and says little about how search engines have treated pages over time.
Before relying on crawl output, confirm the crawler respects the same access rules as the public site, so that staging or gated pages are not mixed into the findings.
An audit tied to a pending migration compares the current site with the target Drupal version or platform and maps every URL that must keep its search equity. Drupal 6 and 7 sites are moved into a new site with the core Migrate modules or Drush, and themes are rebuilt, so URLs, metadata, and sitemap logic must be rebuilt or carried across deliberately. The inventory here is driven by the redirect map rather than the crawl alone.
- Redirect map source: Export legacy URLs from analytics, server logs, the Redirect module, and the sitemap to build the full list.
- Metadata carry-over: Confirm that Metatag, Pathauto, and structured data settings are migrated or recreated on the new site.
- Sitemap and hreflang parity: Compare sitemap output and any multilingual alternates before and after the move.
- 404 monitoring: Decide which unmatched URLs to log during launch and how long to watch them.
- Scope limit: The audit cannot prove ranking outcomes; it only shows whether the mapping and parity checks are complete.
Ask the migration partner to show, in writing, which legacy URLs are covered by the redirect map and which are retired on purpose.
How to run the audit in sequence
The sequence moves from understanding what the site contains to checking how search engines and visitors experience it, so each later step can be reconciled against the earlier inventory. The output is a set of reconciled counts and sampled pages that show where the site's intended structure and its actual behavior differ.
Inventory content types and URL patterns
Start by listing every content type, view, taxonomy vocabulary and language version on the site, along with the URL pattern each one uses. Ask the site owner or the Drupal administrator for the content type list and the current URL alias patterns, then confirm them against the live site's configuration, not just the documentation. The step is complete when every indexable route family has a named owner and a documented pattern, and any pattern that is missing or inconsistent is recorded as a finding.
Export a crawl with status codes and canonicals
Run a site crawl that records the HTTP status code, the canonical tag, the robots directives and the final URL for every page reached from the home page and from the sitemap. Crawl with a user agent and settings that match a logged-out visitor, and exclude admin paths deliberately rather than by accident. The step is complete when the crawl export covers each route family from the inventory and you can filter it for 3xx, 4xx and 5xx responses and for pages whose canonical points elsewhere.
Compare sitemap entries against indexable pages
Reconcile the sitemap output with the crawl. Count the URLs in each sitemap file, then list the URLs that are indexable in the crawl (status 200, self-referencing canonical, no noindex) and compare the two sets. Investigate every URL that appears in the sitemap but not in the indexable set, and every indexable URL that is missing from the sitemap. The step is complete when both counts reconcile, or when each difference has a recorded reason such as a language variant or an intentionally excluded node.
Review redirect and 404 logs
Export the redirect table and the 404 log, then group the 404 paths by pattern. Check whether redirects chain (one redirect pointing to another), loop, or point to pages that now return a 404. Compare the most requested 404 paths against the redirect table, because old paths that still receive traffic or links are the first candidates for a redirect. The step is complete when you have a list of chained, looping and broken redirects, and a count of distinct 404 paths that have no redirect.
Sample rendered HTML for metadata and JSON-LD
Select a sample of pages from each content type and each language, including the highest-traffic nodes and a set of older or unusual pages. For each sampled page, view the rendered HTML, not the editor form, and check the title, meta description, canonical, Open Graph tags and any JSON-LD blocks. Validate the JSON-LD with a structured data testing tool. Record how many sampled pages match the intended defaults and how many fall back to empty or duplicated values. The step is complete when the sample is documented with its size and selection method, so the result can be repeated.
Check Core Web Vitals inputs and accessibility signals
Collect field data for the key templates from the sampled pages, using the Chrome User Experience Report or your own real-user monitoring where it exists, and run lab tests for the same templates. Note page weight, image handling, render-blocking assets and layout shifts from the performance report. In parallel, run an automated accessibility scan on the same sample and record heading structure, image alternative text and form labels. The step is complete when each template has performance and accessibility results attached, and the findings are mapped back to the URLs they affect.
Record findings and agree the remediation order
Consolidate the results from the earlier steps into one findings register, with each item linked to the URLs, templates or configuration it affects. Group items by the Drupal layer that fixes them, such as Metatag defaults, Pathauto patterns, redirect rules, sitemap settings or theme templates, and mark which ones block indexing before others. The step is complete when every finding has an owner, a fix location and a verification check, and the register is reviewed with the site owner before any changes are made.
How duplicate URLs, aliases and redirects interact
An audit of duplicate URLs has to read URL aliases, path redirects, language prefixes and query parameters together, because a single Drupal page can be reachable at several paths at once. The node may answer at its system path, at a Pathauto-generated alias, at an older alias left behind after a pattern change, at a language-prefixed alias, and at any of those with query strings such as tracking parameters or sort options. Checking one layer in isolation will miss most of the duplicates. Start by exporting the full list of aliases from the path_alias table or the URL alias admin screen, then crawl the live site and record the final URL, status code and canonical tag for each path that returns content.
Duplicates can be fixed at three layers, and each carries different trade-offs. Fixing them at the alias layer changes which path is generated for new content, which is the cleanest long-term outcome but does nothing for old links unless the old aliases are kept or redirected. A canonical link element tells search engines which URL to index while leaving every path reachable, which suits query-parameter variants and filtered listings, but it is a hint rather than a command and does not stop crawling. A redirect removes the duplicate path entirely and passes users and link equity to the target, which is the strongest signal, but a redirect chain or loop created by two layers pointing in different directions can be harder to see than the duplicate it replaced.
Any recommendation to change a live URL pattern can break existing inbound links, bookmarks, feeds and integrations. Before the audit proposes a change, record the current paths, their inbound link counts from your analytics or search console exports, and which systems call them. Ask the content and integration owners which paths are referenced outside the site. Then confirm with the Redirect module's behavior and your server configuration how old paths will resolve after the change, and test that mapping on a staging copy. Recording the baseline first is what allows the audit to say whether a fix worked.
What to protect while auditing a live Drupal site
How do we crawl a production Drupal site without overloading it?
Run the crawl at a rate the site can absorb, outside peak traffic, and agree the limits with whoever operates the hosting before the first request. Set a low concurrency and a delay between requests, identify the crawler with a clear user agent, and stop early if response times climb or error rates rise. Crawl from a sample of templates first, then expand. Heavy crawls also trigger cache misses, so ask the operations team whether a crawl can be run against a read-only replica or a staging copy with the same content and configuration. Record the crawl settings in the audit so the results can be reproduced.
Should we audit on a staging copy or on production?
Use a staging copy for anything that changes data, runs cron jobs or sends email, and use production only for read-only checks that the team has approved. A staging copy made from a recent production database contains the same URLs, aliases, metatags and redirects, which is what the audit needs. Confirm that staging is protected by authentication or network controls, that it does not index publicly, and that outbound email and payment or CRM connectors are disabled. Ask who owns the copy and when it is deleted.
What personal data can end up in audit logs and staging copies?
Access logs, Drupal watchdog entries, form submissions, user records and staging databases can all contain personal data such as IP addresses, email addresses and account names. Limit who can read them, keep the audit to the fields it needs, and redact or pseudonymize where possible. Agree a retention period for the copies and logs with the data protection owner, and remove them when the audit closes. Ask your privacy team whether a staging copy of production data needs the same handling as production.
How should admin credentials be handled during the inspection?
Do not share an administrator password with the auditor. Create a named, time-limited account with the narrowest role that lets the auditor view the configuration, such as the permissions needed to read metatag, alias, redirect and sitemap settings, and remove it when the audit ends. Require multi-factor authentication where the site supports it, keep the credentials out of tickets and chat, and rotate any credential that was exposed. Check that the account cannot change content or users unless the work requires it.
Where should audit exports and reports be stored?
Store audit exports, crawl data, redirect maps and screenshots in a restricted repository or document space that only the audit team and the site owners can open. Exports often include internal URLs, unpublished content titles, user data and configuration details that are useful to an attacker. Do not place them in a public web root, an open file share, a public issue tracker or a shared spreadsheet with external links enabled. Set an expiry for the files and delete working copies when the engagement closes.
Do Drupal security advisories affect which audit fixes we can apply?
Yes. Before applying a module or core change recommended by the audit, check the Drupal Security Team advisories for the affected project and version, because a fix may already be shipped in a newer release or a vulnerable version may be the one running in production. The Drupal Security Team publishes advisories with CVE identifiers and risk scores, and security releases come out on the third Wednesday of the month. Plan audit fixes so they follow the same routine as security updates: test in staging, then deploy in the normal window.
How should audit fixes fit the site's normal update routine?
Treat each audit fix as a change request that goes through the same path as any other update: code or configuration in version control, a test in staging, a review, and a deployment in an agreed window. Bugfix releases come out on the first Wednesday of each month, so a monthly routine can absorb most module updates alongside the audit work. Avoid bundling SEO changes with unrelated updates, so that any ranking or traffic change can be traced to a known release. Ask your team how rollbacks are handled before the first change goes live.
What to confirm before commissioning the audit
An SEO audit is only as useful as the access and facts behind it. Confirm each item below with your own team or hosting provider before scoping, because the answers change which checks apply and how long the review takes.
Drupal core and PHP versions
Confirm the exact Drupal core version and the PHP version your host runs, then compare both against the supported releases listed on Drupal.org. Redirect logic, canonical handling and metadata modules behave differently across major versions, so the audit must test the versions you run, not the ones in your documentation. Ask your host to confirm the PHP version in the live runtime, since staging and production often differ.
Drupal 7 security status
Confirm whether the site is still on Drupal 7. Drupal 7 security support ended on January 5, 2025, so any SEO fixes you recommend will sit on an unsupported base. Ask whether the team plans a migration or relies on an extended support provider, because that decision changes whether metadata and redirect fixes are built on the old stack or carried into a new site.
Webmaster tools access
Confirm that someone on your team can export Search Console and Bing Webmaster Tools data for the live properties, including the coverage, indexing and crawl reports. Without this data, the audit can only infer how search engines see duplicate URLs, soft 404s and sitemap errors. Ask for read access for the auditor and for a list of any manual actions or past migration issues already logged.
Live languages and domains
List every live language, domain and subdomain, and the language negotiation method in use, such as path prefixes or domains. Each live host and language variant creates its own URL set, canonical rules and hreflang pairs, so an incomplete list leads to missed duplicates. Confirm whether any translations are unpublished but still reachable by URL.
Planned migration or theme rebuild
Confirm whether a replatform, Drupal 7 migration or theme rebuild is scheduled in the next release cycle. Themes cannot be migrated from Drupal 6 or 7, so markup, heading structure and template-level metadata will change. If a rebuild is planned, the audit should focus on the redirect map and rankings you must protect, and on fixes that carry forward instead of fixes that will be rewritten.
Crawl access to staging
Confirm whether the auditor may crawl staging and whether staging is protected from indexing. A crawl of a staging copy shows template issues before release, but it can also expose duplicate content to search engines if it is publicly reachable. Ask your host to confirm the authentication method, the robots directives and the IP ranges allowed to crawl, and to agree a crawl rate that will not affect performance.
When the audit should pause for a migration
If the site runs Drupal 6 or Drupal 7 and must end up on Drupal 10 or later, the audit changes purpose. Findings stop being a list of in-place fixes because Drupal 6 and 7 sites cannot be updated directly to Drupal 10 or later. They are migrated into a new site using the core Migrate, Migrate Drupal and Migrate Drupal UI modules or Drush, and themes must be rebuilt because they cannot be migrated. Fixing metadata or aliases on the old site may still be worthwhile for the interim, but the durable output of the audit is an input to the new build, not a patch list for the old one. Confirm the current major version and PHP runtime of the existing site first, since the Drupal 6 or 7 upgrade documentation sets the migration path you will follow.
Record every URL-structure finding as a baseline before the migration design is locked. That means the current URL patterns by content type, existing URL aliases, faceted or parameterized paths, pagination, trailing-slash behavior, language prefixes, and any URLs that return errors or redirect chains. Capture the indexed URLs from search console exports and server logs as well, because the redirect map must cover what search engines and external links actually use, not only what the CMS database lists. Ask the migration team to confirm which of these paths will be preserved, which will change, and which will be retired, so every change has a matching redirect entry before launch.
Keep the audit's structured data, sitemap and metadata findings separate from the migration backlog where they depend on the new theme and modules. Metatag defaults, Schema.org output and sitemap configuration belong to the rebuilt site, so document the requirements as acceptance checks for that build rather than as fixes to the old one. The practical rule is that the audit pauses at the point of design decisions: once the target platform and URL scheme are agreed, the remaining SEO work becomes migration verification, covering the redirect map, canonical tags, 404 monitoring and launch checks.
Questions buyers ask before commissioning a Drupal SEO audit
What does a Drupal SEO audit cost and what drives the price?
The price follows from the written scope, and no figure is given here. The main drivers are the number of pages and content types, the number of languages, how many URL patterns and redirect rules exist, whether logs and a staging copy are available for review, and how many fixes you ask the team to implement rather than only document. Ask for a quote that separates the review from any implementation work, so you can see what is one-time and what would recur if you keep the site under review. DeployOpen fixes its scope and deliverables in writing before work starts.
How long does a Drupal SEO audit take?
Duration depends on the same factors as cost: site size, the number of languages and content types, and how much historical data needs analysis. Discovery usually takes longer when documentation is thin, because the team must first learn how content is modeled and how URL aliases are generated. Ask for a timeline in the written scope with named milestones, including when crawl results, the findings report and the prioritized fix list will be delivered. Confirm which dates depend on your staff returning access or answering questions.
What must our team provide before an audit starts?
A useful audit needs access and documentation in four areas:
- Crawl access: a staging or production URL the crawler can reach, with credentials for any protected areas and a sitemap or list of known entry points.
- Analytics and webmaster access: read access to your analytics property and search console properties, so the team can compare crawl findings with indexing and traffic data.
- Content model documentation: content types, taxonomies, fields used for titles and summaries, and the Pathauto or Metatag patterns already in place.
- Change history: recent migrations, redirect files and any known incidents that affected traffic.
Confirm each item in the scope so that missing access is visible early.
Can our internal team run the checklist without a partner?
Yes, a capable internal team can work through the checklist, provided it has a developer who can read Drupal configuration, someone who can run a crawler and interpret its output, and an SEO owner who can judge which findings affect search visibility. The hardest parts are usually the duplicate URL analysis and the redirect review, because they require knowledge of how aliases, taxonomy paths and legacy URLs interact. A partner adds independent review, prioritization and implementation capacity. Decide which parts your team will own after the audit, since the findings only matter if someone maintains the metadata defaults, sitemaps and redirects going forward.
Does an SEO audit guarantee ranking changes?
An audit identifies technical issues and documents them with evidence, but it cannot promise a specific ranking outcome, because search results depend on factors outside the site's control. What the audit can deliver is a written list of findings, their likely effect on crawling, indexing and presentation, and a prioritized set of fixes with owners. Ask the provider to describe exactly what the deliverables contain and what would be retested after fixes are applied. Treat any claim of a guaranteed position as a warning sign.
Which parts of the audit touch security or compliance?
The audit reviews publicly reachable URLs, response headers, redirect behavior and how staging environments are protected from indexing. Staging sites that are open to crawlers can create duplicate content, and exposed admin paths or verbose errors raise security concerns that the audit team should flag to your security function. Confirm in writing how crawl credentials are stored, who receives the crawl data, and how long logs and exports are retained. The audit does not produce a compliance attestation, and any regulatory review needs its own independent assessment.
Should we commission the audit before or after a Drupal migration?
Commission it before the migration when possible, so the team can capture current URLs, ranking-relevant pages, metadata and redirect history that the new site must preserve. An audit run after launch still helps, but it must work from logs and search console data to reconstruct what changed. Pair the audit with a redirect map review and launch checks if the platform is changing. Ask the provider whether the audit scope includes a baseline crawl, because that baseline is the reference for measuring whether fixes or the migration caused regressions.
How DeployOpen scopes and delivers a Drupal SEO audit
DeployOpen approaches a Drupal SEO audit as a fixed-scope technical review of your existing site, agreed in writing before work starts. We inspect the live site, the Drupal configuration and the content model, then document findings and fixes so your team can act on them or ask us to implement them.
How we scope
- Confirm which sites, languages, content types and URL sections the audit covers before any work begins.
- Agree the review areas in writing: metadata defaults, duplicate URLs, redirects, sitemaps, structured data, performance and accessibility signals.
- Record access needed from your team, including staging copies, analytics exports and Search Console access where you choose to share it.
How we build
- Crawl the site and compare rendered output with Drupal configuration for metadata, aliases, canonicals and sitemap entries.
- Test redirect chains, 404 patterns and duplicate paths against the URL structure your editors actually publish.
- Check structured data and performance signals on representative pages, then record each finding with its evidence and affected templates.
How we hand over
- Deliver a written report that ranks findings by affected URLs, with reproduction steps and a suggested owner for each fix.
- Provide a prioritized remediation list that separates configuration changes from custom code and content work.
- Walk your developers and editors through the findings so the fixes can be scheduled into your own release process.
How we support
- Ongoing support, re-audits and continuous testing are available as a retainer, scoped separately from the audit.
- Ask for a quote that states which fixes are included, which are optional and what your team must provide for each.
- Confirm with your own SEO and analytics owners which search engines and reporting tools the findings must be validated against.

