See the work your agency
can deliver.

We tell you up front whether the client’s platform can be supported — and if it can’t, we say so with a named reason.

The client points one DNS record at ssl.preferium.com. We do the rest — no server access, no plugin, no code on the site.

The HTTPS certificate is issued, installed and renewed for the client site, and kept valid without anyone doing anything.

If the DNS provider cannot point a bare domain at us, we detect it and switch to the www variant automatically.

A probe confirms that the client’s server actually answers us before anything goes live, so DNS is never pointed at a broken setup.

Once DNS and certificate are verified, the engine switches itself on and starts the first audit. Nobody has to come back and press a button.

If the DNS record is removed or changed later, we detect it and say so.

Step by step per client site: control level, autopilot, scope rules, Google connection, visible rewrites and brand knowledge.

Move a connected site to a new host by changing one setting. No new DNS, no new setup.

For hosting that only answers on its own internal hostname, one setting sends the right header so the site works behind the engine.

Until DNS, certificate and Google are connected, the panel shows exactly what is left to do.

What happens to already published changes when a client contract ends is set out in the agency terms. If the client explicitly asks for a technical disconnection, the original site is shown again.

Rewrite the page’s title tag, or add one where it is missing.

Rewrite the page’s meta description, or add one where it is missing.

If a page has no title, description, sharing tag or canonical link, one is written and inserted — instead of the optimization quietly doing nothing.

How the page reads when shared on Facebook and LinkedIn, rewritten and added where missing.

Improved where the page already has one. We never invent an image address that might not exist.

Title, description, card type and the client’s account set for sharing on X, and added where missing.

Identifies the preferred URL for duplicate or similar pages, helping search engines choose which version to index.

Controls what is indexed and what is not, with a safety filter that only lets valid instructions through.

Every page declares the right language, validated, and consistent with the version actually served.

Improved where the client site already uses them.

Topic tags on articles are sharpened where they exist.

Mobile display settings and the browser bar color are corrected where they exist.

Icons, tile colors and app settings, so the site looks right when saved to a phone.

Modern security headers are added to every response we serve.

Optimized pages are marked short-lived and private, and old validators are stripped, so a change or a kill switch reaches visitors in about a minute — and no intermediary can serve the old version back.

Every page gets one clean, interlinked block of structured data instead of scattered fragments.

What the site already publishes is merged into our graph instead of thrown away — and duplicates are removed.

Business and website, articles and Q&A, product, price and review, media, place and event, person and author. Each type is written only when it actually fits the page.

We detect Rank Math, Yoast, All in One SEO and Squirrly, and replace their competing markup with our merged graph, so the machines do not get two different answers.

Legal name, logo and official profile links marked up, so the machines can verify who the client is.

The client’s Wikidata identifier connected to the pages, so the site is tied to the entity the machines already know.

Real people named as authors on articles, with role, bio and verified profiles, so the machines see who wrote what.

The structured data is checked against Google’s published rules before it goes live, and the result is logged.

We read Google’s rich-result and indexing verdict for the client’s URLs straight from Search Console, so you see what Google actually thinks — not what a tool guesses.

Which valuable schema types the site is still missing, page by page.

Prices and dates in the text are marked up, so they can appear directly in the results.

The navigation path is marked up, so the path appears in the result instead of a raw address.

The H1 is rewritten to match what people and AI actually search for. If the page has none, you get a suggestion to add.

H2 through H6 rewritten into a logical, descriptive structure.

“Click here” becomes text that says where the link actually goes.

Captions that explain what the image shows.

Quote blocks are sharpened for clarity.

A short plain-language explanation is placed above code examples.

Bullet points rewritten so they are clear and complete.

Tables get a caption and column headers the machines can understand.

Clear labels and helpful placeholder text in the client’s forms.

A block at the top of the page with a short summary, a direct answer, key points and sources. Makes the main information easier to find.

Up to seven internal links chosen by meaning, helping both readers and crawlers find related pages.

Correct text direction for Arabic, Hebrew and similar languages.

Map boxes for physical addresses, built safely from coordinates instead of pasted code.

Visible rewrites deliberately skip everything in the menu, footer and sidebar.

The answer block, links block and map labels write their own labels in the page’s language, in 21 languages.

The titles of neighboring pages are shown to the AI while it writes, so duplicates are avoided immediately instead of being found in an audit weeks later.

Every meaningful image gets a description of what it actually shows.

Purely decorative images are recognized and skipped — no description is written or forced.

Picture markup so the browser can load a much smaller AVIF or WebP version where the host can deliver it, with a safe fallback to the original where it cannot.

