WordPress interviews should reveal how candidates combine content modeling, PHP development, block editing, security, and reliable site operations. Recruiters need to distinguish familiarity with the dashboard from an ability to maintain the system behind it. Ask how a change affects editors, visitors, plugins, caches, and future upgrades, not merely which function a candidate remembers.
This guide to 100+ WordPress Interview Questions and Answers contains 120 questions across beginner, intermediate, and experienced levels. It begins with themes, plugins, hooks, and content types, then develops practical scenarios involving REST APIs, permissions, performance, migrations, and architectural decisions.
How can recruiters verify genuine WordPress development experience when a candidate can name familiar hooks but cannot explain a broken publishing workflow?
Ask the candidate to trace an editorial change through validation, storage, rendering, and caching. Introduce a plugin conflict or a permission failure, and ask which evidence would isolate the cause. A clear explanation of the boundaries and a testable correction reveal more than a memorized snippet.
Sherlock AI helps hiring teams assess signals of potential AI cheating, deepfakes, impersonation, and unauthorized assistance during interviews.
Consider these signals alongside practical exercises and the candidateโs explanation, without treating a signal as conclusive proof of misconduct. Evaluate whether the candidate can adapt their reasoning to the actual content, permissions, and operational constraints of the site.
WordPress Interview Questions
Use this complete question bank to select an interview sequence before consulting the matching answers. Numbering runs continuously across all three difficulty levels.
WordPress Interview Questions for Beginners
Establish the content model, theme and plugin responsibilities, hooks, permissions, and common APIs. Look for clear explanations of what WordPress manages and what custom code must enforce.
What is WordPress?
How do WordPress.org and WordPress.com differ?
What is the difference between a theme and a plugin?
How do posts and pages differ?
What is a custom post type?
What is a taxonomy?
How do categories and tags differ?
What is post metadata?
What is the WordPress Loop?
What does the template hierarchy do?
How do classic themes and block themes differ?
What is a child theme?
What belongs in functions.php?
What are actions and filters?
How do hook priorities and accepted arguments work?
Why should developers avoid editing WordPress core?
How should styles and scripts be loaded?
What is theme.json used for?
What is a WordPress block?
How do static and dynamic blocks differ?
What is block.json?
How do patterns differ from reusable content?
What is the Site Editor?
How do roles and capabilities differ?
What does current_user_can() do?
What is a WordPress nonce?
How do validation, sanitization, and escaping differ?
When should data be escaped?
What does $wpdb provide?
What is WP_Query?
What is the REST API used for?
What is the difference between authentication and authorization?
What are WordPress options?
What are transients?
What is the object cache?
How does WP-Cron work?
What is WP-CLI?
What is WordPress Multisite?
What should a WordPress backup include?
What is a safe approach to WordPress updates?
WordPress Interview Questions for Intermediate
Examine queries, forms, REST routes, blocks, caching, scheduled work, and migrations. Ask candidates to identify the relevant context, failure modes, and verification steps.
How would you choose between a custom post type and a custom table?
How should a custom post type be registered?
How do custom capabilities affect a post type?
How would you register metadata for REST access?
When should you use pre_get_posts?
Why is query_posts() usually a poor choice?
When is wp_reset_postdata() needed?
How do you avoid unnecessary pagination work in a custom query?
How should wpdb::prepare() be used?
How should a search term be used in a LIKE query?
How would you build a secure settings form?
What checks belong in a custom form handler?
How do you handle slashed request data correctly?
How do you safely redirect after a form submission?
How would you register a custom REST route?
What should a REST permission callback check?
How does cookie authentication interact with REST nonces?
When are application passwords useful?
How should admin-ajax.php handlers be secured?
How do you make a shortcode callback reliable?
How should a dynamic block render callback handle data?
What can cause block validation errors?
How should block deprecations be designed?
How do editor and frontend assets differ?
How should translations be handled in PHP output?
How should JavaScript translations be handled?
How would you schedule a recurring task without duplicates?
How would you make a long-running background job reliable?
How should transient cache misses be handled?
What is a cache stampede?
How do page caching and user-specific content interact?
How would you diagnose slow metadata queries?
What is the risk of oversized autoloaded options?
How should custom-table schema changes be deployed?
How do activation, deactivation, and uninstall differ?
What are must-use plugins?
How does switch_to_blog() affect Multisite code?
How should a URL migration handle serialized data?
How would you troubleshoot rewrite-related 404 errors?
How would you evaluate accessibility in a custom block?
WordPress Interview Questions for Experienced
Use architecture and incident scenarios to evaluate trade-offs, recovery, security boundaries, and operational ownership. Strong answers state assumptions and explain how to test them.
How would you investigate a plugin conflict?
How would you design a maintainable custom WordPress plugin?
How would you approach a headless WordPress architecture?
How would you prevent private content from leaking through an API?
How would you investigate a compromised WordPress site?
How would you review an upload feature for security?
How would you defend an external-fetch feature against SSRF?
How would you handle a payment webhook reliably?
How would you prevent duplicate form submissions from creating duplicate records?
How would you design cache invalidation for an editorial site?
How would you investigate stale content after a deployment?
How would you scale a high-traffic WordPress site?
How would you diagnose PHP worker exhaustion?
How would you optimize a slow WordPress homepage?
How would you investigate a database deadlock or race condition?
How would you evolve a plugin database schema without downtime?
How would you manage configuration across development, staging, and production?
How would you build a safe deployment rollback?
How would you assess whether Multisite is appropriate?
How would you perform a large Multisite batch operation?
How would you design an integration with an unreliable external API?
How would you make a background queue observable?
How would you review a third-party plugin before adoption?
How would you test WordPress-specific behavior effectively?
How would you test custom block compatibility across versions?
How would you evaluate an AJAX or REST endpoint for abuse?
How would you handle a stored XSS vulnerability?
How would you design permissions for a collaborative publishing workflow?
How would you design a large content import?
How would you preserve SEO behavior during a redesign?
How would you handle privacy-sensitive data in WordPress?
How would you diagnose failed scheduled publication?
How would you reduce plugin coupling?
How would you modernize a legacy theme incrementally?
How would you choose between a custom block and a pattern?
How would you design an emergency content-correction workflow?
How would you separate content permissions from deployment access?
How would you validate a disaster-recovery plan for a WordPress site?
How would you preserve editorial workflows when changing the content model?
How would you evaluate a senior WordPress developer's architectural judgment?
WordPress Interview Questions and Answers
The answers match the wording and order of the question bank. Verify APIs against the supported WordPress, PHP, theme, and plugin versions. Examples are contextual snippets, not complete installable plugins; WordPress integration behavior requires a representative test installation.
WordPress Interview Questions and Answers for Beginners
Establish the content model, theme and plugin responsibilities, hooks, permissions, and common APIs. Look for clear explanations of what WordPress manages and what custom code must enforce.
1. What is WordPress?
WordPress is an open-source content management system built around PHP, a database, themes, plugins, and extensible APIs. It supports more than blogging, but suitability depends on content, integration, traffic, and governance requirements. A good candidate explains how editors manage content and how developers extend behavior without editing core files. Installing WordPress is only the beginning; updates, security, backups, accessibility, and performance require ongoing ownership.
2. How do WordPress.org and WordPress.com differ?
WordPress.org distributes the open-source software and community resources, while WordPress.com is a hosted service with its own offerings and plan-dependent capabilities. A self-hosted installation gives the operator responsibility for hosting and maintenance, even when a managed host handles some tasks. Clarify which environment an interview scenario uses before proposing plugins, server configuration, or deployment practices that might not be available in that hosting arrangement.
3. What is the difference between a theme and a plugin?
A theme primarily controls presentation, while a plugin adds functionality that should generally remain available when the site changes its appearance. For example, registering a business-specific content type usually belongs in a plugin rather than a theme. This separation improves portability. Real projects can blur the boundary, so assess the effect of switching themes instead of assuming that all code in functions.php is automatically appropriate there.
4. How do posts and pages differ?
Posts typically support chronological publishing and default category and tag organization, while pages commonly represent more stable hierarchical content. Both are WordPress content types stored through shared content APIs. The choice affects templates, navigation, archives, and editorial expectations rather than making one inherently better for search ranking. For a service overview use a page; for a dated announcement a post may fit the publishing workflow better.
5. What is a custom post type?
A custom post type defines another category of structured content, such as a course or product, with its own supported features and behavior. Register it through the appropriate API and configure visibility, capabilities, archives, and REST exposure deliberately. Creating a post type does not automatically define every field or authorization rule. Prefer a durable plugin for business content so switching themes does not hide its management interface.
6. What is a taxonomy?
A taxonomy groups and classifies content through terms. Categories and tags are built-in examples; a course site might define a subject taxonomy. Hierarchical taxonomies support parent-child relationships, while non-hierarchical taxonomies provide flatter organization. Use a taxonomy when classification and filtering are central, rather than storing every reusable label in unrelated text metadata. Define term management capabilities and archive behavior as part of the content model.
7. How do categories and tags differ?
Categories are hierarchical by default and often represent broad editorial groupings; tags are non-hierarchical and commonly identify more specific associations. Both use taxonomy APIs. Establish an editorial vocabulary to avoid near-duplicate terms and unhelpful archive pages. Neither taxonomy guarantees search visibility simply by existing. The useful distinction is how readers and editors organize and discover content, not a universal rule about which produces better SEO.
8. What is post metadata?
Post metadata stores additional values associated with a post, such as an external identifier or event date. Use metadata APIs and register fields when schema, REST exposure, or other explicit behavior is needed. Choose types and validation carefully because metadata is not automatically a fully constrained business schema. Frequent complex queries over many metadata values may require a different storage design and measured indexing strategy.
9. What is the WordPress Loop?
The Loop iterates through query results and establishes the current post context used by template functions. A typical classic theme checks for posts, advances with the_post(), and renders each result. Understand that template tags may depend on global post state. When a secondary query changes that context, restore it appropriately so later headings, links, and metadata do not accidentally refer to the last item in the secondary loop.
10. What does the template hierarchy do?
The template hierarchy selects an appropriate template based on the requested content and available templates, falling back from specific matches to more general ones. For example, a content-type-specific single template can override a generic single template. Block themes and classic themes use different template formats and resolution details. Inspect the actual selected template, including database-stored customizations in block themes, before assuming a file change must affect the rendered page.
11. How do classic themes and block themes differ?
Classic themes primarily use PHP templates, while block themes use block-based templates and support the Site Editor experience. Both can use shared WordPress APIs, and features can overlap. A block theme changes how layouts and styles are authored and customized; it does not eliminate PHP execution from WordPress. Check the project's supported WordPress version and editorial workflow before choosing a migration strategy or assuming every plugin behaves identically in both models.
12. What is a child theme?
A child theme inherits from a parent theme while allowing selected customizations to be maintained separately. It can reduce the risk of losing changes during parent updates, but it does not make those customizations automatically compatible with future parent behavior. Understand template precedence and how styles and functions are loaded. Keep a small, documented override surface and test parent upgrades; copying large amounts of parent code creates long-term divergence.
13. What belongs in functions.php?
Theme-specific setup and presentation behavior can belong in functions.php, which WordPress loads as part of the active theme. Examples include theme support and asset registration. Business logic that must survive a theme change usually belongs in a plugin. Avoid turning the file into an unstructured collection of unrelated handlers. Namespace or prefix symbols and hook behavior at the appropriate lifecycle point instead of performing expensive work immediately on every request.
14. What are actions and filters?
Actions provide extension points for performing work, while filters allow code to transform a value returned to the caller. A filter callback should return the resulting value; printing it is not equivalent. Both use hooks with priorities and accepted arguments. Select the documented hook for the intended lifecycle rather than modifying core files or relying on the incidental order in which unrelated plugins happen to load.
PHP: a scoped output filter
This illustrative filter affects every frontend use of the title filter for post 123. Use a more specific rendering boundary when only one component should change. Escape the resulting title at its output context.
15. How do hook priorities and accepted arguments work?
Priority determines callback execution order on a hook, with lower numbers running earlier; accepted arguments controls how many provided arguments are passed to the callback. A callback can still fail if its required signature does not match registration. Use priorities to express a real ordering need, not as a guessing game. Document dependencies and verify behavior with other extensions, especially when filters transform the same value multiple times.
16. Why should developers avoid editing WordPress core?
Core edits are easily lost during updates and make security patching, troubleshooting, and collaboration harder. Use hooks, plugins, themes, or supported configuration instead. If a requirement cannot be met through existing extension points, document the limitation and evaluate an upstream contribution or a maintained alternative. A local patch may occasionally be necessary, but it creates an explicit maintenance obligation and should never be an invisible production customization.
17. How should styles and scripts be loaded?
Register or enqueue assets through WordPress APIs using stable handles, dependencies, and appropriate lifecycle hooks. This lets WordPress coordinate loading and gives other code a supported way to interact with the asset. Load only where needed and use deliberate versioning for cache invalidation. Hardcoded script tags can bypass dependency management and create duplicate or incorrectly ordered assets, particularly when the editor and frontend have different requirements.
18. What is theme.json used for?
theme.json defines global settings and styles that integrate with WordPress's styling and editor systems. It can describe design tokens, supported controls, and block styles so the editor and frontend share a more coherent design system. Schema versions and available settings depend on WordPress support. It complements rather than universally replaces CSS, and user customizations or other style origins can affect the final result.
19. What is a WordPress block?
A block is a unit of content or layout represented through the block editor's data and rendering model. It can expose attributes and controls and can render saved markup or server-generated output. Blocks are not merely visual widgets: their serialization, registration, accessibility, and compatibility matter. Choose an existing core block or pattern when it meets the requirement instead of creating a custom block solely to change a small styling detail.
20. How do static and dynamic blocks differ?
A static block commonly saves its frontend markup into post content, while a dynamic block renders output on the server when needed through its render implementation. Dynamic rendering suits data that changes independently of the saved post, such as a current listing. It also adds runtime work and dependency considerations. Some blocks combine saved fallback content with dynamic behavior, so inspect the specific registration and render contract rather than treating the categories as absolute.
21. What is block.json?
block.json provides metadata used to register a block consistently across server and client contexts. It can declare the block name, API version, attributes, supports, scripts, styles, and rendering information. Use namespaced block names and validate metadata against the supported schema. The file is not a substitute for implementing editor behavior, server authorization, or accessible markup; it describes how the block participates in the platform.
22. How do patterns differ from reusable content?
A pattern provides a starting arrangement of blocks, while synchronized reusable content shares a common definition so changes can affect multiple placements. The editor terminology and available controls vary by WordPress version. Clarify whether an author expects each insertion to diverge or remain linked. Choosing the wrong model can turn a routine edit into a site-wide change or leave repeated content inconsistent across pages.
23. What is the Site Editor?
The Site Editor provides an interface for editing supported block-theme templates, template parts, and styles. Its changes can be stored in the database and take precedence over theme files. This is useful for editors but important for deployment design: shipping a new template file may not replace a stored customization. Establish ownership and a process for moving, reviewing, and resetting customizations rather than assuming all presentation lives in Git.
24. How do roles and capabilities differ?
A role is a collection of capabilities, while a capability represents permission to perform an action. Check capabilities rather than hardcoding role names, because roles can be customized and users can have different combinations of access. For content-specific operations, use the relevant object-aware capability check. A user who can edit one post is not necessarily authorized to edit every post or manage global site settings.
25. What does current_user_can() do?
current_user_can() checks whether the current user has a specified capability, potentially considering an object such as a post when the capability requires context. It supports authorization decisions in request handlers and templates. Hiding a button based on this check improves the interface, but the server must also enforce the permission when the action executes. Client-side visibility is never a sufficient boundary for privileged operations.
26. What is a WordPress nonce?
A WordPress nonce is a time-limited token used to help protect request intent, commonly against cross-site request forgery. Despite its name, it is not generally a one-use token and does not establish authentication or authorization. A handler still needs capability checks and input validation. Associate the token with the intended action and consider caching and expiration behavior so legitimate users can recover when a form remains open too long.
27. How do validation, sanitization, and escaping differ?
Validation checks whether input meets a rule, sanitization transforms input into an acceptable form, and escaping makes output safe for a particular destination context. Use each at the right boundary. A valid numeric identifier still requires authorization, and sanitized text may still need HTML escaping when displayed. Avoid treating one generic cleanup function as protection for database queries, HTML, URLs, JavaScript, and business rules simultaneously.
28. When should data be escaped?
Escape data as close as practical to its output using the function appropriate to the context, such as HTML text, attributes, or URLs. This preserves the original data for other uses while making the final rendering boundary explicit. Stored content and translated strings are not automatically safe in every context. If approved markup must be retained, use an appropriate allowlist mechanism instead of either blindly printing HTML or stripping everything indiscriminately.
PHP: escape at the output boundary
Assume destination and label are validated strings supplied by the application. URL and HTML-text contexts require different escaping functions.
29. What does $wpdb provide?
The wpdb object provides WordPress's database abstraction for executing queries and accessing results. Prefer higher-level WordPress APIs when they express the operation because they often integrate with caching and hooks. When custom SQL is necessary, use safe query construction and inspect errors. Direct database writes can bypass important application behavior, so a successful SQL statement is not proof that the resulting WordPress state is complete or consistent.
30. What is WP_Query?
WP_Query retrieves posts using WordPress query arguments and participates in the platform's query behavior. It supports filters for content type, status, taxonomy, metadata, ordering, and pagination. Be explicit about the intended result set and whether pagination totals are needed. A flexible query API does not guarantee efficient SQL: complex metadata conditions, broad searches, and oversized result sets can become significant performance problems.
31. What is the REST API used for?
The WordPress REST API exposes structured endpoints for content and application integrations. It can support the editor, external applications, and headless frontends. Authentication, permissions, schema, and response design remain essential, especially for custom routes. A route returning JSON is not automatically safe to expose publicly. Decide which data each caller should access and test unauthenticated and low-privilege requests as well as the successful administrator path.
32. What is the difference between authentication and authorization?
Authentication establishes the caller's identity; authorization determines whether that identity may perform the requested operation on the requested resource. WordPress integrations need both where data is protected. For example, a logged-in author might edit their own draft but not another author's private content. A valid cookie, application password, or nonce does not remove the need for an object-specific permission check in the handler.
33. What are WordPress options?
Options store site-level settings and other values through the Options API. They are useful for configuration such as an integration endpoint or feature setting. Avoid placing large or frequently growing operational datasets into one option without considering loading and update behavior. In Multisite, distinguish site options from network-wide settings. Use explicit defaults and validation so a missing option does not silently enable a risky or expensive behavior.
34. What are transients?
Transients store cached values with a maximum lifetime, but they may disappear before the configured expiration. Code must therefore be able to regenerate a missing value. Depending on the environment, storage may be backed by the database or an external object cache. Do not use a transient as the only durable record of a payment, scheduled job, or business event; cache availability is not a persistence guarantee.
35. What is the object cache?
The object cache stores reusable data during execution, and a persistent object-cache implementation can retain suitable entries across requests. This differs from a full-page cache that returns rendered responses. Know what the hosting environment actually provides before assuming wp_cache_set() creates cross-request persistence. Define cache keys, groups, expiration, and invalidation carefully so a performance optimization does not leak user-specific data or serve stale permissions.
36. How does WP-Cron work?
WP-Cron schedules tasks through WordPress and is commonly triggered by requests rather than by a continuously running operating-system scheduler. A low-traffic or blocked site can therefore run overdue work later than intended. For time-sensitive operations, configure and monitor an appropriate external scheduling mechanism. The existence of a scheduled event does not prove successful execution, so track failures, duplicate scheduling, and job progress explicitly.
37. What is WP-CLI?
WP-CLI is a command-line interface for administering and developing WordPress installations. It can inspect configuration, manage content, run maintenance operations, and support automation. Select the correct installation and site context before executing a command, and distinguish read-only inspection from destructive operations. Scripts should handle exit codes and backups deliberately; a convenient command can still bypass the safeguards an editor expects from the web interface.
38. What is WordPress Multisite?
Multisite operates a network of sites from one WordPress installation with shared core code and network-level administration. Sites have separate content contexts while users and some infrastructure are shared. It is useful for centrally managed networks but creates coupling in updates, plugins, and operations. It is not equivalent to independent security-isolated installations, and not every plugin supports network behavior correctly.
39. What should a WordPress backup include?
A recoverable backup usually needs both the database and relevant files, including uploads and any custom code or configuration not reproducible from deployment artifacts. Protect backup access and verify retention and encryption appropriate to the data. Test restoration into an isolated environment. A database export alone may leave missing media, while a filesystem copy alone may omit the content and settings needed to reconstruct the site.
40. What is a safe approach to WordPress updates?
Review compatibility and changes, create a recoverable checkpoint, test representative workflows in staging, and roll out with monitoring and a rollback plan. Include core, plugins, themes, PHP, and other runtime dependencies. Security urgency can require a faster controlled process, but ignoring updates indefinitely increases risk. Verify actual user journeys after deployment; a successful update screen does not prove checkout, forms, scheduled tasks, and editing still work.
WordPress Interview Questions and Answers for Intermediate
Examine queries, forms, REST routes, blocks, caching, scheduled work, and migrations. Ask candidates to identify the relevant context, failure modes, and verification steps.
41. How would you choose between a custom post type and a custom table?
Use WordPress content structures when their APIs, editorial workflows, and query patterns fit the data. Consider a custom table when volume, constraints, relationships, or access patterns justify dedicated schema and indexes. The latter requires migration, backup, permissions, and lifecycle ownership. Benchmark representative queries before choosing. A custom table is not automatically faster, and forcing transactional application data into numerous metadata rows can be equally costly.
42. How should a custom post type be registered?
Register it at the appropriate initialization hook with a stable prefixed identifier and deliberate labels, supported features, visibility, REST settings, rewrite behavior, and capabilities. Place persistent business types in a plugin. Decide whether visitors, editors, and API clients should see the same content. After registration changes, refresh rewrite rules through a controlled lifecycle operation rather than flushing them on every request.
43. How do custom capabilities affect a post type?
Custom capabilities allow a content type to use a permission model tailored to its workflow. Configure capability mappings and meta-capability behavior, then grant the intended capabilities to appropriate roles through a controlled setup or migration. Merely declaring capability names does not assign them to users. Test creating, editing, publishing, and deleting both owned and others' content across roles, including REST requests.
44. How would you register metadata for REST access?
Declare the field's type, cardinality, default where appropriate, REST exposure, and relevant validation or sanitization behavior using the metadata registration APIs. Ensure the post type supports the required metadata behavior and authorization is correct. A field being visible in the editor is separate from its API schema. Avoid exposing private integration tokens or internal notes simply because a frontend needs a nearby public field.
45. When should you use pre_get_posts?
Use pre_get_posts to adjust an intended WordPress query before it executes, commonly the main frontend query for a specific archive. Guard by query context, such as excluding administration and checking the main query, so unrelated widgets or API requests are not modified. Use the query object's methods where appropriate. An unguarded callback can unexpectedly change dashboards, feeds, and secondary queries throughout the installation.
PHP: constrain a main archive query
This changes frontend main category archives only. Verify pagination and intended feed behavior in the actual site; query context is broader than one template file.
46. Why is query_posts() usually a poor choice?
query_posts() replaces the main query and can disrupt pagination and global query state while doing additional work. Adjust the original main query through an appropriate hook when that is the goal, or use a separate WP_Query for an independent listing. Choose deliberately between these tasks. A visible list may look correct while page counts, conditional tags, and later template output are already inconsistent.
47. When is wp_reset_postdata() needed?
Use wp_reset_postdata() after a secondary loop that called the_post() and changed the global post context, so subsequent template tags return to the main query's post. It does not reset every possible global or undo arbitrary query changes. For a query that only fetches IDs without establishing post context, it may not be necessary. Understand what state the loop actually changes instead of adding resets mechanically.
PHP: restore post context after a secondary loop
This list does not expose pagination totals. The reset restores the main query post context used by subsequent template tags.
48. How do you avoid unnecessary pagination work in a custom query?
When a listing does not need total result counts, an appropriate no_found_rows setting can avoid work used to calculate pagination totals. Limit returned fields and result size when possible, and use a deterministic order. Do not enable the optimization if the interface needs accurate page counts. Performance tuning should preserve the user-visible contract rather than making a query cheaper by silently removing required information.
49. How should wpdb::prepare() be used?
Use placeholders for variable values and pass the values separately, matching the supported placeholder types and argument count. Do not concatenate untrusted data into SQL before calling prepare(). Identifiers require their own supported mechanism or a strict allowlist; placeholder availability depends on WordPress version. Prepared value handling does not establish authorization or validate business meaning, so query safety and permission checks remain separate requirements.
50. How should a search term be used in a LIKE query?
Escape LIKE wildcard characters with the appropriate wpdb helper, add the intended wildcard pattern, and pass the completed value through prepare() as a string parameter. The order matters because SQL-string escaping and wildcard escaping solve different problems. Decide whether users may intentionally supply wildcards. Also bound the result set and inspect the query plan; a safely constructed leading-wildcard search can still be expensive.
PHP: prepare a bounded LIKE search
The table identifier comes from WordPress, not user input. Underscores in the search term are treated literally. Authorization and whether these post types should be exposed must be decided separately.
51. How would you build a secure settings form?
Use the Settings API where it fits, register settings with validation or sanitization callbacks, and enforce the capability required to change them. Include request-intent protection for the form submission and escape displayed values by context. Separate secret storage from ordinary presentation settings when necessary. Test malformed input and low-privilege users, not only a successful administrator submission, and avoid silently replacing valid configuration with invalid defaults.
52. What checks belong in a custom form handler?
Verify the request method and intended action, authenticate the caller where required, check capabilities for the target resource, validate the nonce for cookie-based intent protection, and validate or sanitize each input. Then perform the operation and return a controlled response or safe redirect. Never assume that a hidden field or disabled button cannot be modified. Design error behavior so partial writes and repeated submissions do not create inconsistent state.
53. How do you handle slashed request data correctly?
WordPress request handling can apply slashes to input, so use wp_unslash() at the appropriate boundary before validation or sanitization when working with such values. Confirm the input is the expected scalar or array shape first. Do not blindly strip slashes from every value received through every API; REST-decoded data and already-normalized values can have different handling. Preserve legitimate characters while applying the field's actual data rules.
54. How do you safely redirect after a form submission?
Use a supported safe redirect mechanism for a permitted destination and stop further execution after sending the redirect. Validate any user-controlled return location rather than trusting a hidden field. A redirect response does not itself roll back a failed operation or prevent duplicate submission. Pair the flow with clear success and error states, and avoid including secrets or sensitive records in query parameters that can enter logs and browser history.
55. How would you register a custom REST route?
Register the route during rest_api_init under a namespaced, versioned path, with explicit methods, request arguments, response behavior, and permission_callback. Keep authorization separate from the callback's business logic so its purpose is reviewable. Validate identifiers and distinguish missing resources from unauthorized access appropriately. Use a deliberately public permission callback only for genuinely public operations, not as a workaround for authentication problems.
PHP: a capability-protected REST endpoint
This read-only administrative example requires configured authentication. A route for an individual resource needs object-specific authorization in addition to any broad capability.
56. What should a REST permission callback check?
It should determine whether the authenticated caller may perform the requested operation on the specific resource, using relevant capabilities and object context. A generic logged-in check may be insufficient for another user's data. Return the supported success or error result without performing the protected mutation there. Test anonymous users, the resource owner, other users, and administrators so a route cannot leak private records through an overlooked path.
57. How does cookie authentication interact with REST nonces?
For logged-in browser integrations, WordPress REST cookie authentication uses the appropriate REST nonce to protect request intent. The nonce does not replace the user's capabilities, and omitting or invalidating it changes authentication behavior. Use supported client mechanisms and handle expiration by refreshing the session or token appropriately. Do not embed an administrator's nonce into publicly cached HTML or treat it as a durable external API credential.
58. When are application passwords useful?
Application passwords can authenticate supported external integrations without exposing the user's primary login password. They remain credentials associated with a user and inherit relevant access, so use a suitably scoped account and protect the secret in transit and storage. They are not per-endpoint authorization rules. Plan revocation and auditability, and verify HTTPS and the installation's actual authentication configuration before integrating an external client.
59. How should admin-ajax.php handlers be secured?
Register only the authenticated or unauthenticated hook appropriate to the operation, validate request intent where applicable, and enforce server-side capabilities and data validation. Return structured responses and terminate through supported helpers. A public AJAX hook can be reached without the admin interface, so never infer trust from the endpoint path. For new integrations, compare an AJAX handler with a structured REST route instead of assuming one mechanism is always preferable.
60. How do you make a shortcode callback reliable?
Return the rendered content rather than unexpectedly echoing it, normalize attributes with explicit defaults, validate their meaning, and escape output by context. Avoid expensive unbounded queries and side effects during rendering. Shortcodes can appear in multiple contexts and may be processed more than once. For complex editing needs, consider whether a block provides a clearer authoring contract while preserving existing shortcode content compatibility.
61. How should a dynamic block render callback handle data?
Validate attributes and obtain authorized data through appropriate APIs, then produce escaped, accessible output. Treat rendering as a read-oriented operation rather than an opportunity for hidden mutations or remote side effects. Bound expensive queries and define cache behavior carefully. A dynamic block can update output without resaving every post, but failure of a dependency must still produce a controlled fallback instead of breaking an entire page.
62. What can cause block validation errors?
A saved static block can fail validation when the current save implementation produces markup inconsistent with stored content. Changes to attributes, wrappers, or serialization can trigger this even if the intended visual design seems similar. Use supported deprecations and migrations for historical representations. Do not dismiss every validation warning as harmless; investigate whether content can be recovered without losing user data or silently changing its meaning.
63. How should block deprecations be designed?
Preserve the historical attribute and save behavior needed to recognize an older block representation, and define a migration when the stored data model changes. Test real saved content from previous versions rather than only newly inserted blocks. Deprecations are compatibility code, so avoid referencing mutable helpers that later alter the old serialization contract. A frontend rendering fix alone does not necessarily resolve editor validation or preserve historical attributes.
64. How do editor and frontend assets differ?
Editor assets support the authoring interface, while frontend assets support visitors; some resources can be shared through block metadata or other supported registration. Loading everything everywhere increases cost and can cause styling conflicts. Account for editor iframe behavior and the supported WordPress version. Test both contexts, including nested blocks and previews, so a block that looks correct in the editor does not render differently or fail on the public page.
65. How should translations be handled in PHP output?
Wrap translatable strings with appropriate internationalization functions and the correct text domain, then escape for the output context. Use placeholders for dynamic values so translators can reorder text naturally. Avoid building sentences by concatenating translated fragments with fixed English assumptions. A translated string is still input to a rendering context; translation support does not remove the need for safe HTML or attribute output.
66. How should JavaScript translations be handled?
Use WordPress's JavaScript internationalization facilities and register the script's translation data through the supported loading workflow. Keep message keys and text domains consistent with extraction and packaging. Test pluralization and variable placement rather than only a translated button label. Ensure the build process preserves the metadata and dependencies needed to load translations; a working development bundle does not prove the distributed plugin includes its language assets.
67. How would you schedule a recurring task without duplicates?
Check whether the intended event is already scheduled using the same hook and arguments before scheduling it. Register callbacks predictably and remove scheduled work when the feature is deactivated or uninstalled according to the product's lifecycle. Design the task to tolerate overlap and retries. Duplicate prevention at registration does not by itself guarantee exactly-once execution, especially under concurrent requests or failures.
68. How would you make a long-running background job reliable?
Break work into bounded units, persist progress, and use a queue or scheduling mechanism appropriate to the workload. Make each unit retry-safe and monitor age, failures, and throughput. Avoid performing an entire large import inside one ordinary web request. Define ownership, cancellation, and recovery behavior so a timeout does not leave operators guessing whether the job completed, partially wrote data, or should be retried.
69. How should transient cache misses be handled?
Use a strict false check when reading a transient, because valid cached values can otherwise be mistaken for a miss. Regenerate missing data through a bounded path and store it with an appropriate lifetime. Where false itself is meaningful data, wrap the cached result in a structure that distinguishes presence from absence. Avoid making a cache miss trigger an uncontrolled burst of expensive remote calls.
PHP: distinguish a transient miss
Zero is a valid cached value. This demonstrates miss handling only, not cache invalidation or stampede prevention; transients can disappear before their expiration.
70. What is a cache stampede?
A cache stampede occurs when many requests simultaneously regenerate the same expired or missing value. Mitigate it with a suitable coordination mechanism, staggered expiration, background refresh, or stale-serving behavior that meets the data's correctness requirements. The implementation must work across the actual worker and cache topology. A process-local flag will not coordinate multiple PHP workers, and a cache-backed lock needs explicit expiration and failure handling.
71. How do page caching and user-specific content interact?
A page cache must vary or bypass responses when content depends on identity, permissions, cart state, or other private context. Otherwise one visitor's data can be served to another. Define cache keys and exclusion rules from the application contract, then test with multiple users and anonymous sessions. A fast anonymous homepage does not prove that account pages, authenticated REST responses, and form tokens are safely cached.
72. How would you diagnose slow metadata queries?
Capture the generated SQL and execution evidence, then inspect joins, comparisons, cardinality, indexes, and result size. Multiple meta_query conditions can create expensive joins, especially when values are not shaped for efficient lookup. Evaluate a taxonomy, denormalized lookup, or custom table only after understanding the query. Adding a cache can reduce repeated work but may hide an underlying query that still fails during cold starts or invalidation.
73. What is the risk of oversized autoloaded options?
Options loaded broadly can increase memory use and database or cache transfer work even on requests that do not need the data. Inspect actual autoload behavior and size for the supported WordPress version rather than assuming every option behaves identically. Move large or rarely needed data to a more appropriate loading pattern. Preserve application semantics and backups when cleaning options; unfamiliar names may belong to active extensions.
74. How should custom-table schema changes be deployed?
Version the schema and implement a controlled migration that handles existing data, indexes, and partial failure. Use supported helpers where appropriate, but verify their limitations against the intended SQL change. Avoid running expensive migrations on every request. Test upgrades from realistic prior versions and plan compatibility between old and new application code, especially when a rollout leaves multiple workers temporarily running different releases.
75. How do activation, deactivation, and uninstall differ?
Activation prepares a plugin for use, deactivation stops its active behavior, and uninstall may remove persistent data according to an explicit product policy. Deactivation should not casually erase user content. Consider scheduled events, rewrite rules, capabilities, and network activation where relevant. Provide a clear data-retention choice and test reactivation; administrators often deactivate a plugin temporarily while diagnosing another issue.
76. What are must-use plugins?
Must-use plugins load automatically from the designated mu-plugins location and are managed differently from ordinary activated plugins. They can enforce site-specific platform behavior, but their loading and update lifecycle needs deliberate ownership. They are not a universal security boundary and should not become an undocumented dumping ground. Account for file-loading structure and dependencies, and provide an operational way to diagnose failures without editing arbitrary production files.
77. How does switch_to_blog() affect Multisite code?
switch_to_blog() changes the current site context for supported WordPress operations, such as table and option access, and should be paired with restore_current_blog() when finished. It does not automatically switch every loaded theme or plugin implementation. Restore context even on error paths, for example with a finally block. Incorrect restoration can cause later queries or generated URLs to target the wrong site in a long-running task.
78. How should a URL migration handle serialized data?
Use a migration tool that understands WordPress data representation, such as an appropriate WP-CLI search-replace workflow, and inspect a dry run before applying changes. Blind SQL string replacement can invalidate serialized string lengths or change unintended values. Back up first, select the correct tables and site scope, and verify media, internal links, redirects, and configuration afterward. External identifiers and historical records may require intentional exclusions.
Shell: preview a serialized-data URL replacement
This is a dry run for an authorized installation. Review its table scope, Multisite implications, backups, and domain-specific values before any real migration. It does not update DNS or web-server routing.
79. How would you troubleshoot rewrite-related 404 errors?
Confirm the content exists and is publicly accessible, inspect the registered post type or route, then check permalink settings, rewrite rules, and web-server routing. Distinguish a WordPress-generated 404 from a request that never reaches WordPress. Refresh rules through a controlled action after relevant registration changes. Repeatedly flushing rules on every request is an expensive workaround that conceals the configuration or lifecycle mistake.
80. How would you evaluate accessibility in a custom block?
Test semantic structure, keyboard operation, focus management, labels, contrast, and screen-reader behavior in both editor and frontend contexts. Use native controls where possible and preserve visible focus. Automated checks can catch some issues but cannot establish complete accessibility. Include realistic content lengths and error states, because an accessible empty demo may fail once authors add nested content or visitors submit invalid input.
WordPress Interview Questions and Answers for Experienced
Use architecture and incident scenarios to evaluate trade-offs, recovery, security boundaries, and operational ownership. Strong answers state assumptions and explain how to test them.
81. How would you investigate a plugin conflict?
Reproduce the issue in a safe environment, record versions and symptoms, and isolate the smallest combination of components that causes it. Inspect hooks, assets, logs, and request behavior rather than disabling production plugins indiscriminately. Determine whether the conflict is a naming collision, ordering dependency, unsupported API use, or incompatible data change. Preserve the affected workflow and create a regression case before deploying a targeted correction.
82. How would you design a maintainable custom WordPress plugin?
Separate request handling, authorization, business rules, persistence, and rendering into understandable boundaries, while using WordPress APIs at the integration points. Prefix or namespace public symbols and document hook contracts. Keep dependencies and supported versions explicit. Avoid unnecessary abstraction, but ensure critical behavior can be tested without clicking through the entire admin interface. Plan migrations and removal behavior from the beginning rather than treating them as post-launch cleanup.
83. How would you approach a headless WordPress architecture?
Clarify why a separate frontend is needed and account for preview, authentication, cache invalidation, routing, redirects, forms, and editor expectations. WordPress can remain the content source, but the frontend must reproduce behavior that a traditional theme previously supplied. Measure the operational and editorial costs, not only frontend flexibility. A headless design is successful when the complete publishing workflow works reliably, including drafts and urgent corrections.
84. How would you prevent private content from leaking through an API?
Define visibility and object-level authorization for every response path, including searches, related records, embedded data, and custom fields. Test anonymous users and users who can access only some records. Ensure caches preserve the same boundaries. Filtering the main list is insufficient if a detail route or metadata field still reveals the content. Review error messages and identifiers as well as the primary payload.
85. How would you investigate a compromised WordPress site?
Contain the incident, preserve evidence, and identify the affected files, accounts, credentials, and data access before attempting broad cleanup. Restore or rebuild from trustworthy artifacts and patch the entry point. Changing one password or deleting an obvious malicious file may leave persistence behind. Coordinate credential rotation, logging, and recovery validation with the responsible team, and determine whether notification obligations require specialist review.
86. How would you review an upload feature for security?
Authorize the operation, validate file type and size through appropriate mechanisms, use controlled storage paths, and prevent uploaded content from being executed unexpectedly. Do not trust the browser-provided filename or MIME type alone. Consider metadata, SVG or active content, image processing limits, and access controls for private files. Test direct download paths as well as the upload form so protected media is not publicly reachable by URL.
87. How would you defend an external-fetch feature against SSRF?
Restrict accepted destinations and schemes, use supported safe HTTP request mechanisms where appropriate, and account for redirects, DNS resolution, and internal network targets. Apply timeouts and response-size limits. A URL being syntactically valid does not make it safe for the server to fetch. Prefer an explicit destination allowlist for integrations with known providers, and test attempts to reach loopback, metadata, and private-network addresses.
88. How would you handle a payment webhook reliably?
Verify the provider's signature against the exact request representation it specifies, validate event identity and timing rules, and process the event idempotently. Persist receipt and processing state so retries can be reconciled. Do not trust a browser's payment-success redirect as proof of payment. Return appropriate responses promptly and move slow work to a reliable background path, while keeping an auditable relationship between external events and local order state.
89. How would you prevent duplicate form submissions from creating duplicate records?
Assign a stable operation identifier and enforce deduplication at a durable boundary, ideally with a database constraint or transaction suited to the storage model. A disabled submit button is only a usability aid. Handle retries after timeouts by returning or reconciling the existing result. A WordPress nonce does not provide exactly-once semantics, so it cannot replace an explicit idempotency design for consequential operations.
90. How would you design cache invalidation for an editorial site?
Map which content changes affect which pages, feeds, API responses, and fragments, then invalidate or refresh those dependencies through supported lifecycle hooks. Include taxonomy edits, menus, user-visible metadata, and scheduled publication. Balance correctness with the cost of broad purges. Test a realistic correction workflow end to end so editors know when a change becomes visible across the origin, CDN, and any headless frontend.
91. How would you investigate stale content after a deployment?
Determine whether the response comes from the browser, CDN, page cache, object cache, or database, then inspect the selected template and deployed asset version. In block themes, database-stored template customizations may override files. Compare a cache-bypassed authorized request with ordinary visitor behavior. Purging everything can temporarily conceal the cause; identify the missing invalidation or precedence rule so the next deployment behaves predictably.
92. How would you scale a high-traffic WordPress site?
Measure the bottleneck first, then combine suitable caching, efficient queries, optimized media, adequate PHP workers, database capacity, and a reliable deployment topology. Separate user-specific traffic from cacheable responses and plan shared storage and background work. Scaling web servers does not solve a saturated database or serialized external dependency. Use realistic load tests and recovery exercises, including cache misses, so capacity estimates reflect more than a warm homepage.
93. How would you diagnose PHP worker exhaustion?
Inspect request duration, concurrency, slow logs, external calls, database waits, and queueing before increasing worker counts. More workers can exhaust memory or overwhelm the database. Identify which routes consume time and whether traffic is legitimate, automated, or retry-driven. Apply bounded timeouts and optimize the dominant work, then load-test. A successful static page response does not reveal the health of uncached admin, checkout, or API requests.
94. How would you optimize a slow WordPress homepage?
Break down server response time, database work, remote calls, asset loading, and rendering performance. Measure logged-out and logged-in behavior separately because caching differs. Reduce unnecessary queries and assets, optimize media, and ensure the chosen cache strategy preserves content correctness. Avoid installing multiple overlapping optimization plugins without a hypothesis; their interactions can obscure measurements or break scripts while improving only a synthetic score.
95. How would you investigate a database deadlock or race condition?
Capture the conflicting operations and transaction boundaries, then inspect lock order, indexes, isolation behavior, and retry handling. WordPress helper calls do not automatically make a multi-step business workflow atomic. Reproduce the concurrency pattern with controlled tests and define a consistent update strategy. Retrying can be appropriate for transient deadlocks, but only when the complete operation is safe to repeat and partial external effects are reconciled.
96. How would you evolve a plugin database schema without downtime?
Use compatible staged changes: add new structures, deploy code that can work during transition, backfill in bounded batches, switch reads or writes deliberately, then remove old structures only after verification. Track migration progress and rollback constraints. Test with old and new workers coexisting. A single blocking schema operation during a web request can cause an outage, especially when the data volume differs greatly from development.
97. How would you manage configuration across development, staging, and production?
Separate code, environment-specific configuration, and editorial data, with secrets supplied through an appropriate protected mechanism. Prevent staging from sending production emails or processing real webhooks unintentionally. Define which settings are deployed and which remain administrator-owned. A database copy can overwrite credentials, URLs, and feature flags, so migration scripts must handle those differences deliberately and verify the destination before enabling traffic.
98. How would you build a safe deployment rollback?
Keep versioned application artifacts and configuration, define health checks and rollback criteria, and consider database compatibility before rollout. Reverting code does not undo a destructive migration or restore deleted content. Prefer backward-compatible changes and verified backups for data recovery. Exercise rollback in staging with representative state, including caches and background workers, so the procedure remains usable when a production release fails under load.
99. How would you assess whether Multisite is appropriate?
Choose Multisite when sites benefit from shared code, centralized administration, and a coordinated operational model. Evaluate tenant isolation, plugin compatibility, domain mapping, user management, backup granularity, and independent release needs. Separate installations may fit better when customers require stronger autonomy or different extension stacks. Do not choose Multisite solely to reduce installation count without considering how one broken update can affect the entire network.
100. How would you perform a large Multisite batch operation?
Enumerate the intended sites in bounded batches, switch context carefully, persist progress, and restore context on every path. Make each site's work retry-safe and log failures without exposing sensitive data. Avoid loading the entire network into memory or assuming every site has identical plugins and schema. Include a dry-run or preview where feasible and verify a sample plus aggregate outcomes before declaring the network-wide operation complete.
101. How would you design an integration with an unreliable external API?
Use bounded timeouts, controlled retries with backoff, caching where semantics permit, and a clear fallback for unavailable data. Persist work that must eventually complete and provide reconciliation for ambiguous outcomes. Do not make every page request synchronously depend on an unstable service. Distinguish a harmless stale display from a consequential transaction, because the acceptable fallback and idempotency requirements differ substantially.
102. How would you make a background queue observable?
Track pending count, age of the oldest job, processing duration, attempts, failure categories, and completion rate. Include correlation identifiers that connect a job to the initiating request or business record. Alert on user impact and stalled progress, not only a large count. Provide a controlled retry and cancellation interface, and retain enough history to determine whether an apparently failed job already performed an external side effect.
103. How would you review a third-party plugin before adoption?
Evaluate maintenance activity, compatibility, security history, required privileges, data handling, performance impact, licensing, and the quality of its integration surface. Test the specific workflows and upgrade path in a safe environment. Popularity is useful context but not proof of suitability. Identify an owner and an exit strategy, especially when the plugin controls business-critical data or relies on an external service that may change.
104. How would you test WordPress-specific behavior effectively?
Use focused unit tests for isolated business rules, WordPress integration tests for hooks, queries, permissions, and persistence, and browser tests for important user journeys. Test low-privilege and anonymous paths as well as successful administration. Mock external services deliberately without claiming that mocks prove integration compatibility. A balanced suite catches contract failures while avoiding brittle assertions about incidental markup or internal implementation details.
105. How would you test custom block compatibility across versions?
Maintain fixtures containing saved content from supported block versions and test parsing, editor validation, migration, and frontend output. Exercise supported WordPress and browser combinations, including relevant editor iframe behavior. Verify accessible interaction and content preservation, not just a clean build. A new block inserted today cannot reveal whether yesterday's serialized content still works after an upgrade.
106. How would you evaluate an AJAX or REST endpoint for abuse?
Assess authentication, object authorization, input bounds, expensive operations, rate controls, caching, and error leakage. Consider both anonymous traffic and authenticated users abusing their allowed access. A nonce is not a rate limiter or permission model. Measure the cost of worst-case accepted inputs and ensure failures are bounded so an endpoint cannot consume all workers or trigger unbounded remote requests.
107. How would you handle a stored XSS vulnerability?
Fix the unsafe rendering boundary with context-appropriate escaping or an explicit HTML allowlist, then assess and clean affected stored content through a controlled process. Investigate whether privileged sessions or credentials were exposed. Sanitizing only future submissions may leave existing payloads active. Add regression cases for the real output contexts and verify that the correction preserves legitimate content without allowing another rendering path to reintroduce execution.
108. How would you design permissions for a collaborative publishing workflow?
Map who can create, edit owned content, edit others' content, approve, publish, and manage settings, then implement capabilities and workflow rules accordingly. Enforce them in the server-side operations and API paths, not only the editor interface. Test transitions and ownership changes. Keep a clear audit trail and avoid granting broad administration merely because an editor needs one additional publishing capability.
109. How would you design a large content import?
Validate a representative sample, map stable external identifiers, and process records in restartable batches with explicit create, update, and conflict rules. Preserve relationships, media references, and publication states. Track progress and errors durably, and avoid rerunning the same import as duplicate content after a timeout. Reconcile counts and representative records afterward; an import that exits successfully can still contain incorrect associations or silently skipped fields.
110. How would you preserve SEO behavior during a redesign?
Inventory important URLs, canonical behavior, redirects, metadata, structured data, internal links, and indexability before changing templates or routing. Test the rendered result and response codes, including pagination and archives. Keep meaningful URLs stable where possible and map necessary changes deliberately. A new theme or SEO plugin does not automatically preserve the old site's behavior, and a visually correct page can still expose duplicate or blocked content.
111. How would you handle privacy-sensitive data in WordPress?
Collect only necessary data, define retention and access policies, protect storage and backups, and account for exports, logs, analytics, and external integrations. Use platform privacy mechanisms where they fit and test custom data handling alongside plugins. Legal requirements depend on context and jurisdiction, so translate them with the responsible specialists. Deleting one user row does not necessarily remove their data from orders, uploads, logs, or third-party systems.
112. How would you diagnose failed scheduled publication?
Check the post's schedule and timezone, due cron events, request-trigger behavior, loopback access, errors, and any external scheduler configuration. Determine whether the task was never triggered or ran and failed. Test a bounded scheduled event and inspect logs. Simply rescheduling the post can hide a broken scheduler that also affects updates, emails, and other background workflows.
113. How would you reduce plugin coupling?
Define explicit interfaces and hook contracts, avoid reaching into another plugin's private classes or tables, and handle missing or incompatible dependencies gracefully. Keep shared business data ownership clear so deactivating one extension does not corrupt another's state. Test supported combinations and document required versions. A filter hook is useful only when its arguments, return value, timing, and compatibility expectations are treated as a contract.
114. How would you modernize a legacy theme incrementally?
Inventory templates, business logic, dependencies, accessibility issues, and custom editor behavior, then separate durable functionality from presentation. Improve the highest-risk areas in small compatible steps, with visual and behavioral regression coverage. Introduce block or theme.json capabilities where they solve a real need. A complete rewrite is not automatically safer; preserve content and editorial workflows while reducing the amount of legacy behavior that must change at once.
115. How would you choose between a custom block and a pattern?
Use a pattern when existing blocks can express the layout and behavior, and use a custom block when the content model or interaction requires a distinct editing and rendering contract. Consider maintenance, accessibility, translations, serialization, and editor training. A custom block creates long-term compatibility obligations. Prototype the authoring experience with actual editors before adding code that merely reproduces a reusable arrangement of core blocks.
116. How would you design an emergency content-correction workflow?
Identify who can make the correction, which approval is required, and how it propagates through caches, feeds, search, and external consumers. Provide a way to verify the visitor-visible result promptly without granting unnecessary technical privileges. Preserve revision history and incident context where appropriate. A workflow is incomplete if the CMS shows the corrected text while a CDN or headless frontend continues serving the old version.
117. How would you separate content permissions from deployment access?
Treat editorial capabilities, hosting credentials, repository permissions, and deployment automation as separate boundaries. An editor who can publish an article does not automatically need permission to install executable code. Define roles around real responsibilities, review capability mappings, and audit both CMS and infrastructure changes. Verify the arrangement with representative accounts, including attempts to install plugins or change protected configuration. Document emergency access and revoke temporary privileges after use.
118. How would you validate a disaster-recovery plan for a WordPress site?
Restore a representative database and uploaded media into an isolated environment, deploy matching code and configuration, then test login, rendering, search, scheduled work, and external integrations. Measure actual recovery time and data loss against agreed targets. Disable outbound production actions in the recovery environment. A backup job reporting success is insufficient evidence of recoverability; test missing credentials, corrupted files, and the procedure for switching traffic safely.
119. How would you preserve editorial workflows when changing the content model?
Map existing fields, statuses, relationships, templates, and integrations before introducing the new model. Provide reversible or repeatable migration steps, preserve identifiers where consumers depend on them, and give editors a representative preview. Test drafts, revisions, scheduled posts, and permissions as well as published pages. Roll out with explicit ownership of reconciliation and rollback, because a schema migration can succeed while the editorial process becomes unusable.
120. How would you evaluate a senior WordPress developer's architectural judgment?
Ask them to explain content ownership, request flow, authorization, storage, cache invalidation, deployment, and recovery for a concrete site. Introduce a traffic spike or failed plugin update and examine how they diagnose it. Strong candidates connect WordPress APIs to operational consequences and acknowledge what requires testing. Evaluate maintainability and evidence-based trade-offs rather than rewarding a long list of plugins or a preference for custom code in every situation.
WordPress Documentation and Further Reading
Use these primary WordPress references to check API contracts, security expectations, and current theme and block behavior. Test changes against the versions and extensions supported by the actual site, including editorial permissions, caches, and deployment procedures.
Similar Posts
