Content and SEO agency serving multiple client brands
Multi-Tenant AI Content Platform: 252 Nodes, Three CMS Targets
A live ten-stage pipeline publishing to three CMS platforms. The source documents the architecture and node count; it does not establish a client count, so no scale or 'unlimited clients' claim is made.
- Our role
- Automation architect and builder
- Timeline
- Built as a single production architecture
- Sector
- Content and SEO agency serving multiple client brands
At a glance
- Pipeline stages
- 10: from site scrape to CMS publish
- Automation nodes
- 252 in one architecture
- Prompts generated per client
- 4: written by the pipeline itself
- CMS targets
- 3: Shopify, Webflow, WordPress
- Onboarding a new brand
- One configuration record
- Human gate
- A review draft before every publish
What was breaking
Content for a client brand is only useful if it sounds like it came from inside that business. That means knowing their products, their vocabulary, their audience and what they have already published. Multiply that across several brands and the knowledge requirement, not the writing, becomes the constraint. Each account needed its own briefs, its own keyword research, its own image sourcing, its own quality standards and its own publishing destination, all handled separately with nothing shared between them.
The naive automation answer makes this worse rather than better. Building one workflow per client means every improvement to the process has to be applied N times, and every client's copy of the workflow drifts from the others until nobody knows which one is canonical. The second month is fine; the second year is unmaintainable. It is the same trap as duplicating workflows per case type, with higher stakes because publishing to the wrong client's CMS is a visible failure.
Three further problems compounded it. Clients used different CMS platforms, each with a genuinely different publishing model (Shopify's GraphQL API, Webflow's CMS API and WordPress's REST API do not resemble each other. Credentials and API keys could not be shared between accounts, for obvious reasons. And without a quality gate, automated content either gets published unreviewed) which eventually embarrasses the agency, or piles up waiting for someone to read everything, which removes the benefit.
Client knowledge was the bottleneck, not writing
Producing credible content required understanding each business, and that understanding had to be rebuilt by a human for every brief.
One workflow per client does not survive maintenance
Every process improvement becomes N edits, copies drift apart, and nobody can tell which version is authoritative.
Three incompatible publishing models
Shopify GraphQL, Webflow CMS and WordPress REST have different shapes, so a single naive publish step cannot serve all three.
Credentials cannot be shared across accounts
Each client's API keys and CMS credentials must stay isolated, which rules out a single shared configuration.
No quality gate means two bad options
Publish unreviewed and eventually embarrass the client, or queue everything for human reading and lose the throughput you automated for.
Repeating published topics
Without awareness of what already exists on a client's site, an idea generator will cheerfully propose the article they published last month.
What we built
The architectural decision that everything else follows from is that the pipeline writes its own prompts. Rather than a human composing a brief per client, a dedicated stage scrapes the client's website for context (what they sell, how they describe it, who they talk to), and then uses that context to generate four client-specific prompt templates for that account. Those prompts become the client's voice for every subsequent article. The expensive, knowledge-heavy step is performed once per client by the system, not once per article by a person.
That is what makes a single shared pipeline viable. All clients run the same ten stages and the same 252 nodes; what differs between them is configuration, their generated prompts, their credentials, their schedule, their CMS target. Because the difference lives in data rather than in duplicated workflows, a process improvement is made once and every client benefits, and there is exactly one canonical definition of how content gets made.
Idea generation is deliberately aware of what already exists. The stage that proposes topics reads the client's published content first, so it suggests articles that extend the site rather than repeating it. This sounds obvious and is routinely skipped, which is why automated content programmes so often produce near-duplicates of their own best-performing posts.
Articles are generated as structured output rather than prose. Having the model return a defined structure (headings, sections, metadata, FAQ blocks) rather than a wall of markdown means the publishing stages can map fields onto each CMS's model reliably. This is the detail that makes supporting three genuinely different publishing APIs tractable: the content is already shaped, so each CMS adapter is a mapping rather than a parser. Images are generated and hosted on a CDN, so the CMS receives a stable URL rather than an upload.
Then the quality gate, which has two parts. An automated QA pass checks the article and injects internal links before anything reaches a human, so reviewers are not spending attention on problems a machine can catch. What they receive is a review draft in a document they can comment on, which exists for every article before publication. The human gate is a read-and-approve rather than a rewrite, which is how it stays fast enough not to negate the automation.
Publishing then goes natively to Shopify, Webflow or WordPress depending on the client's configuration. Each adapter speaks that platform's own API properly rather than exporting to a shared format and losing fidelity. And a scheduling engine enforces per-client daily quotas and configurable intervals between articles, with both single-article and multi-article cadence modes, because publishing eight articles in one morning and nothing for a fortnight looks exactly like what it is.
Let the pipeline generate the client-specific part
The knowledge-heavy work, understanding a business well enough to write as it, is done once per client by a prompt-generation stage fed from the client's own website, rather than once per article by a human.
One pipeline, configuration per tenant
Every client runs the same stages; prompts, credentials, schedule and CMS target are data. Per-client workflow copies are the thing that makes multi-tenant automation unmaintainable, so they are ruled out by design.
Generate structure, not prose
Structured article output means each CMS adapter is a field mapping rather than a parser, which is what makes three incompatible publishing APIs practical to support natively.
Machine QA before human review
Automated checks and internal linking run first, so the human gate is read-and-approve rather than find-and-fix. A review step that becomes a rewrite step cancels out the automation.
Know what the client already published
Idea generation reads existing content before proposing topics. Without this, an automated programme reliably reproduces its own earlier articles.
Isolate tenants completely
Separate API keys, credentials and state per account. Shared configuration in a multi-tenant content system eventually publishes one client's article to another client's site.
Non-negotiables
- One pipeline for all clients. Per-client workflow copies were explicitly ruled out as the thing that makes these systems rot.
- Strict per-account isolation of API keys, credentials and state.
- Three CMS platforms supported natively, not via a lowest-common-denominator export.
- A human review step before anything goes live, without that step becoming the bottleneck.
- Adding a client must not require engineering work.
The pipeline
Drawn as text and shapes rather than shipped as an image, so the step labels stay readable and downloadable.
The ten-stage pipeline
Stages one and two run once per client and produce that account's prompts. Everything after them runs per article, configured by the tenant record.
- Trigger
- Processing step
- AI / model call
- Branch / filter
- Human checkpoint
- Delivered output
- Primary path
Why one pipeline instead of one per client
The stages are shared; only the tenant record differs. A process improvement is made once rather than N times, and there is a single canonical definition of how content is produced.
- Data store or CRM
- Processing step
- Branch / filter
- Delivered output
- Primary path
- Flow
How the work runs
Each stage, what it does, and the specific failure it is built to prevent.
A client is onboarded as a single configuration record
Adding a brand means creating one record holding its credentials, schedule, quota and CMS target. No workflow is copied and no engineering work is required, which is the test of whether a multi-tenant design is actually multi-tenant.
If onboarding needed a developer, the architecture would have failed its main requirement.
The client's own website supplies the context
Rather than interviewing the client or writing a brief by hand, the pipeline scrapes their site: products, positioning, vocabulary, audience. This is the most reliable available description of how the business talks about itself, and it is already written down.
A prompt-customisation stage writes the client's prompts
Using that scraped context, the pipeline generates four prompt templates specific to the account. These become the client's voice for every article thereafter. This is the stage that makes everything else shared: the per-client knowledge is captured once, as data, instead of being re-supplied per brief.
Moves the expensive knowledge step from once-per-article to once-per-client.
Ideas are generated with awareness of published content
The idea stage reads what the client has already published before proposing topics, so suggestions extend the site rather than duplicating it. Skipping this is why many automated content programmes quietly republish variations of their own earlier posts.
The article is produced as structured data
Output is a defined structure (headings, sections, metadata, FAQ blocks) not freeform prose. This is a deliberately unglamorous decision with large consequences: because the content arrives already shaped, each CMS adapter becomes a field mapping instead of a parser, which is what makes three different publishing APIs maintainable.
Removes fragile text parsing from the publishing path entirely.
Images are generated and hosted on a CDN
Illustrations are generated, then uploaded to a CDN so the CMS receives a stable URL. Handing each platform a URL rather than performing three different binary upload flows keeps the publishing adapters simple and makes image handling identical across all three targets.
Automated QA and internal linking run before a human sees it
A QA pass checks the article and injects internal links first. The ordering is the point: reviewers should not spend their attention on problems a machine can detect, because a review step that turns into a rewrite step cancels out the automation it was meant to protect.
Keeps the human gate fast enough to survive contact with real volume.
Every article gets a review draft before publication
A document draft is created for client review on every article, with no exceptions. The gate is read-and-approve, which preserves the agency's judgement over what goes out under a client's name without making a person the throughput limit.
A scheduling engine enforces quota and cadence
Per-client daily quotas and configurable intervals between articles, in single-article and multi-article modes. Without pacing, a content programme publishes in bursts, which is both obvious to readers and worse for the search performance the programme exists to produce.
Publishing goes natively to the client's own CMS
Shopify via GraphQL, Webflow via its CMS API, WordPress via REST, each adapter speaks its platform properly rather than exporting to a shared lowest-common-denominator format. Combined with per-stage re-trigger capability, a failure at publish time can be retried without regenerating the article.
Per-stage re-triggering means a late failure costs one stage, not the whole article.
What changed
| Aspect | Before | After |
|---|---|---|
| Client knowledge | A human had to understand each business and write a brief per article. | The pipeline scrapes the client's site and generates their prompts once per account. |
| Adding a client | A new set of briefs, research and publishing setup. | One configuration record, no workflow copied, no engineering work. |
| Process improvements | Would need applying to each client's separate workflow. | Made once in the shared pipeline; every tenant benefits. |
| Publishing | Manual, and different for each of three CMS platforms. | Native adapters for Shopify, Webflow and WordPress, mapped from structured output. |
| Topic selection | Risked repeating what the client already published. | Idea generation reads existing content and extends it. |
| Quality control | Either unreviewed publishing or a human reading everything in full. | Automated QA and internal linking first, then a read-and-approve review draft. |
| Cadence | Publishing in bursts whenever capacity allowed. | Per-client daily quotas and configurable intervals between articles. |
What it runs on
Every tool listed with the job it actually does in this build.
Orchestration
n8n
The orchestration layer holding all 252 nodes across ten stages, chosen so the whole pipeline is inspectable stage by stage and individual stages can be re-triggered after a failure.
Data
Airtable
The tenant registry. One record per client holds credentials, schedule, quota and CMS target, which is what makes onboarding a data change rather than an engineering task.
AI
OpenAI GPT-4.1
Three distinct jobs: generating each client's prompt templates from scraped context, proposing SEO ideas aware of existing content, and writing articles as structured output.
OpenAI image generation
Article illustrations, produced per article rather than sourced from a stock library.
Delivery
Cloudinary
CDN hosting so every CMS receives a stable image URL instead of three different upload flows.
Google Docs
The review draft every article passes through before publication.
Integration
Shopify GraphQL API
Native publishing for commerce clients, mapped from the article's structured fields.
Webflow API v2
Native CMS publishing for Webflow clients.
WordPress REST API
Native publishing for WordPress clients.
What stopped being manual
Snippets are illustrative and generic. No client data appears in any of them.
The pipeline writes each client's prompts
Replaces a human studying a client's business and composing a brief for every article. The understanding is captured once per account, from the client's own website, and reused for everything that follows.
text
// ONCE PER CLIENT, not once per article.
scrape(client.website)
-> context { products, positioning, vocabulary, audience }
-> generate 4 prompt templates for THIS account
-> store on the tenant record
// Every later article uses those stored prompts,
// so the knowledge-heavy step never repeats.Structured output instead of prose
Replaces parsing generated markdown into CMS fields, the step that breaks whenever a model phrases something differently. Structure arriving by contract turns three publishing integrations into three mappings.
javascript
// The model returns a defined shape, not a wall of text.
{ title, slug, metaDescription,
sections: [{ heading, body }],
faq: [{ question, answer }],
images: [{ prompt, cdnUrl }] }
// So each CMS adapter is a mapping, never a parser:
toShopify(article) // GraphQL
toWebflow(article) // CMS API v2
toWordPress(article) // RESTIdea generation that reads the site first
Replaces a human checking whether a proposed topic has already been covered. Without this step an automated programme reliably proposes articles the client published last quarter.
text
existing = fetchPublishedContent(client) // read before proposing
ideas = generateIdeas({ prompts: client.prompts, avoid: existing })
// Extends the site rather than duplicating it.Per-tenant isolation
Replaces nothing a human did. It prevents the failure that would end the engagement. Shared configuration in a multi-tenant publishing system eventually sends one client's article to another client's site.
javascript
// Credentials and state are resolved from the tenant record
// for every run. Nothing is shared between accounts.
const { apiKeys, cmsTarget, schedule, quota } = tenant(clientId);
// One shared pipeline, isolated execution context per client.What it was worth
The decisive move was making the pipeline generate its own client-specific prompts. Everything that makes this system scale follows from it: because the expensive knowledge step happens once per account rather than once per article, all clients can share one pipeline, and because they share one pipeline there is a single canonical definition of how content gets made. The alternative, one workflow per client, works for a quarter and then becomes a set of drifting copies nobody dares to change.
The structured-output decision is the one I would most want another engineer to take away. Having the model return a defined shape rather than prose sounds like a detail and is actually what makes supporting three incompatible publishing APIs tractable. Every CMS adapter becomes a mapping instead of a parser, and the fragile step, interpreting generated text, disappears from the publishing path entirely.
Ordering the quality gate correctly is what keeps the system honest. Automated QA and internal linking run before a human sees the draft, so review is read-and-approve rather than find-and-fix. A review step that degenerates into rewriting is how content automation quietly stops saving anyone time while still appearing to work.
One thing I will not claim: the source record documents the architecture, the node count and the three CMS targets, but it does not establish how many client accounts ran through it. So there is no client-count or unlimited-scale figure here. The architecture is designed so that adding a tenant is a configuration change, which is a statement about the design rather than a measurement of its use.
Automation nodes in one architecture
A single shared pipeline rather than per-client copies.
Pipeline stages
Site scrape through to CMS publish, each individually re-triggerable.
Prompts generated per client account
Written by the pipeline from the client's own website.
CMS platforms supported natively
Shopify GraphQL, Webflow CMS API v2, WordPress REST.
Record to onboard a new brand
No workflow copied, no engineering work required.
Articles passing a review draft
A human approval gate exists before every publication.
Handed over
- A ten-stage production pipeline comprising 252 automation nodes in a single shared architecture.
- A prompt-customisation engine that scrapes each client's website and generates four account-specific prompt templates.
- SEO idea generation that reads a client's already-published content so suggestions extend rather than repeat it.
- Article generation as structured output, making each CMS integration a field mapping rather than a parser.
- AI image generation with CDN hosting, so every CMS receives a stable URL.
- An automated QA pass with internal-link injection, running before human review.
- A review draft created in a document for every article prior to publication.
- Native publishing adapters for Shopify (GraphQL), Webflow (CMS API v2) and WordPress (REST).
- A scheduling engine with per-client daily quotas and configurable inter-article intervals, in single- and multi-article modes.
- Per-client isolation of API keys, credentials and state, with per-stage re-trigger capability for failure recovery.
Questions about this build
What teams usually ask when they recognise their own process here.
Because per-client copies rot. Every process improvement has to be applied to each copy, the copies drift apart, and within a year nobody is certain which one is canonical or whether a fix landed everywhere. A single pipeline with per-tenant configuration means improvements are made once and benefit everyone, and there is one authoritative definition of how content is produced. The cost is that the shared pipeline must be genuinely configurable, which is work up front rather than work forever.
By generating the voice as data rather than hard-coding it. A stage scrapes each client's website for context (products, positioning, vocabulary, audience), and generates four prompt templates specific to that account, which are stored on the tenant record and used for every subsequent article. The per-client knowledge becomes configuration. That single decision is what lets the stages themselves be shared.
Because it moves the fragile part out of the publishing path. If the model returns prose, every CMS integration has to parse it, and parsing breaks whenever phrasing changes. If it returns a defined shape (headings, sections, metadata, FAQ blocks) each CMS adapter is a field mapping that keeps working. With three genuinely different publishing APIs this is the difference between a maintainable system and three brittle ones.
No, it changes what review is for. The automated pass catches mechanical problems and injects internal links before anyone reads the draft, so the human is approving judgement and accuracy rather than fixing formatting. Every article still gets a review draft before publication. The ordering matters more than it sounds: if reviewers end up rewriting, the automation has stopped saving time while still looking like it works.
Have the idea stage read the client's published content before it proposes anything. It is an obvious step that gets skipped constantly, and the result is a system that confidently suggests a variation of the article that already ranks. Generating ideas against what exists means each new piece extends the site instead of competing with it.
Per-tenant isolation of credentials and state, resolved from the tenant record on every run, with nothing shared between accounts. In a multi-tenant publishing system this is the failure that ends an agency relationship, so it is enforced by the architecture rather than by care. It is also the main reason per-client configuration lives in a registry rather than in environment-level settings.
I do not have a verified figure, so I am not going to give one. The source record documents the architecture, the 252 nodes, the ten stages and the three CMS targets. It does not establish a client count. What I can say accurately is that onboarding a brand is a single configuration record, which is a property of the design rather than a measurement of its use.
Capabilities this used
Read next
All ai automation workHave a process that works like this one did?
Book a strategy call. We will walk the workflow with you and say plainly which parts are worth automating and which are not.