Skip to content
← Articles & field notesArticleCase study15 min readRevised

What our Google Ads onboarding system prepares in a day

Research, feeds, ads and pages move through a common workflow; account readiness and human approval determine what can actually launch.

The command inventory describes the article's implementation snapshot. Prepared artifacts, platform-approved campaigns and a live launch are separate states; the managed service's current launch terms appear at the linked service page.

Most teams scale by hiring. We scaled by building.

This is the story of how a 3-person team built a 47-command AI system that deploys complete Google Ads accounts - research, feeds, landing pages, search ads, shopping campaigns, demand gen creative, and reporting - in a single day.

Not a skeleton account. Not a "we'll finish the rest next week" situation. A full deployment with hundreds of live ads, 13 separate shopping feed strategies, pre-sell pages written and deployed, demand gen creative generated across 4 aspect ratios, and campaign architecture designed for compounding performance from day one.

Before we built this system, the same work took us 2-3 weeks. Same deliverables. Same quality. Just humans doing it step by step, file by file, upload by upload.

This article breaks down every phase of the pipeline - what each agent does, why the architecture works the way it does, and how the system compounds over time. Not to show off the tech. To show what becomes possible when you stop hiring for scale and start building for it.


Why Traditional Onboarding Takes 2-3 Weeks

Here's what a standard Google Ads onboarding looks like at most agencies.

Week one is research and setup. A strategist spends 2-3 days analyzing the brand, pulling competitor data, doing keyword research, and building a campaign plan. Then someone else takes the plan and starts building - account structure, extensions, negative keyword lists, audience segments.

Week two is creative and feeds. If the brand runs Shopping, someone manually optimizes the product feed - usually one generic feed with basic title rewrites. Search ad copy gets written, reviewed, revised, approved. If there's a landing page component, that's a separate team with a separate timeline.

Week three (if it happens at all) is launch and QA. Campaigns go live, tracking gets verified, initial optimizations happen.

Three weeks. Multiple handoffs. Multiple people.

The bottleneck isn't talent. It's architecture. Every step depends on the previous step. The feed can't be optimized until research is done. Campaigns can't be built until the feed is deployed. Ads can't be written until landing pages exist.

Sequential execution. That's what makes it slow.

The question we asked: which phases could run in parallel, managed by specialized agents that retain shared records and pass explicit inputs between steps? Dependencies and context checks still matter; automation changes the handoff rather than removing it.


Research: 21 Queries, 620 Angles, Zero Assumptions

Every onboarding starts with the /brand-onboard command. One command. What comes out the other side is 65+ files per market.

Here's what actually happens inside that one command.

The system runs 21 research queries per market. Not generic keyword searches. Structured queries across DataForSEO and Brave Search designed to map the entire competitive landscape:

  • Brand keyword baseline (volume, CPC, competition for every relevant term)
  • Competitor ad copy analysis on both Google and Meta
  • SERP structure analysis (who ranks for what, what content types dominate)
  • Seasonal patterns and trend data
  • Product-level keyword mapping

From those 21 queries, the system builds what we call the angle explosion - taking core product benefits and multiplying them across purchase intents, use cases, audiences, and seasonal contexts.

A typical catalog produces 380-620 angle variations. Each one scored for search volume, competition density, and conversion potential. The top performers become the foundation for everything that follows - feed strategies, ad copy, landing page angles, and campaign structure.

This isn't just data collection. It's the decision layer. The angles that score highest determine which feeds get built, which landing pages get written, and which campaigns get priority budget.

The output includes an 18-section brand guide, a keyword baseline with hundreds of terms, an angle registry with scored angles, 4 RSA foundation files, seasonal calendar, and bid strategy recommendations.

One command. 65+ files in the reported run. Research inputs ready for strategic review.

Most agencies do this with a strategist, a spreadsheet, and 2-3 days of manual work. The agent does it in about 40 minutes.


13 Feeds, Not 1: Why We Segment by Purchase Intent

This is the part of the system that takes most people by surprise.

Standard approach: one product feed, basic title optimization, upload to Merchant Center, run Shopping campaigns against it.

Our approach: the product catalog segmented into 13 separate feed strategies, each built around a different purchase intent.

Different product wording can represent different buyer questions. Keep valid product identity and approved attributes; a title variation does not create a guaranteed independent auction opportunity.

