<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Staging | John Nessime</title>
	<atom:link href="https://john-nessime.com/blog/tag/staging/feed/" rel="self" type="application/rss+xml" />
	<link>https://john-nessime.com/blog/tag/staging/</link>
	<description>Cloud, DevOps, Data &#38; AI — Built, Tested, Explained</description>
	<lastBuildDate>Tue, 10 Nov 2026 07:08:36 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.4</generator>

<image>
	<url>https://john-nessime.com/blog/wp-content/uploads/2026/07/cropped-jn-32x32.png</url>
	<title>Staging | John Nessime</title>
	<link>https://john-nessime.com/blog/tag/staging/</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>WooCommerce HPOS Migration: Moving Orders Out of Postmeta Without Losing the Way Back</title>
		<link>https://john-nessime.com/blog/technical-guides/woocommerce-hpos-migration/</link>
		
		<dc:creator><![CDATA[John Nessime]]></dc:creator>
		<pubDate>Tue, 10 Nov 2026 07:08:36 +0000</pubDate>
				<category><![CDATA[Databases]]></category>
		<category><![CDATA[Technical Guides]]></category>
		<category><![CDATA[WordPress]]></category>
		<category><![CDATA[Action Scheduler]]></category>
		<category><![CDATA[Data Integrity]]></category>
		<category><![CDATA[Database Migration]]></category>
		<category><![CDATA[High-Performance Order Storage]]></category>
		<category><![CDATA[HPOS]]></category>
		<category><![CDATA[MySQL]]></category>
		<category><![CDATA[Order Management]]></category>
		<category><![CDATA[Plugin Conflicts]]></category>
		<category><![CDATA[Rollback Plan]]></category>
		<category><![CDATA[Staging]]></category>
		<category><![CDATA[WooCommerce]]></category>
		<category><![CDATA[WordPress Database]]></category>
		<category><![CDATA[wp_postmeta]]></category>
		<category><![CDATA[WP-CLI]]></category>
		<guid isPermaLink="false">https://john-nessime.com/blog/?p=1077</guid>

					<description><![CDATA[<p>Switching WooCommerce to HPOS takes one click. The trouble starts when sync goes off and every script still reading wp_postmeta quietly sees nothing. Here is the phased path, the WP-CLI checks, and how to keep a way back.</p>
<p>The post <a href="https://john-nessime.com/blog/technical-guides/woocommerce-hpos-migration/">WooCommerce HPOS Migration: Moving Orders Out of Postmeta Without Losing the Way Back</a> appeared first on <a href="https://john-nessime.com/blog">John Nessime</a>.</p>
]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">The switch went fine. The orders screen loads faster, checkout works, and nobody has complained. Then, a week later, someone in finance asks why the nightly export shows no orders since last Tuesday. Nothing errored. The export script is still running every night. It is just reading a table that WooCommerce stopped writing to.</p>



<p class="wp-block-paragraph">That is the failure a WooCommerce HPOS migration is most likely to hand you. Not a broken checkout, not a fatal error, but a reader somewhere that queries <code>wp_postmeta</code> directly and keeps getting answers that look plausible until you compare them with reality.</p>



<p class="wp-block-paragraph">This post walks through moving orders out of postmeta and into High-Performance Order Storage in the order that actually protects you: find the hidden readers first, migrate with sync on, switch, then take sync away in stages while you still have a way back. It covers the WP-CLI commands that do the work, what to check at each step, and the troubleshooting cases that come up most often.</p>



<h2 class="wp-block-heading" id="what-hpos-changes">What HPOS actually changes under the hood</h2>



<p class="wp-block-paragraph">For most of WooCommerce&#8217;s life, an order was a WordPress post with the type <code>shop_order</code>, and everything about it (totals, addresses, payment method, custom fields) lived as rows in <code>wp_postmeta</code>. That table is shared with every post, page and plugin on the site, and it is not indexed for the kind of lookups a store runs all day.</p>



<p class="wp-block-paragraph">HPOS moves orders into four dedicated tables:</p>



<ul class="wp-block-list">
<li><code>wp_wc_orders</code> holds the core order record: status, totals, currency, customer, dates.</li>



<li><code>wp_wc_order_addresses</code> holds billing and shipping addresses as proper columns.</li>



<li><code>wp_wc_order_operational_data</code> holds the internal flags WooCommerce uses while processing an order.</li>



<li><code>wp_wc_orders_meta</code> holds whatever custom metadata plugins attach to orders.</li>
</ul>



<p class="wp-block-paragraph">Two ideas matter more than the table names. First, at any moment one set of tables is <strong>authoritative</strong> (WooCommerce reads and writes there) and the other is the <strong>backup</strong>. Second, <strong>compatibility mode</strong> is WooCommerce&#8217;s name for synchronization: while it is on, every change to the authoritative tables is copied to the backup tables.</p>



<p class="wp-block-paragraph">There is one more detail that explains most of the pain later. When HPOS is authoritative and sync is off, WooCommerce still creates a row in <code>wp_posts</code> for each new order, with the post type <code>shop_order_placehold</code>. It exists to reserve the order ID so the two stores can be synced again if you ever need to. It has no meaningful metadata. It is a hollow row.</p>



<h2 class="wp-block-heading" id="why-it-fails-quietly">Why a WooCommerce HPOS migration fails quietly</h2>



<p class="wp-block-paragraph">Here is the trap. While compatibility mode is on, WooCommerce keeps <code>wp_posts</code> and <code>wp_postmeta</code> fully populated. Every script that reads postmeta directly keeps working. Every test you run looks green.</p>



<p class="wp-block-paragraph">So compatibility mode hides exactly the bug you are testing for. The day you turn sync off, those readers start seeing either nothing (if they filter on <code>shop_order</code>) or placeholder shells (if they don&#8217;t). Neither throws an error. The dashboard just drifts away from the truth.</p>



<p class="wp-block-paragraph">The write path fails the same way in reverse. Code that calls <code>update_post_meta()</code> on an order after the switch writes to the backup tables. WooCommerce never reads that value, so the change silently disappears.</p>



<p class="wp-block-paragraph">These hidden readers and writers come in three families, and each needs a different search.</p>



<h3 class="wp-block-heading" id="readers-outside-wordpress">Readers that never touch PHP</h3>



<p class="wp-block-paragraph">These are the ones a code audit will never find, because they are not in the codebase. A Metabase or Power BI dashboard with a direct MySQL connection. A data warehouse sync. An accounting or shipping integration someone set up with a read-only database user years ago. A cron job on another server that emails a sales summary.</p>



<p class="wp-block-paragraph">The fastest way to find them is not to ask around. Look at who is connecting. List the database users that exist, check which hosts they connect from, and ask the owner of every account that isn&#8217;t WordPress itself what it reads. If your database runs on a managed service or a VPS you control, the connection logs or the process list during business hours will tell you more than any spreadsheet of integrations.</p>



<h3 class="wp-block-heading" id="custom-code-audit">Custom code in themes and plugins</h3>



<p class="wp-block-paragraph">Child themes and small in-house plugins are where direct order access tends to live, because they were written quickly and they worked. A plain grep gives you a first pass:</p>



<pre class="wp-block-code"><code>grep -rnE "get_post_meta|update_post_meta|add_post_meta|delete_post_meta|get_posts|wp_postmeta|shop_order" wp-content/themes/your-child-theme wp-content/plugins/your-custom-plugin</code></pre>



<p class="wp-block-paragraph">Most hits will be false positives, because the same functions handle products and pages. You are looking for the ones that receive an order ID. WooCommerce&#8217;s own extension recipe book publishes a longer regular expression for this audit, which is worth running on anything you maintain.</p>



<p class="wp-block-paragraph">Each real hit gets rewritten to use the order object instead of WordPress post APIs. WooCommerce then decides which tables to touch:</p>



<pre class="wp-block-code"><code>// Before: writes to wp_postmeta regardless of which store is authoritative
update_post_meta( $order_id, '_delivery_slot', $slot );

// After: WooCommerce writes to whichever store is authoritative
$order = wc_get_order( $order_id );
if ( $order ) {
    $order-&gt;update_meta_data( '_delivery_slot', $slot );
    $order-&gt;save();
}</code></pre>



<p class="wp-block-paragraph">Calling <code>save()</code> is not free, so if the same flow saves the order later anyway, don&#8217;t add an extra save. For raw SQL you genuinely need for performance, <code>OrderUtil::custom_orders_table_usage_is_enabled()</code> tells you which tables to query.</p>



<h3 class="wp-block-heading" id="third-party-plugins">Third-party plugins</h3>



<p class="wp-block-paragraph">Plugins declare HPOS compatibility in their main file. If an active plugin declares itself incompatible, WooCommerce disables the HPOS option under <strong>WooCommerce &gt; Settings &gt; Advanced &gt; Features</strong> and lists the offenders behind a &#8220;View and manage&#8221; link.</p>



<p class="wp-block-paragraph">A compatibility declaration is a promise from the vendor, not a test result. Payment gateways, subscription plugins, invoice generators and shipping label plugins deserve their own checkout-and-refund test on staging, declared compatible or not.</p>



<h2 class="wp-block-heading" id="before-production">Before you touch production</h2>



<p class="wp-block-paragraph">The preparation is where the safety comes from. The production switch itself is almost boring if this part is done.</p>



<ol class="wp-block-list">
<li><strong>Take a backup you have actually restored.</strong> A database dump that has never been imported somewhere is a hope, not a backup. Whether it comes from UpdraftPlus, BlogVault, your host&#8217;s snapshots or a plain <code>wp db export</code>, restore it into staging once before you rely on it.</li>



<li><strong>Build staging from a fresh production copy.</strong> Managed hosts like Kinsta, WP Engine, SiteGround and Cloudways do this in a few clicks. On a self-managed VPS from InterServer, Contabo or Hetzner, you clone the database and files yourself. Either way, staging needs the same plugins, versions and custom code as production.</li>



<li><strong>Stop staging from talking to the real world.</strong> Put payment gateways in test mode and block outgoing email before you run test orders against a copy of real customer data.</li>



<li><strong>Run the migration on staging and time it.</strong> The duration of <code>wp wc hpos sync</code> on a full production copy is your best estimate for production.</li>



<li><strong>Test critical flows twice: with sync on, then with sync off.</strong> Checkout with every payment method, refunds, subscription renewals if you run them, and every export or report found in the audit. The sync-off round is the one that finds problems.</li>
</ol>



<p class="wp-block-paragraph">Not sure your restore process would hold up under pressure? A <a href="https://john-nessime.com/projects/cloud-resilience-review/">timed restore drill</a> answers that before the migration rather than during it.</p>



<h2 class="wp-block-heading" id="phased-migration">The phased HPOS migration on production</h2>



<p class="wp-block-paragraph">The order below keeps a one-click way back at every stage until the very end. Run the CLI commands from the WordPress root on the server. If WP-CLI tells you <code>hpos</code> is not a registered command, you left out the <code>wc</code> namespace.</p>



<h3 class="wp-block-heading" id="step-sync-posts-authoritative">Step 1: Turn on sync, keep posts authoritative</h3>



<p class="wp-block-paragraph">In <strong>WooCommerce &gt; Settings &gt; Advanced &gt; Features</strong>, leave WordPress posts storage selected and tick &#8220;Enable compatibility mode&#8221;. Nothing changes for the store yet. WooCommerce starts copying orders into the new tables in the background through Action Scheduler.</p>



<p class="wp-block-paragraph">On a store with a long order history, don&#8217;t wait for the background jobs. Run the sync directly, then confirm nothing is left:</p>



<pre class="wp-block-code"><code>wp wc hpos status
wp wc hpos sync
wp wc hpos count_unmigrated</code></pre>



<p class="wp-block-paragraph"><code>status</code> shows whether HPOS and compatibility mode are on, plus how many orders are unsynced. <code>sync</code> copies orders from the current authoritative store to the other one. Interrupting it and resuming later is safe, which matters if it runs for hours. <code>count_unmigrated</code> should report zero before you continue.</p>



<h3 class="wp-block-heading" id="step-verify">Step 2: Verify the copy</h3>



<pre class="wp-block-code"><code>wp wc hpos verify_data</code></pre>



<p class="wp-block-paragraph">This compares every order across both stores and prints the differing columns and meta keys for any order that doesn&#8217;t match. A clean run is what earns you the next step. The command also accepts <code>--re-migrate</code>, which overwrites mismatched orders. Don&#8217;t reach for it until you know which side is right.</p>



<h3 class="wp-block-heading" id="step-switch">Step 3: Make HPOS authoritative, sync still on</h3>



<p class="wp-block-paragraph">Back in the Features screen, select High-Performance Order Storage and keep compatibility mode ticked. This is a hot switch with no planned downtime, but do it during your quietest hours and stay online afterwards. Place a real low-value order, refund it, and open a few natural orders as they arrive to check the details are complete. A short <a href="https://john-nessime.com/tools/uptime-monitor-trial/">uptime check on the checkout page</a> during this window costs nothing.</p>



<p class="wp-block-paragraph">If anything looks wrong, switching back to posts storage is instant, because sync has kept both stores identical.</p>



<h3 class="wp-block-heading" id="step-sync-on-read">Step 4: Disable sync on read</h3>



<p class="wp-block-paragraph">Sync has two halves. Sync on write copies changes as they happen. Sync on read checks whether the backup copy of an order changed when it is loaded, and it costs more. WooCommerce&#8217;s guide for large stores turns it off first, with a one-line filter in a small must-use plugin or your site plugin:</p>



<pre class="wp-block-code"><code>add_filter( 'woocommerce_hpos_enable_sync_on_read', '__return_false' );</code></pre>



<p class="wp-block-paragraph">Watch the store for a while with this in place. Anything that was quietly writing to postmeta and being rescued by sync on read will surface now, while you can still switch back instantly.</p>



<h3 class="wp-block-heading" id="step-sync-off">Step 5: Turn compatibility mode off</h3>



<p class="wp-block-paragraph">Untick compatibility mode once the store has run cleanly for long enough to cover your full weekly cycle: renewals, exports, scheduled reports, month-end jobs if you can. This is the moment the external readers from your audit either keep working or go quiet, so check each of them the next morning.</p>



<p class="wp-block-paragraph">A quick sanity check is to count what new orders look like on the posts side:</p>



<pre class="wp-block-code"><code>wp db query "SELECT post_type, COUNT(*) FROM wp_posts WHERE post_type IN ('shop_order','shop_order_placehold') GROUP BY post_type;"</code></pre>



<p class="wp-block-paragraph">Adjust the <code>wp_</code> prefix if your site uses another one. A growing <code>shop_order_placehold</code> count is expected. It is also exactly what any direct postmeta reader is now seeing.</p>



<h2 class="wp-block-heading" id="rollback">Rollback: the part to plan before you need it</h2>



<p class="wp-block-paragraph">Your way back gets more expensive at each stage, and it is worth being honest about what each one costs.</p>



<ul class="wp-block-list">
<li><strong>Sync on:</strong> switching back to posts storage is immediate. Both stores match.</li>



<li><strong>Sync off:</strong> you can still go back, but the posts tables are missing every order created since. WooCommerce will refuse to switch while orders are pending sync, so you run <code>wp wc hpos sync</code> first and wait for it. On a busy store, that wait is your rollback time.</li>



<li><strong>After cleanup:</strong> postmeta for migrated orders is gone. Going back means rebuilding the whole posts copy from HPOS.</li>
</ul>



<p class="wp-block-paragraph">That is why WooCommerce&#8217;s own large-store guide mentions running <code>wp wc hpos sync</code> periodically even after sync is off. It keeps the posts copy close enough that a fallback is short. That is a reasonable middle ground for the first few weeks.</p>



<p class="wp-block-paragraph">Cleanup is the only irreversible step, and there is no rush to take it. When you do, it only works with compatibility mode off, and it checks each order before deleting its legacy data:</p>



<pre class="wp-block-code"><code>wp wc hpos cleanup 1000-2000
wp wc hpos cleanup all</code></pre>



<p class="wp-block-paragraph">Start with a range of old order IDs, check the store, then run it for everything. Placeholder rows stay behind in <code>wp_posts</code> by design. Only the metadata goes, which is where the bulk of the legacy data lived anyway.</p>



<h2 class="wp-block-heading" id="troubleshooting">Troubleshooting common HPOS migration problems</h2>



<h3 class="wp-block-heading" id="unsynced-count-stuck">The unsynced order count never reaches zero</h3>



<p class="wp-block-paragraph">Background sync runs through Action Scheduler, which depends on WP-Cron or a real cron hitting the site. If <code>DISABLE_WP_CRON</code> is set with no system cron replacing it, or the site gets little traffic, the queue stalls. Check <strong>Tools &gt; Scheduled Actions</strong> for failed or pending sync actions. The practical fix is simply running <code>wp wc hpos sync</code> from the command line, which doesn&#8217;t wait on the scheduler.</p>



<h3 class="wp-block-heading" id="option-greyed-out">The HPOS option is greyed out</h3>



<p class="wp-block-paragraph">An active plugin has declared itself incompatible. The Features screen links to the list. Update it, replace it, or confirm with the vendor before considering the CLI&#8217;s <code>--ignore-plugin-compatibility</code> flag on <code>wp wc hpos enable</code>. That flag exists for people who have tested the plugin themselves, not as a way past the warning.</p>



<h3 class="wp-block-heading" id="verify-differences">Verification reports differences</h3>



<p class="wp-block-paragraph">Inspect a single order first, then reconcile only what is wrong:</p>



<pre class="wp-block-code"><code>wp wc hpos diff 12345
wp wc hpos backfill 12345 --from=posts --to=hpos --meta_keys=_delivery_slot
wp wc hpos diff 12345</code></pre>



<p class="wp-block-paragraph"><code>diff</code> shows the differing properties side by side and changes nothing. <code>backfill</code> copies a whole order, or just chosen <code>--props</code> or <code>--meta_keys</code>, in the direction you name. A cluster of differences on the same meta key usually points back to one piece of custom code writing directly to postmeta.</p>



<h3 class="wp-block-heading" id="cleanup-refuses">Cleanup refuses an order</h3>



<p class="wp-block-paragraph">The warning that posts data &#8220;appears to be more recent&#8221; means something modified the legacy copy after the migration. That is a finding, not an obstacle. Run <code>diff</code> on the order and work out what wrote to it before you consider <code>--force</code>.</p>



<h3 class="wp-block-heading" id="reports-empty">A report or export suddenly shows no new orders</h3>



<p class="wp-block-paragraph">It is reading <code>wp_posts</code> and <code>wp_postmeta</code> directly. Re-enable compatibility mode as a stopgap if the report matters today, then fix the reader to use the WooCommerce REST API or the new tables. The Query Monitor plugin helps find the offending query when the reader lives inside WordPress.</p>



<h2 class="wp-block-heading" id="common-mistakes">Common mistakes</h2>



<ul class="wp-block-list">
<li>Testing only with compatibility mode on, which keeps every postmeta reader working and proves nothing about them.</li>



<li>Auditing PHP code and forgetting the dashboards, warehouses and integrations that connect straight to MySQL.</li>



<li>Turning sync off the same day as the switch, which removes the instant rollback before the store has seen a normal week.</li>



<li>Running cleanup early to reclaim disk space, turning a reversible migration into a one-way door.</li>



<li>Using <code>--re-migrate</code> or <code>--force</code> to make errors go away without knowing which copy of the data was correct.</li>



<li>Running test orders on a staging copy with live payment keys or outgoing email still enabled.</li>
</ul>



<h2 class="wp-block-heading" id="best-practices">Best practices</h2>



<ul class="wp-block-list">
<li>Write down every system that reads order data, and who owns it, before you change anything.</li>



<li>Use the CLI for the bulk sync on any store with a real order history, and record how long it took on staging.</li>



<li>Take sync away in stages: sync on read first, compatibility mode later, cleanup last.</li>



<li>Keep new custom code on <code>wc_get_order()</code> and the order object&#8217;s meta methods, even on stores still on posts storage. It works on both.</li>



<li>Note the date and time of each stage so a report that looks odd later can be traced to the right change.</li>
</ul>



<h2 class="wp-block-heading" id="faq">Frequently asked questions</h2>



<h3 class="wp-block-heading">Is a WooCommerce HPOS migration reversible?</h3>



<p class="wp-block-paragraph">Yes, until you run cleanup. With compatibility mode on, switching back is instant. With it off, you sync the posts tables first and then switch. After cleanup, going back means rebuilding the legacy copy.</p>



<h3 class="wp-block-heading">Does switching to HPOS cause downtime?</h3>



<p class="wp-block-paragraph">No planned downtime is needed. Both the switch to HPOS and the switch back are hot changes. Do it during quiet hours anyway, because what you want to watch is the first real orders.</p>



<h3 class="wp-block-heading">How long does the order migration take?</h3>



<p class="wp-block-paragraph">It depends on order count, metadata volume and database performance, so there is no useful general number. Run <code>wp wc hpos sync</code> on a staging copy of production and time it. That is your estimate.</p>



<h3 class="wp-block-heading">Why are there shop_order_placehold posts in my database?</h3>



<p class="wp-block-paragraph">They reserve order IDs in <code>wp_posts</code> while HPOS is authoritative and sync is off, so the two stores can still be synced later. They are expected and should not be deleted by hand.</p>



<h3 class="wp-block-heading">Will my plugins still work after moving orders out of postmeta?</h3>



<p class="wp-block-paragraph">Plugins that use WooCommerce&#8217;s order APIs will. Plugins that query postmeta directly won&#8217;t see new orders once sync is off. Check each plugin&#8217;s declared compatibility, then test the flows that matter on staging with sync disabled.</p>



<h3 class="wp-block-heading">When is it safe to delete the old order data from postmeta?</h3>



<p class="wp-block-paragraph">When the store has run on HPOS with sync off through your full business cycle and every external reader has been confirmed on the new tables or the API. There is no performance reason to hurry.</p>



<h2 class="wp-block-heading" id="conclusion">The one thing to remember</h2>



<p class="wp-block-paragraph">A WooCommerce HPOS migration almost never fails on the switch. It fails on whatever reads the database behind WooCommerce&#8217;s back, and compatibility mode hides that until the day you turn it off. Find the readers first, test with sync disabled on staging, and take sync away in stages while you still have an instant way back. Cleanup can wait.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading" id="services">Need a hand moving your store to HPOS?</h2>



<p class="wp-block-paragraph">This is the kind of migration I&#8217;d rather plan with you than clean up after. Here is where I can help:</p>



<ul class="wp-block-list">
<li>Auditing themes, custom plugins and database users for anything reading or writing order data outside WooCommerce&#8217;s APIs.</li>



<li>Building a staging copy of your store with payments and email safely disconnected, then timing the full sync on it.</li>



<li>Running the phased production switch with you, including verification, the sync-on-read step and a written rollback plan.</li>



<li>Rewriting custom code that uses post meta functions on orders so it works on both storage modes.</li>



<li>Fixing reports, exports and integrations that went quiet after sync was turned off.</li>



<li>Reconciling orders that differ between stores using diff and backfill, before anything is cleaned up.</li>
</ul>



<p class="wp-block-paragraph">Send me the output of <code>wp wc hpos status</code> and a list of what reads your orders, and I&#8217;ll tell you where the risk is.</p>



<div class="wp-block-buttons is-layout-flex wp-block-buttons-is-layout-flex">
<div class="wp-block-button"><a class="wp-block-button__link wp-element-button" href="https://www.upwork.com/freelancers/~01f15a912ad84a6620" target="_blank" rel="noreferrer noopener">Work with me on Upwork</a></div>
</div>
<p>The post <a href="https://john-nessime.com/blog/technical-guides/woocommerce-hpos-migration/">WooCommerce HPOS Migration: Moving Orders Out of Postmeta Without Losing the Way Back</a> appeared first on <a href="https://john-nessime.com/blog">John Nessime</a>.</p>
]]></content:encoded>
					
		
		
			</item>
		<item>
		<title>Two Sources of Truth: Git-Based WordPress Deployment From Local to Production</title>
		<link>https://john-nessime.com/blog/devops/git-based-wordpress-deployment/</link>
		
		<dc:creator><![CDATA[John Nessime]]></dc:creator>
		<pubDate>Sat, 01 Aug 2026 09:24:28 +0000</pubDate>
				<category><![CDATA[DevOps]]></category>
		<category><![CDATA[Technical Guides]]></category>
		<category><![CDATA[WordPress]]></category>
		<category><![CDATA[Automation]]></category>
		<category><![CDATA[Bash]]></category>
		<category><![CDATA[Bedrock]]></category>
		<category><![CDATA[CI/CD]]></category>
		<category><![CDATA[Composer]]></category>
		<category><![CDATA[Deployment]]></category>
		<category><![CDATA[Git]]></category>
		<category><![CDATA[GitHub Actions]]></category>
		<category><![CDATA[rsync]]></category>
		<category><![CDATA[Staging]]></category>
		<category><![CDATA[Troubleshooting]]></category>
		<category><![CDATA[WordPress Database]]></category>
		<category><![CDATA[WordPress Hosting]]></category>
		<category><![CDATA[WordPress Migration]]></category>
		<category><![CDATA[WP-CLI]]></category>
		<guid isPermaLink="false">https://john-nessime.com/blog/?p=60</guid>

					<description><![CDATA[<p>A plugin quietly reverts after every deploy and nobody knows why. That is what happens when Git and wp-admin both think they own the file tree. Here is how to build a deployment workflow where the repo is the source of truth and the database only ever travels one way.</p>
<p>The post <a href="https://john-nessime.com/blog/devops/git-based-wordpress-deployment/">Two Sources of Truth: Git-Based WordPress Deployment From Local to Production</a> appeared first on <a href="https://john-nessime.com/blog">John Nessime</a>.</p>
]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">Someone reports that the contact form stopped working. You check the log, and nothing has touched that plugin in three weeks. You SSH into production, look at the plugin directory, and the version on disk is older than the version in your repo. Older than production had yesterday, in fact.</p>



<p class="wp-block-paragraph">Then it clicks. Somebody logged into wp-admin last month, saw an update notice, clicked it. The plugin got updated on the server and never in git. Last night&#8217;s deploy synced the repo over the top and put the old version back, along with the vulnerability the update was patching. No error, no warning. The deploy did exactly what it was told.</p>



<p class="wp-block-paragraph">That is the failure mode that kills most attempts at <strong>Git-based WordPress deployment</strong>, and it has nothing to do with your pipeline. WordPress is designed to modify itself. It installs plugins, updates core, writes files, all from the browser. The moment you put it under version control you have two systems that both believe they own the file tree, and they will quietly overwrite each other until somebody notices.</p>



<p class="wp-block-paragraph">This post covers the whole chain: what belongs in the repo, how to shut the second write path, how configuration differs per environment, which way the database is allowed to travel, and how to make staging safe enough that you can restore production data into it without emailing your customers by accident.</p>



<h2 class="wp-block-heading">The two things that make WordPress awkward under Git</h2>



<p class="wp-block-paragraph">Everything in this workflow follows from two facts.</p>



<p class="wp-block-paragraph"><strong>State is split across files and a database.</strong> Your theme is code. Your posts are data. But so are your plugin settings, your menus, your widget layouts, and your permalink structure, and those live in the database next to the content. Git only manages half your site, and it is not obvious which half a given change landed in.</p>



<p class="wp-block-paragraph"><strong>The two halves travel in opposite directions.</strong> Code moves forward, local to staging to production. Content moves backward, production to staging to local. Once a site is live, production is the only authoritative source of orders, comments and posts, and pushing a database upward destroys everything written since your last pull.</p>



<p class="wp-block-paragraph">Write that rule somewhere the whole team can see it. Almost every catastrophic WordPress deployment story is somebody pushing a database in the wrong direction.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading">Decide what actually goes in the repo</h2>



<p class="wp-block-paragraph">Three approaches, in increasing order of discipline and payoff. Pick one deliberately rather than drifting into the first.</p>



<ol class="wp-block-list">
<li><strong>Theme only.</strong> The repo contains one custom theme, sometimes a custom plugin. Everything else is installed through wp-admin. Easy to start, and it means you have no reproducible build: rebuilding the site from the repo is impossible.</li>
<li><strong>All of wp-content, minus uploads.</strong> Themes, plugins and mu-plugins in git; core and media excluded. This is the pragmatic middle and where most teams land. You get reproducible plugin versions and a real diff when a plugin changes.</li>
<li><strong>Composer-managed, Bedrock-style.</strong> Core, plugins and themes are all declared as dependencies. The repo holds a <code>composer.json</code> and your own code, nothing else. The lockfile is the source of truth and <code>composer install</code> rebuilds the site anywhere.</li>
</ol>



<p class="wp-block-paragraph">Option three is the one I reach for on anything with more than one developer, because &#8220;which plugin version is production running&#8221; becomes a question with an answer. The honest cost: premium plugins that are not on a Composer repository need either a private repository or a manual step, and that friction is real. If most of your plugin stack is commercial, option two is a reasonable place to stop.</p>



<p class="wp-block-paragraph">One thing to check if you are following an older tutorial. The Composer repository landscape for WordPress plugins shifted recently: WPackagist was acquired by WP Engine, and the Roots team launched WP Packages as an independent alternative with different package naming. Both work. Any guide written before that change will use the older <code>wpackagist-plugin/</code> prefix, so make sure the repository URL and the prefixes in your <code>composer.json</code> match each other.</p>



<h3 class="wp-block-heading">The gitignore that matters</h3>



<pre class="wp-block-code"><code># Secrets and machine-specific config. Never committed.
wp-config.php
.env

# Content, not code. This gets pulled down from production,
# it never gets deployed up.
wp-content/uploads/

# Generated at runtime or by the build.
wp-content/cache/
wp-content/upgrade/
wp-content/debug.log
node_modules/
vendor/</code></pre>



<p class="wp-block-paragraph">Ignoring <code>vendor/</code> assumes your deploy runs <code>composer install</code>. If your pipeline just rsyncs the repo with no build step, commit it instead, or you will ship a site with no dependencies. Decide which, then be consistent, because half-and-half is how you end up with a missing autoloader at two in the morning.</p>



<h2 class="wp-block-heading">Close the second write path</h2>



<p class="wp-block-paragraph">This is the step people skip, and it is the one that makes everything else work. If production can still install and update plugins from the browser, your repo is not the source of truth. It is a suggestion.</p>



<pre class="wp-block-code"><code>// wp-config.php on production and staging.

// Removes the ability to install, update or delete plugins and
// themes from the admin. Also disables the built-in file editor,
// so DISALLOW_FILE_EDIT is implied by this one.
define( 'DISALLOW_FILE_MODS', true );

// Stops core from updating itself behind your back, including
// the automatic minor updates that would otherwise change files
// your deploy is about to overwrite.
define( 'AUTOMATIC_UPDATER_DISABLED', true );</code></pre>



<p class="wp-block-paragraph">Be clear-eyed about the trade-off, because it is a real one. You have just taken away automatic security updates. That is only an improvement if you replace them with something: a scheduled dependency update job, a weekly review of the update list, a bot that opens a pull request when a plugin version changes. If you disable updates and then do nothing, you have made the site less safe, not more controlled.</p>



<p class="wp-block-paragraph">The update flow now runs through the repo. On your local machine:</p>



<pre class="wp-block-code"><code># Composer-managed: bump the lockfile, commit it, deploy.
composer update wp-plugin/some-plugin

# wp-content-in-git: let WP-CLI do the download locally,
# then commit the resulting file changes as a normal diff.
wp plugin update some-plugin</code></pre>



<p class="wp-block-paragraph">The second form is worth appreciating. A plugin update becomes a reviewable diff. When something breaks two days later, <code>git log</code> tells you exactly which files changed and <code>git revert</code> puts them back.</p>



<h2 class="wp-block-heading">Configuration per environment</h2>



<p class="wp-block-paragraph">Database credentials, salts and API keys differ per environment and none of them belong in git. Keep <code>wp-config.php</code> out of the repo and place it on each server, or use an environment file with a committed <code>.env.example</code> showing the required keys with no values.</p>



<p class="wp-block-paragraph">Core has a first-class way to tell environments apart, and it is underused:</p>



<pre class="wp-block-code"><code>// Per environment, in wp-config.php.
// Recognised values: 'local', 'development', 'staging', 'production'.
define( 'WP_ENVIRONMENT_TYPE', 'staging' );</code></pre>



<pre class="wp-block-code"><code>&lt;?php
// mu-plugin, committed to the repo, safe on every environment
// because it checks where it is running.

if ( wp_get_environment_type() !== 'production' ) {

    // Keep non-production sites out of search results.
    add_filter( 'pre_option_blog_public', '__return_zero' );

    // Short-circuit wp_mail() entirely. Returning a non-null
    // value stops WordPress before it hands anything to PHPMailer.
    add_filter( 'pre_wp_mail', '__return_false' );
}</code></pre>



<p class="wp-block-paragraph">That mail filter is the single most valuable line in this post. Restore a production database onto staging, forget this, and the first cron run mails real order confirmations, password resets and abandoned-cart nudges to real customers from a URL that does not work. It is silent until it is very loud.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading">Moving the database in the allowed direction</h2>



<p class="wp-block-paragraph">Set up WP-CLI aliases once and the rest becomes short commands instead of a runbook nobody follows.</p>



<pre class="wp-block-code"><code># wp-cli.yml in the project root, committed to the repo.
@staging:
  ssh: deploy@staging.example.com/var/www/staging.example.com
@production:
  ssh: deploy@example.com/var/www/example.com</code></pre>



<p class="wp-block-paragraph">Now pulling production down to your machine is one pipe. The trailing hyphen means &#8220;write the dump to standard output&#8221;, and the leading hyphen on the import means &#8220;read it from standard input&#8221;, so nothing touches disk:</p>



<pre class="wp-block-code"><code># Back up your local database first, then overwrite it.
wp db export local-backup.sql
wp @production db export - | wp db import -</code></pre>



<p class="wp-block-paragraph">The URLs inside that dump still point at production, and they are buried in serialized PHP arrays where a plain SQL find-and-replace corrupts the string length prefixes. This is exactly what <code>wp search-replace</code> exists for: it unserializes, replaces, and reserializes properly.</p>



<pre class="wp-block-code"><code># Always dry-run first and actually read the table list it prints.
wp search-replace 'https://example.com' 'https://example.test' 
  --all-tables-with-prefix --skip-columns=guid --dry-run

# Then for real.
wp search-replace 'https://example.com' 'https://example.test' 
  --all-tables-with-prefix --skip-columns=guid

wp cache flush</code></pre>



<p class="wp-block-paragraph">Two flags worth understanding rather than copying:</p>



<ul class="wp-block-list">
<li><strong><code>--skip-columns=guid</code></strong> because the <code>guid</code> column is a permanent identifier that feed readers and external systems use to decide whether they have already seen a post. Rewriting it makes subscribers re-receive your entire archive, and you find out from an angry email weeks later.</li>
<li><strong><code>--all-tables-with-prefix</code></strong> because plugins create their own tables using your prefix, and those tables are not registered with WordPress. Without this, the replacement misses them and you get half-migrated URLs in places nobody checks.</li>
</ul>



<p class="wp-block-paragraph">Uploads are the other half of the content problem. Do not put them in git; a media library will outgrow a repository quickly and every clone pays for it. Sync them separately with <code>rsync</code> when you need them, or skip them entirely locally and let a plugin proxy missing images from production. Offloading media to object storage sidesteps the question completely and is worth considering on any site with a large library.</p>



<h2 class="wp-block-heading">The deploy itself</h2>



<p class="wp-block-paragraph">Three broad options. <code>git pull</code> on the server is the simplest and the one I would move away from first: it puts a <code>.git</code> directory next to your document root, it has no build step, and a failed pull leaves the site half-updated. Rsync from CI is the pragmatic default. Atomic releases with a symlink swap, the way Deployer or Capistrano work, are the most correct because the site switches versions instantly and rollback is a symlink change.</p>



<p class="wp-block-paragraph">A workable rsync deploy from GitHub Actions, with staging on merge and production on tag:</p>



<pre class="wp-block-code"><code>name: Deploy
on:
  push:
    branches: [main]     # goes to staging
    tags: ['v*']         # goes to production

jobs:
  deploy:
    runs-on: ubuntu-latest
    timeout-minutes: 15
    steps:
      - uses: actions/checkout@v4    # pin to a full SHA in production

      - name: Build
        run: |
          composer install --no-dev --optimize-autoloader
          npm ci
          npm run build

      - name: Sync files
        run: |
          echo "$DEPLOY_KEY" &gt; deploy_key
          chmod 600 deploy_key
          rsync -az --delete 
            -e "ssh -i deploy_key -o StrictHostKeyChecking=accept-new" 
            --exclude-from=.deployignore 
            ./ "$TARGET"
        env:
          DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}
          TARGET: ${{ secrets.DEPLOY_TARGET }}</code></pre>