Images and embeds below the fold load only when the visitor scrolls to them.

Pages that only build themselves in the browser are fetched with a real browser, so AI crawlers get actual content instead of an empty shell.

The files that matter most load first, cutting the time to first paint.

The styles needed for the first screen are inlined, so the page appears immediately.

Real speed numbers — loading, responsiveness and visual stability — from actual Chrome visitors.

Google’s own audit of performance, SEO, accessibility and best practices, run automatically and on request.

Scripts, stylesheets and images that are too heavy are found and reported.

Files that hold up the first paint of the page are identified.

If the origin fails, an eligible cached copy can keep public pages available. This depends on a usable copy already being cached.

Pages are handled close to the visitor, wherever in the world they are.

Generated and served: every page, sensible priorities, blocked pages left out.

Generated and served: AI crawlers allowed in by default, the client’s own rules respected.

A clear declaration of what AI may do with the client’s content — appear in search yes, answer questions yes, train on it the client’s choice.

A file following the llms.txt proposal, with short and full overviews of the site for compatible AI tools.

Machine-readable manifests that describe the site to AI agents.

A content feed generated from the client’s pages.

So the site behaves like an app when saved to a phone.

Search engines are told the moment a page changes, instead of waiting for the next crawl.

Override importance and update frequency for any page.

Thin or private pages are kept out of the map the client hands to search engines.

A published security contact, so researchers can reach the client the right way.

Create 301 and 302 redirects yourself, live immediately, without server access and without a plugin.

Mark a page as permanently gone, so search engines and AI crawlers drop it — rather than just redirecting it.

Links and pages that return errors are found and reported, so you can decide what should be redirected.

When the client’s server redirects to its own internal address, we rewrite it, so visitors and crawlers stay on the client’s domain.

Double slashes, uppercase letters and overly long paths are flagged.

Titles, meta descriptions and headings translated into the languages you choose, with correct regional grammar.

Every visitor and crawler gets the right language version, with a sensible fallback when there is no exact match.

Lock the words that must never be translated — product names, brand terms, technical vocabulary.

Translations rewritten so they read as written by a person in that language, not machine-converted.

The links between country and language versions written and served, so the right version reaches the right visitor.

Eight checks find broken, missing or contradictory links between the language versions.

The country and language that rankings, keyword data and AI answers are measured in — detected automatically, changed by you.

One score from 0 to 1000 for the whole site, with this week’s change and what moved it.

Missing, too short, too long, duplicated across pages, more than one on the page.

Missing, too short, too long, duplicated across pages.

Missing main heading, several main headings, skipped levels, heading identical to the title, repeated across pages, and length.

Thin content, duplicates, low quality, oversized page, oversized HTML, missing language, broken resources, oversized scripts and stylesheets, insecure mixed content.

No internal links, too many links, empty link text, empty addresses, broken internal and external links, orphan pages, invalid link attributes, pages with only one incoming link.

Missing alt text and oversized image files.

Double slashes, uppercase letters, overly long paths.

Missing, invalid, pointing at another page, pointing outside the domain, or more than one.

No schema on the page, invalid schema, missing recommended fields, and schema Google itself rejected.

Open Graph and X/Twitter: missing blocks, missing image, missing card type, invalid card type, and text that gets cut off in the preview.

Error pages, redirects, noindex in the page or the header, missing from the sitemap, non-indexable pages listed in the sitemap, contradictory or invalid robots directives, nofollow, meta refresh, and insecure or inconsistent redirect targets.

Eight checks on the language links: missing return links, no default, missing self-reference, invalid language codes, ambiguous language codes, duplicates, broken targets, orphan alternates.

HTTPS, sitemap and robots serving, unclassified site type, expiring certificate, and AI crawlers blocked for search, training or mixed purposes.

Says when the client site blocks ChatGPT, Claude or Perplexity — and separates a total block from blocking training only.

Shows what the site already passes, not just what it fails.

A separate external engine runs a further set of technical checks on the client’s key pages.

A full external crawl hunting duplicate titles, duplicate content, broken links, redirect loops and non-indexable pages.

Visits the site every night, finds new pages via the sitemap, and logs every change.

Internal links, outbound links, scripts, stylesheets and images are tested for errors.

Finds pages nothing links to, and pages buried so deep they are invisible in practice.

Warns before the client’s own certificate expires and takes the site down.

Works out what kind of site the client runs — store, blog, local business, publisher — and picks the structured data that fits.

Warn when a page’s raw HTML contains little content before JavaScript runs.

How easy the text is to read, with suggestions. Advisory only — never published to the live page.

