If you run marketing at a growing SaaS company, this has been a hard year. There are probably 10 or more AI tools in your stack now, each with its own login and its own invoice, and the team keeps asking for the next one.

Your SEO agency has told you again that organic traffic slipped, because more of the answers show up inside ChatGPT, Perplexity, Claude, and Google’s AI Overviews before anyone clicks. The blog reads like every other blog in the category, and the paid numbers climb every quarter to hold the same pipeline.

We run SEO, content, and paid media for more than 250 companies like yours, so we hear some version of this every week. Our answer is usually the same one: build a marketing system instead of bolting more tools together.

We try to take our own advice, so this May we closed TripleDart for two days, pulled more than 50 people off their client accounts, and put the whole team in one room.

The idea was to stop being a service business that happens to use AI and start running the way a good product team runs engineering. We’ve started calling that a growth engineering org: a marketing team where the repetitive work lives in systems anyone can run, more than one model sits underneath as plumbing, and people are measured on outcomes like pipeline and speed rather than the hours they put in. 

Almost nobody in that room writes software for a living, which is part of the point.

Why a Working Agency Would Shut Its Doors

Closing a profitable agency for two days is expensive. We did it because three problems had been building for a while, and they were starting to land at the same time.

The first is search. We’ve watched informational traffic thin out from close range, since we run SEO and content for SaaS companies ourselves. More of the answers now settle inside ChatGPT, Perplexity, and Google’s AI Overviews, and fewer people click through to read the source.

We’d already made generative engine optimization and answer engine optimization a standard layer on every account, once ranking on its own stopped paying its way.

The second is the brief. Founders want pipeline, and they want it sooner. A founder who can wire up a working flow in Claude over a weekend sets a higher bar for what an outside partner is worth.

The third is the one that kept us up at night. We had four years of playbooks from hundreds of SaaS SEO engagements, and almost all of it lived in documents and in people’s heads.

A document you wrote once never gets any smarter, and the strategist who runs a great audit can only run so many of them in a week. We’d spent the past year building Slate, our internal workflow platform, so the place to keep those playbooks already existed.

‍

It Started With One Question

Before anyone built anything, we ran a survey. We asked the whole team one thing: what eats your week? The answers came back fast, and they lined up almost too neatly.

Reporting was the worst of it, somewhere between 6 and 10 hours per analyst every week, copied and pasted across the same dashboards. Growth ops lived in people’s heads and in Slack threads, so it walked out the door every time someone left, and almost every team had built the same automation on its own without knowing anyone else had.

So we built the hackathon straight from those answers, and handed the team its own week back as the agenda.

How the Two Days Worked

We sorted the answers into 14 problem areas across paid media, SEO, creative, and RevOps. People paired off, each pair claimed one area, and the clock started.

Every pair had 48 hours to put a working agent on a live client account, the kind of thing a teammate could open on Monday and use against the client’s own data.

The part most hackathons get wrong is what they reward, so we graded for whether a build would keep running. Three things decided it: how well it reused across clients, how many hours it handed an analyst back each week, and how cleanly it plugged into the stack we already run.

That meant a clever demo nobody would open again on Tuesday lost to a basic agent that gave an analyst back six hours a week, and everyone understood what we were grading for.

The win we cared about was a quiet one: the agents that keep running on every account, week after week, with nobody babysitting them. Slate carried the SEO and content builds, and the rest of our stack ran everything else.

What Got Built

Left to pick for themselves, almost every pair went after a recurring cost instead of a one-off problem, and the builds ended up covering most of what the agency does in a normal week. One pair built a blog refresh and CRO agent that takes a single live URL and hands back a publish-ready rewrite with the conversion blocks already in place.

Another built a LinkedIn ads agent for the campaign work most teams still do by hand, and a third built a brand perception and GEO audit that reads how AI assistants describe a client and what to do about it. 

There was a backlink outreach engine wired across Clay, Smartlead, and HeyReach, and a landing page builder that turns an approved component library into live Webflow pages with no designer in the loop.

A competitor watch bot now checks the index every week, a kickoff researcher walks into the first client call already briefed, and a Slack command center pulls account insights on request. Two more agents handle creative and audit work for Meta. The one that scored higher than most of the team entries was an outreach bot, built by a single person who doesn’t write code.

Give people 48 hours and a free hand, and most of them skip the gimmicks; they spend the time turning work they hate doing by hand into something they own.

The survey had already told us these tools existed in pieces, scattered across the team, and the weekend pulled them into the open and wired them together. Now the kickoff researcher feeds the content brief, and the competitor bot feeds the refresh agent.

What It Changes for Clients