<p class="wp-block-paragraph"><code>--delete</code> is what makes the target match the source exactly, which is the entire point of a deploy. It is also the flag that will erase your uploads directory if <code>.deployignore</code> is wrong. Test the exclude list against staging before you ever point this at production, and use <code>--dry-run</code> the first time.</p>



<p class="wp-block-paragraph">Files landing on the server is not the same as a working deploy. Run a post-deploy step over SSH:</p>



<pre class="wp-block-code"><code>#!/usr/bin/env bash
set -euo pipefail

cd /var/www/example.com

# Applies schema changes that a core or plugin version bump needs.
# Safe to run when there is nothing to do.
wp core update-db

# Rewrite rules live in the database, so a plugin that registers
# new routes needs this or you get 404s on the new URLs.
wp rewrite flush

# Options and transients are cached; stale ones survive a file deploy.
wp cache flush

# Prove the site answers before you call the deploy finished.
# --fail makes curl exit non-zero on a 5xx instead of shrugging.
curl --fail --silent --show-error https://example.com/ &gt; /dev/null</code></pre>



<p class="wp-block-paragraph">If you run PHP-FPM with OPcache, add a reset to that script. Otherwise PHP happily serves the previous version of your code from its compiled cache and you spend twenty minutes convinced the deploy did not run.</p>



