DEV Community: Abdul Salam

Profound vs Keytomic — Which AI SEO tool fits your workflow?

Abdul Salam — Thu, 29 Oct 2026 13:18:57 +0000

The one-line summary:

Profound = AI visibility analytics platform (measurement-led)
Keytomic = AI SEO automation platform (execution-led)

Feature comparison at a glance:

**
Capability Profound Keytomic
AI visibility tracking ✅ (10+ engines) ✅
Prompt intelligence (real conversation data) ✅ ❌
Citation + sentiment analysis ✅ Partial
Keyword research + 30-day calendar ❌ ✅
AI content generation Via Agents (credit-based) ✅
CMS publishing Via Agents ✅ (WordPress, Shopify)
Auto-indexing Not confirmed ✅
Technical SEO audits Not confirmed ✅

When to use Profound: You need deep AEO analytics — prompt demand data, citation share, multi-engine competitive benchmarking. Positioned for mid-market/enterprise.

When to use Keytomic: You need one workflow that runs from keyword discovery through publish and indexing. Built for SMBs, agencies, lean in-house teams.

Neither guarantees rankings or AI citations. That's true of every tool in this space.

Detailed breakdown: Profound vs Keytomic on the Keytomic blog.

Outrank vs Keytomic — What’s the actual difference for a technical team?

Abdul Salam — Thu, 29 Oct 2026 13:08:42 +0000

Quick breakdown for teams who want the signal without the noise.

Outrank:
AI content briefs from SERP analysis
Content scoring system
Gap analysis vs competitors
Manual export → you still do the publishing

Keytomic:

Keyword clustering + topical map generation
Full article generation (LLM + fact-checking layer)
Multi-CMS push (WordPress, Webflow, Shopify)
Auto-indexing via official Google/Bing APIs
AI Visibility Tracker (monitors ChatGPT, Perplexity, Gemini, Claude citations)

The one thing most comparisons miss:

Outrank has no AI citation tracking. If your buyers are researching in ChatGPT or Perplexity before they hit your site — and increasingly they are — knowing whether you’re cited there is as important as knowing your Google rank. Keytomic tracks this. Outrank doesn’t.

*When to pick which:
*
You have a writing team that needs guidance → Outrank

You need to scale content without scaling headcount → Keytomic

You’re an agency managing 20+ client sites → Keytomic

Full Outrank vs Keytomic comparison with feature tables and workflow diagrams is on the Keytomic blog.

SEO Automation Software That Actually Executes vs. Tools That Just Report

Abdul Salam — Mon, 26 Oct 2026 10:12:25 +0000

There is a problem nobody talks about in the SEO tools market: most platforms that call themselves "automation software" do not automate anything.

They schedule things. They monitor things. They report on things.

Then they hand the work back to you.

I spent 12 months testing more than 30 SEO platforms while building Keytomic — an SEO automation platform — and I kept running into the same pattern. A tool would crawl your site, find 60 pages with broken title tags, generate a beautifully formatted report, and stop. You go fix 60 title tags.

That is not automation. That is a very expensive to-do list that fills itself in.

The distinction that changes the whole purchase decision

Ask what happens after the tool finds the problem.

Monitoring answer: "It appears in a dashboard and you go fix it." Automation answer: "It changes the thing, or ships the thing, and tells you afterwards."

Almost every platform in this category sits on the monitoring side. Scheduled crawls are automation of noticing. Bulk keyword exports are automation of gathering. Neither one publishes a page.

The handoff problem is where the hours actually go

Most people assume the slow part of content production is writing. It is not. The writing is maybe a third of the elapsed time. The rest is transitions between tools.

Here is a typical stack:

Step Tool What breaks at the handoff
Keyword research Ahrefs or Semrush Export a list, lose clustering logic, reformat by hand
Brief Google Docs Re-explain requirements, competitive insight doesn't travel
Draft Separate AI writing tool Start from scratch, brief context partially lost
Optimisation Surfer or Clearscope Paste in, wait for analysis, implement manually
Publishing WordPress Paste, reformat, add images, set metadata, fix what broke
Indexing Search Console Open it, submit manually, hope
Reporting Another tool entirely Rebuild the same report you built last month

Seven tools. Six handoffs. Each handoff costs context, formatting and time.

What a score-5 tool actually looks like

I built a scoring scale called Execution Depth — 1 to 5 — that measures how much of the recurring task a tool carries out after setup.

The only two tools that score a 5:

Alli AI — installs a JavaScript snippet on your site, proposes bulk on-page changes (titles, meta, headings, schema across thousands of URLs), and deploys them when you approve. Nobody opens a CMS. Cancel the subscription and every change vanishes — that is the trade-off you need to understand before buying.

Keytomic — takes a keyword from research through to a published, indexed page. Calendar, brief, draft, image, auto-publish to your CMS, indexing request. I work on this one, so weigh that accordingly. The full honest review including what it is bad at is in the complete guide to SEO automation software.

