EditorialPack Network is an event-driven syndication layer for WordPress sites that live on separate servers. The hub never pushes content. It writes every change to an ordered, append-only event log, pings its nodes, and each node pulls from its own cursor — a Kafka-like architecture, inside WordPress. This page covers the part of that design no push plugin attempts: per-node internal link translation that repairs itself.
Production-validated. Proven on high-frequency, multi-site regional publisher networks in live production environments.
Hub Describes, Node Decides
Why syndicated WordPress posts produce cross-domain 404s
Internal links are the part of content syndication that replication tools get wrong, because a link that is correct on the origin is wrong almost everywhere else. An editor on the hub writes a story and links to three related stories. Those links are hub URLs. Distribute that story to five sites and, for each link on each site, exactly one of three things is true:
- This site also carries the linked story, at a different URL.
- This site does not carry it, but a sister site does.
- No public site in the network carries it.
The hub cannot rewrite these links before sending. The right answer is different on every node, and it changes as more stories are distributed. A tool that copies the HTML verbatim gives you cross-domain traffic leakage in case 1 and a 404 in case 3.
The internal link translation matrix
The hub describes. The node decides.
The hub never guesses what a link should become. Every post event carries a link description for each internal link in the content:
- Target identity — the hub-side identity of the linked post.
- Distribution matrix — which nodes that target has been sent to.
- Anchor — the link text and its position in the content.
The hub's job ends there. It states facts. The node is the only party that knows its own permalinks and its own database, so the node makes the decision, at apply time.
The 3-step fallback sequence
For every described link, the node walks this sequence and stops at the first step that succeeds.
Own Local Copy
The node looks up the target in its own mapping table. If it holds a copy, the link is rewritten to that node's permalink. The reader stays on the site. The link equity stays with the local brand.
Sister-Site Redirection
No local copy. The node consults the distribution matrix and points the link at a sister site that carries the target — real, live content inside your network, never the hub's private authoring domain.
Safe Plain Text Conversion
The target exists nowhere public. The node removes the anchor and keeps the words. The sentence reads as the editor wrote it. There is no link to follow, so there is no 404 to hit.
- Step 1 is the common case. In a well-connected network most links resolve locally, which is what keeps sessions and internal link equity on the title that earned them.
- Step 2 keeps the reader inside the network. A sister-site link is a deliberate, visible cross-link — not a leak to an authoring domain readers should never see.
- Step 3 is the safety net. A missing link costs nothing. A broken link costs reader trust and crawl budget.
The sequence guarantees one property: a syndicated story never ships with an internal link that resolves to a 404.
The Self-Healing Grid
Steps 2 and 3 are correct at the moment of delivery. They may not be the best answer a week later. Stories are distributed out of order: an explainer published on Monday may be linked from a story that went out the previous Friday.
So the node does not forget. Every link that resolved below Step 1 is stored as an edge in the node's content graph: this local post wants to reach that hub target, and currently settles for a sister link — or for plain text.
When a later event delivers that target, the node checks the graph for waiting edges and upgrades them in place:
- Plain text → local link. The anchor is restored, pointing at the new local copy.
- Sister-site link → local link. The link is re-pointed to the node's own permalink.
Three constraints make this safe to run unattended in production:
- Driven by the event queue, not a crawler. Repairs are evaluated as events arrive, across a 90-day event queue window. There is no nightly scan of your content table.
post_modifiedis never altered. A healed link is a repair, not an editorial revision. RSS feeds do not re-order, XML sitemaps do not report falselastmodchanges, and "Updated" labels do not appear on stories nobody touched.- Quiet by design. No revision spam, no editor notifications, no cache stampede. The delivery history records what was healed, for audit.
The result is a grid of sites whose internal linking gets stronger over time on its own, instead of decaying the way hand-copied content does.
Comparison matrix
| EditorialPack Network | Generic REST API Push Plugins | Feed Aggregators (RSS) | |
|---|---|---|---|
| Traffic Architecture | Event-driven node-pull. The hub appends to an ordered, append-only event log and sends a small signed ping; each node pulls from its own cursor. No remote content writes inside the editor's request. | Origin pushes the full post to every destination, synchronously, on save. Publish is as slow as the slowest site. | Destination polls a feed on a timer. The origin has no say in when, or whether, content arrives. |
| Link Security | Per-node 3-step fallback: own local copy → sister site → plain text. No cross-domain 404s, no links to the authoring domain, and links upgrade themselves over a 90-day window. | Links copied verbatim. They leak traffic to the origin domain or break on the destination. | Links copied verbatim, often alongside a forced "source" link back to the origin. |
| Media Ingestion | Re-hosted into each node's own media library. Block attributes are rewritten to local attachment IDs, so every site serves assets from its own domain and CDN. | Often re-hosted; attachment ID remapping inside block markup varies by plugin. | Usually hot-linked from the source server, or reduced to one enclosure image. |
| Fault Tolerance | A node that goes offline resumes from its cursor and replays every missed event in order. Events are idempotent, so replays never duplicate. | A failed push is lost unless someone notices and re-pushes by hand. Retries risk duplicates. | Catches up only while the item is still in the feed window. Updates and deletes are rarely propagated. |
| Updates and deletes | Propagated as ordered events. | Updates typically; deletes vary. | Rarely. |
| Local overrides | Headline, image and byline can be localised per node while the story still tracks its source. | Varies; local edits are often overwritten by the next push. | No source tracking after import. |
| Observability | Cursor position per node and delivery history per story. | Per-push success or failure, at best. | None. |
Also in the box
- Per-site localisation. A node overrides headline, lead image or byline for its own audience. Hub updates keep flowing; local overrides are preserved.
- Taxonomy and metadata sync. Categories, tags and post metadata travel with the story.
- Live blogs. Live blog templates and rolling entries distribute across the network in step.
- Signed, authenticated delivery. Pings and pulls are authenticated end to end over HTTPS.
- Modular. Enable only the capabilities a site needs. Disabled modules leave nothing behind.
- Built for daily publishing. Routine newsroom volume is the design target. Mass historical migrations have their own guidance — see the scale note.
See it against your own topology
Every network has its own shape: how many titles, which stories go where, how much the sites overlap. Send us yours and we will map the link matrix with you.