<h2 class="wp-block-heading">Making staging safe to hold real data</h2>



<p class="wp-block-paragraph">Staging is only useful if it mirrors production, and the moment it does it becomes dangerous. Every one of these has bitten somebody:</p>



<ul class="wp-block-list">
<li><strong>Outbound email.</strong> Covered above. Kill it at the <code>wp_mail()</code> level rather than trusting a plugin setting somebody can toggle.</li>
<li><strong>Cron.</strong> A restored production database brings production&#8217;s scheduled jobs with it. Set <code>DISABLE_WP_CRON</code> on staging and do not add a system cron job unless you specifically need to test scheduling.</li>
<li><strong>Payment gateways.</strong> The database carries live API keys. Overwrite them with test-mode credentials as part of your restore script, not by hand afterwards.</li>
<li><strong>Search indexing.</strong> Filter <code>blog_public</code> as shown, and put HTTP basic auth in front of the whole environment. Duplicate content ranking above your real site is an avoidable embarrassment.</li>
<li><strong>Personal data.</strong> A production restore is real customer data on a server that probably has weaker access controls. Either anonymise user records during the restore or treat staging with the same seriousness as production.</li>
</ul>



<p class="wp-block-paragraph">Write the restore as a single script that does all of this in order, so nobody has to remember step four. If it is a checklist in a wiki, it will be skipped.</p>