Everything else — Semrush, SE Ranking, Surfer, Ahrefs — scores 4 or below. Great tools. None of them touch your site.

The free layer most teams skip entirely

Search Console combined with the Indexing API scores a 3 on my scale — which means it beats two platforms charging over $150/month.

The Indexing API lets you submit URLs at scale on publish. The comparison report in Search Console surfaces your content decay list for free. Both are real execution that most teams ignore while paying for platforms that produce the same output less accurately.

The one question that separates real automation from a feature list

Ask a vendor to demonstrate the full chain — keyword discovery to published page — in one session without you triggering each step. Most cannot. Watching them try is more informative than any feature page.

Full breakdown of all 12 tools with Execution Depth scores, pricing and honest trade-offs: SEO automation software guide.

Treating an SEO agency like a system: capacity, queues, and bottlenecks

Abdul Salam — Thu, 22 Oct 2026 13:48:32 +0000

If you think in systems, SEO agency growth is a throughput problem. Revenue going up while delivery cost goes up proportionally is linear growth, not scale.

The capacity model

python
available_hours = 400 # monthly delivery hours
hours_per_client = 20
rework_and_blocked = 60

naive_capacity = available_hours / hours_per_client # 20
real_capacity = (available_hours - rework_and_blocked) / hours_per_client # 17

Feed it your own time data. It's a working model, not an industry benchmark.

Find the constraint

Work piles up in one of four queues: onboarding, content production, approvals, or reporting. Measure where tasks wait, not where they finish. The longest queue is your constraint.

A blocked-work log schema that's surprisingly effective:

reason | owner | next_action | client_dependency
Separate roles like services
strategy -> keyword mapping, briefs, technical recs
production -> drafting, on-page, CMS publishing
review -> fact checks, voice, final approval
accounts -> client comms, approvals, reporting

One person can hold two roles. The point is that each handoff has an owner.

What to automate

Rule: automate tasks that are repetitive, reversible, rules-based, and reviewable.

Typical manual pipeline:

research_tool -> export CSV -> sheet
content_tool -> copy brief -> doc
doc -> paste -> CMS
CMS -> manual -> index submission
GSC -> copy -> client report

Every arrow is latency and an error surface. Connecting those steps usually beats generating more content.

Escalation rules (keep these human)

Unverified claims, stats, or regulated topics -> senior reviewer
Redirects, robots rules, templates -> approval required
Repeated rework on one deliverable -> workflow review
Metrics to log per client
revenue_per_client, gross_margin, delivery_hours,
utilization, rework_hours_per_deliverable,
blocked_days, retention, lead_to_client_rate

Full playbook: https://keytomic.com/blog/how-to-scale-an-seo-agency

How to evaluate an "AI SEO agent" like an engineer would

Abdul Salam — Thu, 22 Oct 2026 13:44:45 +0000

"Agent" now covers everything from a chat assistant with SEO data access to systems that deploy changes to production websites. If you're evaluating these for your team or a client, treat it like any other system with write access.

Minimum definition

For my comparison of 10 tools, an agent had to pursue an SEO task across multiple steps using data or tools, not just generate a paragraph or render a chart. Execution can still be gated by approvals, integrations, or plan tier.

Five evaluation questions

Worth stating clearly because it trips people up: MCP connects an assistant to supported tools. Data access through MCP and permission to act in another system are separate decisions. Also check whether every web-app action is actually exposed via MCP. Often it isn't, and release scopes differ between the platform UI and the MCP interface.

Evidence to demand in a trial

For deployment tools (e.g., OTTO, Alli AI):

original_value, deployed_value, affected_url,
rendered_result, rollback_steps

For content tools (e.g., Frase, Writesonic, Keytomic):

brief, sourced_draft, editor_revision,
cms_output, list_of_steps_still_manual

For research assistants:

query, source_data, filters, recommendation,
which_tool_produced_each_number, reproducible?
Pilot design

Same task, same inputs, same approval boundaries for every finalist. Don't force a deployment tool into an article-writing test. Log editor time including corrections, not just generation time.

Full comparison with sources and pricing: https://keytomic.com/blog/ai-seo-agents

AI-assisted vs automated: a 4-level model for SEO workflows (with 2026 data)

Abdul Salam — Thu, 22 Oct 2026 13:40:02 +0000

Most "AI SEO" tooling in 2026 is assistance, not automation. The data backs that up: in Keyword.com's 2026 survey, 87% of SEO practitioners use AI regularly, but only 1% describe their work as fully automated.

If you build or run content pipelines, here's the model I use to tell the difference.

The 4 levels

Level What it means Human role
AI-assisted Person prompts, model suggests Prompt + review + move output
Task automation Software executes one step Trigger + review
Workflow automation Steps connected, handoffs removed Approve at checkpoints
Full automation No routine human involvement None (rare, risky)

The diagnostic question: which manual action disappeared? Faster output with the same number of handoffs is still level 1.

What the data says teams automate

