We Tried Both. Neither Is What You Think.
This is the article I wish someone had written before we spent 18 months figuring it out ourselves.
If you're running a Google Ads agency and considering AI systems - whether that's off-the-shelf tools or custom-built infrastructure - the advice you'll find online is almost universally unhelpful. Tool vendors will tell you to buy. Engineers will tell you to build. Neither side has spent meaningful time on the other's approach.
We have. We ran 4 different commercial tools across real client accounts before building our own system. We tracked costs, time savings, quality metrics, and frustration levels (informal but instructive). Here's what we found.
The Buy Side: What Commercial Tools Actually Deliver
We tested tools in four categories: feed optimization, reporting, ad copy generation, and campaign management automation.
Feed Optimization Tool ($200/month/brand)
What worked: basic title optimization. The tool analyzed product attributes and generated improved titles using keyword data. For brands with simple product catalogs - under 100 SKUs, one market, one language - it delivered decent results. Titles improved. Scores went up.
Where it broke: our process. We use intent-based product segmentation (BOFU/MOFU/TOFU) and zone architecture for titles where the first 70 characters get different treatment than the rest. The tool couldn't accommodate either. Its optimization was one-size-fits-all.
We tried workarounds. Custom field mappings. Post-processing scripts. Manual overrides. After 4 months, we were spending 6 hours per week maintaining workarounds on a tool that was supposed to save time.
Total cost for 15 brands over 4 months: $12,000 in subscriptions + roughly 96 hours of workaround maintenance.
Net time savings: approximately zero. Possibly negative.
Reporting Platform ($150/month/brand)
What worked: nice dashboards. Seriously, the visualizations were good. Client-facing reports looked professional. Automated scheduling meant reports went out without manual intervention.
Where it broke: data coverage and downstream utility. The platform pulled from Google Ads and GA4 but couldn't integrate Merchant Center feed health, Search Console data, or our presell page performance tracking. We needed 7 channels. It covered 3.
The reports were also terminal. They generated a PDF or dashboard but couldn't feed their outputs into our optimization workflow. We couldn't automatically flag anomalies and trigger responses. The data went to a human who then had to interpret and act.
At 15 brands, maintaining the platform plus supplementing its gaps was more work than just building reports ourselves.
AI Copy Generator ($100/month)
What worked: volume. The tool could produce 50 headline variants in minutes. For brainstorming or generating first drafts, the speed was real.
Where it broke: quality and differentiation. Every output sounded like every other output. The headlines were technically correct - they mentioned the product, included relevant keywords, had calls to action. But they were indistinguishable from what any competitor could generate with the same tool.
No competitive cross-validation. No brand-specific angle scoring. No awareness of what our existing ads already said. The tool generated copy in a vacuum.
The editing required to make the output usable - ensuring uniqueness, adding differentiation, aligning with brand voice, removing generic phrasing - took nearly as long as writing from scratch with a structured brief.
Campaign Management Automation ($300/month)
What worked: rule-based bid adjustments. Set a CPA threshold, the tool adjusts bids. Set a budget pacing rule, the tool redistributes. Basic optimization that runs without human intervention.
Where it broke: the rules were crude. Our optimization logic has 12 analysis modules that consider cross-channel effects, funnel stage, seasonality, and competitive dynamics. The tool offered "if CPA > X, reduce bid by Y%." That's not optimization. That's a thermostat.
For accounts with simple structures - one campaign type, one market, stable performance - the tool was adequate. For the multi-campaign, multi-market, multi-funnel accounts that make up most of our portfolio, it was too simple to be useful.
The Build Side: What Custom Systems Actually Cost
After the commercial tool experience, we committed to building our own infrastructure. Here's the honest cost breakdown.
Time Investment
Month 1-2: Infrastructure setup. GCP project, API credentials for 6 services, data architecture, brand configuration system. Two people spending roughly 50% of their time on this. Visible output: essentially nothing. The infrastructure is invisible.
Month 3-4: First pipeline (shopping feeds). 7 commands from raw feed to deployed campaigns. Extensive debugging on edge cases - products with missing attributes, non-standard category mappings, feeds with inconsistent formatting. One person at 60% time.
Month 5-8: Remaining pipelines. Presell pages (12 commands), search ads (4 commands), demand gen (4 commands), offer pages (6 commands). Each pipeline: 4-6 weeks to build, 2-3 weeks to stabilize across real client accounts.
Month 9-14: Orchestration and feedback loops. 21 workflows. Reporting system. Optimization engine. Knowledge base. This is where the system went from "collection of scripts" to "operating system."
Month 15-18: Production hardening. Error handling. Credential rotation. Preflight checks. Capacity testing. The unsexy work that determines whether the system runs at 2 AM without you.
Total build time: approximately 4,500 hours across the team over 18 months.
Financial Investment
Direct costs during build: API usage during development ($2,000-3,000), infrastructure (Railway hosting, Cloudflare, storage: $200/month), tools and services used during development ($1,500).
Opportunity cost: the harder number. During months 1-8, the team was split between building systems and managing clients. We probably left 10-15 new accounts on the table because we didn't have capacity to onboard them. At $2,000/month average revenue per account, that's $20,000-30,000/month in deferred revenue.
Total investment through break-even: roughly $150,000-180,000 in combined direct costs and opportunity costs over 18 months.
Ongoing Costs
API usage at 50+ brands: $4,000-6,000/month (Google Ads API, DataForSEO, image generation models, hosting).
Maintenance: 8-10 hours per week on system maintenance, bug fixes, and improvements. This never goes to zero. APIs change. Edge cases emerge. New features get built.
The Decision Framework
After living both approaches, here's how we'd recommend thinking about it.
When to Buy
Under 10 accounts: the math doesn't justify building. Even if commercial tools aren't perfect, the cost of building at this scale exceeds the savings. Use tools where they fit, supplement manually where they don't.
Non-technical team: if nobody on your team can write Python, work with APIs, and debug production systems, building custom infrastructure is a very expensive learning project. The tools will serve you better.
Standardized workflow: if your process doesn't differ meaningfully from how most agencies operate, commercial tools are built for you. They optimize for the average case. If you are the average case, that's fine.
Immediate need: if you need time savings this quarter, not next year, tools are the only option. Building takes 18 months minimum for a mature system.
When to Build
30+ accounts: at this scale, recurring tool costs exceed build costs within 12 months. The math tips decisively toward custom systems. At 50 brands, the difference between $200/month/brand in tools ($10,000/month) and $4,000/month in API costs is $72,000/year in perpetuity.
Process is your edge: if your competitive advantage includes proprietary methods - zone architecture for titles, overgenerate-and-score for RSAs, intent-based segmentation - tools can't accommodate these. You either abandon your edge or build around it.
Technical capability exists: you need at least one person comfortable with Python, APIs, and data architecture. They don't need to be a senior software engineer, but they need to be able to build and maintain production-grade scripts.
Long-term orientation: you're optimizing for next year's capability, not this month's deliverables. Building systems is an investment with delayed returns. If you can't sustain 18 months of investment alongside client work, don't start.
The Hybrid Zone (10-30 accounts)
This is where most growing agencies sit, and it's the hardest decision.
The pragmatic approach: buy tools where they fit your workflow without modification. Build custom systems where your process is unique and gives you a competitive advantage.
For most agencies in this range, that means:
- Buy: reporting dashboards, basic bid management, scheduling
- Build: feed optimization if you have a proprietary method, competitive intelligence if you need depth beyond what tools offer, any pipeline where tool workarounds exceed the time savings
The key metric: if you're spending more than 20% of your tool's time savings on workarounds and supplemental processes, the tool isn't working for you. Either switch tools or build that function.
The Integration Problem Nobody Solves Well
Whether you buy or build, the hardest problem is integration. Individual tools or pipelines work fine in isolation. Making them work together is where complexity explodes.
A commercial reporting tool gives you dashboards. But those dashboards don't feed into your optimization process. The data sits in a PDF or a web interface with no programmatic access. You look at the report, mentally note the issues, open another tool, and make changes. The report and the action are disconnected.
A commercial feed tool optimizes titles. But it doesn't know about your competitive intelligence findings. It doesn't know that a competitor just started bidding aggressively on a keyword that should inform your title strategy. The feed tool and the competitive data live in separate worlds.
This is the fundamental limitation of buying: each tool solves one problem well but creates an integration gap between itself and everything else. The more tools you add, the more gaps you create.
Building solves this because you control the data flow. Our shopping feed pipeline reads competitive intelligence data before generating titles. Our reporting pipeline feeds directly into the optimization engine. Our knowledge base aggregates learnings from all pipelines and makes them available to all pipelines.
But building creates a different integration problem: maintaining all those connections. Every API change, every schema update, every new edge case potentially breaks a connection. Data contracts mitigate this, but the maintenance burden is real.
The honest assessment: neither approach solves integration perfectly. Building gives you tighter integration with higher maintenance cost. Buying gives you looser integration with lower maintenance cost but more manual glue work.
The Team Composition Question
This doesn't get discussed enough: the team you need for each approach is different.
Buy approach: you need people who can evaluate, configure, and manage commercial tools. Marketing operations skills. Vendor management. Workflow design using no-code or low-code platforms. These are relatively common skills in the agency space.
Build approach: you need at least one person who can write production Python, work with REST APIs, manage data architecture, and debug issues at 2 AM when a pipeline fails on a client's critical campaign. These skills are rare in the agency space. Most people who can do this work at tech companies for 2-3x agency compensation.
We have this capability in-house because of an unusual background - developer and marketer in the same person. Most agencies don't have that. The realistic options for most agencies:
Hire a developer. Expensive, and finding someone who understands both code AND marketing context is genuinely difficult. You'll probably hire a good developer who needs 6 months to understand Google Ads deeply enough to build useful systems.
Train an existing team member. Possible if someone is technically curious, but the learning curve from "can modify a Google Ads script" to "can build production-grade data pipelines" is 12-18 months.
Partner or consult. Bring in external technical capability for the build phase, then gradually transfer knowledge to internal team. This is probably the most pragmatic option for most agencies, but it requires finding someone who understands both the technical and marketing sides.
None of these options are easy. The team composition question is often the actual deciding factor between build and buy, more than the cost analysis.
The Hidden Costs Nobody Mentions
Buy Hidden Costs
Vendor lock-in: after 12 months on a tool, your workflows are built around it. Switching costs are real. We spent 3 weeks migrating off one tool because our reporting templates, client dashboards, and internal processes all referenced its specific output format.
Feature dependency: you build processes around features the vendor controls. When they change pricing, sunset a feature, or pivot their product direction, you eat the consequences. This happened to us twice in 18 months.
Ceiling effects: tools improve at the vendor's pace, not yours. If you need a feature they don't prioritize, you wait. Or you build a workaround, which brings you back to the build column anyway.
Build Hidden Costs
Maintenance burden: systems need ongoing maintenance. APIs change endpoints. Edge cases appear. Performance degrades. Budget 8-10 hours per week for a mature system, indefinitely.
Key person risk: if the person who built the system leaves, the system becomes fragile. Documentation helps but doesn't eliminate this risk. We addressed it through code contracts and standardized architecture, but it's a genuine concern.
Scope creep: once you start building, you see opportunities everywhere. The system could do this. It should also handle that. Every feature adds maintenance burden. Discipline about scope is hard when the building is going well.
Debugging at scale: a pipeline that works perfectly on 5 brands might fail silently on brand 6 because of an edge case in their product catalog. Debugging at scale is a different skill than building at small scale.
What We'd Do Differently
Start with data contracts on day 1. Our first 3 pipeline attempts failed because data validation was an afterthought. Every pipeline exchanges data with every other pipeline. If those handoffs aren't validated through contracts, the system breaks in ways that are hard to diagnose.
Build the most measurable pipeline first. We started with shopping feeds because the improvement was quantifiable - feed scores, title quality, deployment success rate. Starting with something harder to measure (like "better ad copy") would have made the ROI case harder to make internally.
Track time savings from week 1. Sounds obvious. We didn't do it for the first 3 months and had to reconstruct estimates. Precise time tracking per function before and after automation makes the business case undeniable.
Don't automate the hard stuff first. We tried to automate strategic recommendations early on. It produced mediocre output that required so much editing it was faster to just think through the recommendations manually. Start with the mechanical, repetitive, pattern-following work. That's where AI excels.
Case Study: The Feed Pipeline Decision
To make this concrete, here's how the build-vs-buy decision played out for our shopping feed pipeline specifically.
The buy option: a commercial feed optimization tool at $200/month/brand. For 50 brands, that's $10,000/month or $120,000/year. The tool produced decent title improvements for simple catalogs. Average feed score improvement: about 15 points on our 152-point scale.
The build option: a custom 7-command pipeline with zone architecture, intent-based segmentation, anti-templating detection, and 152-point quality validation. Build time: approximately 600 hours across 8 weeks. Ongoing API costs: roughly $4-8 per brand per month. That's $200-400/month total, or $2,400-4,800/year.
The results: custom pipeline produces an average 32-point feed score improvement versus 15 points from the commercial tool. Products are segmented by purchase intent, which the tool couldn't do at all. And the pipeline feeds its outputs directly into campaign building, competitive intelligence, and the knowledge base.
Annual cost difference: $115,000+ per year. Quality difference: 2x the improvement. Integration: seamless versus manual.
The build option required 600 hours of upfront work. At the annual cost savings, that investment paid back in under 7 weeks of operation at full scale. After that, it's pure advantage - better results, lower costs, tighter integration, every year.
This specific case made building the obvious choice. But it's important to note: at 5 brands instead of 50, the commercial tool at $1,000/month would have been the pragmatic choice. The build payoff is scale-dependent.
The Bottom Line
There's no universal right answer to build vs buy. But there is a framework:
Scale determines the math. Under 10: buy. Over 30: build. In between: hybrid.
Process uniqueness determines the fit. Standard processes: tools work fine. Proprietary methods: tools fight you.
Technical capability determines feasibility. No code skills: buy. Code-comfortable: build is an option.
Time horizon determines the ROI. Need savings now: buy. Can invest 18 months: build pays compound returns.
The one universal wrong answer: buying tools at scale and watching margins erode, or building custom systems for 5 accounts and wondering why the math doesn't work.
Match the approach to where you actually are. Not where you want to be.
The Timeline Reality Check
If you're leaning toward building, here's the timeline broken down honestly:
Weeks 1-3: Infrastructure. GCP project, API credentials, data architecture, brand configuration. This phase produces nothing visible. You'll feel like you're wasting time. You're not. Every pipeline depends on this foundation. Skip it and you'll rebuild it later, costing more time than doing it properly now.
Weeks 4-8: First pipeline on one brand. Pick the pipeline with the most measurable impact. For most agencies, that's feed optimization or reporting. Get it working end-to-end on a single brand. Expect bugs, edge cases, and at least one complete rewrite of a major component. This is normal.
Weeks 9-14: Remaining pipelines. Each subsequent pipeline goes faster because the infrastructure is in place. But each one has its own edge cases and its own debugging phase. Budget 4-6 weeks per pipeline, with 2-3 weeks of stabilization after the initial build.
Weeks 15-20: Multi-brand and orchestration. This is where the system goes from "useful" to "essential." Running pipelines across multiple brands, building the monitoring layer, connecting the feedback loops. The per-brand time savings become dramatic here.
Week 21+: Scale and compound. Adding new brands gets fast. The orchestration layer handles coordination. The knowledge base makes every new brand benefit from the accumulated learning of all previous brands.
The critical insight: the first 8 weeks feel like a bad investment. You're spending time building infrastructure instead of serving clients. The ROI only becomes obvious around month 4-5. If your organization can't sustain that patience, buying tools is the safer choice.
But if you can sustain it, the math gets better every single month after breakeven. And it never reverses.
Word count: ~3,600 Last updated: 2026-03-18
Gate Scores: insight:11/15 | hook:8/11 | viral:8/10 | authority:5/5 | entertainment:7/10 | info_density:7/10 | composite:7.6
Ruslan co-founded Tegra in 2017. Runs the Google Ads practice - feed, PMax, search, attribution. Writes weekly about the parts of paid search operators are afraid to touch.