<h2 class="wp-block-heading">Troubleshooting</h2>



<h3 class="wp-block-heading">The deploy ran but the site is unchanged</h3>



<p class="wp-block-paragraph">In order: OPcache serving compiled bytecode, a page cache or CDN holding the old response, or rsync excluding the directory you edited. Check them in that order. Confirm the file on disk actually changed before blaming anything upstream of it.</p>



<h3 class="wp-block-heading">White screen immediately after deploying</h3>



<p class="wp-block-paragraph">Usually a missing autoloader, meaning <code>vendor/</code> was neither committed nor built. Check the PHP error log rather than guessing. A memory limit lower on the server than locally is the other common cause, and it produces the same blank page.</p>



<h3 class="wp-block-heading">Site works, admin redirects in a loop</h3>



<p class="wp-block-paragraph"><code>siteurl</code> and <code>home</code> in the options table disagree with the URL you are actually using. Almost always a search-replace that missed. Check with <code>wp option get siteurl</code> and <code>wp option get home</code>, and set them explicitly with <code>wp option update</code> rather than running the replacement again.</p>



<h3 class="wp-block-heading">Serialized data broken after a migration</h3>



<p class="wp-block-paragraph">Somebody ran <code>sed</code> or a SQL <code>REPLACE</code> on the dump. The length prefix inside each serialized string no longer matches the string, so PHP silently fails to unserialize and widgets, theme options and ACF fields come back empty. Restore from the dump and redo it with <code>wp search-replace</code>. There is no partial recovery worth attempting.</p>



