Skip to main content
← Wednesday's Workflows

Content Marketing Engine System Architecture 🏗️

From 100 to 10,000 posts/month with multi-agent orchestration

May 29, 2025
21 min read
📝 Marketing🏗️ Architecture🤖 Multi-Agent📊 Scalable
🎯This Week's Journey

From prompts to production content engine.

Monday showed 3 core prompts for content generation. Tuesday automated the workflow. Wednesday mapped team roles. Thursday (today): complete technical architecture. Multi-agent orchestration, ML pipelines, SEO optimization, and scaling patterns from 100 to 10,000 posts per month.

📋

Key Assumptions

1
Content volume: 100-10,000 posts/month across blog, social, email channels
2
Multi-channel distribution: WordPress/CMS, Twitter/LinkedIn, Email (Mailchimp/SendGrid)
3
SEO requirements: keyword research, on-page optimization, performance tracking
4
Quality standards: 95%+ human-like quality, brand voice consistency, fact-checking
5
Compliance: GDPR data handling, copyright checks, brand safety filters

System Requirements

Functional

  • Generate content from topics/keywords with brand voice consistency
  • SEO optimization: keyword density, meta tags, internal linking, readability
  • Multi-channel formatting: blog HTML, social snippets, email templates
  • Quality assurance: fact-checking, plagiarism detection, brand safety
  • Scheduling and distribution to CMS, social APIs, email platforms
  • Performance tracking: engagement metrics, SEO rankings, conversion tracking
  • Content calendar management with approval workflows

Non-Functional (SLOs)

generation latency p95 ms15000
quality score min0.95
availability percent99.5
seo score min85
plagiarism threshold max0.05

💰 Cost Targets: {"per_post_usd":0.5,"per_1k_posts_usd":450,"ml_inference_per_post_usd":0.15}

Agent Layer

planner

L3

Decompose content request into outline, research needs, and execution plan

🔧 keyword_research_tool, competitor_analysis_tool, brand_voice_retriever

⚡ Recovery: If keyword research fails → use fallback keyword list, If brand voice unavailable → use default tone, Retry with exponential backoff (3 attempts)

executor

L2

Generate content draft based on plan

🔧 llm_generation (GPT-4/Claude), fact_checker, style_enforcer

⚡ Recovery: If LLM timeout → retry with shorter context, If low confidence (<0.8) → flag for human review, If fact-check fails → regenerate with verified sources

seo_optimizer

L3

Optimize content for search engines

🔧 keyword_density_analyzer, readability_scorer, meta_tag_generator, internal_link_suggester

⚡ Recovery: If SEO API unavailable → use rule-based optimization, If score <85 → iterate up to 2 times, If optimization degrades quality → revert to draft

evaluator

L3

Validate content quality and brand alignment

🔧 plagiarism_detector, brand_voice_scorer, grammar_checker, sentiment_analyzer

⚡ Recovery: If plagiarism detected → flag for rewrite, If brand misalignment → send to planner for revision, If grammar issues → auto-correct minor, flag major

guardrail

L4

Safety checks, compliance, and policy enforcement

🔧 content_safety_api (OpenAI Moderation), pii_detector, copyright_checker, brand_safety_filter

⚡ Recovery: If safety violation → block publish, alert human, If PII detected → auto-redact and flag, If copyright issue → reject and log

distributor

L2

Publish content to target channels

🔧 cms_api (WordPress/Contentful), social_api (Twitter/LinkedIn), email_api (Mailchimp/SendGrid)

⚡ Recovery: If API failure → retry with backoff (5 attempts), If publish fails → queue for manual review, If partial failure (some channels) → log and continue

ML Layer

Feature Store

Update: Real-time for engagement, daily for trends, weekly for competitor analysis

  • • brand_voice_embedding (vector)
  • • historical_performance_metrics (engagement, conversions)
  • • keyword_trends (time-series)
  • • competitor_content_features
  • • user_engagement_patterns

Model Registry