How closely a page matches the voice you have defined. Advisory only.

Flags sentences that get too long to read comfortably. Advisory only.

The whole site as a navigable hierarchy, so you can see its shape.

Every page in a sortable table with score, status and focus keyword.

Every page sorted into keep, thin or prune, judged against actual Google impressions instead of a guess.

How often the client publishes, and how many new pages appear each month.

A prioritized list of what should be done next, scored daily by likely impact, so the most valuable work sits at the top.

Disagree with a check? Hide it, for one page or the whole site, without skewing the score.

Scheduled prompts go to the live ChatGPT, Claude, Perplexity and Gemini with web search — on a cadence set by intensity, up to weekly, or on demand — and we log whether the client is named. The plan sets how many of the four are included.

Not just that the client was mentioned, but the actual pages the assistant used to answer.

Open the complete answer the assistant gave, not just the fact that the client appeared in it.

Being named first is worth more than being named last, so position is tracked, not just presence.

Every mention classified as positive, neutral or negative — being spoken of badly is not visibility.

Which rival domains and pages the assistants cite instead of, or together with, the client.

The client’s share of mentions in sampled AI answers, compared with named competitors for the tracked questions.

Mention rates include a confidence interval, so a small sample does not look as certain as a large one.

Define the questions you want the client to win, group them into topics, and follow the trend over time.

Type a question and see live what each assistant answers and who is cited, with suggestions for what to fix.

Citations inside Google’s conversational AI answers.

Whether the client appears in the AI summaries at the top of Google’s results.

Questions people actually ask that the client site does not answer yet.

Where the client’s brand is discussed online, with weekly trend.

The client’s share of mentions in the tracked AI answer samples, week by week.

Who pays to appear in ChatGPT answers on the client’s topics.

Reddit and Quora threads ranking for the client’s keywords — the discussions the assistants draw their answers from.

The client’s presence in Wikipedia, Wikidata and Google’s Knowledge Graph, the sources the machines trust most.

Which AI bots visited which pages, and when.

Confirms whether GPTBot, ClaudeBot and PerplexityBot can reach the site at all — the question that decides whether anything else matters.

Inspect the HTML returned when Preferium requests a page using a crawler user agent. This is a simulated request, not a verified visit from that crawler.

Anyone can check a public page’s raw HTML and crawler rules with a free scan, without an account.

One AI visibility score from 0 to 100 built on seven weighted signals, identical for every site, so scores can actually be compared.

Run the same question through two independent measurement routes and compare their citation signals. This checks measurement consistency; it does not test two page versions.

The first mention, or a citation peak worth noting — logged when it happens.

A summary of a site’s AI visibility that can be handed to a client or a board.

Weekly positions for every keyword you track, with daily tracking available.

The same positions in Bing, which several AI assistants draw from.

Force an immediate check when you need today’s numbers, not last week’s.

The full position history behind a keyword, in one view.

Every keyword classified as improved, stable or dropped.

How many keywords sit in the top three, the top ten and beyond.

Which result features — snippets, images, video, AI answers — appear for each keyword.

You are told when rankings fall below a threshold you set.

You are told when a new rival shows up in the client’s results.

Fill in a new site’s ranking history in one action, so the curve starts full instead of empty.

How many people actually search for each term every month.

Month-by-month history showing whether a term is growing or dying, not just today’s number.

How hard each term will be to win.

What someone actually wants when they search — to buy, to learn, to find a place.

New keyword ideas generated from the client’s brand and market.

Research any keyword on demand, for any site, tracked or not.

Save analyses in named lists you can open, edit and reuse across sites.

The terms competitors rank for and the client does not.

Terms where a small push yields real traffic, ranked by what is achievable.

Finds the client’s own pages competing against each other for the same term.

Pin the term a page should win, and every rewrite of the page aims at it.

The client’s overall search visibility, tracked against competitors.

Estimated traffic for the client and for every competitor you track.

Plots the client against competitors on visibility and traffic, so you see where they actually stand.

Keywords grouped into topics, each scored 0–100 by how thoroughly the client owns it.

Analyze any domain — a competitor, a prospect, an acquisition target: rankings, top keywords, competitors, links, age and AI share.

What any site is built with.

Registration history as an authority signal, for the client or whoever you are researching.

The whole link profile tracked weekly: totals, referring domains and what changed.

The words people use when they link to the client — the quality of the profile, not just the count.

Who links to the client, and how authoritative they are.

You are told when a noteworthy new site links to the client.

Links that disappeared, so you can chase them before the rankings follow.

Domains that link to competitors but not to the client yet.

Pages on the client’s own site that should link to each other, found by meaning instead of word matches.