<h3 class="wp-block-heading">Permalinks return 404 after deploy</h3>



<p class="wp-block-paragraph">Rewrite rules are stored in the database and did not get regenerated. Run <code>wp rewrite flush</code>. If it recurs on every deploy, add it to the post-deploy script permanently.</p>



<h3 class="wp-block-heading">Plugin reverts to an older version after every deploy</h3>



<p class="wp-block-paragraph">Somebody is still updating in wp-admin. That is not a pipeline bug, it is the second write path being open. Set <code>DISALLOW_FILE_MODS</code> and give the team a documented way to request an update.</p>



<h2 class="wp-block-heading">Common mistakes</h2>



<ul class="wp-block-list">
<li>Committing <code>wp-config.php</code>, and with it your database password and salts.</li>
<li>Putting <code>wp-content/uploads</code> in the repo, then wondering why clones take ten minutes.</li>
<li>Pushing a staging database over production because &#8220;the content is the same&#8221;. It never is.</li>
<li>Using <code>sed</code> or SQL to swap URLs instead of <code>wp search-replace</code>.</li>
<li>Replacing the <code>guid</code> column, and re-sending your archive to every RSS subscriber.</li>
<li>Running <code>rsync --delete</code> against production without testing the exclude list.</li>
<li>Leaving updates enabled in wp-admin, so the repo and the server drift apart silently.</li>
<li>Disabling automatic updates without putting a review process in its place.</li>
<li>Restoring production data onto staging with mail still enabled.</li>
<li>Forgetting <code>DISABLE_WP_CRON</code> on staging, so scheduled jobs fire twice across two environments.</li>
<li>Treating &#8220;the files copied&#8221; as proof the deploy worked, with no smoke test.</li>
</ul>