Strategy: Semantic versioning with A/B testing for new models

  • • content_quality_classifier
  • • seo_score_predictor
  • • engagement_forecaster
  • • brand_voice_embedder

Observability Stack

Real-time monitoring, tracing & alerting

0 active
SOURCES
Apps, Services, Infra
COLLECTION
14 Metrics
PROCESSING
Aggregate & Transform
DASHBOARDS
5 Views
ALERTS
Enabled
📊Metrics(14)
📝Logs(Structured)
🔗Traces(Distributed)
content_generation_latency_p50_p95_p99_ms
✓
agent_success_rate_by_type
✓
llm_token_usage_per_post
✓
llm_cost_per_post_usd
✓
seo_score_distribution
✓
quality_score_distribution
✓

Deployment Variants

🚀

Startup Architecture

Fast to deploy, cost-efficient, scales to 100 competitors

Infrastructure

✓
Serverless (Lambda/Cloud Functions)
✓
Managed PostgreSQL (RDS/Cloud SQL)
✓
Managed Redis (ElastiCache/Memorystore)
✓
OpenAI/Anthropic APIs (pay-per-use)
✓
CloudWatch/Stackdriver for observability
✓
S3/GCS for storage
→Fast to deploy (<1 week)
→Low ops overhead (no Kubernetes)
→Cost-effective for <1K posts/month
→Limited customization
→Vendor lock-in acceptable

Risks & Mitigations

⚠️ LLM API outage or rate limiting

Medium

✓ Mitigation: Multi-LLM strategy (OpenAI + Anthropic + Google). Auto-failover. Queue for retry. SLA: 99.5% uptime.

⚠️ Content quality degradation over time

Medium

✓ Mitigation: Continuous evaluation (human + automated). Weekly quality reports. Alert if score drops >5%. Retrain models quarterly.

⚠️ Plagiarism or copyright infringement

Low

✓ Mitigation: 100% plagiarism checks (Copyscape API). Block publish if detected. Audit trail. Zero tolerance policy.

⚠️ Cost overrun (LLM API costs)

High

✓ Mitigation: Cost guardrails ($500/day limit). Multi-LLM routing for cost optimization. Monitor cost per post. Alert if >$0.75/post.

⚠️ Data privacy violation (PII leak)

Low

✓ Mitigation: PII detection and redaction before LLM. No PII in logs. Audit trail. GDPR compliance workflow.

⚠️ SEO penalty (keyword stuffing, low quality)

Medium

✓ Mitigation: SEO score validation (min 85). Readability checks. Human review for high-stakes content. Monitor rankings weekly.

⚠️ Integration failures (CMS, social APIs)

Medium

✓ Mitigation: Retry logic with exponential backoff. Circuit breakers. Fallback to manual queue. SLA: 99% same-day publish.

🧬

Evolution Roadmap

Progressive transformation from MVP to scale

🌱
Phase 1Weeks 1-12

Phase 1: MVP (0-3 months)

1
Deploy serverless architecture (Lambda + RDS + OpenAI)
2
Implement 3 core agents (Planner, Executor, Evaluator)
3
Integrate with WordPress CMS
4
Achieve 100 posts/month with 95% quality
Complexity Level
▼
🌿
Phase 2Months 4-6

Phase 2: Scale (3-6 months)

1
Migrate to queue + workers (ECS + Redis)
2
Add SEO and Guardrail agents
3
Integrate social APIs (Twitter, LinkedIn)
4
Scale to 1,000 posts/month
5
Implement ML evaluation pipeline
Complexity Level
▼
🌳
Phase 3Months 7-12

Phase 3: Enterprise (6-12 months)

1
Migrate to Kubernetes (EKS)
2
Implement multi-LLM strategy
3
Add feature store and model registry
4
Multi-region deployment
5
Scale to 10,000+ posts/month
6
Achieve 99.9% uptime SLA
Complexity Level
🚀Production Ready
🏗️

Complete Systems Architecture

9-layer architecture from presentation to security

1
🌐

Presentation

