We shipped seven comparison pages this week, one per rival, at /comparison/<slug>. Each is one content file of 116 to 142 lines, a 13 line route file, and a shared 271 line shell. The registry is the only list:
export const COMPARISONS: ComparisonEntry[] = [
jobtestprep,
graduatesfirst,
practiceAptitudeTests,
assessmentday,
gameassessmentprep,
gametestprep,
iprep,
];
The routes, the sitemap, the hub's links, each page's "other comparisons" block and the guard test all read it, so a new rival is one file, one line and one folder. That part is unremarkable. The interesting part is the set of rules the content has to pass, because a comparison page is the one page type where the writer is both the referee and a player.
The line we deleted
A day after shipping, this came out of two pages:
- `${PROVIDER_COUNT} providers, including traditional aptitude publishers such as SHL, Kenexa and Saville and national tests such as the Civil Service and Police Scotland tests.`,
It is true. It is in our own registry, so it cannot even go stale. And on a page comparing us with another site that also covers dozens of providers, it says nothing: the reader cannot act on a fact both sides can claim. Our strengths list is not an advert, it is the answer to "why would I pick this one", and a claim the other side meets is a wasted bullet.
On the other page in that commit, the same claim survived, by acquiring the rival's own number:
- `${PROVIDER_COUNT} providers, from game-based ones to SHL, Watson Glaser, the CCAT and national tests such as the Civil Service and police entrance tests.`,
+ `${PROVIDER_COUNT} providers against its 9, adding Watson Glaser, the CCAT, Kenexa and national tests such as the Civil Service and police entrance tests.`,
Same fact, different sentence, and now it is a comparison rather than a boast. The useful test for a line on a page like this is not "is it true" but "would it still be worth printing if the other side printed theirs next to it".
The row where their number is bigger
That rule cuts the other way too, which is the part nobody enjoys shipping. The table is built from rows that take both cells:
{
feature: 'Arctic Shores games',
cogniprep: `${ourGames('arctic-shores')}`,
rival: '16',
},
ourGames counts the playable games for that provider out of our own library. It currently returns 14. Their site says 16. So our comparison page, on our own domain, has a row reading 14 against 16, and the honest version of the page is the one where that row exists. The next row is HireVue games, 13 against 10, and it only means anything because the row above it was not quietly dropped.
The same discipline is in the type:
/** Where the rival is the better choice. Never empty. */
rivalStrengths: string[];
and in the test:
expect(content.rivalStrengths.length, entry.slug).toBeGreaterThan(0);
The shell renders "Where is stronger" before "Where CogniPrep is stronger" on all seven pages. The comment in the types file is blunter than the test: never empty, and never a backhanded compliment.
What counts as a source
Every rival fact had to be read on the rival's own site on a recorded date. The assertion that enforces it is a hostname check:
// The brand label, so assessmentday.co.uk and member.assessmentday.com both count.
const brand = new URL(entry.rivalUrl).hostname.replace(/^www\./, '').split('.')[0];
for (const source of entry.sources) {
expect(source.url).toMatch(/^https:\/\//);
expect(new URL(source.url).hostname.split('.')).toContain(brand);
}
Splitting the hostname on dots and asking whether the brand token is in the list is loose enough for a members subdomain on a different TLD and strict enough to refuse the two tempting sources: a review blog, and a competitor's own page about that competitor. If the rival does not say it on their site, we do not get to say it on ours.
One rival did not get a page at all for exactly this reason. From the registry comment:
/**
* Rivals considered and not built (10 Nov 2026): 12minprep, whose site refused
* automated requests so no fact could be read on its own pages; and "best way
* to prepare for <test>" pages, which would repeat the provider hubs.
*/
A page we could not source is a page we did not publish, and writing the reason down in the registry is cheaper than rediscovering it next quarter.
Our prices cannot be typed, and theirs cannot be converted twice
Both sides of the pricing rows are hostile to a static string. Our prices change by region and are rendered in the visitor's currency; their prices change whenever they run a sale. So the content functions take a context rather than returning constants, and the test runs them with a fake one:
const context: ComparisonContext = {
currency: 'gbp',
region: 'standard',
prices: pricesFor('standard'),
ours: (pence) => `OUR${pence}`,
theirs: (pence) => `THEIR${pence}`,
providerPrice: (provider) => `PROVIDER:${provider}`,
bundlePrice: (provider) => `BUNDLE:${provider}`,
minProviderPrice: 'MIN',
};
Every price formatter becomes a marker, which makes this one line possible:
// Rival GBP prices go through `theirs`, so a bare pound figure is ours typed by hand.
expect(text, entry.slug).not.toMatch(/£\d/);
Flatten every string in the rendered content, and any £ followed by a digit means somebody typed one of our prices into copy. That is the failure this page type is most prone to: a price goes up, eleven pages still say the old one.
ours and theirs are two different formatters on purpose:
* GBP figures are in pence and are shown through `formatReferencePrice`: they
* are prices we report, not charge, so they get a plain mid-market conversion
* with no card-fee buffer. USD figures are in cents and are shown as the rival
* publishes them, in dollars, because converting a dollar price through pounds
* twice would print a number nobody published.
Our own prices carry the buffer we actually charge. A rival's pound price gets a plain mid-market conversion, because we are reporting it rather than collecting it. A rival who prices in dollars is quoted in dollars, with a prefix:
/**
* A dollar price as the rival publishes it, e.g. `US$14.99`. The `US` prefix is
* there because a Canadian or Australian visitor reads a bare `$` as their own.
*/
export function formatUsdAsPublished(cents: number): string {
return `US$${(cents / 100).toFixed(2)}`;
}
And one more rule in the same file, which decided several cells:
* Only prices shown in the page text are kept; a price that only appears inside
* a page's scripts is not one the rival publishes.
A figure sitting in a rival's JSON payload is not a published price. Where the price was only reachable after a sign-in, the cell says "Not published; shown after you sign in" and the page compares the payment model instead.
Two small things
The rows appear twice in the HTML. There is a table at desktop width and a stacked card per row on a phone, so any count of a feature string on the rendered page doubles. Worth knowing before you quote a number out of a page like this.
And a JSX whitespace bug came back. The call to action was a text run containing an interpolation and an escaped apostrophe, wrapped over several lines, which is exactly the shape where the bundled compiler eats the leading space of the run. The fix was to stop giving it a choice:
- Play {FREE_GAME_COUNT} games free with no card required, then unlock the provider
- you're facing from {context.minProviderPrice} with lifetime access.
+ {`Play ${FREE_GAME_COUNT} games free with no card required, then unlock the provider you're facing from ${context.minProviderPrice} with lifetime access.`}
One template literal, one expression container, nothing for the compiler to trim.
See it
Open CogniPrep vs GameTestPrep and find the Arctic Shores row: 14 against 16. Our page, their win. Two rows down, HireVue is 13 against 10.
On the same page, the subscription price prints as US$14.99 while our prices print in your own currency, so you can see the two formatters next to each other in one table.
Then open CogniPrep vs Game Assessment Prep and search for "Not published". It is the first row of the table, and it is the whole reason that page exists.
Across all seven, JobTestPrep, GraduatesFirst, Practice Aptitude Tests, AssessmentDay, Game Assessment Prep, GameTestPrep and iPREP, scroll to the two "where each is stronger" blocks. The rival's comes first every time. On the JobTestPrep page the first words of it are "Far wider coverage", which is the same breadth claim we deleted from our own side, pointed the other way.
What you will not find on any of the seven is a source list. These pages are written as search intent and advice, the way our test-format pages are, so the sources live in the registry as the honesty record rather than as a footnote the reader has to audit. The test is what keeps them honest; the page is what answers the question.
Top comments (0)