From Semrush (early 2026, n=100):

keyword_research 60%
content_ideas 48%
briefs_outlines 38%
content_refresh 34%
meta_titles 26%
full_drafts ~20%

Adoption drops as tasks move toward judgment. That's the right instinct.

A checkpoint pattern that works

research -> automate | human: decide which page owns each keyword
brief -> automate | human: check intent + sources
draft -> assist | human: facts, voice, regulated claims
publish -> automate | human: approve before live
index -> automate | human: check status (no timing guarantees)
report -> automate | human: interpret what changed
Measuring ROI without fake percentages
labor_saved = (baseline_hours - automated_hours) * loaded_hourly_cost
net_roi = labor_saved + avoided_tool_cost - automation_cost - added_review_time

Track hours removed, pages shipped, and business outcomes as separate metrics. Hours saved is efficiency. Traffic and revenue are outcomes.

Full write-up with every source and sample size: https://keytomic.com/blog/seo-automation-statistics

Your SEO Agency Is a Production System. Debug It Like One.

Abdul Salam — Thu, 22 Oct 2026 13:38:17 +0000

If you've ever profiled a slow service, you already know how to scale an SEO agency.

Most agencies treat growth as a sales problem: sign more retainers, hire when it hurts. But an agency is a pipeline. Keywords go in, published and tracked pages come out, and every step in between has throughput, queues, and failure modes. Add load without finding the constraint and you don't get scale. You get a bigger, slower system with the founder acting as the integration layer.

Here's the systems view.

Growth vs. scale: watch the ratios, not the totals
Growth Scale
Revenue Rises with each new client Rises faster than delivery cost
Delivery hours Rise in step with client count Rise more slowly than client count
Rework Absorbed by senior people Tracked and falling
Gross margin Flat or shrinking Holding or improving
If every new client needs a proportional amount of new labor, that's linear growth. Scale is when the ratios improve as volume rises.

The capacity equation
A simple working model (not an industry standard, so feed it your own time data):

def real_capacity(delivery_hours, hours_per_client, rework_hours, blocked_hours):
usable = delivery_hours - rework_hours - blocked_hours
return usable // hours_per_client

Hypothetical month: 400 hours, 20 hours per client, 60 hours lost to rework + blocked work

print(real_capacity(400, 20, rework_hours=40, blocked_hours=20)) # 17, not 20
Three clients' worth of capacity disappears into rework and waiting. That's where margin leaks.

Find the bottleneck: measure wait time, not completion
Work in an SEO agency usually piles up in one of four stages:

Onboarding
Content production
Approvals
Reporting
Most teams track what's done. Very few track what's stuck. Add a blocked-work log with four fields:

reason
owner
next_action
client_dependency
The stage with the longest queue is your constraint, and it's rarely the one the founder assumes. Fix that before adding clients.

Standardize before you scale
Custom work is the agency equivalent of snowflake servers: no two accounts take the same hours, so you can't forecast or staff.

Pick one client profile (e.g. B2B SaaS sites with an existing blog).
Define fixed deliverables: keyword map, content calendar, technical checks, reporting.
Write each step as a checklist with an owner, an input, and a definition of done.
Put quality gates between steps: brief approved → draft fact-checked → page published → indexing checked.
The acceptance test: someone other than the founder can run the workflow without asking for every decision.

Separate the roles (even if one person holds two)
Strategy: keyword mapping, briefs, technical recommendations
Production: drafting, on-page work, publishing to WordPress, Shopify, or Webflow
Review: fact checks, brand voice, final approval
Account management: client communication, approvals, reporting
Run one production queue across all clients, sorted by due date and blocker status, with technical fixes in the same queue so they don't rot.

What to automate: a four-part rule
Automate a task when it is:

Repetitive
Reversible
Rules-based
Easy to review
That usually means research, calendar planning, briefs, publishing, indexing submissions, and report prep. The typical manual stack is full of copy-paste handoffs: keywords exported from Semrush or Ahrefs into a sheet, briefs pasted from a content tool into a doc, drafts pasted into the CMS, Search Console numbers copied into a report. The biggest gain usually comes from removing those handoffs, not from producing more content.

Keep strategy, fact-checking, and final approval with people. Google's guidance on AI-generated content doesn't ban content because AI helped write it, but it does warn that low-value scaled content can violate spam policies however it's made.

Escalation rules (think of them as guardrails)
Any unverified claim, statistic, or regulated topic → senior reviewer
Changes to redirects, robots rules, or templates → approval first
Client-specific strategy calls → stay with the strategist
Repeated rework on one deliverable → trigger a workflow review
Observability: the metrics that prove you're scaling
Track per client and per package, not just agency totals:

Metric Decision it informs
Revenue per client Pricing and package fit
Gross margin by account Keep, reprice, or exit
Delivery hours per client Whether scope matches price
Utilization When to hire or pause sales
Rework hours per deliverable Where briefs or reviews fail
Blocked days per client Which approvals stall work
Content velocity Whether the calendar is being met
Client retention Whether results hold trust
Lead-to-client conversion Whether acquisition works
A rising client count isn't evidence of scale if margin, quality, or delivery predictability is falling.