4 components

Content Dashboard (React)
Calendar UI
Analytics Dashboard
Approval Interface
2
⚙️

API Gateway

4 components

Load Balancer (ALB/NGINX)
Rate Limiter (Redis)
Auth Middleware (JWT/OAuth)
API Versioning
3
💾

Agent Layer

6 components

Planner Agent
Executor Agent
Evaluator Agent
Guardrail Agent
SEO Agent
Distribution Agent
4
🔌

ML Layer

5 components

Feature Store (Feast/Tecton)
Model Registry (MLflow)
Inference Service
Evaluation Pipeline
Prompt Store
5
📊

Integration

5 components

CMS Adapter (WordPress/Contentful)
Social API Gateway (Twitter/LinkedIn)
Email Platform (Mailchimp/SendGrid)
SEO Tools (Ahrefs/SEMrush)
Analytics (Google Analytics/Mixpanel)
6
🌐

Data

4 components

PostgreSQL (metadata, schedules)
Vector DB (Pinecone/Weaviate)
Redis (cache, queues)
S3 (content storage, logs)
7
⚙️

External

5 components

LLM APIs (OpenAI/Anthropic/Gemini)
SEO APIs
CMS APIs
Social APIs
Analytics APIs
8
💾

Observability

5 components

Metrics (Prometheus/Datadog)
Logs (CloudWatch/ELK)
Traces (Jaeger/Honeycomb)
Dashboards (Grafana)
Alerts (PagerDuty)
9
🔌

Security

5 components

IAM/RBAC
Secrets Manager (KMS/Vault)
Audit Logging
WAF
Content Safety Filters
🔄

Sequence Diagram - Content Generation Flow

Automated data flow every hour

Step 0 of 8
UserAPI GatewayPlanner AgentExecutor AgentSEO AgentEvaluator AgentGuardrail AgentCMSPOST /content/generate {topic, keywords, channel}plan(topic, keywords, channel)execute(outline, tone, length)optimize(draft, keywords)evaluate(optimized_content)check_safety(content)publish(approved_content)200 OK {post_id, url}

Data Flow

Request → Published content in 18 seconds

1
User0s
Submits content request → Topic, keywords, channel
2
API Gateway0.2s
Validates, authenticates, routes → Validated request
3
Orchestrator0.1s
Initializes workflow state → State object
4
Planner Agent2s
Creates outline and plan → Outline, tone, length
5
Executor Agent8s
Generates content draft → Draft markdown/HTML
6
SEO Agent3s
Optimizes for keywords → Optimized content + meta
7
Evaluator Agent2s
Quality and plagiarism checks → Quality score + issues
8
Guardrail Agent1.5s
Safety and compliance checks → Safety pass/fail
9
Distribution Agent1s
Publishes to CMS/social → Post IDs, URLs
10
Orchestrator0.2s
Updates state, logs metrics → Final status
11
API Gateway0.1s
Returns response to user → Success + URLs
1
Volume
0-100 posts/month
Pattern
Serverless Monolith
🏗️
Architecture
Lambda/Cloud Functions for API
OpenAI/Anthropic API (pay-per-use)
PostgreSQL (managed, e.g., RDS)
S3 for content storage
CloudWatch/Stackdriver for logs
Cost & Performance
$100/month
per month
15-20 sec per post
2
Volume
100-1,000 posts/month
Pattern
Queue + Workers
🏗️
Architecture
API server (ECS/Cloud Run)
Redis queue (ElastiCache/Memorystore)
Worker pool (3-5 instances)
PostgreSQL (with read replicas)
Vector DB (Pinecone free tier)
Cost & Performance
$400/month
per month
10-15 sec per post
3
Volume
1,000-10,000 posts/month
Pattern
Multi-Agent Orchestration
🏗️
Architecture
Load balancer (ALB/Cloud Load Balancing)
LangGraph orchestrator (ECS/GKE)
Agent pool (auto-scaling 5-20 workers)
Message bus (SQS/Pub/Sub)
PostgreSQL + Vector DB (production tier)
Redis cluster (caching + queues)
S3/GCS (content + model artifacts)
Cost & Performance
$1,500/month
per month
8-12 sec per post
Recommended
4
Volume
10,000+ posts/month
Pattern
Enterprise Multi-Region
🏗️
Architecture
Global load balancer
Kubernetes (EKS/GKE) multi-region
Event streaming (Kafka/Kinesis)
Multi-LLM strategy (OpenAI + Anthropic + self-hosted)
Distributed PostgreSQL (CockroachDB/Aurora Global)
Multi-region Vector DB
CDN (CloudFront/Cloud CDN)
Dedicated ML inference cluster
Cost & Performance
$5,000+/month
per month
5-8 sec per post