<h2 class="wp-block-heading">Best practices</h2>



<ul class="wp-block-list">
<li>Make the repo the only way code reaches a server, and enforce it with <code>DISALLOW_FILE_MODS</code>.</li>
<li>Keep code moving forward and content moving backward, and state that rule where the team can see it.</li>
<li>Deploy staging from a branch and production from a tag, so production releases are deliberate.</li>
<li>Dry-run every search-replace and every rsync the first time.</li>
<li>Back up the target database immediately before any deploy that touches it.</li>
<li>Script the staging restore end to end, including mail, cron, keys and anonymisation.</li>
<li>Finish every deploy with a real HTTP request through the public URL, not a file listing.</li>
<li>Use environment-aware code with <code>wp_get_environment_type()</code> instead of commented-out blocks.</li>
<li>Keep uploads out of git and sync or offload them separately.</li>
<li>Replace automatic updates with a scheduled dependency review, and put it in a calendar.</li>
</ul>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading">FAQ</h2>



<h3 class="wp-block-heading">Should WordPress core be in the repository?</h3>



<p class="wp-block-paragraph">Only if you are not managing it another way. Committing core works and makes the repo self-contained, at the cost of noisy diffs on every update. Declaring core as a Composer dependency is cleaner and gives you a pinned version without the noise. What you should not do is leave core unmanaged, so nobody can say which version production runs.</p>