The /feed-segment command handles the segmentation. It uses LLM-powered analysis to assign products to keyword pockets based on funnel layer (top, middle, bottom), purchase intent, and search behavior patterns.

Then /feed-rewrite takes each segment and rewrites every product:

Titles: prioritize useful, accurate product facts and important distinctions. Character placement is a writing decision within current field requirements, not proof of a fixed algorithmic weighting zone.

Every feed runs through a 152-point validation before it touches Merchant Center. The quality threshold is 98/152 (rated STELLAR). Anything below gets auto-fixed - formatting issues, length violations, missing fields - and re-validated until it passes.

All 13 feeds deployed to Google Merchant Center through API - Python scripts that handle the formatting, validation, and upload in one pass.

This part used to take us a full week. The 13-feed strategy alone - the segmentation, the rewrites, the validation, the deployment - was a 5-day process. Now it's hours. Same depth. Same quality. Same 152-point validation. Just faster.

Here's the part most people miss: the 13 feeds aren't just for Shopping. They become the foundation for PMax campaigns, demand gen creative angles, search ad themes, and landing page strategies. Build the feeds right, and everything downstream inherits that intelligence.


Pre-Sell Pages: Building the Mid-Funnel From Scratch

Most Google Ads accounts go straight from ad to product page.

That works for bottom-funnel, high-intent search. But for top-of-funnel and mid-funnel traffic - where you're creating demand, not just capturing it - you need something between the ad and the checkout.

That's what pre-sell pages do. They educate, build trust, and position the product before the visitor lands on the product page. Advertorials, listicles, comparison pages, guides - content that matches the intent behind the search query.

Our system builds these from scratch. The full pipeline:

/presell-discover - Angle discovery through keyword research and SERP analysis. The system identifies which page types (advertorial, listicle, comparison, guide) match the search intent for each product. Output: scored angle recommendations with keyword data.

/presell-write - Full copy generation. 2,000-3,500 words per page, written with brand voice calibration and conversion architecture. Not thin content. Not AI-generated filler. Research-backed copy with specific claims, product data, and conversion architecture.

/presell-build prepares an HTML/CSS/JS destination for inspection. Check the actual generated page, truthful claims, mobile behavior, accessibility and performance; a command name does not certify production readiness or a Lighthouse score.

/presell-deploy - Deployed to Cloudflare Pages or directly to Shopify as native pages. SSL, global CDN, cross-domain tracking to the store - all configured automatically.

The funnel flow: Ad -> Pre-sell page -> Product page (or offer page) -> Cart -> Checkout.

Each pre-sell page then feeds into its own PMax campaign via /presell-pmax-prep and /presell-pmax-upload. The system generates PMax assets (headlines, descriptions, AI-generated images across multiple aspect ratios) directly from the deployed page content.

This means every pre-sell page becomes its own acquisition channel - with its own campaign, its own budget, its own performance data.

Our research across practitioner forums and Google's own documentation confirmed what we were already seeing: PMax with page feeds is the dominant strategy for scaling pre-sell pages. Demand Gen runs alongside it for top-of-funnel awareness. Search campaigns complement for high-intent informational queries. But PMax does the heavy lifting.

Separate campaigns per page type (advertorial campaign, listicle campaign, comparison campaign) lets us scale what works and pause what doesn't - without campaigns competing against each other.


Offer Pages: Behavioral Economics Built Into the Code

Offer pages sit between the pre-sell and checkout. They present bundle tiers, pricing, and value stacking in a way that's designed to convert.

What makes ours different: Kahneman's behavioral economics principles aren't just applied to the copy. They're built into the code.

The /offer-discover command researches bundle opportunities and designs the tier structure. The /offer-write command generates copy following the offer stack framework. The /offer-build command produces HTML/CSS/JS with interactive tier selection, threshold progress bars, and dynamic CTAs.

Here's what's happening under the hood:

Decoy Effect. The tier structure is engineered so the starter tier is close in price but far in value from the popular tier. This makes the popular tier the "obvious" best choice. Starter exists to make popular look like a steal.

Default Selection. The recommended tier is pre-selected on page load. The effect of a default depends on the offer and buyer; it must not conceal a choice or imply a measured uplift here. The popular tier loads with visual emphasis, social proof only where supported by genuine, relevant purchase evidence, and ownership language.