Your first step
Pull the last 30 days of client work. For each account, record revenue, delivery hours, rework hours, blocked days, and gross margin. Find the single bottleneck. Fix that one thing.

Originally published on the Keytomic blog. The full version covers client acquisition, the common scaling mistakes that hurt margin, and an FAQ.

Don't Let an AI SEO Tool Publish Straight to Production. Put an Approval Gate in Front of It.

Abdul Salam — Tue, 20 Oct 2026 10:09:48 +0000

AI SEO platforms are getting good at the full loop: research, write, publish. The "publish" part is the one developers end up owning, usually after someone in marketing has already connected the tool to the production CMS.

I work on product at Keytomic, and I recently wrote a comparison of Distribb and Keytomic. The biggest difference between them isn't a feature. It's the workflow model:

Agent-led (Distribb): an AI agent researches, writes, publishes, and runs outreach. Humans check the output.
Approval-based (Keytomic): drafts wait for a person to approve them before anything goes live.

Whichever kind of tool your team picks, you can control the last step yourself. Here's how I'd evaluate a tool's publishing integration, and a small pattern for adding your own approval gate.

What to check in any AI tool's publishing integration

Before connecting an AI content tool to a CMS, I'd want answers to these:

Question Why it matters
Is publishing a direct CMS integration, a plugin, or a webhook/API? Determines where you can intercept content
Can auto-publish be turned off per site? You may want it on for a test blog, off for production
Does it publish as draft or as live? "Draft" in the CMS is a free approval gate
What permissions does the integration need? Avoid admin tokens when an author/editor role works
Can you export content and data if you leave? Content ownership and migration cost
What happens on edit? Does it overwrite manual changes? Prevents losing editorial fixes

For the two tools I compared: Distribb documents a WordPress plugin, webhooks, and an API. Keytomic documents direct integrations with WordPress, Shopify, Webflow, Framer, Notion, GoHighLevel, Contentful, and Next.js, plus webhooks and custom APIs. Either way, the webhook path is the one that gives you the most control.

The pattern: webhook in, review queue, then CMS

If a tool can send content to a webhook, don't point that webhook at your CMS. Point it at a small service that stores the draft and waits for approval.

AI tool ──webhook──▶ review service ──(approved)──▶ CMS API
│
└──▶ notify reviewer (Slack/email)

Here's a minimal version in Node with Express. It verifies a shared secret, stores the incoming draft, and only publishes when someone approves it.

js
// review-gate.js
import express from "express";
import crypto from "node:crypto";

const app = express();
app.use(express.json({ limit: "2mb" }));

const drafts = new Map(); // swap for a real DB in production
const WEBHOOK_SECRET = process.env.WEBHOOK_SECRET;
const REVIEW_TOKEN = process.env.REVIEW_TOKEN;

function safeEqual(a = "", b = "") {
const ab = Buffer.from(a);
const bb = Buffer.from(b);
return ab.length === bb.length && crypto.timingSafeEqual(ab, bb);
}

// 1. The AI tool sends drafts here instead of to the CMS
app.post("/webhooks/content", (req, res) => {
if (!safeEqual(req.get("x-webhook-secret"), WEBHOOK_SECRET)) {
return res.sendStatus(401);
}

const { title, slug, html, meta_description } = req.body;
if (!title || !slug || !html) return res.status(400).send("Missing fields");

const id = crypto.randomUUID();
drafts.set(id, {
id, title, slug, html, meta_description,
status: "pending",
receivedAt: new Date().toISOString()
});

notifyReviewer(id, title); // Slack, email, whatever your team uses
res.status(202).json({ id, status: "pending" });
});

// 2. A reviewer approves (or rejects) from an internal UI
app.post("/drafts/:id/approve", async (req, res) => {
if (!safeEqual(req.get("authorization"), Bearer ${REVIEW_TOKEN})) {
return res.sendStatus(401);
}

const draft = drafts.get(req.params.id);
if (!draft || draft.status !== "pending") return res.sendStatus(404);

await publishToCms(draft); // your CMS client
draft.status = "published";
draft.approvedBy = req.body.reviewer;
res.json(draft);
});

app.post("/drafts/:id/reject", (req, res) => {
if (!safeEqual(req.get("authorization"), Bearer ${REVIEW_TOKEN})) {
return res.sendStatus(401);
}
const draft = drafts.get(req.params.id);
if (!draft) return res.sendStatus(404);
draft.status = "rejected";
draft.reason = req.body.reason;
res.json(draft);
});

app.listen(3000);

And a WordPress publishToCms that creates the post as a draft first, so even an approved item gets a final look in the CMS preview:

