I write the same article twice now: once on dev.to, once on my own WordPress.com blog. Same body, same code samples, same outbound link.
What I wanted was the textbook setup: publish on dev.to, syndicate to the blog, and add <link rel="canonical" href="…dev.to/…"> so the search engine knows which copy is the original.
I could not do that. WordPress.com's free plan forces a self-referencing canonical on every post. There is no field for it, no setting, and no plugin directory on the free plan. The tag says "this page is the original" and there is no supported way to make it say anything else.
So this is what I did instead, and what I learned about which parts of that textbook setup are load-bearing.
First: what the canonical tag is and is not
A canonical tag is a hint about which URL should get the credit. It is not a redirect, it does not hide the page, and a page with a self-referencing canonical is not "penalised".
The failure mode without one is not a penalty either. It is duplication: two URLs with the same body, and a search engine that has to choose. Usually it chooses one and folds the other in. What you lose is control — you do not decide which of your two copies is the one people land on, and if the copies drift (one gets updated, the other does not) you get two mediocre pages instead of one good one.
What I actually wanted from the canonical tag was three things:
- one URL accumulating the signals;
- the dev.to copy — where the audience is — being that URL;
- no ambiguity for anyone who finds both.
I could only get the third one by hand.
What I did instead
1. Put the provenance in the body, where humans and crawlers both read it.
The first line of the WordPress copy is:
Originally published on dev.to: the same article on dev.to — the canonical source.
That is a real anchor with real anchor text, at the top of the document, pointing at the original. It is not a canonical tag and I am not going to pretend it is. But it is unambiguous to a reader, it is a followed link, and it is the sentence a person would want anyway.
2. Give each copy its own utm_source, so the traffic separates even when the content does not.
dev.to links carry utm_source=devto; the WordPress copy carries utm_source=wordpress. Both go to the same landing page.
This turned out to be the most useful decision in the whole exercise, because it converts an SEO argument into a measurement. I do not have to guess which platform sends readers. In two days, the WordPress copy of one article has produced a number, and the dev.to copy of the same article has produced a different number, and both are attributable.
3. Publish the same body, not a rewritten one.
There is a school of thought that says syndicated copies should be substantially rewritten to "avoid duplicate content". I did not do that, for a boring reason: the rewrite costs an hour and the canonical tag was going to tell crawlers what to do anyway. With the tag unavailable, the honest trade is: same body plus explicit provenance, versus two half-articles. I took the first.
Three things that bit me on the WordPress side
If you are going to do this, the canonical tag is the least of the surprises.
A new WordPress.com site is not public, it is "Coming soon". The site answers HTTP 200, so every naive check passes — but the head carries <meta name='robots' content='noindex, nofollow'>, and the post body is not in the served HTML at all. My first fetch of the published post was 51,882 bytes containing the title, the meta description, and no article.
Fixing it is not a setting you can flip through the API either: blog_public reports as read-only over XML-RPC, and wp.setOptions silently returns the old value. You have to walk the "Launch site" flow and pick the free plan. Afterwards the same URL was 108,441 bytes, with six <h2>s and the body in the HTML, and robots was max-image-preview:large — no noindex.
That difference is the whole ballgame: a "live" page whose body only exists after JavaScript runs is not a page a link crawler will count.
The REST API refuses cookie-authenticated writes. POST to public-api.wordpress.com/wp/v2/sites/<site>/posts with a session cookie and the editor's nonce comes back 401 rest_cannot_create — it wants an OAuth token. On a .wordpress.com site, /wp-json/ is a 404 as well. What does work is the site's own XML-RPC (wp.newPost), authenticated with the account username and password, taking the HTML exactly as written.
The browser password login can fail while the credentials are fine. My login form filled correctly, submitted, and returned to the login page with no error message at all — Automattic's bot-check sits in front of it and fails silently. The same username and password authenticated over XML-RPC immediately, wp.getUsersBlogs returning the blog with isAdmin=True. If I had judged the account by the browser, I would have thrown away a working login.
What this means for the "which platform" question
Both copies carry a followed link: on dev.to the anchor gets rel="noopener noreferrer" (no nofollow), on WordPress.com the anchor has no rel attribute at all. Both pages are indexable. Both link out to the same place with different UTMs.
What differs is the host. And that is the number I now care about more than the count of articles: two platforms is two domains, ten articles on one platform is one domain. The canonical tag was never going to change that equation, which is why I stopped treating its absence as a blocker.
The rules I would give someone starting this today:
- Check whether the platform lets you set a canonical before you write the second copy. If it doesn't, decide that the copies are peers, not parent and child.
- Put the provenance line first, with a real link, and say which one is the original.
- Split the UTMs per platform on day one. Otherwise you will argue about which channel works using nothing but vibes.
- Verify the served HTML of the new page before you call it published: status, robots meta, body length, and the anchor's
rel. A 200 with an empty body is the most expensive false positive in this whole workflow.
I build Copero, a free browser football career game — no download, no account. The WordPress specifics here were measured on 2026-11-19 on a free-plan site: 51,882 bytes before launch, 108,441 after, rest_cannot_create on the REST write, and wp.getUsersBlogs succeeding with the same credentials the browser form rejected.
Top comments (0)