Offer messaging. Explain the real offer, eligibility and price clearly. Any urgency, threshold or saving needs to be factual and consistent with the checkout; a psychology label does not establish conversion lift.

Peak-End Rule. The selection experience is designed for positive memory: CSS pulse animation on tier selection, haptic feedback on mobile, confirmation toast with "Great choice!" messaging. The end of the interaction shapes how they remember it.

Endowment Effect. Ownership language before purchase: "Your complete kit includes..." not "The bundle includes..." The shift from third-person to possessive changes the psychological relationship with the product.

Every one of these principles is implemented in JavaScript, CSS, and HTML structure. Not as copywriting advice. As functioning code that applies behavioral economics automatically across every offer page the system builds.

The offer page links directly to Shopify via cart URLs. No API integration needed. Each bundle tier maps to a hidden Shopify product variant. Tier selection updates the CTA, the CTA links to /cart/VARIANT_ID:1, and the customer lands in checkout with the right product already in their cart.

The entire offer pipeline - research, copy, build, deploy - runs through 4 commands.


Campaign Architecture: Prepared Work and the Launch Boundary

By this point in the day, we have:

  • Research complete (380-620 scored angles)
  • 13 feeds deployed to Merchant Center
  • Pre-sell pages written, built, and deployed
  • Offer pages live with behavioral economics baked in

Now the campaigns.

Brand campaigns. Product URLs matched to ads matched to keyword clusters. Multiple ad groups, each with tight relevance between the landing page, the ad copy, and the keyword set. This isn't "throw it at Smart Bidding and hope." It's structured for Quality Score from the start.

Cold acquisition search campaigns. For top products, each with 3 to 6 ad groups. Same URL x ads x keyword matching structure. RSAs built from the angle research, not generic copy. The /search-ad-create command generates Shopping Domination RSAs - meaning the search ads mirror the Shopping feed angles, so the brand owns more real estate on the same SERP.

Counter-competitor campaigns. Built directly from the competitor research in /brand-onboard. Targeting competitor brand terms with our positioning. We know their ads, their landing pages, their gaps - because we already pulled them in the research phase.

Direct response campaigns for pre-sell pages. Each pre-sell page gets its own campaign structure with matched keywords and custom ad copy.

13 Shopping campaigns with separate segments for keyword data mining. These aren't just for revenue. They're intelligence-gathering instruments. Search term data from Shopping campaigns feeds directly back into feed title improvements and uncovers new angles for additional feeds.

13 PMax feed-only campaigns. One per segment, optimized for performance and scaling.

Demand Gen image campaigns. AI-generated creative across 4 aspect ratios - landscape (1.91:1), square (1:1), portrait (4:5), and Shorts (9:16). The historical implementation supported several image providers. Current availability and charges come from the live product or service, not these historical per-image estimates. Product images are used as references, and the AI generates lifestyle and contextual variations for each angle.

Demand Gen video campaigns. Existing brand video assets get scanned, analyzed, uploaded to YouTube as unlisted videos, and deployed as in-stream and Shorts campaigns. The system handles batch processing of 200+ video variants with automatic deduplication and rotation management.

Account-level infrastructure runs alongside everything else: sitelinks, callouts, price extensions, structured snippets - all generated and deployed through API. Negative keyword lists across junk terms, brand protection, and competitor segments deployed as shared sets. Placement exclusions across YouTube, Display, and mobile apps.

Everything through API. Everything before the first campaign impression.


The Compounding Loop: Why the System Gets Smarter

Here's what separates this from "fast setup."

Most onboarding processes are linear. Research -> build -> launch -> done. The system produces a static output and then you optimize manually.

This system compounds.

The 13 Shopping campaigns generate search term data from day one. That data feeds directly back into the feed pipeline:

  1. Search terms reveal new keyword patterns the original research didn't catch
  2. New patterns suggest new angles for additional feed segments
  3. New segments get built, validated, and deployed
  4. New feeds generate new Shopping campaigns
  5. New campaigns generate new search term data

The optimization feedback loop (/brand-optimize) takes this further. It's a 2-stage system: Stage 1 analyzes performance across all channels - shopping, search, presell, demand gen, organic. Stage 2 detects opportunities and automatically queues new commands:

  • Underperforming segments trigger new RSA creation via /search-ad-create
  • High-performing angles trigger new presell pages via /presell-write -> /presell-build -> /presell-deploy
  • Gaps in feed coverage trigger new segments via /feed-segment -> /feed-rewrite -> /feed-deploy