js
async function publishToCms(draft) {
const auth = Buffer.from(
${process.env.WP_USER}:${process.env.WP_APP_PASSWORD}
).toString("base64");

const res = await fetch(${process.env.WP_URL}/wp-json/wp/v2/posts, {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: Basic ${auth}
},
body: JSON.stringify({
title: draft.title,
slug: draft.slug,
content: draft.html,
excerpt: draft.meta_description,
status: "draft" // flip to "publish" only once you trust the pipeline
})
});

if (!res.ok) throw new Error(WordPress returned ${res.status});
return res.json();
}

Use a WordPress application password tied to an Editor or Author account, not an admin.

A few checks worth automating in the gate

Since you're already intercepting content, run cheap checks before a human ever looks at it:

Sanitize the HTML (e.g., with sanitize-html) so a tool can't inject scripts or iframes
Flag outbound links to domains you've never linked before, so link quality gets a human look
Check the slug doesn't collide with an existing URL
Require a meta description and an H1 that matches the title

The outbound-link check matters more than it looks. Some AI SEO tools include link exchanges or automated outreach, and Google's spam policies list excessive link exchanges and automated link services as potential link spam. Your gate is a good place to make sure no link ships without someone seeing it.

Wrapping up

Agent-led tools optimize for volume. Approval-based tools optimize for control. But as the developer wiring it up, you get to decide where the last checkpoint sits, regardless of which tool marketing chose.

If you're evaluating the two tools themselves (pricing units, AI visibility coverage, CMS support, link building), here's the full comparison:

👉 Distribb vs Keytomic (2026): Features, Pricing & Which to Choose

Building a Clinic Website That Turns Visits Into Bookings (Without Leaking Patient Data)

Abdul Salam — Tue, 20 Oct 2026 10:07:14 +0000

If you build or maintain websites for healthcare practices, you've probably been handed a vague brief like "we need more patients from the website."

Most of what moves that number isn't clever marketing. It's engineering: consistent data, clear booking paths, fast pages, and tracking that tells the practice what works without sending patient information to third parties.

This is the developer-side slice of a larger guide on organic patient acquisition. I'm writing from a product and growth angle, not as a lawyer or privacy officer, so treat the compliance notes as prompts for your client's compliance lead, not legal advice.

1. Keep location details in one source of truth

Local search depends heavily on accurate, consistent details. Google says local results are mainly based on relevance, distance, and prominence. The most common way practices sabotage this is having slightly different addresses, phone numbers, or hours on the website, the Google Business Profile, and directory listings.

On the site side, you can at least guarantee internal consistency. Store each location once and render everything from it: location pages, the footer, contact blocks, and structured data.

json
// data/locations.json
[
{
"id": "downtown",
"name": "Riverside Physiotherapy – Downtown",
"slug": "downtown",
"telephone": "+1-555-010-0100",
"address": {
"streetAddress": "120 Main Street, Suite 4",
"addressLocality": "Springfield",
"addressRegion": "IL",
"postalCode": "62701",
"addressCountry": "US"
},
"hours": [
{ "days": ["Monday", "Tuesday", "Wednesday", "Thursday"], "opens": "08:00", "closes": "18:00" },
{ "days": ["Friday"], "opens": "08:00", "closes": "14:00" }
],
"bookingUrl": "https://example.com/book?location=downtown"
}
]

Hand the practice manager a printout of this file and ask them to make the Business Profile and directory listings match it exactly. That's the cheapest local SEO win you'll ever ship.

2. Generate structured data from the same data

Patients increasingly ask AI assistants for a nearby provider, and those answers lean on the same signals as local search: clear pages and consistent details. MedicalClinic (or LocalBusiness) schema makes those details machine-readable.

Render it from locations.json so it can never drift from the visible page:

js
// lib/clinicSchema.js
export function clinicSchema(loc, siteUrl) {
return {
"@context": "https://schema.org",
"@type": "MedicalClinic",
"name": loc.name,
"url": ${siteUrl}/locations/${loc.slug},
"telephone": loc.telephone,
"address": { "@type": "PostalAddress", ...loc.address },
"openingHoursSpecification": loc.hours.map((h) => ({
"@type": "OpeningHoursSpecification",
"dayOfWeek": h.days,
"opens": h.opens,
"closes": h.closes
})),
"medicalSpecialty": "Physiotherapy"
};
}
html

Only mark up what's true and visible on the page. Don't add services, ratings, or availability the practice can't keep accurate.

3. Give every high-intent page one obvious next step

The pattern I see most often: service pages get steady search impressions, but the phone stays quiet. That's a conversion problem, and more content won't fix it.

Within one visit, a patient should be able to:

Understand the service
See location, hours, and availability
Know what happens after they make contact
Book, call, or send a short form

In practice, that means a component every service page must include:

html

Book a first appointment

First visits take about 45 minutes. Bring any referral letter and a list of current medications.

Book online
Call the clinic

Keep forms proportionate. A first inquiry rarely needs a date of birth, insurance number, and a free-text box inviting symptoms. Every extra field is friction, and every health detail you collect is data you now have to protect.

