TL;DR:
🔧 Before Averi was a product, it was a Google Sheet, a Claude window, an Ahrefs tab, a Notion database, and a lot of manual copy-paste into Framer. Every feature exists because I hit a wall doing it by hand and wrote down what the wall was
🧱 Brand Core exists because I got tired of re-explaining who we are to the AI every single session. Strategy Map exists because our content plan kept dying in a Google Doc. Content Queue exists because the "what should we write next" decision burned an hour every Monday morning. Analytics exists because checking GSC in a separate tab meant it never happened
💡 The philosophy: the best products aren't designed in Figma. They're discovered in the friction of doing the work yourself. You don't know what the product should do until you've done the work without it
🏗️ This is why Averi doesn't feel like a tool built by engineers who read about content marketing. It feels like a system built by someone who actually published 100 blog posts in 30 days and knows exactly where the process breaks
📖 I'm sharing this because every startup founder building a product should hear it: go do the work manually first. The product reveals itself in the pain
Zach Chmael
CMO, Averi
"We built Averi around the exact workflow we've used to scale our web traffic over 6000% in the last 6 months."
Your content should be working harder.
Averi's content engine builds Google entity authority, drives AI citations, and scales your visibility so you can get more customers.
We Built Averi by Doing the Work by Hand First
In the spring of 2025, I had a problem.
We were building a platform to help startups do their marketing, and we had almost no marketing of our own. A handful of pages. Barely any organic visibility. No topical authority. No content engine. No system.
The irony was loud.
I was the only person doing marketing. No team, no freelancers, no agency. Just me, our half-built product, and the growing realization that if I couldn't figure out how to run a content operation solo, our users couldn't either. And if they couldn't, we didn't have a product worth selling.
So I decided to build the content program by hand.
Not with Averi — Averi was a generalized marketing platform with a growing marketplace of freelancers… needless to say, it wasn't ready yet to be my source of truth.
So I built our content program with whatever tools I could stitch together into something that worked.
The stack looked like this: ChatGPT for drafting (later Claude). Ahrefs for keyword research. Google Sheets for tracking topics, publish dates, and a manual scoring checklist. Notion for the strategy map and cluster architecture. Google Search Console for analytics, opened in a separate tab that I checked when I remembered to. And Framer for the CMS, which meant copying finished articles from a doc, reformatting every heading and link by hand, and publishing one article at a time with manual metadata entry.
Glamorous, this was not.
But I set the goal anyway: I was going to create 100 blog posts in 30 days.
Real articles, not filler. Researched, optimized, internally linked, structured for both Google and the AI search engines that were starting to reshape how buyers discovered products.
What happened over those 30 days, and the ensuing 6 months, didn't just save our marketing.
It became the whole f*cking product.
The Walls
Every product feature in Averi exists because of a specific wall I hit during that sprint.
Not a theoretical wall. A real one.
The kind where you're sitting at your desk at 9pm on a Tuesday thinking "there has to be a better way to do this."
Here's what broke, and what each break became.
The Cold Start Problem → Brand Core
Every morning started the same way. Open Claude. Load context. Paste in our positioning doc, our ICP descriptions, our competitive landscape notes, our voice guidelines. Every single session. Because the AI had no memory between conversations. Yesterday I explained everything about Averi. Today it's forgotten all of it.
Some mornings I'd rush the context loading and the draft would come back sounding like a different company.
Other mornings I'd forget to include the competitor section and the draft would ignore our differentiation entirely.
The quality of every draft was directly tied to how thorough my copy-paste was that morning, which was directly tied to how much coffee I'd had.
I started keeping a master "brand bible" document. One file with everything the AI needed to know about us. Voice, positioning, ICPs, competitors, product details, opinions we hold. I'd paste the whole thing at the start of every session.
That document became Brand Core.
The insight was simple: if the AI needs this context every time, the context should be persistent. Load it once. Apply it to every draft forever. No morning copy-paste ritual. No quality variance based on whether I remembered to include the competitor section.
Brand Core isn't a feature we designed because it seemed like a good idea. It's a feature I needed because the alternative was re-explaining my own company to a machine every day.
The Google Doc Graveyard → Strategy Map
Week one, I built our content strategy in a Google Doc.
Pillars, clusters, topic lists, keyword targets, internal linking plans.
It was a good doc. Thorough. Organized.
I uploaded it to my Claude project.
By week two, it was already out of date.
I'd published 20 articles that weren't reflected in it. New cluster ideas had emerged from keyword research that I'd tracked in a spreadsheet, not the doc. The connection between "what we planned" and "what we published" was dissolving in real time.
I tried maintaining it. Spent 45 minutes one Sunday night updating the doc to reflect current reality.
By Wednesday it was out of date again.
The strategy document was a snapshot of a moment that had already passed. It couldn't stay alive because the operation was moving faster than any static document could track.
What I needed wasn't a document.
It was a living map — something that showed the current state of our content architecture, updated automatically as content was published, and revealed the gaps in real time.
That's Strategy Map.
It exists because Google Docs aren't strategy tools. They're snapshot tools. And snapshots don't survive contact with a content operation running at 3-4 articles per day.
The Monday Morning Paralysis → Content Queue
Every Monday morning: "What should we write this week?"
Sounds like a simple question. It wasn't.
Answering it meant opening Ahrefs, reviewing keyword data, cross-referencing against what we'd already published (checking the Google Sheet), evaluating which clusters needed more depth, considering competitor moves, and trying to balance BOFU conversion content against topical authority building content.
An hour. Sometimes more. Every single Monday. Before I'd written a single word.
The decision fatigue was real.
By the time I'd decided what to write, I'd burned my best creative energy on spreadsheet analysis. The morning was half gone. The drafting that should have started at 8am started at 10.
I started pre-building a queue on Sundays — five topics for the week, pre-approved, ready to go Monday morning. That helped. But maintaining the queue required the same analysis I was trying to avoid.
What I needed was a system that did the analysis automatically and served me recommended topics each morning, prioritized by opportunity and cluster need.
Walk in, review recommendations, approve four, start drafting. No spreadsheet archaeology. No Monday paralysis.
That's Content Queue. The feature that replaced my most frustrating weekly ritual.
The 15-Item Checklist → Content Scoring
Before I published anything, I ran it through a manual checklist.
Fifteen checks:
Primary keyword in H1? In title tag? In first 100 words? FAQ section present? Statistics with attribution? Internal links (3+ minimum)? Meta description under 160 characters? Question-based H2s? Answer blocks after each H2? Readability score? Author bio? Schema markup notes? "Last Updated" date? Outbound links to authoritative sources? TL;DR section?
I checked every single one. For every single article. By hand.
Some days I'd rush through the checklist and miss things.
I'd publish an article without an FAQ section, then realize three days later and have to go back and add it. Other days I'd be thorough but it would take 20 minutes per article just on the checklist — time I could have spent writing.
The checklist worked. It was also unsustainable at any real volume.
What I needed was the checklist running automatically, in real-time, as I edited — showing me exactly what was missing and what was met, with a score I could evaluate at a glance.
That's Content Scoring. The manual checklist became an automated system that evaluates SEO, AEO, and GEO dimensions simultaneously. Same standards. Zero manual checking.
The Copy-Paste Publishing Hell → CMS Publishing
The last mile was the worst mile.
I'd finish an article. It was drafted, edited, scored, ready. Then I'd spend 15-20 minutes getting it into Framer. Copy the text. Lose the formatting. Re-add every heading level. Re-insert every link. Manually enter the meta title, meta description, slug, author, publish date, and featured image. Preview it. Find three formatting issues. Fix them. Preview again. Publish.
Fifteen to twenty minutes of pure mechanical work per article.
At 3-4 articles per day, that's an hour of copy-paste publishing. Every day. For 30 days.
I started to genuinely dread the publishing step. The creative work was energizing. The publishing was soul-crushing. I'd batch articles and then procrastinate on the publishing because I knew it meant an hour of mindless reformatting.
What I needed was a button. Draft done, hit publish, it's live on Framer with correct formatting.
That's it.
That's CMS Publishing. One click to Webflow, Framer, WordPress… whatever you use for your blog.
The feature born from the hour per day I'll never get back.
The Separate Tab Problem → Analytics
I had Google Search Console connected. I had Google Analytics set up. The data was there. I just never looked at it.
Not because I didn't care. Because it lived in a separate tab. In a separate tool. With a separate login. Disconnected from the content operation entirely.
Checking analytics meant context-switching out of my content workflow, opening a different tool, remembering what I was looking for, interpreting the data, then switching back.
So I checked it maybe once a week. Sometimes every two weeks. Which meant I was making content decisions based on gut feeling rather than performance data.
Which articles were ranking? Which keywords were at striking distance? Which pieces were declining? I didn't know because knowing required a context switch I kept not making.
What I needed was the analytics inside the same workflow where I make content decisions. Performance data surfaced as recommendations, not as a separate report I have to remember to read.
That's Analytics. GSC data, AI referral tracking, and performance signals integrated into the dashboard where you plan, draft, and publish.
Same window. No separate tab. No context switch. No "I'll check it later" that turns into never.
The Spreadsheet Library → Library
Every article I published went into a spreadsheet.
Title, URL, target keyword, publish date, cluster assignment, word count. I maintained this spreadsheet religiously because I needed it for two things: knowing what internal links to suggest in new drafts, and giving the AI context about our existing content when generating new pieces.
Every morning, alongside the brand bible, I'd paste a summary of recent articles into the AI's context window. "Here's what we've published recently, reference and link to these where relevant."
The spreadsheet was the primitive version of published memory.
It worked until it didn't.
At article 50, the spreadsheet was unwieldy. At article 75, I couldn't paste the whole thing into a context window. I started summarizing — which meant losing detail. The AI would suggest topics we'd already covered or miss internal linking opportunities because my summary skipped them.
What I needed was a persistent library that accumulated automatically. Every published piece feeding back into the system. Tomorrow's drafts informed by today's publications without me manually updating a spreadsheet at 5pm.
That's Library. The compounding memory that makes article #200 smarter than article #1 — because it knows everything that came before it.
The Philosophy
I'm sharing the walls because I want to make a point about how we think about building product.
The conventional approach: research the market, interview users, design the solution in Figma, build it, ship it, see if people want it.
Our approach: do the work yourself. Hit the walls. Write down what the walls are. Build the product that removes the walls. Ship it to people who are hitting the same walls.
Every feature in Averi passed the same test: did I personally need this while running a real content operation? If I didn't hit the wall, the feature doesn't exist. If I did, it does.
That's why Averi doesn't feel like a tool designed by people who read about content marketing.
The product decisions aren't based on competitor feature lists or analyst reports.
They're based on what I cursed about at 9pm while trying to publish my third article that day.
Brand Core doesn't exist because "persistent brand context" sounds good on a feature page. It exists because I got tired of pasting the same document into Claude 400 times.
Content Scoring doesn't exist because scoring is a trendy feature category. It exists because I ran a 15-item manual checklist on 100 articles and wanted those hours of my life back.
CMS Publishing doesn't exist because "native integrations" test well in surveys. It exists because I copy-pasted formatted articles into Framer for 30 consecutive days and it nearly broke me.
The philosophy is simple.
The best products are discovered in the friction of doing the work, not designed in the abstraction of imagining the work.
Why This Matters for You
I'm not telling this story because it's interesting (though I think it is). I'm telling it because the product you get when you sign up for Averi isn't a theoretical vision of what content marketing should be.
It's the system I actually used. The workflow I actually ran. The walls I actually hit, translated into features that remove those walls.
When you set up Brand Core, you're eliminating the same cold start problem I solved with a copy-pasted brand bible.
When you open Content Queue on Monday morning, you're skipping the same hour of spreadsheet analysis I used to dread.
When the content score updates as you edit, you're running the same 15-item checklist I ran by hand, except it takes zero seconds instead of twenty minutes.
When you hit publish and the article appears on your site, you're avoiding the same copy-paste hell that ate an hour of my day for a month straight.
The system doesn't feel like a tool because it wasn't built like a tool. It was lived in before it was built. The rough edges got smoothed because I felt them on my own hands first.
That's the difference between a product designed from research and a product discovered from work. Research tells you what people say they want. Work tells you what they actually need.
Those are often very different things.
The Results of the Manual System
The manual version of everything I described above — the duct-taped stack of Claude, Ahrefs, Google Sheets, Notion, and Framer — produced 100 articles in 30 days and grew our organic impressions from 50K to 1.68 million monthly within four months.
The product version of the same system does the same work in a fraction of the time.
Not because it's magic. Because every hour of manual friction I absorbed during the sprint became an hour of automation in the product.
47% of startup founders do all their own marketing. 56% have one hour or less per day for it. The manual system I ran required 5-6 hours per day. The product version requires about 5 hours per week.
Same system. Same logic. Same walls removed. The difference is whether you build the walls-removal yourself or use the version someone already built.
I already built it. The hard part is done.
FAQs
Did you actually build Averi by doing content marketing manually first?
Yes. The entire product originated from a 30-day sprint where I published 100 blog posts using a duct-taped stack of ChatGPT/Claude, Ahrefs, Google Sheets, Notion, and manual CMS publishing to Framer. Every friction point I hit during that sprint became a product feature. The workflow is the product because I lived in the workflow before building it.
What tools were you using before the product existed?
Claude for drafting (with a manually loaded brand context document every session), Ahrefs for keyword research, Google Sheets for topic tracking and content scoring checklists, Notion for the strategy map and cluster architecture, Google Search Console in a separate tab for analytics, and Framer with manual copy-paste for publishing. About 15 tools and processes stitched together with effort.
How does each manual process map to a product feature?
Copy-pasted brand document → Brand Core. Dying Google Doc strategy → Strategy Map. Monday morning topic analysis → Content Queue. 15-item manual checklist → Content Scoring. Copy-paste CMS formatting → CMS Publishing. Separate-tab analytics → Analytics. Manually maintained spreadsheet of published content → Library.
Why does building from manual work produce a better product?
Because you discover what actually matters, not what sounds like it should matter. Market research tells you what people say they want. Doing the work tells you where the process actually breaks. The gaps between those two things are significant. Products built from friction solve real problems. Products built from research solve reported problems. They're often different.
Can I replicate your manual system without the product?
You can. I did. It works. It also requires 5-6 hours per day, constant context-switching between tools, and the discipline to maintain spreadsheets, checklists, and context documents manually across hundreds of articles. The product version produces the same results in about 5 hours per week because every hour of manual friction became an hour of automation.
What was the hardest wall you hit during the manual sprint?
The cold start problem. Re-explaining our brand to the AI every morning was the most demoralizing part of the process because it felt so unnecessary. The AI should know who we are. It shouldn't require a daily briefing. That frustration is why Brand Core was the first feature we built — and why it's the first thing new users set up. The context loads once and never needs loading again.
