BlitzAdmin Automation Architecture

What We Now Know About BlitzAdmin

After reading Dylan Kirby’s project handoff emails (Sept 2025) and Sam’s documentation, here’s the confirmed technical architecture of the site builder.

Code Repositories (GitLab)

Tech Stack (Confirmed)

Required Skills for Engineering

From Dylan’s handoff: Must-haves: AWS (esp. Lambda), Python, PHP, WordPress (custom plugins). Nice-to-haves: Angular, Bash, Google & Meta APIs.

Current Process vs. Target Process

How It Works Today (6 Steps, 3 Manual)

Target Process (Zero-Human, 6 Steps All Automated)

The 3 Things We Need to Build

Everything else already exists. These are the only gaps between the current manual process and full automation.

Build 1: GoDaddy DNS Automation

Technical Approach

The GoDaddy API has a PUT /v1/domains/{domain}/records/NS endpoint that updates nameserver records. We need to store the GoDaddy API key/secret and the 4 BlitzAdmin nameserver addresses, then expose a Claude tool that calls this endpoint after domain purchase.

# Pseudocode for NS update
def update_nameservers(domain: str):
    godaddy_api.put(
        f"/v1/domains/{domain}/records/NS",
        headers={"Authorization": f"sso-key {API_KEY}:{API_SECRET}"},
        json=[
            {"data": "ns1.blitzadmin.com", "ttl": 3600},  # Replace with actual NS
            {"data": "ns2.blitzadmin.com", "ttl": 3600},
            {"data": "ns3.blitzadmin.com", "ttl": 3600},
            {"data": "ns4.blitzadmin.com", "ttl": 3600},
        ]
    )

Effort: ~2 hours. The GoDaddy MCP already has domain tools — this is just adding nameserver update capability.

Build 2: BlitzAdmin Provisioning API Enhancement

Changes to the Site Builder Codebase

In git.adectra.com/blitzmetrics/wordpress-site-builder:

Key Insight: The White-Label Dashboard Already Stores Credentials

Dylan’s system already has a credential store — the white-label dashboard with the “lock icon” that shows site passwords. We don’t need to build a new credential store; we just need to add a column for the application password and expose it via an API endpoint that the MCP connector reads.

# In the white-label-dash-back-end repo
# New Lambda endpoint: GET /api/sites/{domain}/credentials
def get_site_credentials(domain):
    """Returns credentials for MCP connector"""
    site = db.get_site(domain)
    return {
        "site_url": site.url,
        "wp_username": site.admin_username,
        "app_password": site.application_password,  # NEW FIELD
        "admin_email": site.admin_email,
        "template_tier": site.tier,
        "provisioned_date": site.created_at
    }

Effort: ~1-2 days. This is the biggest change — modifying the Lambda functions and adding the application password generation to the post-provisioning hook. The CSV bulk upload flow should also be updated to generate app passwords.

Build 3: BlitzAdmin MCP Connector (Claude’s Gateway)

Architecture

┌─────────────┐     ┌──────────────────────┐     ┌─────────────────────┐
│   Claude     │────▶│  BlitzAdmin MCP       │────▶│  WordPress Site      │
│   (Cowork)   │     │  Connector            │     │  REST API            │
│              │◀────│                        │◀────│  /wp-json/wp/v2/     │
└─────────────┘     └──────────────────────┘     └─────────────────────┘
                           │                              │
                     ┌─────┴──────┐              ┌────────┴──────────┐
                     │ White-Label │              │  Rank Math API     │
                     │ Dashboard   │              │  /wp-json/rankmath/│
                     │ (cred store)│              │  Content Factory   │
                     └────────────┘              └───────────────────┘

Flow:
1. Claude calls blitz_create_post("thedavidcarroll.com", ...)
2. MCP connector fetches app_password from White-Label Dashboard API
3. MCP connector calls WordPress REST API with Basic Auth
4. WordPress creates the post and returns success

MCP Tools to Expose

Starter MCP Server Code

// blitzadmin-mcp/index.js
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const DASHBOARD_API = "https://api.blitzadmin.com";  // White-label dashboard
const DASHBOARD_KEY = process.env.BLITZ_API_KEY;

// Fetch site credentials from the White-Label Dashboard
async function getSiteCredentials(domain) {
  const res = await fetch(`${DASHBOARD_API}/api/sites/${domain}/credentials`, {
    headers: { "Authorization": `Bearer ${DASHBOARD_KEY}` }
  });
  if (!res.ok) throw new Error(`Site ${domain} not found`);
  return res.json(); // { site_url, wp_username, app_password }
}

// Generic WordPress REST API caller
async function wpApi(domain, method, endpoint, body = null) {
  const creds = await getSiteCredentials(domain);
  const auth = Buffer.from(
    `${creds.wp_username}:${creds.app_password}`
  ).toString("base64");

  const res = await fetch(`${creds.site_url}/wp-json/wp/v2/${endpoint}`, {
    method,
    headers: {
      "Authorization": `Basic ${auth}`,
      "Content-Type": "application/json",
    },
    body: body ? JSON.stringify(body) : undefined,
  });

  if (!res.ok) throw new Error(`WP API ${res.status}: ${await res.text()}`);
  return res.json();
}

// Tool: Create a blog post
async function createPost({ site, title, content, status, categories }) {
  const result = await wpApi(site, "POST", "posts", {
    title, content, status: status || "draft", categories
  });
  return `Post created: "${result.title.rendered}"
ID: ${result.id}  |  URL: ${result.link}
Status: ${result.status}`;
}