Where rivals pick up links the client misses out on entirely.

A heat map around the business showing the Google Maps position at every point, not one average number.

Addresses, opening hours and phone numbers discovered from the client’s own site and gathered in one place.

The client’s accounts found automatically and linked into the structured data.

What is registered, checked against what the site actually publishes.

Whether the client is listed in the leading local directories in their market, plus Facebook everywhere.

Trustpilot, Google Reviews and Tripadvisor tracked weekly: rating, volume and movement.

Addresses, opening hours and contact details marked up, so the machines can answer “who is nearby”.

A ready-made QR code that sends the customer straight to the review form in Google.

Real clicks, impressions, positions and click-through rates imported daily.

Real sessions and behavior imported daily.

Compare Google performance data before and after a published change. The comparison shows a trend, not proof that the change caused it.

Published fixes, content changes and rollbacks marked on the click curve, so you can compare timing with performance trends.

Real visitors arriving from ChatGPT, Perplexity and other assistants.

Every visit classified as human, search engine, AI assistant or bot — not just the AI share.

Which pages pull clicks and which do not, with position and click-through rate.

The actual searches that bring people to the client.

Where the traffic comes from and what it uses.

How each page’s quality and performance change over time.

Your logo, your colors, your sender address. The report looks like your own document, not ours.

Choose which sections appear and in what order.

Set the frequency and which weekday it lands on.

Different recipients per site, or one template every site inherits.

A plain-language explanation written into each section — which you can edit and approve before it is sent.

See the report before it is generated or sent.

Produce a report when you need it, outside the schedule.

Export a report as an image for slides and email.

Share a report through a link that opens without a login. Anyone with the link can read it; you can revoke it at any time.

Exactly when each report was sent, and to whom.

All clients rolled into one report for your own use.

Every site in one view with overall score, trend lines and the buckets Winning, Stable and At risk.

Pin the accounts that matter most, so they stay at the top.

Export the whole multi-site view as a file.

A conversation that knows the site’s actual numbers and answers with concrete, linked steps. It can read everything and change nothing.

Ask for a plan and get ordered steps, each linking straight to the screen where the work is done.

Upload documents, guidelines and PDFs; ask questions and get answers grounded in the client’s own material.

The pages we have read are turned into brand knowledge automatically, so grounded answers work without anyone uploading anything.

Name, description, audience and distinguishing traits discovered from the client’s own site.

You confirm or lock the fields, so automatic discovery never overwrites what you have curated.

How the brand is modeled as an entity the machines can recognize.

A weekly sentence on how the client’s topics are moving in AI answers.

Preview the page title, address and description with length guidance. Search engines may display different titles or snippets.

How many issues the engine fixed, how many hours it saved, and how many pages are now clean.

What the automation intends to work on next, and why, before it runs.

Something changed the live page, and we could not get it back.

A change did not reach the live site.

A change made something worse and was reversed automatically.

We could not read the client site.

The first scan is complete and the results are ready.

New issues found, filterable so you only hear about what you care about.

What the engine did yesterday.

Everything urgent across the client sites.

Score, change, and what opened and closed.

Keywords fell below your threshold.

The client is cited less often than before.

The first mention, or a citation peak worth noting.

How the client’s share of AI answers moved.

The PDF has been generated and sent.

All clients in one weekly message.

Short, helpful messages on day 0, 1, 3 and 7 while a new site gets going.

Send any of these into a Slack channel, choose which events go there, and send a test message.

A searchable record of every message we actually sent, and one-click unsubscribe from anything recurring.

Full autopilot, Invisible-only, or Review everything. You choose per client site.

Removing a stray noindex or a contradictory canonical link goes through a safety assessment first, is flagged for your attention, and can always be undone.

Thin pages with no traffic can be set to noindex and taken out of the sitemap — reversible with one click.

Some changes, like turning on the sitemap, are offered as a button instead of being done for you.

The last 50 automatic changes listed in plain language, with one click to undo the reversible ones.

New and changed pages are picked up and optimized without anyone asking.

When the client changes a page, the engine detects it and updates its work.

Choose light, standard or aggressive, and see immediately how prioritization and pace of coverage change.

Address patterns that decide exactly which pages the engine may and may not touch.

A hard ceiling on how extensively the autonomy may work on each site.

Deterministic bulk templates for titles, descriptions, robots and canonical links, applied to a pattern or the whole portfolio — with a dry run first.

Keep the rules that work, and reuse them on the next site.

Split-test titles, descriptions and headings across matching pages; the winner is decided statistically on real Google clicks, not on opinion.