<h3 class="wp-block-heading">How do I handle the database in a Git workflow?</h3>



<p class="wp-block-paragraph">You do not put it in Git. Git handles code; the database is handled by scripted pulls in one direction. Production to staging to local, with a search-replace on import. The only time a database legitimately goes upward is the initial launch, before there is real content to lose.</p>



<h3 class="wp-block-heading">What about plugin settings changed in staging?</h3>



<p class="wp-block-paragraph">This is the genuinely hard part and there is no clean answer. Settings live in the database, so they do not deploy. Options are: reapply them by hand in production with a documented checklist, script them as WP-CLI commands in a deploy step, or use a plugin that exports configuration to files. Whichever you pick, write it down, because &#8220;I&#8217;ll remember&#8221; is how a setting gets applied to staging and never production.</p>



<h3 class="wp-block-heading">Is Bedrock necessary?</h3>



<p class="wp-block-paragraph">No. It is a well-made set of defaults for Composer-managed WordPress with environment-based configuration, and it saves assembling those pieces yourself. Plenty of teams run a perfectly disciplined Git deployment with a standard directory layout. Adopt it if you want the conventions; do not adopt it as a prerequisite.</p>



<h3 class="wp-block-heading">Do I need three environments?</h3>



<p class="wp-block-paragraph">You need local and production. Staging earns its cost when you have multiple people, a client who signs off on changes, or a site where breakage costs money. On a personal blog it is overhead. On a store, skipping it means production is your test environment.</p>