Key Integrations

WordPress/Contentful CMS

Protocol: REST API + OAuth 2.0
Distribution Agent formats content as HTML
POST to /wp-json/wp/v2/posts or Contentful API
Set meta fields (title, description, tags)
Upload featured image to media library
Publish or schedule post

Twitter/LinkedIn Social APIs

Protocol: OAuth 1.0a (Twitter) / OAuth 2.0 (LinkedIn)
Distribution Agent formats as tweet thread or LinkedIn post
POST to Twitter API v2 or LinkedIn UGC API
Handle character limits (280 for Twitter, 3000 for LinkedIn)
Upload media if included
Track post IDs for analytics

Mailchimp/SendGrid Email

Protocol: REST API + API Key
Distribution Agent formats as email template
POST to /campaigns (Mailchimp) or /mail/send (SendGrid)
Set subject, preview text, sender
Schedule or send immediately
Track campaign ID for analytics

Ahrefs/SEMrush SEO Tools

Protocol: REST API + API Key
SEO Agent requests keyword data
GET /keywords or /domain/overview
Parse keyword difficulty, search volume, trends
Use for content optimization
Track keyword rankings post-publish

Google Analytics / Mixpanel

Protocol: REST API or SDK
Track publish event with content metadata
Query engagement metrics (views, time-on-page, conversions)
Feed into ML evaluation pipeline
Generate performance reports

Security & Compliance

🔒

Authentication & Authorization

Controls
OIDC/OAuth 2.0 for user auth
JWT tokens with 1hr expiry
RBAC: Admin, Editor, Viewer roles
Service-to-service auth via mTLS or API keys
Implementation:
🔒

Secrets Management

Controls
API keys stored in AWS Secrets Manager or HashiCorp Vault
Automatic rotation every 90 days
Encrypted at rest (AES-256) and in transit (TLS 1.3)
Audit logging for secret access
Implementation:
🔒

Data Privacy

Controls
PII detection and redaction before LLM processing
GDPR-compliant data handling (right to deletion, data portability)
Anonymized analytics data
No PII in application logs
Implementation:
🔒

Content Safety

Controls
OpenAI Moderation API for hate/violence/self-harm
Custom brand safety rules (no competitor mentions, no controversial topics)
Copyright infringement detection
Plagiarism checks on 100% of content
Implementation:
🔒

Audit Logging

Controls
All content generation logged (who, what, when)
API access logs (CloudTrail/Cloud Audit Logs)
7-year retention for compliance
Tamper-proof logs (write-once S3 bucket)
Implementation:
🔒

Network Security

Controls
VPC isolation for production workloads
WAF for API protection (rate limiting, SQL injection)
TLS 1.3 for all external traffic
Private endpoints for AWS services
Implementation:

Failure Modes & Fallbacks