One click, and the client’s original site is served untouched, everywhere, within a minute.

Your agency can switch visible rewrites on or off per site at any time.

Each element type can be switched on, off, published or withdrawn on its own.

For any page: choose the original, the AI version, or your own text.

An override you write is never overwritten by the automation.

Click an element in a live preview of the client’s own page and edit it in place.

Six curated voices — professional, friendly, clear, creative, exclusive, explanatory — as a starting point.

One free-text instruction applied to everything the AI writes for the site.

Separate guidance for titles, alt text, link text and every other element type.

Words the AI may never use, and words you want it to reach for.

Audience, industries, locations, distinguishing traits and competitors, fed into every rewrite.

The AI proposes a style guide from the client’s own site, which you accept or edit instead of writing from scratch.

An optional extra layer of rules tuned to being cited by AI assistants.

Export the optimized content as a spreadsheet.

Edit in a spreadsheet and import the changes back, with job tracking.

Export a machine-readable record of exactly what is live on the site right now.

Tracked keywords with positions, and the affected pages behind any finding.

Set your own working limits for pages, audits, prompts, topics, keywords and grid points — each workflow can be switched off entirely.

If optimization fails, the engine falls back to the original page when the origin is available.

If optimization data is unavailable, the engine requests the original page from the origin instead of applying incomplete changes.

Error pages, redirects and non-HTML responses are passed straight through and never rewritten.

Generated text that looks like code, runs too long, or hides characters is rejected before it can reach the page.

Every inserted address is restricted to ordinary, secure web links.

Page text and third-party data are screened before use in AI workflows to reduce the risk of hidden instructions influencing a rewrite.

Rewrites use the page and available context, including keywords, Search Console data, anchor text and business details.

Values that are too long, malformed or risky are blocked before they go live.

A real browser checks the core elements — title, meta description, H1 and schema — on the live page after every change.

A change that made things worse reverses itself, and you are told.

Every 30 minutes the live page is compared with what it should be, and repaired if something overwrote it.

Every optimized page is fetched twice — as a person and as GPTBot — and any serious difference is flagged to you.

If serving starts to fail, the engine switches itself off instead of continuing with something broken.

What happens to already published changes when a client contract ends is set out in the agency terms, and the complete change record can be exported as CSV at any time.

The original DNS record is snapshotted when the site connects and shown for good, so the client always knows exactly what to restore on leaving.

A public, honest status page that says plainly when something is wrong, instead of showing false green.

Member, administrator and owner, with a clear matrix of what each role can and cannot do.

Invite people to the whole workspace.

Invite someone to exactly one site and nothing else.

With a preview before they are accepted, and revocable at any time.

Who did what, on which site.

SAML SSO with your identity provider, and email-first discovery on the login screen.

A documented REST API with token authentication, scopes, rate limits and a usage log.

An OpenAPI specification you can generate a client library from.

Create scoped tokens shown once, restrict them to IP addresses, rotate one with a transition window so integrations do not break, and revoke them immediately.

Dedicated non-human identities for your own automation.

Fourteen event types sent to your systems as they happen.

Every delivery is signed, so you can verify it came from us.

Every attempt with request and response, a test button, and manual resend.

Failed deliveries are retried on a backoff schedule, and the endpoint is disabled after repeated failure.

Connect ChatGPT, Claude or any compatible client straight to the workspace, with 17 read tools and one guarded publishing tool.

Regenerate and publish page elements straight from your own systems.

Connected in the wizard, with a picker for which property.

Connected the same way.

Jump to any page, site or setting from a keyboard search, with shortcuts and a reference sheet.

A running timeline of what the engine did, plus every content change detected on the site, flagged when something was reversed.

A public page that names which security controls are in place and which are not yet — instead of a vague badge.

Every external service that touches the data, with location and transfer basis, published.

A signable data processing agreement under the GDPR.

GDPR Article 30 records of processing are kept for the platform.

A named privacy contact and a documented escalation path. No formal data protection officer is appointed, and none is claimed.

A defined path for access, correction and deletion.

Documented retention periods and automatic deletion of expired data. See Trust for current operational status.

A published way to report security issues, with rules for good-faith research and fair treatment of reporters.

A record of what the platform is built from.

Every sensitive action logged in a chained log that cannot be altered quietly.

Every piece of data is scoped to its owner at the database level, not just filtered in code.

The connected Google credentials are encrypted and never stored in readable form.

Client workspace data is backed up by the database provider. Three independent backup locations are not claimed until they are verified.

Export published changes, tracked keywords, findings and affected pages. Preferium’s source code and runnable engine are not included.