# wppoland.com, full markdown digest
> Curated long-form Markdown for retrieval-augmented LLM agents. Includes the canonical EN service pillars and top EN blog posts. For the short index see /llms.txt. For other locales, fetch any URL with `Accept: text/markdown` content negotiation.
Source of truth: https://github.com/wppoland/wppoland-new
Generated at build time, 52 pillars + 60 blog posts.
---
# Service pillars
## AI-built website rescue and remediation
URL: https://wppoland.com/en/ai-built-website-rescue/
Description: Audit and repair for WordPress and WooCommerce sites built or heavily modified by AI. Senior review of vibe-coded plugins, security holes, broken flows, and AI-slop content.
Published: Sat Jun 20
Updated: Fri Jul 10
Type: guide
Level: advanced
## What this service fixes
AI can build a WordPress or WooCommerce site fast. It cannot take responsibility when that site leaks data, breaks checkout, or quietly fills Google with duplicate pages. This service is the senior cleanup after the AI: we audit what was generated, find what is unsafe or broken, and fix it, with a human accountable for every change.
This is not the same as our general [WordPress repair and technical support](/en/wordpress-repair-service-technical-support/) or a standard [WordPress security audit](/en/wordpress-security-audit/). Those assume a site built by people. Here the failure patterns are specific to generated code and content, and the remediation is different.
## How AI-built sites tend to break
The damage clusters into a few recognisable patterns. A typical case is a WooCommerce store where an AI-generated checkout customisation skipped nonce verification, so the cart could be manipulated through a forged request, and nobody noticed until chargebacks started. Another is a marketing site where an assistant generated forty near-identical service pages that compete for the same query, so none of them rank and the whole domain looks thin to Google.
Other recurring failures:
- Generated PHP that calls functions that do not exist, or that were hallucinated from a different plugin's API.
- Admin-ajax and REST endpoints registered without a capability or nonce check.
- Unsanitised form input written straight into the database or echoed back into the page.
- Plugin sprawl: ten plugins installed to solve a problem one line of code would have handled, dragging Time to First Byte over a second.
- Content with confident but wrong facts, fabricated statistics, and invented client names.
- Migrations the AI "finished" that silently dropped redirects, breaking indexed URLs.
## Symptom triage: rescue vs rebuild
Not every broken AI-built site needs the same response. The symptom usually points to whether a targeted rescue is enough or the foundation should be replaced. Use this table as a first-pass triage before you commit budget or downtime.
| Symptom | Likely cause | First action |
| --- | --- | --- |
| Checkout or cart fails intermittently | AI-wired WooCommerce hooks, missing nonce on cart mutations | Pause paid traffic; run a functional audit on the checkout path |
| Subscriber or anonymous user can trigger admin AJAX | Missing `current_user_can()` on a `wp_ajax` handler | Security pass on generated PHP; see [auditing AI-generated plugin code](/en/auditing-ai-generated-wordpress-plugin-code/) |
| Scanner flags critical CVEs on common plugins | Outdated versions installed during a fast AI-assisted build | Run a [WordPress security audit](/en/wordpress-security-audit/) and patch or remove exposed plugins |
| Forty near-identical service pages, none rank | AI content cannibalisation and thin duplication | Content inventory; consolidate or noindex duplicates |
| White screen or fatal error after a small change | Hallucinated function calls in generated custom code | Code inventory against developer.wordpress.org; scope rescue vs rewrite |
| Time to First Byte above one second on a simple page | Plugin sprawl from "install a plugin for that" answers | Performance strip-down; measure before adding more tooling |
| Form saves but stored data looks corrupted or executable | Unsanitised `$_POST` written straight to options or post meta | Plugin code audit; treat as active XSS or injection risk |
| REST or admin-ajax endpoint returns data it should not | Missing `permission_callback` or nonce on custom routes | Endpoint audit; block public access until fixed |
| Owner wants to keep using AI in the build | No review gate, no version control on generated output | Rescue first, then guardrails; see remediation stages below |
If most rows point to isolated, fixable gaps in otherwise sound WordPress core usage, rescue is usually the cheaper path. If hallucinated APIs, missing security primitives, and plugin sprawl show up together across custom code and content, plan for a partial or full rebuild and say so before repair work starts.
## What we check in an AI-build audit
The audit inventories everything the AI touched and triages it by two axes: security risk and revenue risk. We separate the code AI wrote, the plugins it chose, and the content it produced, because each needs a different fix. You get a written split of what is safe to keep, what must be rewritten, and what should be removed, with the reasoning behind each call.
## Remediation stages
Remediation follows a fixed order so security and revenue risks close before cosmetic work. Stages can overlap in calendar time, but we do not skip ahead to performance tuning while checkout is still broken or a public endpoint still leaks data.
| Stage | Focus | Deliverable |
| --- | --- | --- |
| 1. Inventory and triage | Map every AI touchpoint: custom PHP, plugin choices, content, migrations | Written keep / rewrite / remove split with reasoning |
| 2. Security pass | Nonces, capabilities, sanitisation, exposed AJAX and REST routes | Patched or removed vulnerable handlers; [plugin code audit](/en/auditing-ai-generated-wordpress-plugin-code/) findings closed |
| 3. Functional repair | Checkout, forms, CRM and payment integrations | Broken user flows restored and regression-checked |
| 4. Content remediation | Duplicate pages, hallucinated facts, thin AI filler | Consolidated pages that can rank; corrected or removed false claims |
| 5. Performance recovery | Plugin bloat, render-blocking assets, cache misconfiguration | Core Web Vitals back in range on key templates |
| 6. Guardrails | Version control, staging workflow, review checklist for future AI use | Short runbook so the next prompt does not reopen the same holes |
Emergency items (active exploit, broken checkout during a campaign, legal or compliance exposure) jump the queue inside stage 2 or 3 regardless of where the rest of the site sits in the table.
## Security gaps generated code commonly ships
Generated WordPress code passes the "it runs" test while failing the "it is safe" test. We test directly for the gaps that matter: missing `wp_verify_nonce` and `current_user_can` checks, input that reaches the database without `sanitize_*` or prepared statements, output that skips `esc_*`, PHP files reachable without an `ABSPATH` guard, and endpoints exposed without authorisation. The failure patterns repeat often enough that we published a diagnostic walkthrough in [auditing AI-generated WordPress plugin code](/en/auditing-ai-generated-wordpress-plugin-code/). Where the security surface is large, this connects to a full [WordPress security audit](/en/wordpress-security-audit/). We documented the real CVE patterns these stacks carry in [outdated-plugin CVEs](/en/wordpress-security-audit-outdated-plugins-cve-2026/).
## Content remediation, not just code
A site built with AI usually has an AI-content problem too. We deduplicate pages that cannibalise each other, correct hallucinated facts and round-number fake statistics, and consolidate thin pages into ones that earn citations. This is the same discipline behind [GEO and LLMO optimisation](/en/geo-llmo-optimization/): content that is accurate and distinct, not generated filler.
## Performance recovery
AI tends to solve problems by adding plugins. We reverse that: remove the bloat, replace plugin stacks with targeted code, and bring Core Web Vitals back into range. The dedicated [Core Web Vitals rescue for AI-built WordPress sites](/en/core-web-vitals-rescue-ai-built-wordpress/) page walks through the staged teardown, measurement checklist, and the anonymised case where median uncached TTFB dropped from 1.47 s to 0.68 s after cutting 38 plugins to 21. See [plugin sprawl after an AI build](/en/plugin-sprawl-ai-wordpress-build/) for the full diagnostic and [AI-slop content cleanup](/en/ai-slop-content-cleanup-wordpress/) when hallucinated facts need editorial triage. For a formal audit scope, the [Core Web Vitals audit](/en/services/core-web-vitals-audit/) service covers the same metrics with a written backlog.
## Rescue, rebuild, or do it right next time
After the audit you get an honest recommendation. If most of the AI output is salvageable, a targeted rescue is the cheapest path. If the foundation is unsound, we scope a rebuild instead of patching forever. When rebuild is the right call, our [agency rescue case study](/en/case-study-astro-migration-agency-rescue-2026/) documents a full stack migration where load time went from 12 s to 0.3 s after a bad agency delivery. And if you want to keep using AI in the build, but safely, with a human gate, that is exactly what our [AI implementation for companies](/en/services/ai-implementation/) covers: agents and tooling with version control, tests, and review built in.
## What you get
A working, accountable site: insecure generated code rewritten, broken flows repaired, AI-slop content cleaned, performance restored, and a short guardrails document so the next round of AI assistance does not reopen the same holes. Every change is reviewed by a senior engineer, not applied autonomously.
## Related services
- [Auditing AI-generated WordPress plugin code](/en/auditing-ai-generated-wordpress-plugin-code/), Diagnostic patterns for vibe-coded PHP before you ship
- [WordPress security audit](/en/wordpress-security-audit/), Deep security pass for high-risk generated code
- [WordPress repair and technical support](/en/wordpress-repair-service-technical-support/), Ongoing support after the rescue
- [AI implementation for companies](/en/services/ai-implementation/), Using AI in the build safely, with human gates
- [Core Web Vitals rescue for AI-built sites](/en/core-web-vitals-rescue-ai-built-wordpress/), Staged performance recovery after AI plugin sprawl
- [Core Web Vitals audit](/en/services/core-web-vitals-audit/), Formal audit with written backlog
- [Agency rescue case study](/en/case-study-astro-migration-agency-rescue-2026/), Full rebuild when rescue alone is not enough
- [GEO and LLMO optimisation](/en/geo-llmo-optimization/), Turning cleaned content into citations
Pricing is individual and scoped after the audit. [Contact us](/en/contact/) with the site and a short note on how it was built.
---
## AMP for WordPress, speed and Core Web Vitals
URL: https://wppoland.com/en/amp-accelerated-mobile-pages-en/
Description: Make your WordPress site fast with AMP. Accelerated Mobile Pages implementation for better Core Web Vitals, mobile speed optimization, and improved user experience.
Published: Sun Jan 01
Updated: Sat Jan 31
Type: guide
Level: advanced
## What is AMP Service?
AMP (Accelerated Mobile Pages) implementation service makes your WordPress site load instantly on mobile devices. With scope agreed individually, we deliver:
- **AMP Implementation** - Official AMP plugin setup with three modes (Standard, Transitional, Reader)
- **Core Web Vitals Optimization** - Achieve sub-1-second LCP, optimal FID, and zero CLS
- **Schema.org Markup** - Structured data for Top Stories carousel and rich results
- **Analytics Integration** - Track performance with amp-analytics
- **Testing & Validation** - Full validation with Google Search Console
## Who Needs AMP?
### News Publishers
Essential for Top Stories carousel placement. AMP ensures your news articles load instantly and qualify for Google's premium mobile positions.
### E-commerce Sites
Reduce mobile bounce rates with near-instant page loads. AMP-compatible WooCommerce integration available.
### Businesses in Emerging Markets
Critical for regions with poor internet infrastructure. AMP Cache serves content from Google's global CDN.
### Sites with Limited Dev Resources
Get enterprise-level mobile performance without complex custom development.
## Where Does AMP Work?
AMP optimization benefits your site across multiple touchpoints:
- **Google Search** - Top Stories carousel, rich results, AMP badges
- **Mobile Devices** - Near-instant loading on all mobile browsers
- **Slow Connections** - Optimized delivery via AMP Cache
- **Social Media** - Faster sharing and preview experiences
- **Email** - AMP for Email interactive experiences
## AMP Service Pricing
Our AMP implementation service includes, with scope agreed individually:
### Basic Package (individual quote)
- Official AMP plugin installation and configuration
- Standard mode or Transitional mode setup
- Basic theme compatibility adjustments
- Schema.org markup implementation
- Google Search Console validation
- Core Web Vitals baseline report
### Advanced Package (individual quote)
- Everything in Basic, plus:
- Custom AMP template development
- WooCommerce AMP integration
- Advanced analytics setup
- AdSense/ad integration
- Page builder compatibility
- Performance monitoring dashboard
### Enterprise Package (individual quote)
- Everything in Advanced, plus:
- Multi-site AMP implementation
- Custom component development
- A/B testing setup
- Monthly performance reports
- Priority support for 6 months
### Factors Affecting Price:
- Theme complexity and customizations
- Number of custom post types
- WooCommerce product catalog size
- Third-party integrations required
- Multi-language requirements
[Get a custom quote](/en/contact/) for your WordPress site.
## What Are AMP (Accelerated Mobile Pages)?
AMP (Accelerated Mobile Pages) is an open-source HTML framework developed by Google and the AMP Open Source Project to create fast-loading web pages for mobile devices. Launched in 2015, AMP was designed to address the growing need for faster mobile web experiences, especially in regions with limited internet connectivity.
The core principle behind AMP is simple: strip down web pages to their essential content and eliminate elements that slow down loading times. This is achieved through a combination of simplified HTML, restricted JavaScript usage, and the AMP Cache system that serves content from Google's servers.
## Where AMP actually stands in 2026
A reality check before we go further: AMP is not a 2026 best practice. It is a 2015-era framework that Google demoted in 2021 when the Top Stories carousel stopped requiring it. Mobile-first indexing did not save AMP, because AMP was never the only way to be fast on mobile, and Core Web Vitals replaced it as the metric Google actually cares about.
What AMP does well, technically, has not changed. Strict CSS limits, no arbitrary JavaScript, and prefetching from Google's CDN produce sub-1-second LCP almost by default, low CLS because layout rules are enforced, and predictable INP because there is no third-party script chaos. If you are working with a small team and need a mobile variant that is hard to make slow, AMP still delivers on that narrow promise.
What AMP does not do anymore is buy you preferential search treatment. The AMP badge is gone in most markets. Top Stories ranks canonical URLs with good Core Web Vitals just as readily as AMP URLs. The crawl-efficiency argument matters only at very large scale. So if you are considering AMP for the SEO upside specifically, that upside is mostly historical at this point.
## How AMP Works
### AMP HTML
AMP uses a specialized version of HTML with custom tags and restrictions:
- All CSS must be inlined and limited to 75KB
- JavaScript is restricted to AMP-approved components
- Images and videos use lazy loading by default
- Third-party scripts are sandboxed to prevent blocking
### AMP Cache
Google's AMP Cache stores AMP pages and serves them directly from Google's infrastructure, providing:
- Pre-validation of AMP pages
- Compression and optimization
- Global CDN distribution
- Near-instantaneous delivery
### AMP JavaScript
The AMP JS library implements best performance practices:
- Asynchronous loading of all resources
- Pre-calculation of layout before loading
- Sandboxed iframes for third-party content
- Built-in analytics support
## The WordPress AMP plugin landscape in 2026
Before touching anything, look at what is actually still maintained.
The official **AMP** plugin (`amp` on WordPress.org, formerly "AMP for WordPress") is the only one I would still install on a new project. It is the plugin Google and Automattic backed, and it still ships updates against current WordPress and PHP versions. Three modes: Standard (the whole site is AMP), Transitional (AMP and canonical coexist), Reader (legacy templates, mostly relevant for old blogs you do not want to rebuild). Standard mode is the cleanest, but it will surface every theme incompatibility you have. Most paid themes from 2018-2020 break Standard mode in ways that take a day to fix.
**AMP for WP, Accelerated Mobile Pages** by Ahmed Kaludi and Mohammed Kaludi is the other plugin most clients arrive with. It is more permissive about ads, page builders, and WooCommerce, which is why agencies pushed it. Update cadence has slowed, GitHub issues sit open for months, and the WooCommerce add-ons broke in several WC 8.x releases. Functional, but I now treat it as legacy code I am migrating off, not a fresh choice.
**Penci AMP**, **Schema AMP** and the long tail of theme-bundled AMP plugins are mostly abandoned. If a client is on one of these, the migration question is not "if" but "when".
Whichever plugin you are on, the setup that actually matters is small: pick Standard or Transitional, run the AMP validator from Search Console (while it still exists), wire `amp-analytics` to your existing GA4 property, and audit which canonical-page features silently disappear on the AMP variant. The plugin's UI will not warn you when it strips your contact form's reCAPTCHA or your booking widget's JavaScript.
## What actually breaks in production
The AMP failure modes I keep seeing on real client sites, not the theoretical ones from the docs:
**Validation errors after a plugin update.** A perfectly valid AMP variant breaks the morning after someone activates a popup plugin, a chat widget, or a new analytics snippet. The non-AMP analytics tag injects inline JavaScript, and AMP rejects the whole page. The fix is removing the offending plugin's frontend output from the AMP variant via the official plugin's "Plugin Suppression" panel, but every new plugin reopens the question.
**The 75 KB inline CSS limit.** AMP requires all CSS inlined into a single `
```
**After cleanup:**
```html
Your Page Title
```
### Tools to verify
1. **View Page Source** (`Ctrl+U`): Check `` section
2. **Chrome DevTools**: Network tab shows HTTP requests
3. **PageSpeed Insights**: See reduction in HTML size
4. **GTmetrix**: Compare before/after page weight
## Performance impact
**Typical improvements:**
- **HTML size**: -2KB to -5KB per page
- **HTTP requests**: -3 to -8 requests per page
- **JavaScript**: -15KB (emoji script)
- **CSS**: -5KB (emoji styles)
- **Page load time**: -50ms to -200ms
**Real-world example:**
- Before: 45KB HTML, 12 HTTP requests in ``
- After: 40KB HTML, 4 HTTP requests in ``
- Improvement: 11% smaller HTML, 67% fewer requests
## Security considerations
### WordPress version hiding
Removing the generator tag is good, but:
1. **Plugins still reveal version**: Check plugin headers
2. **Readme.html**: Delete `/wp-content/readme.html`
3. **Login page**: Version shown in source (harder to hide)
4. **REST API**: May reveal version in responses
**Complete version hiding:**
```php
// Remove from head (already done above)
remove_action( 'wp_head', 'wp_generator' );
// Remove from RSS
add_filter( 'the_generator', '__return_empty_string' );
// Remove from login page (advanced)
add_filter( 'login_headertext', function() {
return get_bloginfo( 'name' );
} );
```
## Best practices
### 1. Test before deploying
Always test cleanup on a staging site first. Some plugins/themes may depend on removed elements.
### 2. Keep what you need
…[truncated, fetch the canonical URL for the full body]…
---
## Headless WordPress sitemap and canonical: one source of truth, served from the front
URL: https://wppoland.com/en/headless-wordpress-sitemap-canonical/
Description: In a headless WordPress build, the sitemap and the canonical URL must be rendered by the front end, not the WordPress origin. This is the specific pattern that prevents two sitemaps and two canonical URLs from competing.
Published: Tue Apr 14
Updated: Tue Apr 14
Type: guide
Level: intermediate
Tags: headless-wordpress, sitemap, canonical, astro, nextjs, schema-org
# Headless WordPress sitemap and canonical: one source of truth, served from the front
Two of the seven [SEO patterns for headless WordPress](/en/seo-patterns-for-headless-wordpress/) deserve their own article because they break first and break silently. The sitemap and the canonical URL are the two signals Google trusts most for "what is this site, and which URL is the real one". A headless build that gets either wrong loses the rank it migrated to keep.
This article makes the pattern concrete. It assumes the architectural decision (Astro or Next.js per [the decision matrix](/en/headless-wordpress-nextjs-vs-astro-2026/)) is already made.
## The pattern, in one paragraph
Generate the sitemap from the front-end framework, with URLs that match the actual public site. Render the canonical URL as `` in the HTML head, sourced from WordPress (Yoast or Rank Math) and emitted by the front. Disable or 301 the WordPress origin sitemap and origin canonical. One sitemap, one canonical per page, both rendered server-side.
## Why two sitemaps is the default failure mode
WordPress 5.5 introduced `/wp-sitemap.xml` as a core feature. Every WordPress install since has it on by default. SEO plugins (Yoast, Rank Math) generate their own sitemaps that override or supplement the core one. A headless build that ignores this ends up with three sitemaps on the same hostname:
1. `/wp-sitemap.xml` from WordPress core.
2. `/sitemap_index.xml` from Yoast or Rank Math.
3. `/sitemap.xml` from the front-end framework.
Search Console sees overlap, sometimes flags inconsistency, and the actual indexed URLs become a function of which sitemap Google reads first that day. The fix is mechanical:
- The front-end framework generates the canonical sitemap at one well-known path (we use `/sitemap-index.xml` because Cloudflare Pages serves it cleanly).
- The WordPress origin sitemap is disabled (Yoast and Rank Math both have a toggle) or 301-redirected to the front-end sitemap.
- The WordPress core sitemap at `/wp-sitemap.xml` is also 301'd to the front-end equivalent.
After the cutover, only one sitemap responds 200 OK. The rest 301 or 404.
## How the front-end sitemap is built
Two real options for an Astro or Next.js front:
**Build-time generation.** The front-end build pulls every published post, page, and term URL from the WordPress origin during the build, sorts them, and emits the XML. This works for sites with predictable publishing cadence (most sites). Cache invalidation is handled by triggering a rebuild on publish.
**On-demand at the edge.** A Cloudflare Worker route generates the sitemap on request, reading from a cached list of URLs that the WordPress origin pushes via webhook on publish. This works for sites with high publish frequency where rebuild latency would be a problem.
We default to build-time generation. The Worker pattern is reserved for sites publishing more than a few times per hour.
## How the canonical URL is rendered
The canonical URL must be in the HTML head, in the initial server response, before any client-side script runs. The pattern:
```html
```
Three rules.
**One, render server-side.** Astro renders this from the page frontmatter or from the layout. Next.js renders it from `metadata` (App Router) or from `` in `getServerSideProps` paths. The thing to avoid is updating the canonical URL in a client effect; generative engines and many AEO surfaces parse the initial HTML only.
**Two, source from WordPress.** Yoast and Rank Math both expose the canonical URL per post via REST. The front fetches it during build (or per request) and renders it in HTML. WordPress remains the source of truth.
**Three, self-referential by default.** Every URL declares itself as canonical unless there is an explicit reason to point elsewhere (paginated archives, parameterised filtered URLs, syndicated content). When pointing elsewhere, the destination canonical points back at itself.
## Edge cases that bite
- **Trailing slash inconsistency.** WordPress permalinks usually end with `/`. The front-end framework may default to no trailing slash. Pick one, redirect the other, and never let both exist.
- **HTTP vs HTTPS, www vs apex.** Usually solved at the CDN, but the canonical URL must declare the chosen variant. We declare `https://` apex; everything else 301s to it.
- **Filtered URLs (faceted catalogue search).** These often produce thousands of thin URL variants. Their canonical points to the unfiltered base; they also have `noindex` to keep them out of the sitemap.
- **Paginated archives.** Page 2, page 3, etc. each canonical to themselves, with `rel="prev"` and `rel="next"` for clarity. Some teams point the canonical to page 1; that loses unique pages from the index. We do not recommend it.
- **Translated content.** Each language variant canonical to itself, with `` for siblings. The hreflang map is self-referential and must agree across all language variants.
## Validation before going live
Two checks we run on every headless WordPress build:
**Sitemap diff.** Generate the new sitemap, compare against the legacy WordPress sitemap by URL set. Anything missing from the new one is a content gap. Anything new is a regression suspect (often a draft or a private post leaking).
**Canonical sample.** For 50 high-traffic pages, request the URL on the new front and assert the canonical in HTML head matches the URL itself (or matches the expected target if intentionally cross-canonical). One mismatch is a bug; ten mismatches is a pattern that needs the front-end build re-checked.
Both checks run in CI. A new build that fails either one does not deploy.
## Where this fits
Anchored to the [SEO patterns for headless WordPress](/en/seo-patterns-for-headless-wordpress/) checklist. Pairs with the [Headless WordPress service pillar](/en/services/headless-wordpress/) and the [Next.js vs Astro decision matrix](/en/headless-wordpress-nextjs-vs-astro-2026/) for the broader build-time decisions.
---
## WordPress vs. Contentful 2026: Headless CMS architecture for enterprise
URL: https://wppoland.com/en/wordpress-vs-contentful-2026-headless-comparison/
Description: Choosing between WordPress and Contentful in 2026? This 2000+ word comparison dives into Headless architectures, API-first delivery, total cost of ownership, and developer experience.
Published: Tue Apr 08
Updated: Tue Apr 08
Type: guide
Level: advanced
Tags: wordpress-vs-contentful, headless-cms, api-first, enterprise-architecture, performance-2026
## WordPress vs. Contentful 2026: The battle of headless CMS architectures
By 2026, the term "CMS" has undergone a radical transformation. We no longer just manage pages; we manage **content graphs**. As omnichannel delivery becomes the standard, the choice between **WordPress** (in its Headless or Hybrid capacity) and **Contentful** (the pure SaaS Headless king) has become a primary architect-level decision.
In this exhaustive 2000-word analysis, we explore the technical, financial, and strategic implications of choosing between the world's most popular CMS and the industry leader in Composable Content.
---
## 1. The core architecture: Document-Based vs. Schema-First
### WordPress: The evolution to decoupled
WordPress was born as a blogging engine - a document-based system. However, in 2026, it is a **Hybrid Framework**.
- **The Hybrid Advantage**: You can use WordPress for a traditional website while simultaneously exposing all data via **WPGraphQL**.
- **Ease of Use**: Marketing teams can still use the visual block editor (Gutenberg) to see their content, even if the actual frontend is a separate React or Astro application.
### Contentful: The pure-Play headless
Contentful is **API-First** and **Content-First**. It doesn't care about a website.
- **Content Modeling**: You start with a blank canvas and define "Content Types" (e.g., "Product," "Hero Banner," "Review").
- **Omnichannel Power**: Because the content is purely structured data, it is equally comfortable being consumed by a React website, a Flutter mobile app, an Apple Vision Pro interface, or an in-store kiosk.
---
## 2. Developer experience: React, next.js, and Astro 5
In the modern dev-stack of 2026, developers no longer want to write PHP templates. They want to consume JSON.
- **Working with WordPress**: Developers use **WPGraphQL**. It’s the standard for 2026. The ability to query only the data you need (e.g., "Give me the title and featured image of the last 5 posts") reduces payload sizes significantly.
- **Working with Contentful**: Contentful’s **Content Management API (CMA)** and **Content Delivery API (CDA)** are incredibly robust. They offer specialized SDKs for every major language. It feels like a software tool, whereas WordPress still feels like a content tool.
---
## 3. SEO & llm optimization (llmo)in 2026
The way AI models "ingest" your content depends on how clear your structure is.
| Metric | WordPress (Headless) | Contentful |
| :--- | :--- | :--- |
| **Schema Generation** | Easy via RankMath/Custom Plugins. | Must be manually defined in the frontend layer. |
| **Sitemap Control** | Automatic and highly granular. | Requires separate middleware or frontend logic. |
| **Semantic Clarity** | Blocks provide good context. | Highest; fields are strictly typed and modeled. |
| **LLM Indexing** | Excellent for long-form narrative. | Best for technical, data-heavy "Facts." |
**E-E-A-T Signal:** WordPress allows you to easily connect authors to authoritative "Expert" profiles. In Contentful, you have to build this entire relationship model from scratch.
---
## 4. Total cost of ownership (tco)in 2026
This is where the divergence is most visible.
**The WordPress TCO:**
- **License**: $0 (Global Open Source).
- **Hosting**: $50 - $200 (Managed VPS/Edge).
- **Scaling**: Linear. Serving 1 million users via a static frontend (Astro) with WordPress as the Headless source costs very little in server resources.
**The Contentful TCO:**
- **License**: Can scale from $0 (Free) to **$3,000+ per month** for Enterprise.
- **API Call Limits**: High traffic means higher API costs.
- **Management**: You don't have to manage the server, which saves dev time, but the monthly Saas tax is permanent and significant.
---
## 5. Security & governance
- **WordPress**: Security is a "Shared Responsibility." You must ensure your API endpoints are locked down and your WordPress core is updated. However, in 2026, **Headless WordPress** is inherently more secure because the "attack surface" (the public-facing part) is decoupled from the backend.
- **Contentful**: Security is "Managed." Contentful handles the backend security. You only need to worry about the security of your own API keys. For risk-averse enterprises that don't want to manage updates, Contentful's "walled garden" is attractive.
---
## 6. Performance: The speed of API content
When building a high-performance site **Edge Computation** is king.
- **Headless WordPress**: Using **WP Engine Atlas** or a custom Vercel/Netlify setup, you can pre-render your entire site. When an editor hits "Publish," the Headless WordPress sends a webhook to your CI/CD pipeline, rebuilding the static site in seconds.
- **Contentful**: Designed for this workflow. It is incredibly fast. However, because it is multi-tenant SaaS, you are occasionally subject to global API latency during peak hours, whereas a dedicated Headless WordPress instance on a high-tier VPS is entirely under your control.
---
## 7. The workflow challenge: Gutenberg vs. Form fields
This is the biggest pain point for marketing teams.
- **WordPress**: Authors love it. They can drag and drop blocks, see the layout, and use AI to generate images and text inside the editor.
- **Contentful**: Authors often find it "cold." You are filling out form fields. While Contentful's "Compose" app aims to bridge this gap, it still feels more like a database interface than a creative writing platform.
---
## 8. Case study: Omnichannel retailer 2026
A global retail brand needed to manage product descriptions across:
1. An e-commerce website.
2. An iOS/Android mobile app.
3. Interactive dressing room screens.
**The Choice**: They chose **Contentful**.
**The Rationale**: They didn't need a "Website" in the traditional sense; they needed a "Central Hub of Truth." Contentful’s strict modeling ensured that a product description updated once was reflected perfectly on all three devices with 100% API reliability.
---
## 9. Case study: High-Traffic educational blog 2026
A leading tech publisher was managing 50,000 articles.
**The Choice**: They chose **Headless WordPress**.
**The Rationale**: Contentful’s cost for 50,000 records was prohibitive. By using WordPress with **WPGraphQL**, they maintained their legacy data while building a fast frontend with **Astro 5**.
---
## 10. Wppoland comparison matrix 2026
| Feature | WordPress (Hybrid) | Contentful (Pure Headless) |
| :--- | :--- | :--- |
| **Market Share** | 45%+ | < 1% |
| **Customization** | Infinite (GPL) | Limited to API |
| **Plugin Ecosystem** | 60,000+ | Marketplace growing |
| **TCO** | Low to Medium | High (Enterprise) |
| **Ease for Editors**| High | Medium |
| **Developer DX** | High (WPGraphQL) | High (CMA/CDA) |
---
## 11. Faq: Frequently asked questions
1. **Can WordPress be used as a Headless CMS?**
Yes, and in 2026 i of the most stable and popular ways to do so.
2. **Is Contentful better for small projects?**
The free tier is great for small projects, but scaling becomes expensive very quickly.
3. **Does Headless WordPress hurt SEO?**
No. In fact, by allowing you to use frameworks like **Astro**, it can significantly *improve* your SEO scores.
4. **Is Contentful more secure than WordPress?**
Managed security is easier, but a hardened WordPress instance is just as secure for professional use.
5. **What is a "Hybrid CMS"?**
A system that allows you to use traditional templates *and* Headless APIs simultaneously. WordPress excels at this.
6. **Do I need a server for Contentful?**
No, it is 100% SaaS. However, you do need a server (or serverless platform like Vercel) for your frontend.
7. **Can I use WooCommerce Headless?**
Yes. Headless WooCommerce (using the REST API) is a powerful 2026 trend for high-perf stores.
8. **Is Contentful better for mobile apps?**
Generally yes, because it was built from day one for non-web environments.
9. **Which is better for AI integration?**
WordPress has a more mature plugin ecosystem for AI (indexing, generation, analysis).
10. **Can I switch from one to another?**
It's difficult. It involves migrating data between different philosophical models (documents vs. data).
11. **Does Contentful support multiple languages?**
Yes, it has native localization support that is very robust for structured data.
12. **What is WPGraphQL?**
It’s a WordPress plugin that provides a GraphQL schema for your site, making it easier for developers to query data.
13. **Is Contentful a database?**
No, but it feels like a "Content Database with an API."
14. **Why would an enterprise NOT choose WordPress?**
If they have a very strict "SaaS-only" policy or zero desire to manage a PHP codebase.
15. **What is the 2026 trend?**
The trend is **Composable Architecture**. Brands are using multiple Headless tools to build one unified experience.
---
## Conclusion: The decision-Maker's verdict
Learn more about [WordPress speed optimization](/en/speed-up-wordpress/) at WPPoland.
In 2026, **WordPress win** on versatility, cost, and editor experience. It is the "Safe" and "Scalable" choice for 90% of business use cases. **Contentful wins** on pure data modeling and omnichannel sophistication for massive, global brands with complex app ecosystems.
At **WPPoland**, we are experts in **Headless WordPress**. We help you turn your WordPress installation into a high-performance content engine that powers the frontends of the future.
**Don't settle for yesterday's CMS. Build for 2026 with WPPoland.**
---
## SEO patterns for headless WordPress: the seven things most migrations break
URL: https://wppoland.com/en/seo-patterns-for-headless-wordpress/
Description: Headless WordPress migrations rank well when they preserve seven specific signals: canonical URLs, hreflang, sitemap output, structured data, redirect history, robots.txt parity, and image search.
Published: Tue Apr 07
Updated: Tue Apr 07
Type: guide
Level: intermediate
Tags: headless-wordpress, canonical, hreflang, sitemap, schema-org, core-web-vitals
# SEO patterns for headless WordPress: the seven things most migrations break
Headless WordPress sells on Core Web Vitals, content reuse, and editorial speed. It buries seven specific SEO signals if no one is paying attention. We have shipped enough of these migrations to know which ones cost weeks of recovery and which ones are mechanical to keep right.
This article is the checklist. It is not a substitute for the [headless WordPress service pillar](/en/services/headless-wordpress/), which makes the architectural case. It is what we run before, during, and after every migration, in that order.
## TL;DR
- Preserve canonical URLs at the URL level, not the slug level.
- Preserve hreflang in HTML, not just in the sitemap.
- Render meta tags and JSON-LD on the server, not on the client.
- Migrate redirect history before changing URLs, not after.
- Keep one sitemap as the source of truth, not two.
- Block the WordPress origin from search index visibility.
- Carry image alt text and structured image data forward.
## Pattern one: canonical URLs survive the migration
A canonical URL is a promise. Every external link, every Google index entry, every social share counts on it. A headless migration that quietly trims a path segment, changes case, or reorders query parameters has just broken every one of those promises silently.
Two rules. First, capture the full canonical URL set from the legacy WordPress build before touching the front. We export every published post, page, and term page with the URL Google has indexed; that is the source of truth. Second, write the canonical URL into the headless front's HTML response, not into a client-side `` mutation. Generative engines and answer engines parse the initial HTML; client-side meta updates do not exist for them.
If you must change a URL, redirect 301 from the old to the new and keep doing so for at least a year.
## Pattern two: hreflang is HTML, not JSON
Multilingual WordPress sites use WPML, Polylang, or a custom solution to manage translations. The mapping ends up correct in the database. The headless front then has to render `` for every language variant in the HTML response.
The pattern most agencies miss: hreflang must be self-referential. The English page lists itself plus all translated alternates. The Polish page lists itself plus all alternates. The two lists agree. Tools like the [Search Console international targeting report](https://search.google.com/search-console/about) flag the mismatch when one side forgets.
We treat hreflang generation as part of the build, not as a runtime decision. The path map is computed at build, hashed, and any drift fails the build.
## Pattern three: meta tags and JSON-LD render on the server
The most common SEO regression we have seen in headless migrations: meta tags and JSON-LD inserted via JavaScript after the page loads. The browser sees them. Googlebot can sometimes see them. Generative engines, voice assistants, and most LLM crawlers usually do not.
Two rules. Render the meta tags, the canonical, the Open Graph, and every Schema.org JSON-LD block in the initial HTML response. If you use Astro, that is the default. If you use Next.js, that means rendering on the server (App Router metadata, or the legacy `getServerSideProps` path) and not relying on `next/head` re-runs in the client.
The same applies to images: an `` element with `alt` and `src` in HTML is indexable. An `` injected after a client effect is invisible to most crawlers and to AI training data pipelines.
## Pattern four: structured data inherits, not gets rewritten
WordPress with Yoast SEO or Rank Math already produces good Article, Product, and Organization JSON-LD. The temptation in a headless migration is to rewrite it from scratch on the front end. Resist.
Read the existing JSON-LD from the WordPress origin via the REST or GraphQL endpoint. Pass it through. Add only what the front end legitimately knows that WordPress does not (for example, build timestamps for `dateModified` if your editorial workflow does not touch dates). Two systems generating overlapping JSON-LD is how Search Console's rich-result reports start failing.
For our own pages we use the Phase 0 components in `src/components/seo/`: [DirectAnswer](/en/), [FAQ](/en/), and [Quote](/en/). Each emits its own minimal JSON-LD without overlapping with the page-level Article schema.
## Pattern five: redirects move before URLs do
Order matters. The pre-migration checklist captures every internal and external redirect, including the silent ones (`/wp-content/...` to `/uploads/...`, country-code redirects, AMP variants). The new front-end ships those redirects on day zero, before the public switch to the new URLs.
On Cloudflare Pages we keep the `_redirects` file under the platform's 2000-rule cap. A build that would exceed the cap fails. Anything that needs more than 2000 rules ends up in a Worker for parameterised redirect logic instead.
When the public DNS finally cuts over to the new front, no redirect is ever new in production: every rule was tested as part of the build for weeks before the cutover.
## Pattern six: only one sitemap
WordPress 5.5 added a default `/wp-sitemap.xml`. Yoast SEO and Rank Math add their own sitemaps. The headless front-end framework produces a sitemap as well. Three sitemaps at the same domain is a recipe for Search Console pulling its hair out.
The rule: pick one canonical sitemap and disable or redirect the others. We typically generate the sitemap from the front-end framework so URLs match the actual public site exactly, then 301 the WordPress origin sitemap to the front-end one. The WordPress origin then becomes invisible to search.
## Pattern seven: the WordPress origin must be invisible to search
A headless migration leaves the WordPress origin running, usually at a subdomain or a private hostname. It still serves rendered HTML, has a working sitemap, and answers REST queries. Search engines that find that origin will index it as a duplicate of the public site, and the duplicate will not be the one that ranks.
Three controls. The origin's `robots.txt` blocks all paths except the REST and GraphQL endpoints. The origin sends `X-Robots-Tag: noindex, nofollow` in HTTP headers for every HTML response. The origin's sitemap is removed or returns a 410.
If your origin is on the same domain as the public site under a path prefix (for example, `/wp-admin/` or `/wp/`), the same controls apply scoped to those paths.
## Where this fits in the cluster
This article supports the [Headless WordPress service pillar](/en/services/headless-wordpress/). For decision-time framing, see [Headless WordPress, Next.js vs Astro 2026](/en/headless-wordpress-nextjs-vs-astro-2026/). For the broader visibility story including LLM citations, the [AI and LLM visibility playbook](/en/ai-llm-visibility-geo-playbook-2026/) is the canonical statement of what we ship for AEO and GEO on top of these SEO foundations.
---
## When to rebuild your website? 7 signs it's time for a redesign
URL: https://wppoland.com/en/when-to-rebuild-your-website-guide-2026/
Description: When a website rebuild makes sense: technical, business, and SEO signals that show further patching is costing more than a planned rebuild.
Published: Tue Apr 07
Updated: Tue Apr 07
Type: guide
Level: intermediate
Tags: website-rebuild, modernization, core-web-vitals, redesign, ux
## Your website is losing customers every day
A website that takes longer than 3 seconds to load loses **53% of visitors** before they see any content. This is not an opinion -- it is data from Google's 2026 research. If your business website was built more than 2-3 years ago, it is likely pushing customers away instead of attracting them.
**Rebuilding your website** is not a luxury -- it is a business decision that directly impacts revenue. Below you will find 7 measurable signals that your site needs modernization.
## 7 signs your website needs a rebuild
### 1. Core Web Vitals in the red zone
Google measures three metrics: LCP (loading time), CLS (visual stability), and INP (interaction responsiveness). If any of them fails the "good" threshold in [PageSpeed Insights](https://pagespeed.web.dev/), your site is losing search rankings.
### 2. Bounce rate above 60%
A high bounce rate on the homepage means visitors cannot find what they are looking for or the site does not inspire trust. Modern UX and clear information hierarchy can reduce this metric by 30-50%.
### 3. The site is not responsive
In 2026, **over 65% of traffic** comes from mobile devices. A site that does not work smoothly on a smartphone is invisible to the majority of potential customers.
### 4. Outdated technology stack
PHP 7.4 reached end of life in 2022. If your WordPress site runs on an old PHP version, outdated plugins, or an unsupported theme, every day is a risk of being hacked and losing data.
### 5. Declining Google visibility
Search algorithms in 2026 prioritize speed, accessibility, and content quality. A site carrying technical debt steadily loses rankings to modernized competitors.
### 6. No WCAG 2.1 compliance
The European Accessibility Act (EAA) requires commercial websites to meet the WCAG 2.1 AA standard. Non-compliance does not just exclude users with disabilities -- it is a legal risk and reputation damage.
### 7. The site does not generate leads
If the contact form is hard to find, clear CTAs (calls to action) are missing, and the conversion path is unintuitive, the site is failing its core business function.
## What a professional rebuild includes
An effective [website rebuild and modernization](https://wppoland.com/en/website-rebuild-and-modernization/) combines three layers: technical, visual, and content.
**Technical layer**: migration to PHP 8.4+, database optimization, object cache implementation (Redis), CDN configuration, and security headers.
**Visual layer**: new design aligned with 2026 trends, responsive layout, WCAG 2.1 AA accessibility, optimized conversion paths.
**Content layer**: content audit and consolidation, thin content elimination, SEO metadata updates, Schema.org structured data implementation.
## Rebuilding without losing SEO -- it is possible
The biggest fear about modernization is losing Google rankings. A professionally executed rebuild **protects and improves** visibility through:
- mapping and 301 redirecting all URLs,
- migrating metadata, structured data, and internal linking,
- submitting the sitemap to Google Search Console,
- monitoring indexing errors for the first 30 days.
## Technical debt accumulation: why old code costs more every day
Technical debt is the hidden tax your business pays for every month you postpone a rebuild. It starts small. A plugin stopped receiving updates. The theme author abandoned the project. Your hosting company nudged you to upgrade PHP but you put it off because the site was "working fine."
Two years later, here is what the ledger looks like.
PHP 7.4 reached end of security life in November 2022. PHP 8.0 followed in November 2023. If your WordPress installation still runs on either version, automated scanners are probing your site right now looking for exploits that will never be patched. These are not theoretical threats. Malware injection, credential theft, SEO spam injection, and ransomware affecting small business sites are documented daily on forums like Sucuri's threat intelligence reports.
Beyond security, old PHP versions drag performance. PHP 8.4 processes the same WordPress request approximately 30 to 40 percent faster than PHP 7.4. That improvement costs nothing extra once you migrate, but it meaningfully reduces your server response time (TTFB) and helps every Core Web Vitals metric.
Abandoned plugins create a second layer of risk. When a plugin author stops maintaining their code, they stop patching known vulnerabilities. Worse, the plugin may become incompatible with newer WordPress core releases, creating a situation where every WordPress update is a gamble. I have seen sites running 14 outdated plugins where the site owner was afraid to click "update all" because the last time they did it, the site went offline.
Browser compatibility is the third layer. Modern browsers have retired CSS and JavaScript patterns that felt normal five years ago while shipping container queries, view transitions, and the `:has()` selector that legacy themes seldom adopt cleanly. Your site may visually break on current Chrome or Safari versions in ways you have never noticed because you test on the same setup you used when the site launched.
The cumulative cost of technical debt is not just security risk. It is the developer hours spent investigating why a plugin update broke the checkout form, why images stopped loading after a server migration, or why a simple text change on the homepage requires three people and a deployment pipeline to execute safely.
## Core Web Vitals failure: how Google measures your site's performance
Google introduced Core Web Vitals as ranking signals in 2021 and has been increasing their weight in the algorithm ever since. In 2026, a site that fails these thresholds is not just slower for users. It is algorithmically deprioritized in search results in favor of faster competitors.
**LCP (Largest Contentful Paint)** measures how quickly the main content of a page loads. Google's "good" threshold is 2.5 seconds or faster. The LCP element is typically your hero image, a large heading, or a background video. On most outdated sites, LCP failure comes from unoptimized images served in JPEG format rather than AVIF or WebP, images lacking width and height attributes causing layout recalculation, render-blocking scripts preventing the browser from parsing HTML, or hosting without a CDN delivering assets from a server hundreds of miles from the visitor.
Every 100 milliseconds of additional load time reduces conversions by approximately 1 percent for e-commerce sites according to Google's research data. A site with a 4-second LCP versus a 1.5-second LCP is not just 2.5 seconds slower. It is statistically losing 25 percent of potential conversions to page speed alone.
**CLS (Cumulative Layout Shift)** measures visual stability. The threshold for "good" is a score below 0.1. Layout shifts happen when elements move after the page starts rendering: images without defined dimensions, web fonts swapping after page load (flash of unstyled text), late-injecting ads or cookie banners, and JavaScript dynamically injecting content above the fold. A high CLS score means users click the wrong button, miss content, and experience the page as broken even if all functionality technically works.
**INP (Interaction to Next Paint)** replaced the older FID metric in 2024 and measures how quickly your page responds to any user interaction. The "good" threshold is under 200 milliseconds. High INP usually indicates excessive JavaScript on the main thread, long tasks blocking the browser's ability to respond to clicks, or poorly optimized WordPress themes that load large JavaScript bundles even on pages where those scripts are not needed.
A site with all three Core Web Vitals in the "good" range ranks measurably better than an identical site with poor scores. The SEO benefit compounds with UX improvement: a fast, stable, responsive page keeps visitors engaged longer, signals positive user behavior back to Google, and creates a reinforcing loop of better rankings and more traffic.
## Mobile experience degradation: your site on the device that matters most
Google has operated mobile-first indexing since 2019. This means Google's crawler evaluates the mobile version of your site when deciding how to rank it. If your mobile experience is degraded, your rankings reflect that degradation for all users, including those on desktop.
The difference between a responsive site and a mobile-first site is significant. Responsive design takes a desktop layout and adjusts it for smaller screens using CSS breakpoints. Mobile-first design starts with the smallest screen and builds up. The practical difference is visible in content prioritization: a responsive site often crams too much into mobile screens because it was designed for desktop. A mobile-first site makes deliberate choices about what is most important on a small screen.
Touch targets are a frequently overlooked issue. Google's guidelines specify that interactive elements (buttons, links, form fields) should have a minimum tap target size of 44 by 44 pixels. Navigation menus built for mouse hover do not translate to touch. A user on a smartphone cannot hover over a parent menu item to reveal a dropdown. If your menu relies on hover states, mobile users see a broken navigation experience.
Viewport configuration issues on older sites cause text to render at 10 pixels when the user expects 16, forcing a pinch-to-zoom interaction that Google explicitly penalizes in its mobile-friendliness evaluation. Some older WordPress themes hard-code pixel widths in their CSS, preventing the layout from adapting to different screen sizes at all.
Image handling on mobile is another significant factor. Serving a 2500-pixel-wide image to a smartphone with a 390-pixel screen wastes bandwidth, slows load time, and increases the page's carbon footprint. Modern WordPress implementations using the `srcset` attribute and modern formats (AVIF first, WebP as fallback) can reduce image payload by 60 to 80 percent without any visible quality loss.
Performance on mid-range devices deserves attention. Your team's development machines and your client's flagship smartphones are not representative of average users. Many business websites are browsed on two or three-year-old Android phones with 3GB of RAM over 4G connections. Testing on real mid-range hardware reveals problems that never appear in Chrome DevTools' device simulation mode.
## SEO position erosion: how outdated sites lose rankings gradually
Search ranking decline from technical debt is rarely sudden. It is a slow erosion that becomes visible in your Google Search Console data over six to twelve months. By the time the pattern is undeniable, competitors have built a significant lead.
The mechanism works like this. Google updates its algorithm continuously. Each update refines what signals matter and how much. A site that was built to 2021 standards may have been perfectly adequate then. But as Google increased the weight of Core Web Vitals, mobile-friendliness, content quality signals, and structured data in its ranking calculations, a site that received no maintenance fell further from the optimal profile with each passing month.
Thin content penalties compound this effect. Legacy WordPress sites often have dozens of tag archive pages, date-based archive pages, author pages for writers who no longer contribute, and search result pages indexed by Google. These pages contain little unique content, dilute your site's crawl budget, and signal low content quality to the algorithm. A proper rebuild includes a content audit that identifies and correctly handles (noindex, consolidation, or canonical) all of these low-value page types.
…[truncated, fetch the canonical URL for the full body]…
---
## WordPress for enterprise: scalability and security
URL: https://wppoland.com/en/wordpress-for-enterprise-scalability-and-security-2026/
Description: Enterprise WordPress architecture in 2026: scaling patterns, governance, security controls and integration trade-offs.
Published: Thu May 15
Updated: Thu May 15
Type: guide
Level: advanced
Tags: enterprise-wordpress, scalability, security, cms-for-business, performance-2026
In 2026, the digital landscape for large-scale organizations has shifted from "can we build it?" to "can we scale it safely and infinitely?". For a long time, the word "WordPress" was associated with small blogs and personal portfolios. Today, that perception is ancient history. In the enterprise world, WordPress has become the **dominant operating system for the high-performance web**.
As an enterprise-level decision-maker, you aren't just looking for a Content Management System (CMS); you are looking for a **growth platform**. You need a platform that can handle global traffic spikes, integrate with complex SAP or Salesforce backends, and support documented security controls - all while giving your marketing team clear publishing autonomy.
This section explains where WordPress fits in enterprise architecture in 2026: governance, security controls, scaling patterns and integration constraints.
---
## 1. The architecture of scale: Beyond the typical server
Scaling for enterprise in 2026 isn't just about "buying a bigger server." It is about **Architectural Intelligence**. Modern WordPress enterprise stacks have evolved into distributed, multi-layered systems.
### Horizontal vs. Vertical scaling
When a global brand launches a product, traffic doesn't just double; it explodes. Vertical scaling (adding RAM to a single server) has limits. Enterprise WordPress utilizes **Horizontal Scaling**.
- **Containerization**: Using Docker and Kubernetes, we spin up identical copies of the WordPress application layer in seconds to handle traffic surges.
- **Database Decoupling**: We separate the write-database from the read-replicas. This ensures that even under heavy user interaction, the site remains fast.
### The role of edge computing
the "request-response" cycle happens at the **Edge**. By utilizing providers like Cloudflare or Akamai, we serve the majority of your WordPress site from servers physically located near your users (e.g., Warsaw, London, New York). This reduces latency to almost zero, which is critical for **Core Web Vitals** and user retention.
---
## 2. High-Grade security: Hardening the core
Security in the enterprise sector is a binary outcome: it either works, or you are in the news. WordPress is often unfairly maligned because of insecure third-party plugins used by amateurs. At the **enterprise level**, we treat security as a lifestyle, not a feature.
### Soc2 and compliance standards
In 2026, e isn't optional. Enterprise WordPress hosting (like WordPress VIP or specialized Private Clouds) comes with:
- **SOC2 Type II Compliance**: Ensuring data privacy and security.
- **GDPR/CCPA Native Controls**: Automated tools for data erasure and access requests.
- **WAF (Web Application Firewall)**: Advanced rulesets that block SQL injections and Cross-Site Scripting (XSS) before they even reach the server.
### The "least privilege" principle
Large corporations have hundreds of users. We implement strict **Identity and Access Management (IAM)**.
- **SSO Integration**: Connecting WordPress to your corporate Azure AD or Okta.
- **Granular Permissions**: A "Junior Editor" should never have the power to update a plugin or change a theme setting.
---
## 3. Integrations: The hub of your digital ecosystem
An enterprise website doesn't live in a vacuum. It must communicate with your entire "MarTech" stack.
- **CRM & Marketing Automation**: Bidirectional sync with Salesforce, HubSpot, or Marketo, including field-level mapping and webhook-driven updates on both sides.
- **ERP Integration**: Connecting your website's frontend to SAP or Microsoft Dynamics for real-time inventory and pricing.
- **Custom APIs**: WordPress's **REST API** and **GraphQL** maturity allow it to serve as a "Headless" content hub, pushing data to mobile apps, IoT devices, and digital signage simultaneously.
---
## 4. Total cost of ownership (tco) vs. Proprietary lock-In
Why are companies like Disney, Meta, and the White House choosing WordPress over Adobe Experience Manager or Sitecore?
### Zero licensing fees
Proprietary systems often demand six-figure annual licensing fees before you’ve even written a single line of code. WordPress is open source. Every dollar of your budget goes towards **innovation and user experience**, not to a software vendor's bottom line.
### Preventing platform lock-In
If you build on a proprietary system and the vendor changes their pricing or stops supporting a feature, you are trapped. With WordPress, **you own your data and your code**. You can move to any hosting provider or any agency at any time.
---
## 5. Performance monitoring (apm)in 2026
You cannot manage what you do not measure. For our enterprise clients at **WPPoland**, we implement real-time Application Performance Monitoring.
- **New Relic/Datadog Integration**: We know the second a database query takes more than 100ms.
- **Automated Regression Testing**: Every time code is changed, headless browsers (Playwright/Cypress) test your checkout and lead forms automatically.
---
## 6. Content governance for global teams
Managing 50 different country sites is a nightmare without the right tools.
- **Multisite Architecture**: Run 500 websites from a single WordPress installation. Share users, themes, and plugins while maintaining separate content and domains.
- **Editorial Workflows**: Multi-stage approval processes (Draft -> Legal Review -> SEO Review -> Published) ensure that no content goes live without being vetted.
---
## 7. The human factor: The talent pool
Finding a specialist for a niche, proprietary CMS is hard and expensive. In 2026, the **Woronomy** is the largest in the tech world. There are millions of developers, SEOs, and designers who speak the language of WordPress fluently. This ensures that your project is never "stuck" due to a lack of talent.
---
## 8. Case study: Scaling to 100m visitors
Consider a European news portal we optimized in late 2025.
- **The Challenge**: Handling unpredictable spikes during election cycles.
- **The Solution**: A Headless WordPress backend with an **Astro 5** frontend delivered via Global Edge.
- **The Result**: sustained availability during a 10x traffic spike, with an average LCP of 0.6 seconds.
---
## 9. Future-Proofing with AI and llmo
In 2026, search is changingt just optimize for Google; we optimize for **LLMs** (ChatGPT, Gemini, Perplexity).
- **Structured Data**: We embed deep JSON-LD schemas so AI models can correctly attribute and cite your enterprise's expertise.
- **Semantic Search**: Using vector databases, we help you build internal search engines that actually understand what your customers are looking for.
---
## 10. Conclusion: The logical enterprise choice
Learn more about [WordPress security services](/en/wordpress-security-audit/) at WPPoland.
The debate is over. WordPress is no longer the "underdog" in the corporate world; it is the **infrastructure of choice**. It provides the scalability of a cloud-native platform, the security of a hardened vault, and the flexibility of an open ecosystem.
If your organization is looking for a platform that will grow with you into 2027 and beyond, WordPress is the only logical answer.
**Considering an enterprise WordPress audit? Contact WPPoland to scope it. We deliver a written audit report with concrete remediation steps, not generic security checklists.**
---
## Complete WordPress Migration Guide: Move Your Site Safely in 2024
URL: https://wppoland.com/en/wordpress-migration-complete-guide-2024/
Description: Moving your WordPress website can be daunting, but with the right knowledge and preparation, it becomes manageable. Whether changing domains, upgrading hosting, or restructuring site architecture, this comprehensive guide covers every step.
Published: Thu Jun 19
Updated: Thu Jun 19
Type: guide
Level: advanced
Tags: wordpress, migration, hosting, domain, database
Moving your WordPress website can be a daunting task, but with the right knowledge and preparation, it becomes a manageable process. Whether you're changing domains, upgrading hosting, or restructuring your site architecture, this comprehensive guide will walk you through every step of the WordPress migration process.
## Understanding WordPress Site URLs
Before diving into migration techniques, it's crucial to understand the two fundamental URL settings in WordPress:
- **WordPress Address (URL)**: This is where your WordPress core files reside
- **Site Address (URL)**: This is the address visitors type in their browser to reach your site
Both settings should include the `https://` part and should not have a trailing slash `/` at the end. These settings control how WordPress displays URLs throughout your site, including the admin section and frontend.
## Why WordPress Migration Becomes Necessary
Several scenarios might require you to migrate your WordPress site:
1. **Domain Changes**: Rebranding or switching to a better domain name
2. **Hosting Migration**: Moving to a better hosting provider
3. **Server Changes**: Upgrading server infrastructure
4. **Site Restructuring**: Moving WordPress to a subdirectory or root directory
5. **Development to Production**: Moving from staging to live environment
6. **HTTP to HTTPS**: Implementing SSL certificates
## Preparation: The Key to Successful Migration
### Backup Everything
Before attempting any migration, create comprehensive backups:
1. **Database Backup**: Export your WordPress database via phpMyAdmin or WP-CLI
2. **File Backup**: Download all WordPress files and directories
3. **Configuration Backup**: Save your wp-config.php file separately
4. **Plugin/Theme Settings**: Document custom configurations
### Test Environment Setup
Always test migrations in a staging environment before going live:
```bash
## Create a test subdirectory
mkdir /var/www/html/test-site
## Copy files to test location
cp -r /var/www/html/wordpress/* /var/www/html/test-site/
```
## Migration Methods: From Simple to Advanced
### Method 1: Using wp-config.php (Quick Fix)
For temporary URL changes, add these lines to your wp-config.php:
```php
define('WP_HOME', 'https://example.com');
define('WP_SITEURL', 'https://example.com');
```
**Pros**: Quick and immediate
**Cons**: Hard-coded values, can't edit in WordPress admin anymore
### Method 2: functions.php Approach (Temporary Fix)
If you have FTP access but can't access WordPress admin:
1. Access your active theme's functions.php file
2. Add these lines after the opening ` General to verify URLs
5. Remove the RELOCATE constant afterward
**Security Warning**: Never leave RELOCATE constant in wp-config.php as it creates security vulnerabilities.
### Method 4: Direct Database Editing
For precise control, edit URLs directly in the database:
1. Access phpMyAdmin
2. Select your WordPress database
3. Find wp_options table (prefix may vary)
4. Edit the 'siteurl' and 'home' rows
5. Update option_value to new URLs
**Critical**: Always backup your database before making direct edits!
## Advanced Migration Scenarios
### Moving Between Servers
When migrating to a new server:
1. **Backup Everything**: Complete site and database backup
2. **Export Database**: Use phpMyAdmin or WP-CLI
3. **Transfer Files**: Use FTP, SFTP, or rsync
4. **Import Database**: Create new database and import
5. **Update wp-config.php**: Modify database credentials
6. **Update URLs**: Use one of the methods above
7. **Test Thoroughly**: Check all functionality
### Domain Name Changes
Changing domains requires special attention to serialized data:
```bash
## Using WP-CLI (recommended)
wp search-replace 'olddomain.com' 'newdomain.com' --skip-columns=guid
## Or use specialized plugins like:
## - Velvet Blues Update URLs
## - Better Search Replace
```
**Important**: Never update the GUID column in wp_posts table. GUID stands for Globally Unique Identifier and should never change to maintain feed reader compatibility.
### Subdirectory to Root Migration
Moving WordPress from a subdirectory to root:
1. **Update URLs in WordPress Admin**: Settings > General
2. **Copy Files**: Move WordPress files to new location
3. **Update .htaccess**: Modify rewrite rules
4. **Update Permalinks**: Resave permalink structure
5. **Check Internal Links**: Update hardcoded URLs
### Multisite Migration
WordPress Multisite requires additional considerations:
1. **Backup Network**: All sites and databases
2. **Edit wp-config.php**: Update multisite constants
3. **Update .htaccess**: Modify multisite rewrite rules
4. **Database Updates**: Update wp_blogs and wp_site tables
5. **Individual Site Options**: Update each site's options tables
## Post-Migration Checklist
### Immediate Actions
- [ ] Test frontend functionality
- [ ] Verify admin access
- [ ] Check all forms and submissions
- [ ] Test e-commerce functionality
- [ ] Verify user login/registration
### SEO Considerations
- [ ] Implement 301 redirects from old URLs
- [ ] Update sitemap.xml
- [ ] Submit new sitemap to search engines
- [ ] Update Google Analytics property
- [ ] Verify Google Search Console
### Performance Optimization
- [ ] Clear all caches
- [ ] Optimize database tables
- [ ] Check plugin compatibility
- [ ] Test site speed
- [ ] Verify SSL certificate
## Common Migration Problems and Solutions
### White Screen of Death
Usually caused by:
- Memory limit exhaustion
- Plugin conflicts
- Theme incompatibility
**Solution**: Increase memory limit in wp-config.php:
```php
define('WP_MEMORY_LIMIT', '256M');
```
### Database Connection Errors
Check wp-config.php settings:
```php
define('DB_NAME', 'database_name');
define('DB_USER', 'username');
define('DB_PASSWORD', 'password');
define('DB_HOST', 'localhost');
```
### Mixed Content Issues
HTTP resources on HTTPS pages cause security warnings:
```bash
## Find mixed content
grep -r "http://" wp-content/
```
### Image and Media Link Problems
Update media URLs in database:
```sql
UPDATE wp_posts SET post_content = REPLACE(post_content,'olddomain.com/wp-content/uploads','newdomain.com/wp-content/uploads');
```
## Tools and Plugins for Migration
### Recommended Migration Plugins
1. **All-in-One WP Migration**: Complete site migration tool
2. **Duplicator**: Create migration packages easily
3. **WP Migrate DB**: Database migration specialist
4. **Velvet Blues Update URLs**: URL updating tool
5. **[Migrator](https://plogins.com/plogins-migrator/)**: single-file backup and migration with no artificial size cap (unlike All-in-One's free 512MB limit) and serialization-safe URL rewriting. See the [backup and migration guide](https://plogins.com/learn/backup-migration/).
### Command Line Tools
```bash
## WP-CLI database export
wp db export backup.sql
## WP-CLI database import
wp db import backup.sql
## Search and replace
wp search-replace 'old-url' 'new-url' --dry-run
```
## Security Considerations During Migration
1. **Use HTTPS**: Ensure SSL is configured on new server
2. **Update File Permissions**: Secure wp-config.php (600) and directories (755)
3. **Remove Migration Scripts**: Delete temporary files and constants
4. **Update Security Keys**: Generate new WordPress keys in wp-config.php
5. **Monitor Logs**: Watch for unusual activity post-migration
## Performance Optimization After Migration
### Database Optimization
```sql
OPTIMIZE TABLE wp_posts;
OPTIMIZE TABLE wp_postmeta;
OPTIMIZE TABLE wp_options;
```
### Caching Configuration
- Configure page caching
- Set up browser caching
- Enable CDN integration
- Optimize database caching
## Testing and Validation
### Functionality Testing
1. **Navigation**: All menu items work correctly
2. **Forms**: Contact forms and submissions function
3. **Search**: Site search returns results
4. **Comments**: Comment system works
5. **Media**: Images and videos load properly
### SEO Validation
1. **Meta Tags**: Titles and descriptions display correctly
2. **Canonical URLs**: Point to new domain
3. **Structured Data**: Schema markup validates
4. **Internal Links**: All links work and redirect properly
## Maintenance Post-Migration
### Monitoring
- Set up uptime monitoring
- Monitor Google Search Console for errors
- Track analytics for traffic patterns
- Watch for 404 errors in logs
### Ongoing Optimization
- Regular database optimization
- Image optimization and compression
- Plugin performance monitoring
- [Security scan](/en/wordpress-security-audit/) implementation
## Real-World Migration Case Studies
### Case Study 1: E-commerce Domain Migration
**Scenario**: A popular online store with 50,000+ products needed to migrate from `store-old.com` to `brandnew.com` while maintaining SEO rankings and customer trust.
**Challenges Faced**:
- Massive product database with complex variations
- Active shopping cart sessions during migration
- Third-party payment gateway integrations
- Customer email campaigns with old domain links
**Migration Strategy**:
1. **Pre-migration preparation** (2 weeks):
- Created complete site backup including customer data
- Set up temporary staging environment
- Tested all payment gateway integrations
- Prepared email templates for customer notification
2. **Technical implementation** (4 hours):
- Used WP-CLI for database URL replacement
- Implemented custom 301 redirect rules
- Updated all third-party API endpoints
- Configured SSL certificate for new domain
3. **Post-migration optimization** (1 week):
- Monitored Google Search Console for indexing issues
- Updated all marketing automation workflows
- Implemented enhanced tracking for migration impact
- Conducted customer satisfaction survey
**Results**:
- Nearly all SEO rankings maintained within 2 weeks
- Zero data loss during migration
- Customer complaints fell sharply with proper communication
- Site speed improved on the new hosting infrastructure
**Key Lessons Learned**:
- Customer communication is as important as technical execution
- Testing payment gateways in staging environment prevents revenue loss
- Having rollback plan ready provides confidence during execution
### Case Study 2: Multisite Network Migration
**Scenario**: A educational institution with 200+ subdomain sites needed to migrate from shared hosting to dedicated cloud infrastructure.
**Technical Complexity**:
- 201 individual WordPress sites
- Custom user roles and permissions across sites
- Shared media library with 100GB+ of content
- Complex plugin dependencies between sites
**Migration Approach**:
1. **Network Analysis Phase**:
- Mapped all site interdependencies
- Identified custom plugin configurations
- Documented user role hierarchies
- Analyzed media library usage patterns
2. **Staging Environment Setup**:
- Replicated exact server configuration
- Created automated testing scripts
- Implemented performance monitoring
- Set up rollback procedures
3. **Phased Migration**:
- Migrated 10 pilot sites first
- Documented and refined process
- Batch migrated remaining sites
- Continuous monitoring and optimization
**Technical Solutions**:
```bash
## Custom script for batch multisite migration
#!/bin/bash
for site in $(wp site list --field=url); do
echo "Migrating $site"
wp search-replace 'old-domain.com' 'new-domain.com' --url=$site
wp cache flush --url=$site
done
```
…[truncated, fetch the canonical URL for the full body]…
---
## WordPress hosting for 2026: Cloud vs. Edge vs. Traditional hosting compared
URL: https://wppoland.com/en/wordpress-hosting-2026-cloud-vs-edge-vs-traditional-guide/
Description: Choosing the right server architecture in 2026 is a multi-million dollar decision. This 2000+ word guide compares Cloud, Edge, and Traditional hosting.
Published: Thu Jun 12
Updated: Thu Jun 12
Type: guide
Level: advanced
Tags: wordpress-hosting-2026, cloud-hosting, edge-computing, server-architecture, performance-optimization
In 2026, a "server" is no longer a physical box sitting in a rack in a cold room. It is a **distributed resource**. For a WordPress site in 2026,ce of hosting architecture is the single most important factor determining your speed, security, and scalability.
We have moved past the era where you just "bought a host." Today, you are architecting a **Content Delivery Ecosystem**. Whether you are a small SaaS startup or a global enterprise leader, understanding the differences between **Cloud**, **Edge**, and **Modern Traditional** hosting is critical.
This section compares WordPress hosting choices in 2026 across cloud, edge and traditional infrastructure, with performance and operations trade-offs.
---
## 1. Traditional managed hosting: The "reliable workhorse" evolved
Don't let the name fool you. "Traditional" managed hosting in 2026 (like WP r Kinsta) is lightyears ahead of its 2020 predecessors.
- **Microservice Architecture**: These hosts no longer run your site on a single OS. They use containers (Docker/K8s) to isolate your environment completely.
- **Managed Governance**: The value here isn't just the CPU; it's the **management**. Automatic backups, automated core updates, and specialized WordPress security layers.
- **Best For**: Mid-sized businesses that want high performance without needing a dedicated DevOps team.
---
## 2. Cloud-Native hosting: Scaling to infinity
Hosting directly on AWS, Google Cloud, or Azure is the choice for the "Elite" in 2026.
- **Horizontal Auto-Scaling**: If your site suddenly gets 100,000 visitors due to a viral campaign, the system automatically spins up 10 new server instances to handle the load.
- **Precision Cost Management**: You pay for exactly what you use, down to the millisecond of CPU time.
- **Best For**: High-traffic enterprise applications, e-commerce giants, and sites with massive, unpredictable traffic spikes.
---
## 3. Edge hosting: The 2026 performance frontier
Edge hosting (often called "Headless Hosting" or "Edge Computing") is the newest and fastest architecture.
- **No Origin Server**: Instead of having one primary server in Germany, your WordPress code runs on **hundreds of edge locations** simultaneously.
- **Sub-50ms Latency**: Because the content is processed at the network edge (closest to the user), the "geographic delay" is virtually eliminated.
- **Best For**: Global brands that require 100/100 Core Web Vitals across every continent.
---
## 4. Key 2026 decision matrices
### Speed vs. Complexity
- **Edge**: Highest Speed / Highest Technical Complexity.
- **Managed**: High Speed / Lowest Complexity.
- **Cloud**: High Speed / Medium Complexity.
### Security and compliance
data residency laws are strict.
- **Cloud** and **Traditional** hosting allows you to pin your data to a specific region (e.g., Warsaw for GDPR compliance).
- **Edge** hosting requires advanced configuration to ensure data doesn't "leak" into non-compliant regions.
---
## 5. The role of the APIin 2026 hosting
Modern hosting in 2026 is **API-First**.'t just use a dashboard; you use CI/CD pipelines. When a developer pushes code to GitHub, the host automatically runs tests, builds the assets, and deploys the site across the global network without manual intervention.
---
## 6. Environmental impact: Green hostingin 2026
Enterprises in 2026 are rated on their sustai.
- **Dynamic Resource Allocation**: Cloud and Edge hosting are inherently "greener" because they don't leave servers running at 10% capacity. They only consume power when there is traffic.
- **Green Data Centers**: Most serious 2026 hosts are powered by 100% renewable energy.
---
## 7. Why wppoland is your hosting architect
Choosing a host is only 20% of the battle. The other 80% is **Configuration**.
1. **Architecture Design**: We analyze your traffic patterns and business goals to choose the perfect model (Cloud, Edge, or Hybrid).
2. **Performance Tuning**: We don't just install WordPress; we optimize the Nginx/Varnish/Redis layers for maximum throughput.
3. **Security Hardening**: We implement WAFs (Web Application Firewalls) at the network edge to block attacks before they even reach your server.
---
## 8. Faq: The hosting landscape of 2026
1. **Do I still need a CDN if I have Edge hosting?**
In Edge hosting, the CDN *is* the host. The distinction between where the files are stored and where they are served has vanished.
2. **Is WordPress slow on Cloud hosting?**
Only if it is poorly configured. A properly tuned Kubernetes-based WordPress install is one of the fastest digital experiences on the planet.
3. **How do I migrate to Edge hosting?**
It requires a "decoupled" approach where the WordPress backend stays on a traditional server, but the frontend is served from the edge.
---
## 9. Conclusion: Don't build on sand
Learn more about [WordPress speed optimization](/en/speed-up-wordpress/) at WPPoland.
Hosting is one of the foundations of a serious website. In 2026, an enterprise site on cheap shared hosting usually creates avoidable risk: slow response times, limited observability and weak recovery options. Whether you choose managed hosting, cloud infrastructure or an edge-first setup, the choice should match the traffic model, editorial workflow and recovery requirements.
If hosting is slowing the site down, start with a short written brief: current provider, traffic pattern, slow templates, cache layer and recent incidents.
---
## How to choose a WordPress agency: what to look for when you commission a site or store
URL: https://wppoland.com/en/how-to-choose-a-wordpress-agency/
Description: A buyer's guide: agency, freelancer or in-house team, what questions to ask before signing, how to judge performance and security, and who owns the rights to the code, design and content once the project is done.
Published: Thu Jun 11
Updated: Thu Jun 11
Type: guide
Level: intermediate
Commissioning a WordPress site or store is not buying a product off the shelf, it is entering a relationship that is hard to walk away from halfway through. The most important decision is not about price or whose portfolio looks nicer, but about what stays in your hands once the project is over: access, code and rights. This guide gathers the questions that really separate a good contractor from trouble, plus one area almost nobody thinks about until it is too late: the law.
## Agency, freelancer or in-house team
It is a choice about continuity, not quality. A single freelancer can be the best technical choice and the fastest to make decisions, but is also a single point of failure. We have seen a store grind to a halt for a week because the only person who knew its code had gone to the mountains with no signal, and the project knowledge was written down nowhere. An in-house team solves the continuity problem, but it only pays off under a steady, heavy workload; with irregular tasks a salaried role sits idle and still costs money.
An agency is the middle ground: you pay a premium for the team and the process, and in return you get replaceable people and documentation, so the project does not stop when one person leaves. The sensible middle model for most B2B companies and stores is a fixed, named engineer on the contractor's side, but with a team and recorded knowledge behind them. The control question is simple: what happens to my project when that specific person falls ill or leaves.
| Dimension | Freelancer | Agency | In-house team |
|---|---|---|---|
| Continuity | Single point of failure | Replaceable people and documentation | Solved, but only under steady load |
| Cost model | Lowest rate, irregular availability | Premium for the team and process | Salary, sits idle on irregular work |
| Decision speed | Fastest | Fast, through a named engineer | Fast, but internal only |
| Documented knowledge | Often none | Recorded and handover-ready | Depends on the team |
| Best fit | Small, well-scoped tasks | Most B2B sites and stores | Steady, heavy workload |
## What to look for instead of a pretty portfolio
A portfolio shows how something looks in a screenshot, not how it behaves under load. Three things say more than a gallery of past work.
The first is performance that is measured, not declared. Ask for a Core Web Vitals result from field data, or from a test on a mid-range phone on a slower connection, not from a laptop on fibre. The methodology and thresholds are described by the Google team in the [Web Vitals documentation](https://web.dev/articles/vitals). A good contractor will show before-and-after numbers, explain how they handle heavy page builders and how many database queries a product page generates.
The second is how they work with code. Ask directly whether the code is version-controlled in a repository or pushed straight to the server over FTP. Version control is not a whim: it is the ability to undo a mistake, audit changes and let anyone else take over the project. No repository means you are tied to one contractor, because nobody else can step into that code without archaeology.
The third is security after launch. A site is not a painting you hang and forget; plugins need updating, and the plugin supply chain can be an attack vector. Ask who is responsible for updates after go-live and what incident response looks like. No answer means you are responsible, you just do not know it yet.
## Five questions before you sign
These five questions cost a minute and save months.
1. Who will hold the economic copyright to the code and design once the project ends, and on which fields of exploitation?
2. Will I get full administrative access to hosting, the domain, the repository and external accounts, or are we working on your closed account?
3. Is the code version-controlled and the deployments reproducible, or do changes land on the server by hand?
4. Who is responsible for updates, backups and security after launch, and what does the care plan cover?
5. Will I see a real performance result on a phone, or only portfolio screenshots?
If any of these gets an evasive answer, it is not a matter of knowledge but of a business model that keeps the client tied to the contractor by force rather than by quality.
## Law and ownership: the area nobody thinks about early enough
This is where the part begins that is easiest to skip and hardest to fix after the fact. Under Polish law, paying for a project does not automatically transfer the economic copyright to the code, graphics or text; you need an explicit clause in the contract naming the fields of exploitation. Without it, the rights stay with the contractor and you hold only a licence to use what you paid for. Polish lawyer Tomasz Palak puts it without dressing it up: as he writes in his guide to [copyright for creators](https://www.tomaszpalak.pl/), "publishing does not lose you the rights", which cuts both ways, including on the contractor's side, until those rights are knowingly assigned.
The same caution applies to the material you put on the site. The fact that a photo is available online, or that an AI model generated it, does not mean you may use it commercially; you have to check the licence, because, as Palak reminds us, not every "free image" is really free, and a CC BY licence is not the same as CC0. On your side it is worth securing three things in the contract:
- An assignment of the economic copyright to the code, design and content, not merely a licence.
- A declaration by the contractor that they hold the rights to all material used, photos, fonts and premium plugins, along with their licences.
- GDPR compliance if the site collects data, meaning who is the controller and who is the processor, and what happens to the data once the cooperation ends.
If you use AI tools for content or graphics, remember one rule that Palak repeats: the tool does not remove your responsibility for what you publish. Check the tool's terms and do not feed it data you are not allowed to disclose. The same goes for the agency you hire: it is worth asking whether and how it uses AI, and who is responsible for the rights to the output.
## Contract and billing models
How you pay shapes how the contractor behaves, so it is worth understanding what each model rewards before you argue about the number. There is no universally correct answer, and any serious agency will price the specifics of your project individually, but the incentives differ in predictable ways.
A fixed project fee buys you cost certainty and puts the delivery risk on the contractor. The catch is what happens at the edges: a fixed price only works when the scope is written down precisely, and every change becomes a negotiation. If the offer contains "unlimited revisions" at a fixed price, treat it as a warning rather than a gift; it means the scope was never defined, and the contractor plans to make the model profitable by wearing you down or by cutting invisible corners such as skipping the staging environment and testing on production.
Hourly billing is the most honest model for exploratory work: migrations of old sites nobody fully understands, rescue jobs after a hack, integrations with an ERP where the other system's documentation turns out to be fiction. You carry the budget risk, so it only works with two safeguards in the contract: a cap you approve before it is exceeded, and access to a work log specific enough that you can see what a given hour produced. An agency that resists both wants hourly billing without hourly accountability.
A retainer, a fixed monthly fee for care and a pool of development hours, is what most sites actually need after launch, because WordPress is not a deliverable but a process: core updates roughly twice a year, plugin updates weekly, PHP version migrations on the hosting side. The retainer incentivises the agency to keep the site boring and stable, since incidents eat their margin. What matters is what the fee covers in writing: update cadence, backup frequency and retention, guaranteed response time for a site-down incident, and whether unused hours roll over. This is the model behind a typical [WordPress maintenance service](/en/wordpress-website-maintenance/), and it is where the questions about update policy and rollback from the checklist above stop being theoretical.
Whichever model you choose, the pricing itself should be individual, built from your requirements, not read off a menu. A quote produced without a discovery call, without access to the current site and without questions about traffic and integrations is a quote for a project the contractor has imagined, not yours.
## Red flags
A few signals after which it is better to say no before signing. A contractor who will not hand over access to hosting, the domain and the code. No repository and deployments done by hand only. A price quoted in isolation from scope, without analysing the real requirements. Promises of Google rankings or "AI visibility" given on someone's word, with no explanation of what they are supposed to consist of. Finally, silence on copyright, because that usually means the rights stay with the contractor and you will find out only when you try to change supplier.
Beyond those, four patterns show up so often in inherited projects that they deserve their own list. No staging environment: if every change is made directly on the live site, one bad plugin update during a sales campaign takes the store down, and you find out the agency's rollback plan is "restore yesterday's backup and lose today's orders". No written update policy: WordPress ships several core releases a year and popular plugins patch security issues monthly, so "we update when needed" in practice means "we update after the site gets hacked". Licence lock-in on page builders: the site is built on Elementor Pro or a premium theme licensed to the agency's account, so the day you leave, updates stop, and re-licensing or rebuilding becomes the exit fee nobody mentioned. No repository access for the client: the code exists only on the agency's server or private account, which turns every future migration into archaeology and gives the incumbent a veto over your choice of the next contractor.
Each of these is cheap to prevent at contract stage and expensive to fix afterwards. The pattern behind all of them is the same: the contractor's business model relies on the cost of leaving, not on the quality of staying.
## How a good handover looks
The end of the project is where a professional contractor is easiest to tell from the rest, because handover is pure cost for them and pure value for you. A good one treats it as part of the deliverable and schedules it; a bad one treats it as a favour. Here is what complete looks like.
Repository access comes first: the full history transferred to a GitHub or Bitbucket organisation that you own, not a zip of the final state. History matters because the next [WordPress developer](/en/wordpress-developer/) will use it to understand why things were done the way they were, and because it proves what was actually custom work versus configured plugins. Alongside the code you should receive documentation: which plugins are load-bearing and why, where the customisations live, how to deploy a change, and any cron jobs or external services the site quietly depends on.
…[truncated, fetch the canonical URL for the full body]…
---
## Japanese keyword hack: why your security plugin missed it
URL: https://wppoland.com/en/japanese-keyword-hack-2026-detection-cleanup/
Description: The July 2026 wave of the Japanese keyword hack renders only for Googlebot, which is why Wordfence, Sucuri and MalCare report a clean site. How to prove cloaking in one command and clean it in the right order.
Published: Thu Jul 30
Updated: Thu Jul 30
Type: guide
Level: advanced
Tags: malware, security, seo-spam, wp-cli
## The scanner is not lying to you, it is being lied to
On 29 July 2026, Joe Youngblood [posted an alert](https://x.com/YoungbloodJoe/status/2082477986712875431) that the Japanese keyword hack is moving through WordPress sites at speed and, in his words, "easily defeating WordFence, Securi, and Malcare along with other security methods / plugins."
That last part is the interesting one, and it is not a failure of those products in the way it looks. The reason a scan comes back clean is that the payload is not there when the scanner asks for it.
The injected content is served conditionally. The site keeps a web shell, and the shell decides at request time whether to inject. If the request looks like a browser, it returns your ordinary page. If the request looks like Googlebot, it returns a page full of Japanese ecommerce keywords linking to counterfeit goods. Your security plugin fetches the page as itself, gets the ordinary version, and reports nothing.
This is why the first symptom is almost never on the site. It is in Search Console, or in a Google result for your own brand, or in a traffic collapse nobody can explain.
## Prove it in one command before you touch anything
Before you start deleting files, establish what you are actually dealing with. Fetch the same URL twice from a shell:
```bash
curl -s https://example.com/some-page/ > browser.html
curl -s -A "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)" \
https://example.com/some-page/ > crawler.html
diff browser.html crawler.html
```
If the two differ, and the crawler version carries links or keywords the browser version does not, you have cloaking and the diagnosis is finished. No plugin scan, no guessing.
Do the same with your sitemap. A frequent companion symptom is Search Console reporting that the sitemap "appears to be an HTML page" while the sitemap loads correctly in your browser. That is the same mechanism: something intercepts the sitemap route and serves the crawler something else.
Two more places to look, both outside the site:
- **Search Console, Security Issues.** If Google has classified the site, the report names the pattern and holds the review request you will need later.
- **Search Console, Performance, filtered to queries you do not recognise.** Japanese ecommerce terms on a Polish or German site are not ambiguous.
## What each tool can and cannot see
It is worth being precise about why the scanners come back clean, because "the plugin failed" leads people to buy a different plugin rather than change the method.
| Method | Sees a modified core file | Sees a shell in uploads | Sees content served only to crawlers | Sees a seed planted months earlier |
|---|---|---|---|---|
| Plugin malware scan (signature based) | usually | often | **no** | only if the file matches a signature |
| `wp core verify-checksums` | **yes, deterministically** | no, uploads are not checksummed | no | yes, if the file is inside core |
| Grep for base64 and eval | yes, with false positives | yes | no | yes, if the payload is unobfuscated |
| Two-fetch cloaking test | no | no | **yes** | **yes, indirectly, it proves the site is still serving** |
| Search Console Security Issues | no | no | yes, after Google has classified it | no |
The pattern in that table is the whole point. Every method that inspects files answers "is there something in the filesystem", and every method that inspects behaviour answers "is this site currently lying to crawlers". You need both, and only one of them is offered as a product.
## Catching it early, and catching a relapse
The gap between infection and discovery is where the SEO damage happens. Three signals arrive before a traffic collapse does.
**Impressions for queries that make no sense for your business.** Search Console, Performance, sort by impressions, look for anything in a script you do not publish in. This is usually the earliest signal available to you and it costs a minute a week.
**A page that spikes out of nowhere.** In the current wave, the first injected page often shows a sudden impression jump before the rest follow. A page you have not touched in a year suddenly performing is worth thirty seconds of curiosity.
**The favicon in results changing.** Youngblood notes that this wave carries a distinctive favicon, visible in Search Console. A favicon you did not set is a file you did not write.
Once you have cleaned, the same two-fetch test makes a serviceable relapse monitor. This runs from any machine with `curl`, not from the site itself, which matters because a compromised site is a poor judge of its own state:
```bash
#!/usr/bin/env bash
# cloaking-watch.sh - alerts if the crawler view diverges from the browser view
URL="https://example.com/"
UA_BOT="Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
a=$(curl -s --max-time 20 "$URL" | md5sum | cut -d' ' -f1)
b=$(curl -s --max-time 20 -A "$UA_BOT" "$URL" | md5sum | cut -d' ' -f1)
if [ "$a" != "$b" ]; then
echo "DIVERGENCE on $URL at $(date -u +%FT%TZ)"
exit 1
fi
```
Two caveats before you cron this. Pages with rotating content, A/B tests, or personalised blocks will differ legitimately, so point it at a stable page such as an evergreen post or the sitemap. And a determined shell can fingerprint more than the user agent, including the requesting IP range, so a clean result here is evidence rather than proof. It still catches the common case, and it catches it within a day rather than a quarter.
## Telling it apart from the other spam variants
Three infections get called "SEO spam" and they need different first moves, so it is worth spending a minute on which one you have.
**Pharma spam** puts drug keywords into post titles, excerpts and content. It lives in the database, it is visible to ordinary visitors, and you find it by searching `wp_posts` and `wp_options` for the terms Google is showing. If a `SELECT` finds the words, you are in this case, not the Japanese one.
**Casino and betting spam** sits between the two. It often cloaks like the Japanese variant, but it tends to arrive with injected `hreflang` blocks and fabricated language versions of your pages, because the operators want several markets at once. If the crawler view shows alternate-language links you never created, look there.
**The Japanese keyword hack** leaves the database alone. The payload is in files, rendered at request time, and only for crawlers, which is the combination that defeats both the database search and the plugin scan.
There is also a mobile-only redirect variant that switches on the user agent the way this one does, except it checks for phones rather than for Googlebot. If your visitors report being sent to another site and your own desktop tests keep coming back clean, repeat the two-fetch test with a mobile user agent string instead of Googlebot. The mechanism is identical, only the condition changes.
## Verify files deterministically, then look at dates
Youngblood's write-up suggests searching the filesystem for base64 and asking an AI model to review the list. That works, but it is the second step, not the first, because it asks a model to guess which files belong to WordPress. WordPress already knows:
```bash
wp core verify-checksums
wp plugin verify-checksums --all
```
This compares every core and plugin file against the official checksums from WordPress.org and names anything modified or added. It is deterministic, it takes seconds, and it produces a much shorter list to reason about than a base64 grep across the whole tree.
What checksums cannot verify: your theme, anything premium, `wp-content/uploads`, and `mu-plugins`. That is where the manual pass goes:
```bash
grep -rl --include="*.php" -E "base64_decode|eval\(|gzinflate|str_rot13" wp-content/ | head -50
find wp-content/uploads -name "*.php"
ls -la wp-content/mu-plugins/
```
A PHP file inside `uploads` has no legitimate reason to exist. Neither does an `mu-plugins` file you did not write, and that directory deserves particular attention because it loads automatically and never appears in the plugins list.
Then sort what you found by modification time. The bulk of injected files usually share one timestamp, which is the moment of the visible attack. The exception is what Youngblood calls the seed: a single file planted weeks, months or occasionally years earlier, with a timestamp that matches nothing else. If you clean everything except the seed, the infection returns, and it returns quietly.
The practical test for whether you got it: restore a clean `index.php`, wait two minutes, and read the file again. If it has reverted, something still running rewrote it, and you have not finished.
## The order that matters
Cleanup order is where recoveries go wrong, and the sequence is not intuitive.
**Copy before you clean.** Take a full file copy and a database export of the compromised state first. Restoring a backup over the top destroys the only evidence of how entry happened, and if the backup itself is already infected, you have nothing left to compare against. Given a seed file can predate the visible attack by months, treat "restore last month's backup" as an assumption, not a solution.
**Clean, then rotate, then deal with search.** In that order. Rotating credentials before the shell is gone just hands over the new ones.
**Rotate more than passwords.** This is the step almost every guide stops short of:
- **Application passwords**, in each user profile under Users, survive a password reset and keep full REST API access. They are per user, they are easy to create programmatically once an attacker has admin, and most people do not know the feature exists. Enumerate and delete them.
- **Delegated owners in Search Console**, under Settings, Users and permissions, live outside your site entirely. Nothing you do in WordPress removes them. Check ownership verification too, for stray HTML files or DNS TXT records.
- **Database and FTP or SSH credentials**, because if the entry was credential stuffing against `wp-admin`, whatever else shared that password is also exposed.
**Then search.** Regenerate the sitemap, confirm with a live URL Inspection test in Search Console that Googlebot now receives the real page, and request a review in the Security Issues report. Resubmitting a sitemap does not clear a manual flag; the review request does.
## Two pieces of the standard advice worth arguing with
The alert that prompted this article is a good piece of field reporting, and two of its recommendations deserve pushback.
**"Immediately request to remove your full website via Search Console."** This is a heavier instrument than the situation usually needs. The Removals tool hides URLs from results for about six months; it changes nothing about the infection and nothing about how Google eventually re-evaluates the site. Removing the injected URL patterns with a prefix removal is proportionate. Removing the entire site also removes the pages that still bring in enquiries, and every one of those has to come back through a cancellation and a recrawl you do not control. Reach for the whole-site version when the injected pages genuinely outnumber the real ones, not as step one.
**"Find any excuse imaginable to run a press release to drive fresh interest from Googlebot."** Recrawling is driven by things you can actually influence: accurate `lastmod` values in the sitemap, internal links from pages that get crawled often, and URL Inspection requests on the pages that matter. A press release is an expensive way to buy a few crawler visits.
The rest of that write-up, particularly the observation about the seed file having a unique timestamp and the warning to re-check `index.php` after restoring it, matches what these cleanups look like in practice.
## Closing the door the attack actually used
…[truncated, fetch the canonical URL for the full body]…
---
## Gutenberg vs Elementor vs Divi in 2026
URL: https://wppoland.com/en/gutenberg-vs-elementor-divi-2026-page-builder-comparison/
Description: Compare Gutenberg, Elementor, and Divi as 2026 WordPress page builders. Practitioner takes on performance, lock-in, dev workflow, and editorial maintenance.
Published: Tue Mar 18
Updated: Thu Jul 30
Type: guide
Level: advanced
Tags: gutenberg-vs-elementor, wordpress-page-builders, divi-2026, web-performance, block-editor
Three builders define much of the WordPress page-builder decision in 2026. Gutenberg ships with WordPress core. The WordPress.org plugin directory reports 10+ million active Elementor installations, while Elementor markets 22M+ websites worldwide. Those are different measures and should not be merged. Divi does not publish a directly comparable audited active-install figure, so a precise three-way footprint ranking would be false precision.
The choice between them is not a beauty contest. It is a trade between asset overhead, vendor lock-in, developer workflow, and how a non-technical client edits the site after handover. This guide walks each axis with the trade you actually face.
Short answer: Gutenberg for content sites where an editorial team will be trained and a developer maintains theme.json. Elementor for landing-page agency workflows where a non-developer needs to ship pages without touching code. Divi for solo freelancers handing finished sites to non-technical clients on a long-term retainer.
---
## 1. What each builder actually outputs
The architectural difference is not a slogan, it is what ends up in the database and on the wire.
### Gutenberg
Block markup is stored as HTML with comment delimiters (``). On render, blocks emit semantic HTML; styling lives in theme.json plus block stylesheets. Deactivate Gutenberg (impossible in practice since it is core) and the HTML still parses. Migrate to a different platform and the content body is portable.
### Elementor
Page content is stored as `_elementor_data` postmeta - a JSON tree of widget definitions. The `post_content` column itself is mostly empty for Elementor pages. Deactivate Elementor and the front end falls back to whatever is in `post_content`, which is usually nothing.
### Divi
Layout lives in shortcodes inside `post_content`: `[et_pb_section][et_pb_row][et_pb_column][et_pb_text]...`. Deactivate Divi and the front end shows raw shortcode brackets. The lock-in pattern is older than Elementor's but visually identical to a reader.
The takeaway: Gutenberg outputs portable HTML, Elementor and Divi output proprietary structures that bind your content to the plugin runtime.
---
## Page builder market share in 2026: who is actually most used?
Elementor is by far the most used third-party page builder: [W3Techs](https://w3techs.com/technologies/details/cm-wordpress) detected it on 31.5% of WordPress sites on 28 July 2026, and WordPress.org reports 10+ million active installations. Gutenberg does not appear in these lists for a structural reason: it ships inside WordPress core, so the meaningful question is how many sites use it as their primary layout tool rather than whether it is installed.
| Builder | Share of WordPress sites (W3Techs, 28 Jul 2026) |
|:---|:---|
| Elementor | 31.5% |
| WPBakery | 7.5% |
| Beaver Builder | 1.0% |
| Oxygen | 0.4% |
| Bricks | 0.3% |
| Divi Builder (plugin) | 0.1% (see note) |
Two caveats before quoting these numbers anywhere. First, Divi is undercounted here: it ships primarily as a theme, not a plugin, so W3Techs' plugin detection misses most Divi sites, and the multi-million figure usually quoted for Divi comes from Elegant Themes' own marketing rather than an independent measurement. Second, share of installs is not share of new projects: WPBakery's 7.6% is largely legacy ThemeForest themes, while newer builders like Bricks show small totals but grow from a recent base. For choosing a builder in 2026, the practical reading is simple: Elementor has the largest ecosystem and hiring pool, Divi has a loyal but less measurable base, and Gutenberg is the only one guaranteed to be on every WordPress install you will ever touch.
---
## 2. Feature matrix at a glance
Before the per-axis argument, here is the whole comparison on one screen. Read the rows, not the columns: the interesting differences are where one builder does something structurally that the others cannot.
| Capability | Gutenberg (block editor / FSE) | Elementor Pro | Divi |
|---|---|---|---|
| Ships inside WordPress core | yes | no (plugin) | no (theme plus plugin) |
| Visual drag-and-drop canvas | partial (block placement, not free-form) | yes (full) | yes (full) |
| Full site editing (header, footer, templates) | yes (native FSE) | yes (Theme Builder, Pro only) | yes (Theme Builder) |
| Ready-made template and pattern library | growing native plus block-suite packs | large first-party library | large first-party library |
| Free-form and absolute positioning | limited by design | yes | yes |
| Content stored as portable HTML | yes | no (postmeta JSON) | no (shortcodes) |
| Custom extension model | React blocks via block.json | PHP widget API | PHP module and child-theme API |
| Renders with the tool uninstalled | yes (it is core) | no | no |
| Native WooCommerce blocks | yes (Cart and Checkout blocks) | via widgets | via modules |
| Editor learning curve for a non-developer | moderate | low | low |
The shape of the table is consistent: Elementor and Divi win the rows about free-form visual control and a large ready-made template library, Gutenberg wins the rows about portability, core alignment, and the extension model. The one row where the three are not close is content storage, and that is the row that turns into a cost line item two or three years later.
---
## 3. Performance: real numbers, not Lighthouse vibes
| Axis | Gutenberg + block theme | Elementor (Pro) | Divi |
|---|---|---|---|
| CSS added on a typical page | 0-30 KB (theme + block CSS) | 150-300 KB | 120-280 KB |
| JS added | 0-20 KB | 100-200 KB (frontend.js, swiper, dialog) | 80-180 KB |
| DOM nodes on a marketing page | baseline | 3-5x baseline (wrapper-per-widget) | 2-4x baseline |
| INP under bulk editorial load | low | sensitive to widget count | sensitive to module count |
Two practitioner observations behind those ranges:
A WooCommerce store running 30+ Elementor templates across product, archive, single, and checkout will routinely show TTFB above 1.5s on shared hosting because Elementor parses widget JSON on every front-end request before render. Caching helps - Elementor's own asset-loading-experiment helps - but the structural overhead does not vanish.
A Gutenberg site with 100+ block patterns and no pattern registry discipline becomes its own maintenance problem: editors copy-paste a hero pattern, customise it inline, and now you have 40 hero variants in production with no central source. Gutenberg performance wins do not survive editorial drift unless someone owns theme.json and the pattern library.
Divi sits between the two: lighter than legacy Elementor since the version 5 rewrite, heavier than Gutenberg, with the same shortcode-lock-in tax.
---
## 4. Core Web Vitals: what deactivating a builder does
Two separate questions get conflated in most comparisons. One is how fast the builder is in normal operation, covered above. The other is what happens to Core Web Vitals, and to the content itself, if the builder is ever removed. That second question is the lock-in tax expressed as a rendering problem, and it is the one that decides whether a site can survive its own tooling.
With Gutenberg, deactivation is a non-event because the block editor is core and cannot be switched off. The useful thought experiment instead is exporting the content: block markup is valid HTML, so an exported post keeps its structure, headings, lists, and image references intact. Largest Contentful Paint and Cumulative Layout Shift are then governed by the theme and the images, not by an editor runtime that has to boot on every request.
With Elementor, the front end depends on the plugin parsing `_elementor_data` and injecting its own CSS and JavaScript on render. Remove the plugin and the layout is gone; keep it and every page carries the builder's stylesheet and script budget, which is exactly the weight that pressures LCP through render-blocking CSS and pushes Interaction to Next Paint up through the event handlers attached per widget. The builder is not merely how a page was built once, it is a permanent runtime dependency of how that page renders forever.
Divi behaves the same way through shortcodes. The modules have to be resolved by the active Divi runtime, so its CSS and JavaScript travel with every page, and deactivation leaves raw shortcode brackets on the front end. The practical Core Web Vitals consequence is identical to Elementor even though the storage mechanism differs.
The single sentence that matters for a site meant to last: with Gutenberg the content outlives the tool, and with Elementor or Divi the content is the tool's output and cannot render without it. Every performance-remediation project on a builder-heavy site eventually runs into this wall, because you cannot strip the runtime weight without also stripping the layout.
---
## 5. Developer experience and the build pipeline
This is where the comparison stops being about end users.
**Gutenberg** assumes a React + ESNext build pipeline. To ship a custom block you need `@wordpress/scripts`, a `block.json` metadata file, and `registerBlockType()` on the JS side. The learning curve is real - WordPress shops that grew up on classic PHP themes hit it hard the first time. The payoff is that custom blocks behave like first-class WordPress citizens: REST API support, block templates, block patterns, and theme.json overrides come for free.
**Elementor** lets a non-developer ship pages without code. The custom-widget API exists, but most agencies never touch it - they assemble from the built-in widget library and third-party packs. This is the actual reason Elementor wins agency-to-client handoffs: the client can edit the site without breaking it, and the agency does not get a 2 a.m. call about a broken syntax error.
**Divi** sits between. The Divi Builder is non-technical-friendly like Elementor; the Divi child-theme + module API is closer to Gutenberg's developer model than Elementor's widget API. Solo freelancers who do design but not React tend to land here.
If you need to know which one to learn: a 2026 WordPress developer ships Gutenberg blocks and FSE templates, knows enough Elementor to migrate sites off it, and knows Divi exists for client retainer work.
---
## 6. Lock-in and migration cost
Two failure modes that show up repeatedly:
A 200-page brochure site built in Elementor with 30+ Elementor templates and no template inheritance. Adding a single new field to the "case study" template means editing 200 pages by hand because Elementor templates are copy-on-create, not reference. The agency that built it billed quarterly maintenance for years off this exact friction.
A real-estate broker on Divi for eight years. Switching themes means manually rebuilding every page because Divi shortcodes are bound to Divi modules, and no migrator tool exists that preserves layout fidelity. The site is functionally trapped in Divi until someone budgets a rebuild.
Gutenberg's portability is the practical answer. Block markup survives theme switches, plugin churn, and even export-to-static workflows.
---
## 7. Editorial workflow and template inheritance
Where Gutenberg and Elementor diverge sharpest is bulk editorial.
Gutenberg has **synced patterns** (formerly reusable blocks): edit once, propagate everywhere. This is the killer feature for editorial teams running a magazine, knowledge base, or documentation site. Combined with block templates and template parts in FSE, you get genuine inheritance: change the article-footer template part, every article reflects the change.
Elementor has **global widgets** in Pro and **theme parts** in the Theme Builder, but template instances are typically copy-on-create. Editorial teams that did not learn the global-widget pattern early end up with N copies of the same hero, drift across them, and a maintenance bill.
Divi has global modules and the Theme Builder, similar to Elementor.
…[truncated, fetch the canonical URL for the full body]…
---
## jQuery vs Vanilla JS in 2026: migration, risks and when to keep it
URL: https://wppoland.com/en/jquery-vs-vanilla-js-migration-guide/
Description: From $.click() to addEventListener, from $.ajax() to fetch(). A comprehensive technical guide for WordPress developers migrating from jQuery to modern vanilla JavaScript (ES2024+), including Web Components, performance benchmarks, and migration strategies.
Published: Wed Oct 08
Updated: Thu Jul 30
Type: guide
Level: advanced
Tags: jquery, vanilla js, performance, migration, web components, es2024
jQuery solved real browser compatibility problems for over a decade. In 2008, when this article was first published, writing cross-browser JavaScript without jQuery was genuinely painful. Internet Explorer 6 handled events differently, CSS selectors were inconsistent, and AJAX required browser-specific XMLHttpRequest implementations.
Learn more about [WordPress speed optimization](/en/speed-up-wordpress/) at WPPoland.
In 2026, every problem jQuery solved is now handled natively by browsers. The question is no longer *whether* to migrate, but *how* to do it safely without breaking existing functionality.
## Why jQuery is technical debt in 2026
jQuery 3.7 weighs 87KB uncompressed (30KB gzipped). That may sound small, but consider what it costs:
- **Total Blocking Time (TBT)**: jQuery must parse and execute before any dependent code runs. On mid-range mobile devices, this adds 150-300ms to TBT.
- **Interaction to Next Paint (INP)**: jQuery's event delegation system adds overhead to every user interaction, measurably worsening INP scores.
- **Dependency chain**: Loading jQuery means every script that depends on it must wait, creating a waterfall of blocking resources.
- **Redundant code**: Every jQuery method you call has a native equivalent that the browser already ships. You are paying twice for the same functionality.
### Performance benchmarks: jQuery vs vanilla JS
Real-world measurements on a WordPress theme with typical interactions (menu toggle, tab switching, form validation, AJAX load-more):
| Metric | With jQuery | Without jQuery | Improvement |
|--------|-------------|----------------|-------------|
| Total JS size | 142KB | 55KB | -61% |
| TBT (mobile) | 480ms | 180ms | -62% |
| INP (p75) | 220ms | 95ms | -57% |
| LCP | 2.1s | 1.7s | -19% |
| Lighthouse Performance | 72 | 94 | +22 points |
These numbers come from a production WordPress site running GeneratePress with WooCommerce, tested on a Moto G Power (a representative mid-range device).
## What is the difference between jQuery and JavaScript?
JavaScript is the programming language that browsers run; jQuery is a library written in that language. They are not two competing options at the same level. jQuery code executes as JavaScript, so every `$()` call is really a shorter way of invoking the browser's own DOM API.
jQuery, first released in 2006, exists to paper over the DOM, event, and AJAX inconsistencies that plagued Internet Explorer and early browsers. `$('.btn')` wraps `document.querySelectorAll('.btn')`; `$.ajax()` wraps `XMLHttpRequest`. When developers search for the difference between jQuery and JavaScript, they usually mean the difference between jQuery's API and the browser's native API, which is the comparison this guide calls jQuery vs vanilla JS.
The practical consequence: you can express everything jQuery does in plain JavaScript, but you cannot run jQuery without JavaScript underneath it. In 2026 the native APIs (`querySelector`, `addEventListener`, `fetch`, `classList`, `IntersectionObserver`) cover what jQuery once abstracted, which is why loading the 87KB library on top of the language it is built from is now optional rather than necessary.
## Modern JavaScript (ES2024+) replaces every jQuery pattern
The ES2024 specification, fully supported in Chrome 124+, Firefox 126+, Safari 17.4+, and Edge 124+, provides native alternatives for every common jQuery pattern.
### DOM selection
```js
// jQuery
const $buttons = $('.btn');
const $container = $('#main-container');
const $firstItem = $('.menu-item:first');
// Vanilla JS (ES2024+)
const buttons = document.querySelectorAll('.btn');
const container = document.getElementById('main-container');
const firstItem = document.querySelector('.menu-item');
// Scoped selection (like jQuery .find())
const navLinks = container.querySelectorAll('a.nav-link');
```
**Key difference**: `querySelectorAll` returns a static `NodeList`, not a live collection. This is actually safer because the list does not change unexpectedly when the DOM mutates.
### Event handling
```js
// jQuery
$('.btn').click(function () {
$(this).toggleClass('active');
});
$('.menu').on('click', '.menu-item', function () {
// delegated event
});
// Vanilla JS
document.querySelectorAll('.btn').forEach(btn => {
btn.addEventListener('click', () => {
btn.classList.toggle('active');
});
});
// Event delegation (replaces .on() with selector)
document.querySelector('.menu').addEventListener('click', (e) => {
const item = e.target.closest('.menu-item');
if (item) {
// handle menu item click
}
});
```
The `closest()` method is the modern equivalent of jQuery's delegated event matching. It traverses up the DOM tree to find the nearest ancestor matching a selector.
### Class manipulation
```js
// jQuery
$el.addClass('active');
$el.removeClass('hidden');
$el.toggleClass('open');
$el.hasClass('visible');
// Vanilla JS
el.classList.add('active');
el.classList.remove('hidden');
el.classList.toggle('open');
el.classList.contains('visible');
// Multiple classes at once
el.classList.add('active', 'highlighted', 'animate-in');
el.classList.remove('hidden', 'collapsed');
```
### AJAX with fetch API and async/await
```js
// jQuery
$.ajax({
url: '/wp-json/wp/v2/posts',
method: 'GET',
data: { per_page: 5 },
success: function (posts) { renderPosts(posts); },
error: function (xhr) { console.error(xhr); }
});
// Vanilla JS (modern async/await)
async function loadPosts() {
try {
const response = await fetch('/wp-json/wp/v2/posts?per_page=5');
if (!response.ok) {
throw new Error(`HTTP ${response.status}: ${response.statusText}`);
}
const posts = await response.json();
renderPosts(posts);
} catch (error) {
console.error('Failed to load posts:', error);
}
}
// POST with nonce (WordPress pattern)
async function submitForm(data) {
const response = await fetch('/wp-json/custom/v1/submit', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'X-WP-Nonce': wpApiSettings.nonce,
},
body: JSON.stringify(data),
});
return response.json();
}
```
### Animations without jQuery
jQuery's `.fadeIn()`, `.slideDown()`, and `.animate()` can all be replaced with CSS transitions, CSS animations, or the Web Animations API.
```js
// jQuery
$('.panel').slideDown(300);
$('.modal').fadeIn(200);
// CSS approach (preferred for performance)
// In CSS:
// .panel { max-height: 0; overflow: hidden; transition: max-height 0.3s ease; }
// .panel.open { max-height: 500px; }
// In JS:
panel.classList.add('open');
// Web Animations API (for complex, programmatic animations)
modal.animate(
[
{ opacity: 0, transform: 'scale(0.95)' },
{ opacity: 1, transform: 'scale(1)' },
],
{ duration: 200, easing: 'ease-out', fill: 'forwards' }
);
```
The Web Animations API runs on the compositor thread, meaning animations do not block the main thread. jQuery animations run on the main thread and cause jank on slower devices.
### DOM manipulation
```js
// jQuery
$('
Hello
').appendTo('#container');
$('.old-element').replaceWith('New');
$('.item').remove();
$('.list').empty();
// Vanilla JS
const notice = document.createElement('div');
notice.className = 'notice';
notice.textContent = 'Hello';
container.append(notice);
// Or use insertAdjacentHTML for HTML strings
container.insertAdjacentHTML('beforeend', '
Hello
');
// Replace
oldElement.replaceWith(Object.assign(document.createElement('span'), { textContent: 'New' }));
// Remove
item.remove();
// Empty
list.replaceChildren();
```
### Document ready
```js
// jQuery
$(document).ready(function () { /* ... */ });
$(function () { /* shorthand */ });
// Vanilla JS
document.addEventListener('DOMContentLoaded', () => {
// DOM is ready
});
// Or simply place your
```
### Advanced prerender (for high-Intent links)
```html
```
### Differences: Prefetch vs prerender
| Technique | What It Does | When to Use | Resource Cost |
|-----------|--------------|-------------|---------------|
| **Prefetch** | Downloads HTML/CSS/JS | Always safe | ⬤○○ Low |
| **Prerender** | Full DOM + JS rendering | High click probability | ⬤⬤⬤ High |
### Eagerness levels
- **`conservative`**: Only when user clicks and holds
- **`moderate`**: Hover/pointer down (best for most cases)
- **`immediate`**: Immediately after page load
- **`eager`**: Immediately, aggressively
## 5. WordPress implementation
### Method 1: Plugin (quick)
```php
cart) {
foreach (WC()->cart->get_cart() as $item) {
$prerender_urls[] = get_permalink($item['product_id']);
}
}
// Prerender next archive page
if (is_archive() || is_home()) {
$next_link = get_next_posts_link();
if ($next_link) {
preg_match('/href="([^"]+)"/', $next_link, $matches);
if (!empty($matches[1])) {
$prerender_urls[] = $matches[1];
}
}
}
if (empty($prerender_urls)) return;
$rules = [
'prerender' => [[
'source' => 'list',
'urls' => array_unique($prerender_urls),
'eagerness' => 'moderate'
]]
];
echo '';
});
```
## 6. Case studies: Before and after
### Case study 1: WooCommerce store (500 products)
**Problem**: Category → product navigation took seconds
**Solution**:
- Prefetch for links in viewport
- Prerender for "Add to Cart" and "Checkout"
**Result**:
- Before: seconds of wait
- After: perceived as instant
- Bounce Rate: fell noticeably
### Case study 2: WordPress blog (1000+ articles)
**Problem**: INP outside the green band, users felt "lag"
**Solution**:
- Defer all scripts
- Prerender for "Read more"
- Object Cache (Redis)
**Result**:
- INP: moved into the green band
- LCP: moved into the green band
- Organic Traffic: grew
## 7. Pitfalls and warnings
### ❌ don't prerender:
- Pages with authentication (login, user panel)
- Pages with side effects (subscriptions, payments)
- External URLs
### ⚠️ limitations:
- **Mobile Data Saver** disables speculation
- **Non-supporting browsers** (Firefox, Safari < 17) ignore rules
- **Prerender limit**: Chrome allows max 10 simultaneously
### Fallback for non-Supporting browsers
```javascript
if (!HTMLScriptElement.supports?.('speculationrules')) {
// Fallback: classic prefetch
document.querySelectorAll('a[href^="/"]').forEach(link => {
link.addEventListener('mouseenter', () => {
const prefetch = document.createElement('link');
prefetch.rel = 'prefetch';
prefetch.href = link.href;
document.head.appendChild(prefetch);
}, { once: true });
});
}
```
## 8. Browser support (january 2026)
| Browser | Prefetch | Prerender | Notes |
|---------|----------|-----------|-------|
| Chrome 121+ | ✅ | ✅ | Full support |
| Edge 121+ | ✅ | ✅ | Full support |
| Safari 17.4+ | ✅ | ⚠️ | Partial |
| Firefox | ❌ | ❌ | Planned |
## 9. Measurement and monitoring
### Tools
- **Chrome DevTools**: Application → Speculative Loads
- **Lighthouse CI**: Performance test automation
- **WebPageTest**: Real tests from different locations
- **DebugBear**: Real User Monitoring (RUM)
### Metrics to track
```javascript
// Track "wasted" prefetches in GA4
new PerformanceObserver((list) => {
for (const entry of list.getEntries()) {
if (entry.initiatorType === 'speculation') {
gtag('event', 'speculation_load', {
url: entry.name,
duration: entry.duration
});
}
}
}).observe({ type: 'resource' });
```
## 10. Implementation checklist
### ✅ before implementation
- [ ] Measure baseline Lighthouse score
- [ ] Check TTFB < 200ms
- [ ] Ensure Object Cache is active
- [ ] Images are served as AVIF
### ✅ speculation rules implementation
- [ ] Add basic prefetch (moderate)
- [ ] Analyze heatmaps (Hotjar, Clarity)
- [ ] Identify top 3 navigation paths
- [ ] Add prerender for high-intent links
- [ ] Test on 10% traffic (A/B)
- [ ] Monitor "wasted" prefetches
### ✅ after implementation
- [ ] Compare LCP, INP, Navigation Time
- [ ] Check Cache Hit Ratio
- [ ] Long-term: Bounce Rate, Conversion Rate
---
## Summary
**Speculation Rules API** is a significant shift for 2026. By preloading pages in the background, navigation becomes **instant**, without any infrastructure changes.
Key takeaways:
1. Start with **prefetch with moderate eagerness**, it's safe
2. Add **prerender for checkout flow** in e-commerce
3. **Monitor metrics**, don't guess, measure
> **Need professional optimization?** As a [WordPress specialist](/en/wordpress-specialist/), I help speed up WordPress and WooCommerce sites. Also see [WordPress speed optimization](/en/speed-up-wordpress/).
---
## 100/100 Core Web Vitals on WordPress
URL: https://wppoland.com/en/core-web-vitals-100-score-case-study-2026/
Description: How we took a slow WooCommerce site from score 45 to 100. A technical deep dive into Speculation Rules, AVIF, and Critical CSS in 2026.
Published: Thu Jan 08
Updated: Thu Jan 08
Type: guide
Level: advanced
Tags: core-web-vitals, lcp, inp, cls, woocommerce-optimization
Everyone says they optimize for speed. Few can prove it.
This week, we completed a performance overhaul for a client in the competitive "Home Decor" e-commerce space.
**The Starting Point:**
* **Mobile Score**: 42/100
* **LCP**: 4.8s
* **INP**: 450ms (Poor)
* **CLS**: 0.25 (Layout shifting everywhere)
**The Result (After 4 Weeks):**
* **Mobile Score**: 100/100
* **LCP**: 1.2s
* **INP**: 48ms
* **CLS**: 0.00
This wasn't magic. It was engineering. Here is exactly how we did it.
---
## 1. Fixing LCP (Largest Contentful Paint)
**The Villain**: The Hero Slider.
The client used a heavy Revolution Slider. It loaded 4MB of JavaScript before showing the first image.
**The Fix**:
1. **Delet the Slider**: We replaced the slider with a static CSS Grid layout.
2. **Fetch Priority**: We added `` to the main hero image. This tells the browser "Download this BEFORE the logo and the menu."
3. **AVIF Format**: We converted all PNGs to AVIF. The 800KB header image became 45KB.
**Result**: LCP dropped from 4.8s to 1.9s instantly.
---
## 2. Solving CLS (cumulative layout shift)
**The Villain**: Custom Fonts and Lazy Loading.
1. **Fonts**: The text appeared, then the custom font loaded, shifting the layout by 10 pixels.
2. **Images**: Lazy-loaded images appeared and pushed text down because they lacked `width` and `height` attributes.
**The Fix**:
1. **Font Preloading**: We added `` for the primary font and used `font-display: optional`. If the font doesn't load in 100ms, the browser sticks with the system font forever (no shift).
2. **Aspect Ratio**: We enforced `aspect-ratio: 16/9;` on all image containers in CSS. The browser reserves the white space even before the image downloads.
**Result**: CLS dropped to 0.00.
---
## 3. Crushing INP (interaction to next paint)
**The Villain**: Third-Party Scripts.
Chat widgets, Facebook Pixel, Google Tag Manager, Hotjar. They were all fighting for the main thread. When a user clicked "Menu", the browser was too busy tracking the user to open the menu.
**The Fix: Partytown**.
We moved all distinct third-party scripts to a **Web Worker** using Partytown.
This runs the heavy tracking code on a background thread. The main thread (UI) remains buttery smooth.
**Result**: INP dropped from 450ms to 48ms.
---
## 4. The 2026 secret weapon: Speculation rules API
We didn't just want it to *be* fast. We wanted it to *feel* instant.
We implemented the **Speculation Rules API**.
When a user hovers over a product card, the browser:
1. **Prefetches** the HTML of the next page.
2. **Prerenders** it in a hidden background tab.
When they click, the page load is literally **0ms**. It is already there.
---
## 5. Server-Side optimization (the infrastructure)
You can't get a 100 score on a $5 server.
We migrated the client to **WordPress VIP** layout (or consistent high-end architecture).
1. **Redis Object Cache**: Database queries for the "Menu" and "Options" are cached in memory.
2. **Edge Caching (Cloudflare Enterprise)**: The HTML of the homepage is served from a server in Warsaw, not the origin in New York. TTFB dropped from 600ms to 40ms.
---
## 6. Business impact
Why did we do all this? Not for vanity metrics.
* **Bounce Rate**: Decreased by 18%.
* **Ad Spend**: CPC dropped by 12% (Google Ads Quality Score improved due to speed).
* **Revenue**: Organic traffic grew 40% in 2 months as Google rewarded the "Page Experience" signals.
**Conclusion**: Speed is not technical debt. It is a revenue lever.
**Is your [WooCommerce site](/en/woocommerce-developer/) leaking money due to slowness? WPPoland optimizes for green scores and green bank accounts.**
---
## WordPress best practices for security, SEO and performance
URL: https://wppoland.com/en/the-ultimate-guide-to-wordpress-best-practices/
Description: A practical notes covering essential WordPress best practices for security, SEO, and performance using only core features.
Published: Thu Feb 12
Updated: Thu Feb 12
Type: guide
Level: advanced
Tags: wordpress, security, seo, performance, best-practices, wordpress-core, evergreen
# WordPress hardening, performance, and SEO: what actually moves the needle in 2026
There is no single ultimate guide to WordPress. Anyone selling you one is selling a listicle. What follows is a practitioner checklist of the changes that consistently move the needle on real client engagements at wppoland.com, organised across three planes that interact more than most write-ups admit: hardening, page weight, and how search engines and LLMs actually parse the result.
The pattern is almost always the same. A site arrives with a plugin graveyard, an unaudited `wp_options` table, three SEO plugins fighting over the title tag, and a `/wp-login.php` that takes 200 hits per minute from residential IP rotators. None of that gets fixed by a generic checklist. It gets fixed by knowing which knobs in `wp-config.php`, which Cloudflare rules, and which schema decisions return time and rankings, and which are theatre.
## What this post is not
This is not exhaustive reference documentation. The Codex of WordPress hardening lives at `wordpress.org/documentation/article/hardening-wordpress/` and it is more complete than anything one blog post can be. What this post adds is opinion: which subset of those controls is worth implementing first, in what order, and where the typical "best practices" article quietly skips the painful detail.
If you are running a brochure site on shared hosting, half of the recommendations below are overkill. If you are running WooCommerce with member-only pricing and a payment integration, half of them are the bare minimum.
## Hardening that pays for itself
Most WordPress incidents I have cleaned up traced back to one of three things: a stale plugin with a known CVE, a leaked admin password reused from a breached service, or an XML-RPC or REST endpoint left open to enumeration. Almost nothing traces back to a missing security plugin. The implication is that hardening is mostly configuration, and a small number of `wp-config.php` constants do more for the threat model than any "all-in-one" security suite.
### The wp-config.php block I drop into every install
```php
define( 'DISALLOW_FILE_EDIT', true );
define( 'DISALLOW_FILE_MODS', true );
define( 'FORCE_SSL_ADMIN', true );
define( 'WP_AUTO_UPDATE_CORE', 'minor' );
define( 'AUTOMATIC_UPDATER_DISABLED', false );
define( 'WP_POST_REVISIONS', 5 );
define( 'EMPTY_TRASH_DAYS', 7 );
```
`DISALLOW_FILE_EDIT` removes the in-dashboard code editor, which is the single most useful blast-radius reduction available. `DISALLOW_FILE_MODS` goes further and blocks plugin and theme installs and updates from the dashboard entirely; pair it with a deployment pipeline that updates via WP-CLI or Composer. `FORCE_SSL_ADMIN` stops the embarrassing case where someone briefly hits `http://` admin and leaks a session cookie. The revisions and trash limits are not security per se, but they prevent the `wp_posts` and `wp_postmeta` tables from becoming the slow query that masks an actual incident.
### Application passwords and 2FA, with a CLI fallback
Application passwords were enabled by default in WordPress 5.6 and almost nobody audits them. Run `wp user application-password list ` for every administrator on every quarterly review. Revoke anything that does not map to a documented integration. Treat any application password attached to a user with `manage_options` as equivalent to that user's main credential.
For 2FA, the Two-Factor feature plugin is still the cleanest option, but configure it with the assumption that a phone will eventually be lost. Document the recovery path: SSH into the server and run `wp user meta delete _two_factor_*` to drop the second factor, then immediately rotate the password. If you skip this step, you will lock a client out of their own production site at a moment that is always inconvenient.
### Move the brute force fight off WordPress
PHP is the worst place to handle a `/wp-login.php` flood. By the time `wp-login.php` decides a request is bad, you have already spent CPU bootstrapping WordPress. Push the rate limit one layer up.
On Cloudflare, a Rate Limiting rule that allows ten POSTs to `/wp-login.php` per ten minutes per IP, combined with a managed challenge for the same path from non-EU geographies if your audience is regional, removes more than 95% of credential-stuffing traffic without ever touching origin. If your stack runs ModSecurity, OWASP Core Rule Set at paranoia level 1 with `xmlrpc.php` blocked outright is the baseline. Paranoia 2 starts to false-positive on Gutenberg block JSON, so do not jump there without testing the editor.
### File permissions, briefly
Directories `755`, files `644`, `wp-config.php` `440` or `400` and owned by the user PHP-FPM runs as, not by `root`. If your host insists on `777` anywhere, change host. This is not 2008.
### Set Proper File Permissions
File permissions determine who can read, write, and execute files on your server. Incorrect permissions can leave your site vulnerable to attacks. The standard recommended settings are:
- Directories: 755 (rwxr-xr-x)
- Files: 644 (rw-r--r--)
You can modify permissions through your hosting control panel's File Manager or via FTP client. Most reputable hosting providers set these correctly by default, but it's worth verifying.
### Implement Login Security Measures
While we focus on core features, several built-in WordPress settings can improve login security. Consider implementing a custom login URL by using pretty permalinks - this makes it harder for automated bots to find your login page.
Additionally, limit login attempts at the server level if your hosting provider offers this feature. Many hosts provide built-in protection against brute force attacks through their firewall configurations.
## SEO that survives contact with reality
The WordPress SEO conversation has been stuck on permalinks and alt text for a decade. Both still matter, but they are not what separates a site that ranks from one that does not in 2026. The four things I see actually move rankings on client sites are: a coherent Schema.org graph, an SEO plugin configured for one job rather than fighting another plugin, hreflang done correctly for multilingual builds, and a sitemap structure that prioritises what the business cares about.
### Schema as a graph, not a checklist
Most SEO plugins emit a flat list of unconnected JSON-LD blocks: an Organization here, an Article there, a BreadcrumbList that references neither. Search engines and LLMs reward a connected graph: `Article` whose `author` is a `Person` whose `worksFor` is the `Organization` whose `logo` is referenced by the `WebSite`. Both Yoast and Rank Math support this through their respective filters; the work is in defining the graph once and feeding both the user-facing pages and the LLM crawlers a consistent set of `@id` references. If your `about` and `mentions` arrays in front-matter are populated with Wikidata URLs, half this work is already done; the other half is making sure the rendered HTML actually emits them.
### Yoast vs Rank Math: pick one and disable the other completely
The most common collision pattern is two SEO plugins both writing `` and ``, with the result that whichever runs later wins, but both leave their schema in the head. Symptom: duplicate `BreadcrumbList`, duplicate `WebPage`, conflicting `Article` blocks. Google merges what it can and discards the rest, but the signal is muddy. Pick one, deactivate the other, then check the rendered HTML for stale schema cached by an object cache or page cache. Flush both after the migration.
Rank Math tends to win on schema flexibility, Yoast on the opinionated content analysis that authors actually read. Neither matters more than the consistency of using one.
### Hreflang for the six-language builds we ship
If you are running a multilingual site, hreflang is the difference between Google serving the right language to the right country and serving Polish content to Portuguese visitors who then bounce. The annotations have to be reciprocal (every alternate must list every other alternate, including itself), they have to point at canonical URLs, and they have to include `x-default`. Plugins handle this, but verify in Search Console under International Targeting; silent hreflang errors are common after a slug change.
### Sitemap priorities, the WordPress default versus what you want
WordPress core ships `/wp-sitemap.xml`, which is fine for small sites and inadequate for everything else because it does not let you weight or exclude. Yoast and Rank Math both publish `/sitemap_index.xml` with separate post-type indices, which is what you want. The non-obvious move: exclude the `attachment` post type from sitemaps unless you are running a media library that is itself the product. Attachment URLs spawned by image uploads do not need to be in Google's index; they dilute crawl budget on larger sites and produce thin-content soft 404s on smaller ones.
### Optimize Your Permalinks
Permalinks are the permanent URLs to your individual pages and posts. WordPress defaults to a numeric format (/?p=123), which provides no information to search engines or users. Instead, use a descriptive permalink structure that includes your post title.
To change your permalink structure, go to Settings > Permalinks in your Dashboard. The "Post name" option is generally recommended as it creates clean, readable URLs like `yourdomain.com/your-post-title/`.
For custom post types or categories, you can also configure custom structures. Just ensure your URLs are concise and include relevant keywords when appropriate.
### Create Quality Content with Proper Structure
Search engines prioritize content that provides value to users. Structure your articles using heading tags (H1 for titles, H2 for main sections, H3 for subsections) to create a logical hierarchy. This helps search engine crawlers understand your content organization.
WordPress's Block Editor makes it easy to add headings, lists, and other structural elements. Use the built-in blocks to create:
- H2 and H3 headings for section organization
- Numbered lists for step-by-step content
- Bullet points for quick tips
- Quote blocks for testimonials or citations
- Table blocks for comparative data
### Optimize Images for SEO
Images can significantly impact your page load times and SEO performance. Before uploading images to WordPress, compress them using online tools or image editing software. WordPress also includes basic image optimization settings.
When adding images, always include descriptive alt text - this improves accessibility and provides search engines with context about the image content. You can add alt text through the Image block sidebar in the Block Editor or via the Media Library.
### Use categories and tags with intent
WordPress's taxonomy system helps organize your content and improve site navigation. Categories are broad groupings (like "Technology" or "Business"), while tags are more specific descriptors. Both help search engines understand your content structure.
Create logical category hierarchies and use relevant tags sparingly. Avoid over-tagging, as this can dilute your content's relevance signals. A typical post should have 1-2 categories and 5-10 relevant tags.
### Use Excerpts Effectively
Excerpts are brief summaries of your posts that appear in various contexts - search results, archive pages, and RSS feeds. Write custom excerpts that include your primary keyword naturally. You can set custom excerpts in the Document settings sidebar of the Block Editor.
### Enable XML Sitemaps
WordPress automatically generates XML sitemaps that help search engines discover and index your content. These sitemaps are accessible at `yourdomain.com/wp-sitemap.xml`. Search engines like Google can use these sitemaps to understand your site structure and find new content quickly.
…[truncated, fetch the canonical URL for the full body]…
---
## WordPress vs. Webflow 2026: An unbiased, comprehensive comparison
URL: https://wppoland.com/en/wordpress-vs-webflow-2026-comprehensive-comparison/
Description: Choosing between WordPress and Webflow in 2026? This 2000+ word guide covers performance, SEO, E-E-A-T, and a complete TCO analysis for enterprise and creative teams.
Published: Thu Dec 18
Updated: Thu Dec 18
Type: guide
Level: advanced
Tags: wordpress-vs-webflow, cms-comparison, web-design, enterprise-cms, seo-2026
## WordPress vs. Webflow 2026: The definitive guide for decision makers
The digital landscape of 2026 is vastly different from that of five years ago. Websites are no longer just information brochures; they are high-performance conversion engines, primary sources for LLM training data, and the bedrock of brand authority. In this environment, choosing between **WordPress** and **Webflow** isn't just a technical choice - it's a strategic business decision that will impact your scalability for the next decade.
In this comprehensive 2000-word deep dive, we break down every facet of these two giants, moving past surface-level marketing to look at actual performance data, TCO (Total Cost of Ownership), and the technical E-E-A-T requirements of 2026.
---
## 1. The philosophical divide: Ownership vs. Lease
Before we dive into CSS grids and database queries, we must address the fundamental difference in how these platforms operate.
### The WordPress way: Absolute data sovereignty
WordPress is an open-source monument. In 2026, it remains the champion of the "Indie Web." When you build on WordPress, you own the code, the database, and the files. You can move from any host (e.g., WP Engine, Kinsta, or self-hosted Edge servers) without losing functionality.
**Expert Tip:** For enterprises concerned with GDPR, data privacy, or long-term risk mitigation, WordPress is the only logical choice. You are not at the mercy of a single company's pricing changes or shutdown.
### The Webflow way: Hosted design synergy
Webflow is a modern SaaS (Software as a Service). You are "leasing" a proprietary platform. While the visual designer is strong, your CMS data and site logic live on Webflow's servers. If Webflow decides to increase prices by 50% (as SaaS companies often do), your only options are to pay or perform a costly migration.
---
## 2. Design flexibility & the builder experience
### Gutenberg & full site editing (fse)
WordPress has fully matured into the **Blocks era**. The era of messy "shortcodes" and third-party page builders (like Elementor or Divi) slowing down sites is largely over.
- **Native Block Editor**: Fast, accessible, and standards-compliant.
- **Pattern Libraries**: Organizations can create "Design Systems" in WordPress that allow non-technical editors to build complex pages while staying strictly on-brand.
- **AI Integration**: WordPress's 2026 AI core allows for "Intent-based building," where you describe a section, and the editor generates the correct block structure with your brand colors and fonts.
### Webflow designer
Webflow remains the gold standard for **Visual CSS Manipulation**. It is essentially a visual interface for writing code.
- **Precision**: If you need pixel-perfect, complex interactions (parallax, 3D transforms) without writing manual JS/CSS, Webflow is unparalleled.
- **The "Clean Code" Myth**: While Webflow claims cleaner code, a well-built WordPress site with a "Block Theme" is equally performant in 2026. Webflow’s advantage is that it *forces* you to be clean, whereas WordPress *allows* you to be messy if you aren't careful.
---
## 3. SEO & llm optimization (llmo)in 2026
In 2026, longer just about ranking on Google; it's about being the primary citation for AI models (like ChatGPT, Gemini, and Apple Intelligence).
| SEO Factor | WordPress 2026 | Webflow 2026 |
| :--- | :--- | :--- |
| **Technical Metadata** | Absolute control; custom fields out of the box. | Built-in, easy to use, but limited in logic. |
| **Schema.org** | Advanced (RankMath/JSON-LD Custom). | Native support, but harder to scale for custom types. |
| **LLMO (Search for AI)** | Strong; easy to implement specialized LLM cards. | Good, but relies on Webflow's static delivery. |
| **Speed (LCP/INP)** | Edge-hosting dependent; can be sub-200ms. | Excellent out-of-the-box on Webflow's CDN. |
**The E-E-A-T Factor:** Search engines in 2026 heavily favor sites that show "Experience" and "Authoritativeness." WordPress facilitates this through complex taxonomies - linking authors to their biographies, credentials, and multiple content types - much more effectively than Webflow’s flatter CMS structure.
---
## 4. Performance: The 100/100 core web vitals race
Performance is measured by **Time to First Byte (TTFB)** and **Interaction to Next Paint (INP)**.
- **WordPress Performance**: With a modern stack (PHP 8.4+, Object Caching, and Edge Delivery), a WordPress site can be just as fast as any static site. At **WPPoland**, we specialize in optimizing WordPress to achieve 100/100 CWV scores by removing "bloat" and using modern build tools like Vite.
- **Webflow Performance**: Webflow sites are fast by default because they are served from a global CDN. However, as a project grows into hundreds of pages with heavy animations, the CSS and JS files can become bloated, and you have limited power to optimize them compared to the server-side control offered by WordPress.
---
## 5. E-commerce: WooCommerce vs. Webflow shop
If you are selling products, the choice becomes clear very quickly.
**WooCommerce (WordPress):**
- **Pros**: Unlimited scalability. 100% control over the checkout flow. Integration with every payment gateway on earth. No transaction fees (outside of your processor).
- **Cons**: Requires management. You are responsible for security and performance.
**Webflow E-commerce:**
- **Pros**: Beautifully designed cart and product pages. Fully managed.
- **Cons**: Transaction fees on lower plans. Limited to 3,000 items (in many configurations). Very difficult to customize the checkout logic or integrate with complex ERP/Logistics systems.
---
## 6. Case study: A 2026 corporate migration
We recently worked with a mid-sized SaaS company that started on Webflow. They reached 150 pages and noticed two things:
1. Their monthly Webflow bill was $250+ just for hosting.
2. They couldn't implement a complex "User Portfolio" section that required a database connection to their app.
**The Solution:** We migrated them to WordPress.
- **The Result**: Their hosting cost dropped to $50/mo on a managed VPS.
- **Functionality**: We used **Advanced Custom Fields (ACF)** to build a truly dynamic user portal.
- **Performance**: We increased their **Search Visibility** by 35% within 3 months, purely due to better technical SEO handling and "Information Gain" content strategies.
---
## 7. Scaling to enterprise: Security & maintenance
Enterprise teams in 2026 **Security** and **Workflow**.
- **Security**: Webflow is a walled garden. It’s hard to hack because you can’t touch the server. WordPress is an open field - if you don’t build a fence (security plugins, 2FA, managed hosting), you are vulnerable. However, for a professional team, WordPress offers **Security Hardening** that far exceeds SaaS capabilities.
- **Maintenance**: Webflow requires almost zero maintenance. WordPress requires regular updates. In 2026, most busilve this by using **Managed WordPress Hosting**, where updates are automated and tested in staging environments first.
---
## 8. Total cost of ownership (tco) analysis
When calculating costs, look at the **3-year horizon**.
| Expense Type | WordPress (Professional) | Webflow (CMS/Business) |
| :--- | :--- | :--- |
| **Setup Cost** | Higher (Dev fees) | Lower (Designer fees) |
| **Monthly Hosting** | $30 - $100 | $23 - $60+ |
| **Plugin/Add-on fees** | $100 - $300 (Annual) | $0 (Included) |
| **Scaling (High Traffic)** | Minor hosting increase | Significant plan jumps |
| **Total 3-Year TCO** | **Winner: Approx $4,000** | **Approx $5,500** |
---
## 9. The "wppoland" checklist: Which one should you choose?
**Choose WordPress if:**
- [ ] You want full ownership of your data and content.
- [ ] You plan to scale beyond 100 pages.
- [ ] You need a blog that drives actual SEO topical authority.
- [ ] You require complex integrations (CRM, ERP, Custom APIs).
- [ ] You want the best possible "Search for AI" optimization.
**Choose Webflow if:**
- [ ] You are a solo creative or a boutique agency.
- [ ] You have a small site (under 50 pages) that won't change often.
- [ ] You want a "Set it and forget it" managed hosting experience.
- [ ] You need highly complex, pixel-perfect visual interactions.
---
## 10. Frequently asked questions (faq)
1. **Is WordPress still relevant in 2026?**
Absolutely. It powers over 40% of the web and its shift to AI-assisted building has made it more competitive than ever.
2. **Does Webflow export clean code?**
Yes, it is very clean. However, you cannot easily edit this code and re-upload it to the CMS.
3. **Is WordPress slow?**
Only if it's poorly built. A modern WordPress site with **Vite** and **Edge Caching** is among the fastest on the internet.
4. **Can I use AI to build on both?**
Yes, both platforms have integrated AI assistants for layout, copy, and performance optimization.
5. **Which is better for multilingual sites?**
WordPress. The ecosystem for translations (WPML, Polylang) is decades ahead of Webflow’s current offering.
6. **Does Webflow have better customer support?**
Webflow has a dedicated support team for paying customers. [WordPress support](/en/wordpress-website-maintenance/) comes from your host and the massive global community.
7. **What happens if Webflow goes out of business?**
You would have to export your HTML/CSS and rebuild your entire CMS logic on another platform. With WordPress, you just move your files to a different server.
8. **Can I build a social network on Webflow?**
Not easily. Webflow is essentially a front-end builder. WordPress (with BuddyBoss or custom APIs) is a full-scale application framework.
9. **Which is better for a personal portfolio?**
Webflow is excellent for unique, design-heavy portfolios. WordPress is better if that portfolio also includes a high-traffic technical blog.
10. **How do these platforms handle 2026 Accessibility (EAA/WCAG)?**
Both have great tools. In WordPress, blocks are built with accessibility in mind. In Webflow, you have to manually ensure your visual styles meet contrast and labeling standards.
11. **Do I need to know how to code for WordPress?**
In 2026, no. Gutenberg allosual building. However, knowing code (PHP/JS) allows you to do things that are impossible in Webflow.
12. **Is WooCommerce better than Shopify?**
It depends on your need for control. WooCommerce vs Webflow is similar - WooCommerce offers much more power for serious businesses.
13. **Can I use both?**
Some companies use Webflow for their marketing landing pages and WordPress for their main content hub (blog/documentation).
14. **Which is better for small businesses?**
WordPress, primarily due to lower long-term costs and local SEO advantages.
15. **Who wins in 2026?**
The user wins. Both platforms have pushed each other to be faster, better, and more accessible.
---
## Conclusion: The road ahead
In 2026, the "no-code" vs "code" debate has mostly become a low-code reality. Whether you choose **WordPress** or **Webflow**, success depends on content governance, technical execution and who can maintain the system after launch.
Ownership matters when a site needs custom integrations, SEO control, migration paths and long-term maintainability.
Before choosing, list the editors, required integrations, SEO constraints and expected redesign cycle.
---
## How to remove render-blocking CSS and JS? (Async, defer, critical CSS)
URL: https://wppoland.com/en/remove-render-blocking-css-js/
Description: PageSpeed Insights says: 'Eliminate render-blocking resources'. What does it mean? How to use async, defer attributes and Critical CSS.
Published: Wed Oct 31
Updated: Thu Dec 18
Type: guide
Level: advanced
Tags: core web vitals, pagespeed, css
Every millisecond a visitor stares at a blank screen is a millisecond closer to hitting the back button. When PageSpeed Insights flags "Eliminate render-blocking resources," it is telling you that CSS and JavaScript files are standing between your server response and visible content. At wppoland.com we have optimized hundreds of WordPress sites, and removing render-blocking resources consistently delivers the single largest improvement in First Contentful Paint (FCP) and Largest Contentful Paint (LCP). This guide walks through every practical technique, from basic `defer` attributes to advanced Critical CSS extraction, with real code you can apply today.
## What render-blocking actually means
When a browser receives an HTML document, it begins constructing the DOM (Document Object Model) by reading the markup top to bottom. This process is called the **critical rendering path**, and it has a strict rule: the browser cannot paint pixels on screen until it has built both the DOM and the CSSOM (CSS Object Model).
A standard `` tag in the `` is render-blocking by definition. The browser discovers the stylesheet, sends a request, waits for the response, parses the CSS, builds the CSSOM, and only then proceeds to compose the render tree and paint. During that entire download-and-parse cycle, the user sees nothing.
JavaScript makes it worse. A `
```
### The async attribute
```
HTML parsing: ======>| BLOCKED |========>
Script: |--download--|--execute--|
```
With `async`, the browser also downloads in the background, but it executes the script the moment the download finishes, pausing HTML parsing if necessary. Execution order is not guaranteed. This makes `async` ideal for independent scripts that do not interact with the DOM or with other scripts.
```html
```
**When to use each:**
- Use `defer` for your application code, jQuery-dependent scripts, and anything that manipulates the DOM.
- Use `async` for analytics, tracking pixels, A/B testing snippets, and other standalone scripts.
- Never use `async` on scripts that have dependencies on other scripts unless you handle the load order manually.
## Critical CSS, the CSS solution
Unlike JavaScript, CSS does not have a simple `defer` attribute. Every stylesheet is render-blocking because the browser needs styles to render anything meaningful. The solution is a two-part strategy called **Critical CSS**.
### What critical CSS is
Critical CSS is the minimal set of CSS rules required to render the content visible in the viewport on initial load (the "above the fold" content). Instead of waiting for your entire 200 KB stylesheet to download, you inline these critical rules directly in the `` and load the rest asynchronously.
### Extracting critical CSS
**Manual extraction** works for small sites. Open your page, inspect the above-the-fold elements, and copy only the CSS rules that style those elements. This is tedious and error-prone but gives you maximum control.
**Automated tools** are the practical choice:
- **Critical** (by Addy Osmani) is a Node.js module that loads your page in a headless browser, captures the viewport, and extracts only the CSS needed for that viewport. Integrate it into your build process:
```bash
npm install critical --save-dev
```
```javascript
const critical = require('critical');
critical.generate({
base: 'dist/',
src: 'index.html',
css: ['dist/styles.css'],
width: 1300,
height: 900,
inline: true
});
```
- **PurgeCSS** removes unused CSS from your stylesheets entirely. It does not extract critical CSS, but it dramatically reduces the size of the CSS that remains, making the render-blocking impact far smaller.
### Inlining and async loading
Once you have the critical CSS, inline it in the ``:
```html
```
The `preload` with `onload` trick downloads the full stylesheet without blocking rendering. The `noscript` fallback ensures the stylesheet loads normally when JavaScript is disabled. This pattern eliminates the render-blocking stylesheet from the critical path while still delivering all styles.
## Preloading key resources
The `` directive tells the browser to start downloading a resource early, before it would naturally discover it during parsing. This is particularly useful for resources buried deep in CSS files or loaded by JavaScript.
```html
```
### Priority hints with fetchpriority
The `fetchpriority` attribute (supported in all modern browsers) lets you fine-tune which resources the browser should prioritize:
```html
```
Use `fetchpriority="high"` on your LCP element (usually the hero image or heading) and `fetchpriority="low"` on resources that can wait. This gives the browser clear signals about what matters most for the initial viewport.
## WordPress-specific solutions
WordPress has unique challenges because themes and plugins enqueue scripts and styles independently, often without considering performance. Here are the most effective approaches.
### Plugin-based solutions
**WP Rocket** provides the most complete out-of-the-box solution. Enable "Load JavaScript deferred" under File Optimization, and turn on "Remove unused CSS" to generate Critical CSS automatically. WP Rocket handles edge cases like jQuery migration and script dependencies.
**Autoptimize** is a free alternative. Under the JS Options tab, enable "Optimize JavaScript Code" and "Aggregate JS-files." Check "Also aggregate inline JS" for maximum reduction. For CSS, enable "Optimize CSS Code," "Aggregate CSS-files," and "Inline and Defer CSS."
**Perfmatters** offers granular script management. Its Script Manager lets you disable specific plugin scripts on pages where they are not needed. A contact form plugin loading on every page? Disable it everywhere except the contact page.
### The functions.php approach
WordPress 6.3 introduced a native `strategy` parameter for `wp_enqueue_script()` that adds `defer` or `async` properly:
```php
// WordPress 6.3+ native defer support
wp_enqueue_script(
'my-app',
get_template_directory_uri() . '/js/app.js',
array(),
'1.0.0',
array(
'in_footer' => true,
'strategy' => 'defer',
)
);
// Async for analytics
wp_enqueue_script(
'my-analytics',
get_template_directory_uri() . '/js/analytics.js',
array(),
'1.0.0',
array(
'in_footer' => false,
'strategy' => 'async',
)
);
```
For older WordPress versions, use the `script_loader_tag` filter:
```php
add_filter( 'script_loader_tag', 'wppoland_add_defer_attribute', 10, 2 );
function wppoland_add_defer_attribute( string $tag, string $handle ): string {
$defer_scripts = array( 'my-app', 'my-slider', 'my-lightbox' );
if ( in_array( $handle, $defer_scripts, true ) ) {
return str_replace( ' src', ' defer src', $tag );
}
return $tag;
}
```
To conditionally dequeue plugin assets on pages where they are not needed:
```php
add_action( 'wp_enqueue_scripts', 'wppoland_dequeue_unnecessary_assets', 100 );
function wppoland_dequeue_unnecessary_assets(): void {
if ( ! is_page( 'contact' ) ) {
wp_dequeue_style( 'contact-form-7' );
wp_dequeue_script( 'contact-form-7' );
}
}
```
## Font loading and render blocking
Web fonts are a hidden render-blocking resource. By default, browsers hide text until the custom font file downloads, causing a **Flash of Invisible Text (FOIT)**. On slow connections, visitors see a blank area where text should be for several seconds.
### The font-display property
The simplest fix is `font-display: swap` in your `@font-face` declarations:
…[truncated, fetch the canonical URL for the full body]…
---
## WordPress debloat: 11 targeted fixes i use to slash bloat
URL: https://wppoland.com/en/how-to-disable-wordpress-bloat-debloating-guide/
Description: I've been building WordPress sites for over a decade, and one thing never changes: the 'out of the box' setup is too heavy. Here is how I prune the unnecessary scripts and styles safely.
Published: Thu Dec 04
Updated: Thu Dec 04
Type: guide
Level: advanced
Tags: wordpress
WordPress is a powerhouse, but its "one size fits all" defaults mean it often ships with baggage most modern projects don't need. Over the years, I've refined a specific set of snippets to trim the fat without compromising the core experience.
Learn more about [WordPress development services](/en/wordpress-developer/) at WPPoland.
This guide isn't just a list of things to delete; it's a strategic approach to performance. It's inspired by [Terence Eden's excellent list](https://shkspr.mobi/blog/2025/11/a-big-list-of-things-i-disable-in-wordpress/), which I've paired with my own production-tested solutions.
## The case for pruning
Why bother with these small scripts? Because they add up. Every unnecessary line is a potential conflict, a tiny rendering delay, or a wasted byte.
**What we're targeting:**
- **DOM Size**, Stripping unused inline styles.
- **HTTP Overhead**, Dequeuing scripts that shouldn't be there.
- **Security Surface**, Disabling legacy protocols like XML-RPC.
- **Core Web Vitals**, Directly impacting LCP and CLS by removing render-blocking fluff.
> [!IMPORTANT]
> **Use Caution:** Not every "bloat" is useless. If you rely on the classic editor's specific styling or built-in emojis for older browsers, some of these fixes might not be for you. Test in staging first.
## The complete debloating script
Add the following to your theme's `functions.php` file. Each section is commented with explanations and source links.
### 1. Remove classic theme styles
WordPress adds "classic-theme-styles" even on custom themes. Remove them:
```php
// Remove mandatory classic theme.
function disable_classic_theme_styles() {
wp_deregister_style( "classic-theme-styles" );
wp_dequeue_style( "classic-theme-styles" );
}
add_action( "wp_enqueue_scripts", "disable_classic_theme_styles" );
```
### 2. Remove emoji support
WordPress converts text emojis to images and adds detection scripts. If your visitors have emoji support (which all modern browsers do), this is unnecessary:
```php
// Remove WP Emoji.
// https://www.denisbouquet.com/remove-wordpress-emoji-code/
remove_action( "wp_head", "print_emoji_detection_script", 7 );
remove_action( "wp_print_styles", "print_emoji_styles" );
remove_action( "admin_print_scripts", "print_emoji_detection_script" );
remove_action( "admin_print_styles", "print_emoji_styles" );
// https://wordpress.org/support/topic/remove-the-new-dns-prefetch-code/
add_filter( "emoji_svg_url", "__return_false" );
// Stop emoji replacement with images in RSS / Atom Feeds
// https://danq.me/2023/09/04/wordpress-stop-emoji-images/
remove_filter( "the_content_feed", "wp_staticize_emoji" );
remove_filter( "comment_text_rss", "wp_staticize_emoji" );
```
### 3. Disable automatic text formatting
WordPress "texturizes" your content: straight quotes become curly quotes, and ASCII `--` / `---` become en dash / em dash characters (U+2013 / U+2014). That breaks code samples and fights an ASCII-hyphen editorial policy (` - ` or `--`, never long-dash glyphs in source). Disable it on technical content:
```php
// Remove automatic formatting.
// https://css-tricks.com/snippets/wordpress/disable-automatic-formatting/
remove_filter( "the_content", "wptexturize" );
remove_filter( "the_excerpt", "wptexturize" );
remove_filter( "comment_text", "wptexturize" );
remove_filter( "the_title", "wptexturize" );
// More formatting crap.
add_action("init", function() {
remove_filter( "the_content", "convert_smilies", 20 );
foreach ( array( "the_content", "the_title", "wp_title", "document_title" ) as $filter ) {
remove_filter( $filter, "capital_P_dangit", 11 );
}
remove_filter( "comment_text", "capital_P_dangit", 31 );
remove_filter( "the_content", "do_blocks", 9 );
}, 11);
```
> **Note:** The `capital_P_dangit` filter is WordPress's way of auto-correcting "WordPress" to "WordPress". It's aggressive and sometimes unwanted.
### 4. Remove Gutenberg styles and scripts
If you're using a custom theme and don't rely on Gutenberg's frontend styles, remove them:
```php
// Remove Gutenberg Styles.
// https://wordpress.org/support/topic/how-to-disable-inline-styling-style-idglobal-styles-inline-css/
remove_action( "wp_enqueue_scripts", "wp_enqueue_global_styles" );
// Remove Gutenberg editing widgets.
// From https://wordpress.org/plugins/classic-widgets/
// Disables the block editor from managing widgets in the Gutenberg plugin.
add_filter( "gutenberg_use_widgets_block_editor", "__return_false" );
// Disables the block editor from managing widgets.
add_filter( "use_widgets_block_editor", "__return_false" );
// Remove Gutenberg Block Library CSS from loading on the frontend.
// https://smartwp.com/remove-gutenberg-css/
function remove_wp_block_library_css() {
wp_dequeue_style( "wp-block-library" );
wp_dequeue_style( "wp-block-library-theme" );
wp_dequeue_style( "wp-components" );
}
add_action( "wp_enqueue_scripts", "remove_wp_block_library_css", 100 );
```
### 5. Remove header meta tags
Clean up your `` section by removing unnecessary meta tags:
```php
// Remove shortlink.
// https://stackoverflow.com/questions/42444063/disable-wordpress-short-links
remove_action( "wp_head", "wp_shortlink_wp_head" );
// Remove RSD.
// https://wpengineer.com/1438/wordpress-header/
remove_action( "wp_head", "rsd_link" );
// Remove extra feed links.
// https://developer.wordpress.org/reference/functions/feed_links/
add_filter( "feed_links_show_comments_feed", "__return_false" );
add_filter( "feed_links_show_posts_feed", "__return_false" );
// Remove api.w.org link.
// https://wordpress.stackexchange.com/questions/211467/remove-json-api-links-in-header-html
remove_action( "wp_head", "rest_output_link_wp_head" );
// https://wordpress.stackexchange.com/questions/211817/how-to-remove-rest-api-link-in-http-headers
// https://developer.wordpress.org/reference/functions/rest_output_link_header/
remove_action( "template_redirect", "rest_output_link_header", 11, 0 );
```
### 6. Remove image enhancements
WordPress adds `sizes` attributes and other enhancements to images. If you handle these yourself, remove them:
```php
// Remove WordPress forced image size
// https://core.trac.wordpress.org/ticket/62413#comment:40
add_filter( "wp_img_tag_add_auto_sizes", "__return_false" );
// Remove enhancements
// https://developer.wordpress.org/reference/functions/wp_filter_content_tags/
remove_filter( "the_content", "wp_filter_content_tags", 12 );
// Stop rewriting http:// URLs for the main domain.
// https://developer.wordpress.org/reference/hooks/wp_should_replace_insecure_home_url/
remove_filter( "the_content", "wp_replace_insecure_home_url", 10 );
// Remove the attachment stuff
// https://developer.wordpress.org/news/2024/01/building-dynamic-block-based-attachment-templates-in-themes/
remove_filter( "the_content", "prepend_attachment" );
// Remove the block filter
remove_filter( "the_content", "apply_block_hooks_to_content_from_post_object", 8 );
```
### 7. Remove browser check and other admin features
```php
// Remove browser check from Admin dashboard.
// https://core.trac.wordpress.org/attachment/ticket/27626/disable-wp-check-browser-version.0.2.php
if ( !empty( $_SERVER["HTTP_USER_AGENT"] ) ) {
add_filter( "pre_site_transient_browser_" . md5( $_SERVER["HTTP_USER_AGENT"] ), "__return_null" );
}
// Remove hovercards on comment links in admin area.
// https://wordpress.org/support/topic/how-to-disable-mshots-service/#post-12946617
add_filter( "akismet_enable_mshots", "__return_false" );
```
## My additional recommendations
Beyond the techniques above, here are my own solutions for further optimization:
### 8. Disable XML-RPC
If you don't use external apps to post to WordPress, disable XML-RPC to improve security:
```php
// Disable XML-RPC entirely
add_filter( 'xmlrpc_enabled', '__return_false' );
// Remove XML-RPC link from head
remove_action( 'wp_head', 'rsd_link' );
```
### 9. Remove jquery migrate
Modern WordPress themes and plugins rarely need jQuery Migrate. If your site works without it, remove it:
```php
function remove_jquery_migrate( $scripts ) {
if ( ! is_admin() && isset( $scripts->registered['jquery'] ) ) {
$script = $scripts->registered['jquery'];
if ( $script->deps ) {
$script->deps = array_diff( $script->deps, array( 'jquery-migrate' ) );
}
}
}
add_action( 'wp_default_scripts', 'remove_jquery_migrate' );
```
### 10. Disable oembed
If you don't embed content from other sites (YouTube, Twitter, etc.), disable oEmbed:
```php
// Remove oEmbed discovery links
remove_action( 'wp_head', 'wp_oembed_add_discovery_links' );
remove_action( 'wp_head', 'wp_oembed_add_host_js' );
// Remove oEmbed REST API endpoint
remove_action( 'rest_api_init', 'wp_oembed_register_route' );
// Disable oEmbed auto discovery
add_filter( 'embed_oembed_discover', '__return_false' );
```
### 11. Defer javascript loading
Add `defer` to non-critical scripts for better performance:
```php
function add_defer_attribute( $tag, $handle ) {
// Add scripts that should NOT be deferred
$scripts_to_not_defer = array( 'jquery-core' );
if ( in_array( $handle, $scripts_to_not_defer ) ) {
return $tag;
}
return str_replace( ' src', ' defer src', $tag );
}
add_filter( 'script_loader_tag', 'add_defer_attribute', 10, 2 );
```
## Measuring the impact
After implementing these changes, test your site using:
1. **Google PageSpeed Insights**, Check your Core Web Vitals
2. **GTmetrix**, Detailed waterfall analysis
3. **WebPageTest**, Multiple test locations and connection speeds
You should see:
- Reduced page weight (fewer CSS/JS bytes)
- Fewer HTTP requests
- Improved Time to First Byte (TTFB)
- Better Largest Contentful Paint (LCP)
## Conclusion
WordPress's "batteries included" approach is great for beginners, but developers seeking maximum performance need to trim the fat. The techniques in this guide, inspired by [Terence Eden's excellent debloating script](https://shkspr.mobi/blog/2025/11/a-big-list-of-things-i-disable-in-wordpress/), will help you achieve a leaner, faster WordPress installation.
Remember: **less is more**. Every line of code you remove is one less potential point of failure, one less byte to download, and one step closer to a perfect PageSpeed score.
---
## Headless WordPress, ISR vs SSR: pick the rendering mode by content cadence
URL: https://wppoland.com/en/headless-wordpress-isr-vs-ssr/
Description: Incremental Static Regeneration and Server-Side Rendering are not interchangeable. ISR wins when content changes on a predictable cadence and traffic is high. SSR wins when the page is personalised or session-driven. The choice is per-route, not per-stack.
Published: Thu Apr 16
Updated: Thu Apr 16
Type: guide
Level: intermediate
Tags: headless-wordpress, isr, ssr, astro, nextjs, cloudflare-workers
# Headless WordPress, ISR vs SSR: pick the rendering mode by content cadence
The "ISR or SSR" question only makes sense per-route. There is no whole-site answer. Astro and Next.js both let you choose mode at the page or layout level, and the senior-engineering move is to choose deliberately, route by route, against a content-cadence model.
This article anchors to the [Headless WordPress service pillar](/en/services/headless-wordpress/) and pairs with the [Next.js vs Astro decision matrix](/en/headless-wordpress-nextjs-vs-astro-2026/), which covers the framework-level choice.
## TL;DR
- ISR (or static + revalidation) wins when content cadence is predictable and traffic is high.
- SSR wins when the page is personalised, session-driven, or contains live data.
- Cache invalidation drives ISR correctness; webhooks beat time-based revalidation.
- Cloudflare Workers runs both; ISR pays almost no CPU, SSR pays the full render.
- The default is the cheapest mode that satisfies correctness; promote to SSR only when needed.
## What each mode actually does
**Static / Static Site Generation (SSG).** The page is built once, at build time, and served as flat HTML. Cheapest at request time, slowest to update.
**Incremental Static Regeneration (ISR).** The page is built once but can be regenerated on a trigger, usually a webhook on publish or a time-based revalidation interval. Cheap at request time, eventual consistency on update.
**Server-Side Rendering (SSR).** The page is rendered on every request. Always fresh, but the runtime cost scales with traffic. Personalisation, authentication, and live data fit naturally here.
In headless WordPress, all three read from the WordPress origin via REST or GraphQL. The difference is when they read.
## The decision rule
Two inputs matter:
**Content cadence.** How often does this page change? Once a quarter, once a day, every minute, in real time?
**Personalisation surface.** Does this page differ per visitor? Logged-in state, location-aware pricing, A/B test variant.
The rule: pick the cheapest mode that satisfies correctness. Static is cheapest. SSR is most expensive. Promote toward SSR only when correctness fails on a cheaper mode.
| Page type | Default mode | Why |
|---|---|---|
| Marketing pages, blog posts | Static (rebuild on publish) | Low cadence, no personalisation |
| Category and tag archives | ISR with publish webhook | Cadence tied to content publish |
| Product pages, stable catalogue | ISR with stock webhook | Predictable invalidation |
| Product pages, real-time stock | SSR with edge cache | Stock changes within seconds |
| Cart and checkout | SSR | Session-driven by definition |
| Authenticated dashboard | SSR | Per-user state |
| Editorial homepage | ISR with publish webhook | Cadence tied to publish events |
## Cache invalidation is the load-bearing piece
ISR sounds free until it serves a stale canonical URL after a slug change. The pattern that prevents that:
**Webhook-driven invalidation.** WordPress fires a webhook on publish, slug change, or post deletion. The front-end framework consumes the webhook and triggers a regeneration of the affected pages. The cost is one webhook integration on the WordPress origin, paid once.
**Time-based revalidation as a backstop only.** Setting a 60-second revalidation interval covers webhook delivery failures but should not be the primary trigger. A page that revalidates every 60 seconds also rebuilds 60 times per hour; on a 5000-page site that is unsustainable.
**Cache tags, not URLs.** Every cached page is tagged with the WordPress post ID, the term IDs it references, and any cross-cutting tags (homepage, sitemap). When a webhook arrives, the front purges by tag, not by URL. This is the difference between "regenerate the product page" (fragile) and "regenerate everything that references product 8421" (correct).
## Where Cloudflare Workers fits
Both Astro and Next.js compile to a Workers-compatible runtime. The mode-by-mode cost picture:
- **Static at the edge.** Cloudflare Pages serves flat HTML for almost no CPU per request. Cheapest mode.
- **ISR.** First request after invalidation pays the full render cost; cached requests pay almost nothing. Workers handles both.
- **SSR.** Every request pays the full render cost on Workers. Predictable per-request, expensive at scale.
Per the [headless economics article](/en/economics-of-headless-wordpress-2026/), the cost difference matters at high traffic. At low traffic, the choice is correctness, not cost.
## Three real route patterns
**Marketing homepage.** Static, rebuilt on every editorial publish via webhook. Cache for 24 hours at the edge with manual purge override. SSR fallback only if a country-specific banner is added.
**WooCommerce product detail page.** ISR keyed by product ID. Webhook from WooCommerce on stock change, price change, or content update. Cache window: 1 hour as backstop. SSR only if real-time stock display is a UX requirement.
**Customer order history.** SSR. Per-user, session-driven, no caching at the edge.
The same architecture; three different rendering modes; one decision rule.
## Where this fits
This long-tail article anchors to the [Headless WordPress service pillar](/en/services/headless-wordpress/). For framework-level choice, see the [Next.js vs Astro decision matrix](/en/headless-wordpress-nextjs-vs-astro-2026/). For migration-side risks, the [SEO patterns checklist](/en/seo-patterns-for-headless-wordpress/) is the seven-point list. For commerce specifics, [Headless WordPress for WooCommerce](/en/headless-wordpress-for-woocommerce/) is the focused decision article.
---