Most of this never shows up on a client’s invoice or their screen, but they feel it in the waiting. The lag between deciding to do something and seeing it done is where trust slips out of an agency relationship, and that lag is closing.

The content refresh is the clearest example we have.

The old way takes days and five people: an analyst audits the page, a strategist writes the brief, a writer reworks the copy, a designer builds the assets, and an SEO reviewer checks it all, while the calendar eats every handoff in between.

The agent runs the audit, the competitor read, the rewrite in the client’s voice, and the conversion blocks in a single pass, then hands back an editor-ready brief and a draft. Early runs are lifting SEO and AI-search scores on refreshed pages by 20 to 50%, and the people who used to grind through those manual steps now spend that time on judgment and on the client.

The same change is turning up across the rest of the work. Kickoff calls start with the team already holding the competitive and keyword map, competitor moves arrive in a weekly digest instead of waiting until someone finds a spare hour, and landing pages go from brief to live Webflow with no design queue in between.

Within four weeks, these agents were running on live accounts in logistics, security, fintech, and payments, paired with GEO audits that track how ChatGPT and Perplexity describe each brand.

The pitch to a client comes out simple: the distance between deciding and doing has shrunk, and the time we win back lands in their pipeline instead of our margin. Saying you use AI doesn’t carry much weight now, because every agency says it.

What This Changed for Us

The usual worry about AI inside an agency is that it thins out the team. For us it has done the opposite so far.

The person who built the top-scoring agent used to be capped by the hours in their day; now the limit is how good the systems are that they can design, which is a higher ceiling and a better job. The same goes for the SEO lead now running a six-step production pipeline, and for the designers whose component library builds its own pages.

The texture of the day changed too. The grind that used to fill calendars, the manual audits and the status decks, is moving into systems, and what’s left is the part that was the point all along: judgment, and the design of the systems that carry the rest.

The weekend also turned out to be the best skills audit we’ve run, surfacing builders in corners of the org chart we’d never have thought to check.

What We Got Wrong

The gap between a demo and something a team can lean on was wider than two days made it look. Within a week of going live, the dull problems showed up: subscriptions that expired and took API connections down with them, platform limits that needed vendor support to lift, hosting nobody had budgeted for, and access requests that crossed three desks before they cleared.

None of it is glamorous, and all of it is the work. A hackathon buys you proof that something can run; then you still have to build the plumbing that keeps it running.

We also automated too much in a couple of spots. One early version of the refresh agent rewrote whole articles, including pages already sitting in the top 10, so it spent its time breaking what was working.

The correction came from someone who knows the craft: change only what the brief asks for, answer the search intent better, and leave whatever already ranks alone. The rule we kept is that the system proposes changes no bigger than the problem in front of it, and a person always owns the final call.

A few builds taught us something by missing the cut. Some solved problems too small to be worth a system, and a couple stalled when a search update pulled their builders back onto client work. That pull between billable-now and build-for-later never fully goes away inside a services business, and pretending it does would be the least honest line we could write here.

How to Run This Yourself

If you run a services business and you’re wondering whether your own team could rebuild itself this way, the format travels well.

• Clear two full days. Pause client work and put the team in one room, because a half-day squeezed around live accounts only gets you half-built demos.
• Let the team pick its own pain. A free hand surfaces the costs that keep recurring, and it doubles as a skills audit, since people build best for the job they most want to stop doing by hand.
• Weight adoption as heavily as novelty. If a clever demo nobody will use can win, that’s what you’ll end up with, so score for what the team will open on Monday.
• Judge in the open. Demos in front of the whole company, with leadership scoring, set the bar at “would we run this” instead of “is this clever.”
• Fund the path to production. Budget for the dull parts like subscriptions, hosting, access, and vendor support, because the demo proves the idea and paying to run it is where the cost lives.
• Give every build an owner and a deadline. Each surviving project got a channel, an executive sponsor, someone chasing blockers, and four weeks.

What This Means for TripleDart

We’ve started calling this a growth engineering org. In everyday terms, it’s a marketing team that runs the way a good product team runs engineering.

Here’s what we believe after the weekend. An agency grows by turning its repetitive work into systems and letting its people own the strategy on top, and adding headcount to that repetitive work only buys you a bigger version of the old thing.

The repeatable work now lives in systems anyone can run, with more than one model underneath as plumbing, so we’re never tied to a single lab. People get measured on outcomes like pipeline and speed while the systems handle the busywork, and the playbooks get better over time because they’re built and versioned instead of aging in someone’s head.

We’d rather spend a weekend becoming a growth engineering org than announce one in a memo. If the year we described at the top sounds like yours, that’s the conversation our SaaS marketing team is best at having, so come talk to us about building the system before you buy the next tool.

‍