4. Track actions, not people

The practice needs to know which pages produce inquiries. You need to get them that answer without exposing protected health information.

HHS has published guidance on online tracking technologies under HIPAA, and the short version for developers is: analytics pixels, session replay, and call recordings on patient-facing pages can expose PHI. A condition-specific URL plus an IP address can be sensitive on its own.

So design the events to carry as little as possible:

js
// Send the action and a coarse page type. Nothing else.
document.querySelectorAll("[data-track]").forEach((el) => {
el.addEventListener("click", () => {
window.gtag?.("event", el.dataset.track, {
page_type: el.dataset.pageType // "service" | "location" | "faq"
// No form values, no condition names, no free text, no user IDs.
});
});
});

A few guardrails worth agreeing with the client's compliance lead before anything ships:

No third-party pixels on booking, intake, or authenticated pages
No form field values in events or URLs (use POST, not query strings)
Page-type labels instead of full paths for condition-specific pages
A documented list of every script on patient-facing pages and what it sends

Then pair the digital data with a low-tech check: an intake question asking how the patient found the practice. The two sources will disagree sometimes, which is useful.

5. Mobile, speed, and accessibility are acquisition work

Patients often search on phones, sometimes while in pain or stressed. Slow, cramped pages lose inquiries.

Before calling a service page done:

Test it on an actual phone, not just a resized browser
Check readable text sizes and tap target spacing
Navigate the booking flow with a keyboard only
Make sure the call and booking actions are visible without hunting

6. Build in a review date

Healthcare content should show an author, a clinical reviewer, and a review date. If you're building the CMS templates, make those fields required for patient education pages and surface the date on the page. It's a trust signal for patients, and it gives the practice a natural trigger to refresh pages that get impressions but few inquiries.

Wrapping up

None of this is exotic. It's consistent data, honest structured data, one clear next step per page, and tracking designed around privacy from the start. But together, that's most of what decides whether a practice website produces appointments or just traffic.

If you want the non-developer side (Google Business Profile, reviews, referrals, content review gates, and a 90-day plan for small teams), the full guide covers 20 organic tactics grouped by stage:

👉 20 Patient Acquisition Strategies to Get More Patients Organically

Evaluating White-Label SaaS for an Agency: A Technical Checklist (Domains, Tenant Isolation, Exports)

Abdul Salam — Tue, 20 Oct 2026 08:48:58 +0000

If you're the developer at an agency, white-label software eventually lands on your desk. Someone in sales promised clients "our own platform," and now you have to make a vendor's product look like yours without leaking anything.

SEO software is a good case study because the market is crowded and "white label" means wildly different things depending on the vendor.

Three levels of rebranding

Level What's rebranded What becomes your problem

Branded reports Logo, colors, maybe sender email on PDFs/dashboards Very little
Branded client portal Live data behind a login on your domain Auth, permissions, email deliverability, DNS
Full platform resale The whole product on your domain Support, roles, data isolation, uptime expectations

Most vendors document at least Level 1. Fewer do Level 2 cleanly. Level 3 changes your business model: you're selling software access, not just reports.

Where the vendor's brand leaks

Before signing, walk through every surface a client can touch and check whose brand appears:

Login page

Browser tab title and favicon
URL (custom domain or subdomain via CNAME?)
TLS certificate (issued for your domain, or a vendor wildcard?)
Transactional emails: sender address, reply-to, footer, unsubscribe link
Password reset flow
PDF metadata and embedded fonts
Shared dashboard links
Error pages and 404s
Help/support links inside the UI

Several vendors gate custom domains to higher plans. Never assume the entry tier includes them.

The "promise test"

Tag every feature on the vendor's list as client-visible, operator-visible, or both.

Operator-only features (bulk editing, internal dashboards, admin settings) might make your team faster, but they don't change what the client sees. If the sales promise was "clients get their own branded platform," only client-visible features count toward it.

Test tenant isolation yourself

Don't take "client access controls" on faith. In a trial:

Create two client workspaces, A and B, with distinguishable test data.
Invite a client-view user to A only.
Log in as that user and try to reach B's data: navigation, search, direct URL manipulation (swap IDs in the path or query string), shared report links, exports.
Check whether a shared dashboard link for A is guessable or enumerable.
Revoke the user and confirm sessions and shared links stop working.

If step 3 finds anything, stop the evaluation.

Model cost by billing unit, not headline price

Vendors bill on different units, which makes list prices misleading:

true_cost_per_client =
(base_subscription + add_ons + seats + reports + usage + setup_and_ops_time)
÷ active_client_sites

Using list prices checked in October 2026:

Billing model Example 5 clients 10 clients 20 clients
Per client AgencyAnalytics at $20/client/mo (annual) $100 $200 $400
Per report add-on Semrush Pro Reports at $20/report/mo, plus subscription $100 + sub $200 + sub $400 + sub
Platform add-on SE Ranking Agency Pack from $69/mo (annual), plus base plan flat, but base-plan limits may force an upgrade