The system doesn't just run campaigns. It identifies what's working, finds what's missing, and builds more of what works.

The unified reporting command (/brand-report) pulls analytics across every channel in one view - Shopping performance, Search term analysis, presell page metrics, demand gen engagement, PMax asset performance, even Google Search Console organic data. One command, full picture.

This is the part that's hard to explain until you see it running. The account doesn't just launch on day one. It starts learning on day one. And every week it runs, the data layer gets richer, the angles get sharper, and the campaigns get more precise.


The Agent Architecture: 47 Commands, 6 Pipelines

Let me pull back the curtain on how this actually works.

47 commands. Each one handles a specific phase of a specific pipeline. They're not generic AI tools. They're purpose-built agents with 1,500-2,000 lines of instructions, access to Python scripts for API operations, and strict validation contracts that enforce quality standards.

The 6 main pipelines:

Shopping Feed Pipeline (10 commands): From brand research through feed segmentation, rewriting, AI image generation for product photos, validation, and upload to both GMC and Google Ads. Handles Shopping campaigns, PMax campaigns, and the Thief/Protector ad rank strategy.

Search preparation: review intent, negative scope, destinations and the match types appropriate to the actual campaign. The chosen setup is an account decision, not a universal prohibition on one match type.

Demand Gen Pipeline (4 commands): Image generation with 5 AI models across 4 aspect ratios, video scanning and YouTube upload, and campaign deployment for both image and video formats.

Pre-Sell Pages Pipeline (8 commands): Angle discovery, copy generation, HTML/CSS/JS build, deployment to Cloudflare or Shopify, PMax asset generation, and campaign upload. Plus theme extraction from competitor pages and GA4 tracking setup.

Offer Pages Pipeline (4 commands): Bundle opportunity research, offer stack copy, interactive page build with behavioral economics, and deployment with Shopify cart integration.

Account Setup Pipeline (5 commands): Extensions (sitelinks, callouts, price, structured snippets), negative keyword lists, and placement exclusions - all generated and deployed through the Google Ads API.

Each agent has strict quality gates. The feed agent won't deploy anything scoring below 98/152 on validation. The presell agent won't build a page without passing copy quality checks. The search ad agent enforces 26-column CSV format and keyword match type restrictions.

They run in parallel where possible. While the feed agent rewrites and validates, the presell agent discovers angles. While the search agent builds RSAs, the demand gen agent generates images. While all of them do their work, I'm on tracking fixes and page tagging.

(The agents build faster than I can configure GTM. I've made my peace with that.)

The retrospective described 16+ brands across 19+ markets at the time of this run - from US-en to DE-de to FR-fr to NL-nl. The shared architecture supports target-language research, localized feeds and translated presells; each market still needs its own language, product and configuration review.


What a Month Looks Like at This Speed

Day one: full deployment. Hundreds of ads live. Pre-sell pages deployed. Demand gen running. 13 Shopping campaigns generating search term data.

Week two: the compounding loop kicks in. Search term data reveals new angles. New feeds get built. Underperforming campaigns get new creative. High-performing pre-sell pages get additional PMax budget.

Week three: the optimization feedback loop starts suggesting new presell pages for gaps the system detected. New offer page variations test different tier structures. Demand gen creative rotates based on performance data.

Week four: the account is operating at a level most teams don't reach in 90 days. Not because we're working harder. Because the system that runs the account was built to learn, compound, and scale without adding headcount.

This is the part that makes the work fun. Not the speed itself - speed is just a side effect of good architecture. The fun part is watching a system you spent years building do in hours what used to take weeks. Watching it find angles you didn't think of. Watching it compound.

3 people. 16+ brands. 19+ markets. 47 commands.

And systems we spent years building.

Put the framework to work

See the managed onboarding process

Give your growth
an operating team.

Google Ads, Meta Ads and Klaviyo Email/SMS. Buying, creative, copy, pages, testing and optimization, handled by the team that built the AI systems.

Typically live within 48 hours. The clock starts when we have account access and the assets we need.

Discuss your growth goalCompare services and fees

Keeping execution in your team?
Book a paid working session or explore licensed systems.