FailureFallbackImpactSLA
LLM API timeout or rate limitRetry with exponential backoff (3 attempts) → Switch to backup LLM (Anthropic ↔ OpenAI) → Queue for manual generationDegraded latency, not broken99.5% (5 min downtime/month allowed)
Low content quality score (<0.8)Regenerate with refined prompt → Human review queue if still low → Block publishQuality maintained, slower throughput99.9% quality pass rate
Plagiarism detectedBlock publish → Alert content team → Regenerate with different sourcesZero tolerance, no degradation100% plagiarism block rate
CMS/Social API unavailableRetry with backoff (5 attempts) → Queue for later → Alert ops teamDelayed publish, eventual consistency99.0% same-day publish
Database connection failureFailover to read replica → Circuit breaker after 3 failures → Graceful degradation (read-only mode)Read-only mode for writes, reads continue99.9% database availability
Safety violation (hate speech, etc.)Block publish immediately → Alert safety team → Log violation → Blacklist topic if repeatedZero tolerance, no publish100% safety enforcement
Worker pool exhaustion (queue backlog)Auto-scale workers (up to 20) → Throttle new requests → Alert if queue >500Increased latency, no data loss95% requests processed within 5 min
System Architecture
┌──────────────┐
│ Orchestrator │ ← Coordinates all agents, manages state
└──────┬───────┘
       │
   ┌───┴────┬─────────┬───────────┬──────────┬──────────┐
   │        │         │           │          │          │
┌──▼──┐  ┌─▼───┐  ┌──▼────┐  ┌───▼────┐  ┌──▼─────┐  ┌─▼────┐
│Plan │  │Exec │  │  SEO  │  │ Eval   │  │Guardrail│  │Dist  │
│Agent│  │Agent│  │ Agent │  │ Agent  │  │ Agent   │  │Agent │
└──┬──┘  └─┬───┘  └──┬────┘  └───┬────┘  └──┬──────┘  └─┬────┘
   │        │         │           │          │           │
   └────────┴─────────┴───────────┴──────────┴───────────┘
                              │
                          ┌───▼────┐
                          │  CMS   │
                          │ Social │
                          │ Email  │
                          └────────┘

🔄Agent Collaboration Flow

1
Orchestrator
Receives content request (topic, keywords, channel) → Routes to Planner Agent
2
Planner Agent
Retrieves brand guidelines, competitor content → Creates outline, tone, length → Returns to Orchestrator
3
Executor Agent
Receives outline → Generates content draft → Returns to Orchestrator
4
SEO Agent
Receives draft → Optimizes keywords, meta tags, readability → Returns optimized content
5
Evaluator Agent
Checks quality, plagiarism, brand alignment → Returns quality score + issues
6
Orchestrator
Decision: Quality pass? → Yes: Route to Guardrail. No: Loop back to Planner with feedback
7
Guardrail Agent
Safety checks (hate speech, PII, copyright) → Returns pass/fail
8
Distribution Agent
If safety pass: Publishes to CMS, social, email → Returns post IDs and URLs

🎭Agent Types

Reactive Agent

Low

Distribution Agent - Receives approved content, publishes to channels

Stateless (no memory between requests)

Reflexive Agent

Medium

SEO Agent - Uses rules + context (keyword data, readability scores)

Reads context (keyword trends, competitor data)

Deliberative Agent

High

Planner Agent - Plans content strategy based on goals, brand, competitors

Stateful (remembers previous content, performance)

Orchestrator Agent

Highest

Orchestrator - Makes routing decisions, handles loops, manages workflow state

Full state management (tracks entire workflow)

📈Levels of Autonomy

L1
Tool
Human calls, agent responds with output
→ Monday's prompts (user provides input, LLM generates)
L2
Chained Tools
Sequential execution of multiple tools
→ Tuesday's code (extract → validate → question)
L3
Agent
Makes decisions, can loop, has memory
→ Planner Agent (decides what to retrieve, iterates)
L4
Multi-Agent
Agents collaborate autonomously, coordinate via orchestrator
→ This system (6 agents working together)

RAG vs Fine-Tuning Decision