Base + usage WebCEO: base fee + domain fee + project and scan charges varies with usage

That's list-price arithmetic, not a quote. Run it at your next year's client count, not today's.

Exit plan

The part everyone skips. Before signing, confirm:

Can you export raw data (not just PDFs) in a usable format?
Is there an API, and is it on your plan?
What happens to client-facing URLs if you cancel? Do you control the DNS record?
How long is data retained after cancellation?

Owning the domain and the CNAME means you can point it somewhere else later. That's leverage.

Reporting vs execution

One last distinction. Reporting and portal products brand the work; they don't produce it. If the agency's real bottleneck is research, content, and publishing, that's a separate tool, and the client-facing layer sits on top of it.

The full comparison of 10 platforms (white-label level, billing unit, and honest limitations for each) is here: https://keytomic.com/blog/best-white-label-seo-software-for-agencies

Measuring SEO Automation Like an Engineer: Levels, a Task Matrix, and an ROI Formula

Abdul Salam — Tue, 20 Oct 2026 08:46:12 +0000

Two numbers from Keyword.com's 2026 State of AI in SEO survey (97 usable responses, so treat it as directional):

87% of respondents use AI regularly or as a central part of their SEO work.
1% describe that work as fully automated.

If you've ever looked at an SEO team's stack, the gap makes sense. Keyword tool in one tab. AI writer in another. CMS in a third. Search Console next to a spreadsheet. Every tool has AI in it. None of them passes work to the next one.

That's not automation. That's a faster human in the middle of a manual pipeline.

Define the levels before you measure anything

Most "AI SEO statistics" mix four very different things. Separate them:

Level What it means Engineering analogy
AI-assisted A person prompts and reviews Autocomplete in your editor
Task automation Software runs one step A single script
Workflow automation Steps connect, handoffs disappear A CI/CD pipeline
Full automation No routine human involvement Unattended production deploys

The useful question for any new tool: which manual action disappeared? If the output just arrives faster and a human still moves it to the next step, you bought assistance.

Where teams actually are

From Semrush's early-2026 survey of 100 marketers (small sample, snapshot only):

60% use AI for keyword research
48% for content ideas
38% for briefs and outlines
34% to refresh existing content
26% for titles and meta descriptions
About 1 in 5 for full article drafts

The pattern: adoption is highest where inputs are clear, and drops as tasks get closer to judgment. Keyword.com's data explains the caution: 70% name poor output, hallucinations, or quality-control time as their biggest AI limit.

Measurement lags the most. In Semrush's separate study of 481 marketers, only 22% say SEO and AI search are fully integrated across strategy, execution, and reporting. 40% check AI visibility by typing prompts manually.

A task matrix with human checkpoints

This is an editorial framework, not survey data. Think of each human checkpoint as a required review on a PR.

Task Typical automation Human checkpoint KPI
Keyword discovery & clustering AI-assisted / rule-based Decide which page owns each keyword Keywords mapped to pages
Content briefs AI-assisted Check intent and sources Brief-to-publish time
Internal linking Rule-based Check anchor relevance Links added per page
CMS publishing Workflow-executed Approve before going live Manual posting hours removed
Indexing submission Workflow-executed Review index status URLs submitted vs indexed
Reporting Rule-based Interpret what changed Reporting hours per client
AI visibility tracking Workflow-executed Choose prompts, judge sources Mentions & citations per prompt set

Note the indexing row. Sitemaps and URL submissions are signals, not guarantees. Any tool that promises a fixed indexing time is overpromising.

The ROI formula

No study supports a universal "automation saves X%" number. So compute your own:

text
labor_saved = (baseline_hours − automated_hours) × loaded_hourly_cost
net_roi = labor_saved + avoided_tool_cost − automation_cost − added_review_cost
Baseline hours: real time per published page, including handoffs.
Loaded hourly cost: salary plus overhead.
Added review time: automation shifts work into review. Count it.

A minimal calculator:

python
def automation_roi(
pages_per_month: int,
baseline_hours_per_page: float,
automated_hours_per_page: float,
review_hours_per_page: float,
loaded_hourly_cost: float,
avoided_tool_cost: float,
automation_cost: float,
) -> dict:
labor_saved = (
(baseline_hours_per_page - automated_hours_per_page)
* pages_per_month
* loaded_hourly_cost
)
review_cost = review_hours_per_page * pages_per_month * loaded_hourly_cost
net = labor_saved + avoided_tool_cost - automation_cost - review_cost
return {
"labor_saved": round(labor_saved, 2),
"review_cost": round(review_cost, 2),
"net_monthly_roi": round(net, 2),
}

Example with your own numbers:

print(automation_roi(
pages_per_month=12,
baseline_hours_per_page=6,
automated_hours_per_page=1.5,
review_hours_per_page=1,
loaded_hourly_cost=40,
avoided_tool_cost=50,
automation_cost=99,
))