<h3 class="wp-block-heading">Can I do this on shared hosting?</h3>



<p class="wp-block-paragraph">Partly. You need SSH and ideally WP-CLI, and plenty of shared plans have neither. Some managed WordPress hosts offer a git push deployment target, which handles the file half for you. If you want the full workflow with your own build steps and post-deploy hooks, a small VPS from a provider like InterServer gives you the SSH access and cron control the workflow assumes.</p>



<h3 class="wp-block-heading">How do I roll back a bad deploy?</h3>



<p class="wp-block-paragraph">Files are easy: redeploy the previous tag, or swap the symlink back if you use atomic releases. The database is the hard part, which is why you take a dump immediately before any deploy that runs a migration. Rolling files back without rolling the database back can leave you worse off than the broken version, so know which of the two actually changed before you act.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading">The one thing to remember</h2>



<p class="wp-block-paragraph">Git-based WordPress deployment is not really a pipeline problem. The pipeline is the easy part, and you can build a working one in an afternoon. The hard part is making the repo the only way code reaches a server, and then keeping the database flowing in exactly one direction.</p>



<p class="wp-block-paragraph">Get those two right and everything else is detail. Get them wrong and you will keep having the same confusing morning, staring at a plugin version that nobody remembers changing.</p>



<h2 class="wp-block-heading">Want this set up properly on your site?</h2>



<p class="wp-block-paragraph">Retrofitting version control onto a live WordPress site is fiddly work, mostly because you have to do it without downtime and without losing whatever has been changed directly on the server. Things I take on:</p>



<ul class="wp-block-list">
<li>Moving an existing production site into Git without downtime, including reconciling whatever has drifted on the server.</li>
<li>Converting a site to Composer-managed plugins and core, with a working lockfile and a sane update process.</li>
<li>Building local, staging and production environments that actually match, with per-environment configuration.</li>
<li>Deploy pipelines in GitHub Actions or GitLab CI: build, rsync or atomic releases, post-deploy WP-CLI steps, smoke test, rollback path.</li>
<li>Scripted database refreshes from production to staging with mail, cron, API keys and personal data handled automatically.</li>
<li>Server setup for the workflow: SSH deploy users, correct file ownership, OPcache resets, cron.</li>
</ul>



<p class="wp-block-paragraph">Tell me how your site is hosted and how plugins currently get updated, and I will tell you what the first step should be.</p>



<div class="wp-block-buttons is-layout-flex wp-block-buttons-is-layout-flex">
<div class="wp-block-button"><a class="wp-block-button__link wp-element-button" href="https://www.upwork.com/freelancers/~01f15a912ad84a6620" target="_blank" rel="noreferrer noopener">Work with me on Upwork</a></div>
</div>
<p>The post <a href="https://john-nessime.com/blog/devops/git-based-wordpress-deployment/">Two Sources of Truth: Git-Based WordPress Deployment From Local to Production</a> appeared first on <a href="https://john-nessime.com/blog">John Nessime</a>.</p>
]]></content:encoded>
					
		
		
			</item>
	</channel>
</rss>