Brand guidelines, competitor content, and SEO trends change frequently. RAG allows daily updates without retraining. Fine-tuning reserved for brand voice embeddings (updated quarterly).
✅ RAG (Chosen)
Cost: $100/mo (vector DB + embeddings)
Update: Daily (add new docs to vector store)
How: Retrieve relevant context, augment prompt
❌ Fine-Tuning
Cost: $2K/mo (training + inference)
Update: Quarterly (retrain on new data)
How: Fine-tune GPT-3.5 or Llama on brand corpus
Implementation: Pinecone vector DB with brand guidelines (500 docs), competitor analysis (1K articles), SEO best practices (200 docs). Retrieved top-5 docs per request. Fine-tuned Sentence-BERT for brand voice embeddings.

Hallucination Detection & Mitigation

LLMs hallucinate facts, stats, quotes. Unacceptable for brand content.
L1
Confidence scoring - Flag if LLM confidence <0.85
L2
Fact-checking API - Verify claims against knowledge base
L3
Source attribution - Require citations for stats/quotes
L4
Human review queue - Manual check for flagged content
Hallucination rate: 1.2% detected, 100% caught before publish. False positive rate: 3% (acceptable).

Evaluation Framework

Content Quality Score
0.97target: 0.95+
Brand Alignment Score
0.93target: 0.90+
SEO Score
88target: 85+
Plagiarism Rate
0.3%target: <1%
Engagement Prediction Accuracy
82%target: 80%+
Testing: Shadow mode: 1000 posts generated in parallel with human writers. Metrics compared weekly. Production cutover after 95% quality parity achieved.

Dataset Curation & Labeling

1
Collect: 20K blog posts + 10K social posts - Scraped from top brands, anonymized
2
Clean: 25K usable (removed duplicates, low-quality) - Deduplication, language detection, quality filters
3
Label: 25K labeled - ($$75K (professional content writers))
4
Augment: +5K synthetic - LLM-generated edge cases (low-quality, off-brand, plagiarized)
→ 30K high-quality examples. Inter-rater agreement (Cohen's Kappa): 0.89. Used for training quality classifier and brand voice embedder.

Agentic RAG (Iterative Retrieval)

Agent doesn't retrieve once. It reasons about what it needs, retrieves, then decides if it needs more context.
User requests 'AI in healthcare' blog. Planner Agent retrieves general AI trends. Realizes healthcare-specific stats needed. Retrieves medical AI studies. Realizes regulatory context missing. Retrieves FDA AI guidance. Now has full context for Executor Agent.
💡 Not one-shot retrieval. Agent builds context iteratively based on reasoning. Reduces hallucination, improves depth.

Multi-LLM Strategy & Cost Optimization

Tech Stack Summary

LLMs
OpenAI (GPT-4 Turbo, GPT-3.5), Anthropic (Claude 3.5 Sonnet, Claude 3 Haiku), Google (Gemini Pro)
Orchestration
LangGraph (primary), CrewAI (evaluation), Custom state machine (fallback)
Database
PostgreSQL (RDS/Cloud SQL), CockroachDB (enterprise multi-region)
Vector DB
Pinecone (managed), Weaviate (self-hosted option)
Queue/Streaming
Redis (ElastiCache), SQS (AWS), Kafka (enterprise)
Compute
Lambda/Cloud Functions (startup), ECS/Cloud Run (scale), EKS/GKE (enterprise)
Storage
S3/GCS (content, logs, model artifacts)
Observability
CloudWatch/Stackdriver (startup), Datadog/New Relic (enterprise), Prometheus + Grafana (self-hosted)
ML Ops
MLflow (model registry), Feast/Tecton (feature store), SageMaker/Vertex AI (training)
Security
AWS KMS/Cloud KMS (encryption), Secrets Manager/Vault (secrets), WAF (API protection)
CI/CD
GitHub Actions, GitLab CI, or CircleCI
IaC
Terraform (primary), CloudFormation/Deployment Manager (cloud-specific)
🏗️

Need Architecture Review?

We'll audit your content system design, identify bottlenecks, and show you how to scale to 10,000+ posts/month with multi-agent orchestration and ML optimization.

©

2026 Randeep Bhatia. All Rights Reserved.

No part of this content may be reproduced, distributed, or transmitted in any form without prior written permission.