The example inputs are placeholders. Plug in your own baseline, measured honestly over a few weeks.

Then keep efficiency and outcomes separate. Hours saved and pages shipped are efficiency metrics. Indexing, rankings, and conversions are outcomes. Don't let one stand in for the other.

What not to automate

Volume amplifies whatever process sits underneath it. Weak briefs produce weak pages, faster. A team publishing 40 unreviewed pages a month hasn't removed risk; it's automated it.

Keep humans on factual claims, regulated topics, topic selection, brand positioning, and backlink decisions.

Where to start

Bottleneck is research? Automate discovery and planning first.
Bottleneck is handoffs? Connect CMS publishing, indexing, and reporting.
Bottleneck is quality? Keep approvals and fix your evidence process before adding volume.

For each change, record three things: the manual step removed, the quality checkpoint kept, and the outcome affected.

I compiled every sourced 2026 stat (with sample sizes and what each actually measured) here: https://keytomic.com/blog/seo-automation-statistics

Read, Decide, Act, Verify: What Actually Makes Software an "AI SEO Agent"

Abdul Salam — Tue, 20 Oct 2026 08:41:59 +0000

Every SEO product shipped in the last year calls itself an "agent." Most of them are tools with a chat box.

If you build on the web, you already have the vocabulary to tell the difference. An agent is a loop, not a feature. Here's the spec I use when I evaluate one, whether I'm buying it or wiring one up myself.

The loop: read → decide → act → verify

A real AI SEO agent does all four, on a repeating schedule:

Read real data: Search Console, live SERPs, crawl results. Not just whatever you paste into a prompt.
Decide what to do next based on that data.
Act: draft, publish, change a page, submit a URL.
Verify the result after acting.

A tool does one of those steps and hands the rest back to you.

The fastest test: once a problem is found, who does the work? If it's you, it's a tool.

Four classes that shouldn't share a spreadsheet

When I compared 13 products on the market, they split into four groups. Comparing across groups is how teams buy the wrong thing.

Class What it touches Examples
Content-loop agents Plans, drafts, publishes articles Keytomic, Frase, Outrank, Writesonic, RankYak, Distribb, SEObot
Technical execution Live pages, how crawlers see them Alli AI
Workflow platforms Several jobs under one login Search Atlas, BabyLoveGrowth
Visibility analytics Measures AI answers and citations, changes nothing Peec AI, Profound

An analytics product and a publishing agent are as different as a monitoring dashboard and a deploy pipeline. Both useful. Not interchangeable.

The autonomy ladder

Treat agent permissions like you'd treat a CI/CD bot. Start low, promote deliberately:

Level 1 Recommendation only → agent suggests, human does
Level 2 Draft for approval → agent writes, human merges
Level 3 Scheduled publishing → agent ships on a timer, human can cancel
Level 4 Low-risk automatic changes → e.g. internal links, metadata
Level 5 High-risk changes → always require explicit approval

If a product can't tell you which level a given action runs at, that's your answer.

Least privilege, change logs, rollback

Same rules as any service account:

Least access. Give the agent the narrowest CMS role that lets it do the job. Draft-only is a fine starting point.
Change log. Every action should be traceable: what changed, when, why.
Rollback path. Especially for anything that edits live pages at the site level. If there's no undo, it doesn't go to production.
What the agent should verify after it acts

"Published" isn't "done." After an action, check:

Page renders correctly
Page is indexable (no stray noindex, correct canonical)
Internal links resolve
Structured data matches visible content (schema that describes content the user can't see is a problem, and structured data never guarantees rich results anyway)
Publishing status in the CMS
Index status and performance in Search Console over the following weeks

One honest caveat: submitting a URL supports discovery. It does not guarantee indexing. Google describes sitemaps as hints, not commands. Be suspicious of any tool that promises a fixed indexing time.

Build vs buy

Build when your workflow is unusual and you can maintain the connectors, the approval gates, and the verification step yourself. MCP now makes it practical to connect an LLM like Claude directly to SEO data sources.

Buy when speed matters more than customization. Just apply the same spec above to whatever you buy.

What stays human

Agents remove repetitive work. They don't remove accountability. Keep a person on:

Topic selection (it depends on business goals)
Fact-checking and sources
Brand voice
The publish decision
Anything regulated, and anything that places links on third-party sites

Google's position is that AI-generated content is fine when it's accurate, useful, and original, and that scaled low-value content is spam. That's a quality bar, not a tooling question.

A 30-day test before you commit
Connect a real site with the least access required.
Baseline one article and one technical task.
Hand the agent one low-risk recurring workflow.
Log every human correction and how long approvals take.
Verify publishing status, rendering, and index status.
Compare its AI visibility reporting against the questions your buyers actually ask.

The correction log from step 4 tells you more than any feature page.

Find a detailed comparison of 12 best AI SEO Agents here: https://keytomic.com/blog/best-ai-seo-agents