// Tool: List all content on a site
async function listContent({ site, type }) {
  const endpoint = type === "page" ? "pages" : "posts";
  const items = await wpApi(site, "GET", `${endpoint}?per_page=100`);
  return items.map(i => ({
    id: i.id,
    title: i.title.rendered,
    status: i.status,
    url: i.link,
    modified: i.modified
  }));
}

// Tool: List all BlitzAdmin sites
async function listSites() {
  const res = await fetch(`${DASHBOARD_API}/api/sites`, {
    headers: { "Authorization": `Bearer ${DASHBOARD_KEY}` }
  });
  return res.json();
}

// ... register tools with MCP server framework

Effort: ~1-2 days for the P0 tools, another 1-2 days for P1/P2. Can be built as a Cowork plugin for easy installation.

Retrofitting Existing Sites (Like thedavidcarroll.com)

For sites already provisioned by BlitzAdmin, we need a one-time operation to generate application passwords so Claude can manage them.

Option A: Batch Script via White-Label Dashboard

If the white-label dashboard has SSH/WP-CLI access to all sites (likely, since it manages them), run this across all sites:

#!/bin/bash
# retrofit-app-passwords.sh
# Run once to generate application passwords for all existing BlitzAdmin sites

SITES=$(curl -s "${DASHBOARD_API}/api/sites" -H "Authorization: Bearer ${API_KEY}" | jq -r '.[].domain')

for site in $SITES; do
  echo "Generating app password for $site..."
  # SSH into the site's WordPress install and create app password
  APP_PASS=$(wp user application-password create blitzadmin "claude-mcp" --porcelain --url="https://$site")

  # Store the password in the dashboard
  curl -X PUT "${DASHBOARD_API}/api/sites/$site/credentials" \
    -H "Authorization: Bearer ${API_KEY}" \
    -H "Content-Type: application/json" \
    -d "{\"application_password\": \"$APP_PASS\"}"

  echo "  Done: $site"
done

Option B: One-at-a-Time via wp-admin

For a quick proof of concept on thedavidcarroll.com right now:

1. Log into thedavidcarroll.com/wp-admin (credentials in white-label dashboard lock icon)
2. Go to Users → Profile → Application Passwords
3. Enter name: “claude-mcp” and click Add New Application Password
4. Copy the generated password and share it with me
5. I immediately start creating content via REST API

Content Factory Plugin — What It Already Does

BlitzAdmin already has a custom WordPress plugin called Content Factory that auto-injects client information (social links, Google properties). This is important because it means some of the “personalization” step is already partially automated.

What Content Factory Handles

The MCP connector replaces the manual steps — Claude does the find/replace, content population, and Rank Math configuration via API instead of a VA doing it by hand.

End-to-End: “Build a Site for David Carroll”

Here’s exactly what happens when someone says this to Claude, once all 3 builds are complete:

Step-by-Step Detail

Step 1-2 (Domain): ~2 minutes
Claude: “Let me check domain availability for David Carroll.” Calls domains_suggest(“David Carroll entrepreneur Minneapolis”) and domains_check_availability(“thedavidcarroll.com”). Presents options. On approval, completes purchase.

Step 3 (DNS): ~1 minute
Claude calls the GoDaddy API to update nameservers to BlitzAdmin’s 4 NS records. Confirms change.

Step 4 (Provisioning): ~30 minutes to 48 hours
Claude calls blitz_provision_site which triggers BlitzAdmin’s Lambda function. DNS propagation happens. BlitzAdmin auto-creates the WordPress site, installs all plugins, and generates an application password. Claude gets notified when ready (or polls periodically).

Step 5 (Research): ~5 minutes
While waiting for DNS, Claude runs the full research playbook: web search for media features, podcast appearances, social profiles; Ahrefs for SEO baseline; YouTube for video content. Produces a structured dossier. (We already proved this works — see the David Carroll audit report from this session.)

Step 6 (Content): ~15 minutes
Claude uses the MCP connector to: (a) Update site title and tagline, (b) Create/update About page with full biography from research, (c) Create Press & Media page with publication logos and links, (d) Create Podcast page with embeds, (e) Write and publish 3 SEO-optimized blog posts, (f) Configure Rank Math Person schema with sameAs links, (g) Generate a final report for the team.

Total time: ~25 minutes of Claude work + DNS wait time. Zero human logins.

Template Tiers (From Existing Documentation)

BlitzAdmin has a tiered template system. Each tier determines which plugins and features are installed.

For the automated pipeline, all personal brand sites should be Tier 2 minimum so they get Digital Plumbing and Search Console verification automatically.

QA Checklist (From Existing Documentation)

These are the quality benchmarks from the existing BlitzMetrics documentation. Claude should verify these after every site build.

Immediate Next Steps

Today (Proof of Concept)

This Week (Build 3 — MCP Connector)

Next 2 Weeks (Builds 1 & 2)

Month 1 (Full Pipeline Live)

Summary

BlitzAdmin already does most of what we need. The site builder auto-provisions WordPress sites, Content Factory auto-injects client info, and the white-label dashboard stores credentials. We only need 3 builds to go from “3 manual steps” to “zero manual steps” — and the hardest one (Build 2) is a modification of existing Lambda code, not a greenfield build.

The fastest path: get one application password working on thedavidcarroll.com today, prove the content pipeline, then build outward.

Sources: Dylan Kirby project handoff (Sept 2025), Sam McLeod documentation, BlitzMetrics personal branding checklist

Architecture Document v2.0 • April 5, 2026