Notes on building systems that last.
How we think about AI automation, answer engine optimization, and shipping software that holds up. Written by the people who build it.
AEO is the new SEO: how to show up in answer engines
Search is splitting in two. Half your audience still types into Google; the other half asks ChatGPT, Claude, or Perplexity. Here's how to be the answer either way.
Read articleWhat to automate first (and what to leave alone)
Most teams automate the wrong thing first — the flashy thing, not the expensive thing. A simple way to find the workflow that actually pays for itself.
How we ship the first system in weeks, not quarters
Speed usually means cutting corners. It doesn't have to. Here's the operating model that gets a real system live in three weeks without the technical debt.
The hidden cost of manual handoffs
Every time work passes from one person or tool to another by hand, you pay a tax. It rarely shows up on a budget line — which is exactly why it grows.
Why your internal tools should be boring
The best internal software is the kind nobody talks about. Boring is a feature — it means the tool gets out of the way and the work gets done.
Topical authority: the last real SEO moat
Anyone can publish one good article. Building a defensible position means owning a whole topic — depth, breadth, and the links between every piece.
Human-in-the-loop: where AI actually belongs
The choice isn't automate everything or automate nothing. The best systems put AI on the plumbing and keep humans on the judgment.
Build vs buy: a framework for internal software
Off-the-shelf is faster until it isn't. A simple way to decide when to adopt a tool and when to build the thing only you need.
How to write content that LLMs cite
Answer engines don't reward the longest page. They reward the clearest one. Here's how to structure content so a model pulls you into its answer.
Structured data: the cheapest SEO win you're skipping
Schema markup takes an afternoon and pays off for years. It's the lowest-effort, highest-leverage thing most sites still don't do.
Workflow debt: the silent tax on your operations
Like technical debt, workflow debt accrues interest. Every manual workaround you keep is a payment you'll make again tomorrow.
From spreadsheet to system: when to graduate
Spreadsheets are the best prototype tool ever made — and a terrible place to run a growing operation. Here's how to know when you've outgrown one.
Why most automation projects stall
It's rarely the technology. Automation projects die from vague scope, no owner, and trying to boil the ocean on day one.
The case for owning your content engine
Renting your content operation from agencies and point tools leaves you with nothing that compounds. Owning the engine changes the math.
Measuring automation ROI without fooling yourself
Hours saved is the headline metric and the easiest to fake. Here's how to measure automation returns in a way that survives scrutiny.
What "AI-native" actually means
Bolting a chatbot onto an old workflow isn't AI-native. Being AI-native means designing the process around what models are good at from the start.
Three questions to ask before automating anything
Before you build a single integration, three questions will tell you whether the automation is worth it — or whether you should delete the work instead.
Maintainable beats clever
The cleverest solution is rarely the right one. Software that's easy to understand and change beats software that's impressive and brittle.
How answer engines pick their sources
When ChatGPT or Perplexity cites a page, it isn't random. Understanding the selection logic tells you exactly what to optimize for.
The compounding returns of clean data pipelines
Messy data taxes every decision downstream. Clean pipelines aren't glamorous, but they're the foundation everything else compounds on.
Content operations that survive a team change
If your content quality drops the moment a key person leaves, you don't have a content operation — you have a dependency. Here's the difference.
Why we stay on after launch
Most builders hand over the keys and disappear. The work that actually pays off is what happens after launch — so that's where we stay.
The anatomy of a content brief that works
A vague brief produces vague content. A great brief does most of the thinking up front, so the draft almost writes itself — and ranks.
The cost of context switching
Every tool a person juggles is a tax on focus. The most overlooked automation win is simply reducing how many places work lives.
Why dashboards go unused
Most dashboards are built once, admired briefly, and then ignored forever. The reason is almost never the data.
Internal documentation people actually read
Most internal docs are written once, never updated, and quietly distrusted. A few habits make the difference between a wiki and a graveyard.
The difference between data and information
You're probably drowning in data and starved for information. Knowing the difference is the first step to reporting that matters.
When to say no to a feature request
Every feature has a cost that outlives the request. Saying no well is one of the highest-leverage skills in building software.
The 80/20 of process improvement
You don't need to fix the whole operation. A small number of steps cause most of the pain — find them and the rest can wait.
Automating onboarding for new hires
Onboarding is the same checklist run over and over, done by hand, every time someone joins. It's a textbook case for automation.
Why your CRM is half-empty (and how to fix it)
A CRM is only as good as the data in it, and most are full of gaps because keeping them current is someone's least favorite manual chore.
The case against real-time everything
Real-time sounds like a universal upgrade. It's often expensive complexity solving a problem you don't have.
Designing alerts people don't ignore
Alert fatigue kills more systems than downtime does. If everything is urgent, nothing is — here's how to keep alerts meaningful.
The hidden API in every SaaS tool
Most of the software you already pay for can talk to other software. Discovering that is the start of real automation.
Webhooks 101 for non-engineers
Webhooks are the quiet workhorse behind most automation. You don't need to code to understand what they do and why they matter.
How to audit a workflow
Before you fix or automate anything, you have to see it clearly. A workflow audit is the cheapest, most valuable hour you'll spend.
The single source of truth, explained
When the same fact lives in five places, all five eventually disagree. A single source of truth is the cure for a whole class of problems.
Idempotency: the unglamorous key to reliable automation
The difference between automation you trust and automation you babysit often comes down to one idea: running it twice should be safe.
Error handling is a product feature
What your software does when things go wrong shapes trust more than what it does when things go right. Errors deserve design, not an afterthought.
Why retries fail and backoff saves you
Retrying a failed step sounds obviously good. Done naively, it can turn a small hiccup into a full-blown outage.
The queue is your friend
When work arrives faster than you can handle it, a queue is the difference between graceful and broken. It's the most underused tool in operations.
Rate limits and how to live within them
Every API you depend on will eventually tell you to slow down. Designing for that from the start saves a world of pain.
Content velocity vs quality is a false choice
The 'publish more' and 'publish better' camps are both half right. A system lets you stop choosing between them.
Programmatic SEO: when it works and when it backfires
Generating thousands of pages from a template can dominate search or get you penalized. The line between the two is thinner than it looks.
Internal linking as a strategy, not an afterthought
Internal links are the cheapest SEO lever you fully control, and most sites treat them as decoration. They're actually structure.
The myth of the 10x content piece
Chasing one viral, definitive article is a worse strategy than steadily building a connected body of work. Authority is cumulative.
Keyword research in the age of answer engines
Keyword volume still matters, but it's no longer the whole picture. Answer engines reward covering questions, not just terms.
Search intent: the thing most content gets wrong
You can write the best article on a topic and still fail, because it answers a different question than the one being asked.
How to repurpose one piece into ten
A single well-researched article contains enough raw material for a dozen formats. Most teams publish once and waste the rest.
Editorial calendars that survive contact with reality
Most content calendars are abandoned by week three. The ones that last are built around capacity and priority, not wishful thinking.
The brief-to-publish pipeline
The gap between 'we have an idea' and 'it's live' is where content operations succeed or stall. The whole path should be a system.
Measuring content that doesn't convert directly
Not every piece should be judged by leads. Holding top-of-funnel content to bottom-of-funnel metrics kills your best work.
Why freshness matters (and what it really means)
Freshness isn't changing the date and calling it new. It's keeping content true, and it's a real signal you can earn honestly.
The reporting cadence that keeps teams aligned
Report too often and it's noise; too rarely and you're flying blind. The right rhythm depends on how fast the thing actually moves.
Leading vs lagging indicators in operations
Lagging metrics tell you what already happened. Leading ones let you change it. Most teams track far too much of the former.
How to run a useful retro on a system
Most retros are venting sessions that change nothing. A good one turns what went wrong into a concrete change in how the system works.
The cost of a wrong number in a report
One bad number doesn't just cause one bad decision. It quietly destroys trust in every number that follows it.
Naming things: the underrated skill
Good names make systems understandable; bad ones quietly tax everyone who touches them. It's not a cosmetic concern.
Versioning your processes like code
Code has version history; most processes have folklore. Treating how you work like something that can be versioned changes everything.
The runbook every automated system needs
Automation runs fine until it doesn't. The difference between a five-minute fix and a five-hour scramble is whether there's a runbook.
What to log and what to ignore
Logging everything is the same as logging nothing — the signal drowns. Good logging is a series of deliberate choices.
Monitoring vs observability for ops teams
Monitoring tells you something is wrong. Observability lets you figure out why. Knowing which you have shapes how fast you recover.
The blast radius question
Before you build or change anything, ask what breaks if it goes wrong. The answer should shape how carefully you proceed.
Graceful degradation for business processes
When part of an automated process fails, the question is whether the whole thing collapses or quietly falls back to manual. Design the fallback.
The two-pizza rule for internal tools
Internal tools that try to serve everyone serve no one well. The best ones are scoped to a small team and a specific job.
Shadow IT and what it's telling you
When teams quietly adopt their own tools and spreadsheets, it's easy to see it as a problem. It's actually valuable information.
The integration tax nobody budgets for
Connecting two systems is rarely as simple as the sales demo suggests. The ongoing cost of integrations is real and chronically underestimated.
When good enough is the right answer
Polishing past the point of usefulness is its own kind of waste. Knowing when to stop is as important as knowing how to build.
The migration nobody wants to do
The old system everyone complains about but no one replaces is usually costing more than the scary migration would. Avoidance has a price.
Sunsetting a tool without breaking everything
Retiring software is harder than launching it. Done carelessly, you discover all the things that quietly depended on it the hard way.
The compounding advantage of small automations
Everyone waits for the big transformative automation. The real advantage comes from many small ones, stacked over time.
Why the next decade belongs to systems, not headcount
The old way to do more was to hire more. The organizations pulling ahead now grow capacity through systems instead of bodies.
Why context, not cleverness, makes AI useful
The gap between an AI feature that wows in a demo and one that holds up in production is rarely the model. It's the context you feed it.
The first hour of an incident
When something breaks, the first hour decides whether it's a blip or a disaster. Most of that comes down to preparation, not heroics.
Postmortems without blame
A postmortem that hunts for a culprit teaches everyone to hide mistakes. One that examines the system makes the whole team safer.
Why your team keeps reinventing the same wheel
If three people have solved the same problem three different ways this quarter, that's not initiative — it's a missing system.
The cost of waiting for perfect data
Holding a decision until the data is flawless usually costs more than deciding on data that's merely good enough.
Decision logs: the cheapest institutional memory
Six months from now, nobody will remember why you chose what you chose. A one-line decision log saves you from relitigating it.
When to centralize and when to federate
Should one team own this, or should every team run their own? The wrong call creates either bottlenecks or chaos.
The meeting that should have been an automation
Some recurring meetings exist only to move information from one place to another. Those aren't meetings — they're manual data syncs with snacks.
Async by default: making distributed teams work
Distributed teams that try to operate like co-located ones drown in meetings. Async-by-default isn't a compromise — it's an upgrade.
Why estimates are always wrong (and what to do)
Software estimates are reliably optimistic for deep reasons. The answer isn't better estimates — it's depending on them less.
Scope creep starts in the kickoff
By the time scope creep is obvious, it's expensive. It almost always traces back to a vague definition of done at the very start.
The demo-to-production gap
The distance between 'it works in the demo' and 'it works in production' is where most of the real engineering lives.
Feature flags for the non-technical
Feature flags let you ship something to everyone but turn it on for a few. It's one of the safest ways to release change.
Rolling back is a feature, not a failure
Teams that treat rollback as an embarrassment ship slower and more nervously. Teams that make it routine move faster and break less.
The staging environment nobody trusts
A staging environment that drifts from production gives false confidence — worse than no staging at all.
Why your tests pass but production breaks
Green tests and a broken production aren't a contradiction. They're a sign your tests are checking the wrong things.
The bus factor and how to lower it
If one person being unavailable would halt a critical process, you don't have a team strength — you have a single point of failure.
Tribal knowledge is a liability
The things 'everyone just knows' are exactly the things that break when someone leaves. Undocumented knowledge is borrowed time.
The cost of a slow feedback loop
How long it takes to learn whether something worked shapes everything. Slow loops don't just delay learning — they degrade it.
Batch vs stream: choosing how data moves
Should data move in scheduled batches or flow continuously? The right answer depends on the decision it feeds, not on what sounds modern.
The dead letter queue and why you need one
In any automated pipeline, some items will fail to process. Where they go determines whether you notice — or lose them silently.
Backfills: the migration's evil twin
Changing how data works going forward is the easy part. Fixing all the data that already exists is where projects quietly blow up.
Schema changes without downtime
Changing the shape of your data while the system is live is one of the trickiest things in operations. There's a safe way to do it.
The audit trail you'll wish you had
The moment you need to know who changed what and when, it's too late to start recording it. Audit trails are insurance you buy in advance.
Soft deletes vs hard deletes
When a user deletes something, should it really be gone? The answer shapes everything from undo buttons to compliance.
Caching, explained without the jargon
Caching makes things fast by remembering answers instead of recomputing them. The catch is knowing when the remembered answer is stale.
Why your internal search is bad
If people can't find what they need in your own tools, the knowledge might as well not exist. Search is infrastructure, not a feature.
Deduplication: the quiet data killer
Duplicate records corrupt your reports, double your outreach, and erode trust in your data — usually without anyone noticing for months.
The reconciliation report every finance team needs
When two systems should agree about money and don't, you want to know immediately — not at the end of the quarter.
Approval workflows that don't become bottlenecks
Approvals exist to manage risk, but a clumsy approval process adds delay without adding safety. The two can be separated.
Permissions: start restrictive, loosen carefully
It's far easier to grant access later than to claw it back. Defaulting to least privilege saves you from a sprawl of over-permissioned accounts.
SLAs you can actually keep
An ambitious service level you miss every month is worse than a modest one you always hit. Credibility beats aspiration.
The on-call rotation for small teams
Small teams need to cover failures too, but copying big-company on-call burns people out. There's a humane middle path.
What "done" means — define it before you start
Half the arguments at the end of a project are really disagreements about what 'done' meant that nobody settled at the beginning.
Writing requirements that don't lie
Vague requirements feel safe because they're hard to be wrong about. They're also where projects go to die.
The vendor lock-in you signed up for
Lock-in rarely arrives as a dramatic decision. It accumulates quietly until leaving a tool means rebuilding half your operation.
Exporting your data: the test of real ownership
You only truly own your data if you can get it out. Try the export before you need it, because that's when you'll learn the truth.
The CSV is not an API
Emailing a spreadsheet between systems is integration the way a carrier pigeon is telecommunications. It works until it really doesn't.
Email is not a database
When important information lives only in someone's inbox, it's invisible, unsearchable to the team, and one delete away from gone.
The spreadsheet that runs the company
Almost every organization has one: a critical spreadsheet that grew load-bearing by accident and that one wrong cell could break.
From reactive to proactive operations
A team stuck firefighting never gets ahead. The shift from reacting to problems to preventing them is the difference between treading water and progress.
Your business as an operating system
The most useful way to think about a modern organization isn't an org chart — it's an operating system of processes, data, and automation.
The content audit nobody schedules
Old content doesn't just sit there harmlessly. Stale and thin pages can actively drag down the work you want to rank.
Writing for humans and machines at once
You no longer write only for readers. You write for readers and the engines that summarize you — and the good news is they want the same things.
When to update vs rewrite a page
A page is slipping in the rankings. Do you refresh it or start over? Choosing wrong wastes effort or throws away earned authority.
The pillar page, done right
A pillar page anchors a whole topic cluster. Done well it ranks and organizes; done lazily it's just a long article that links to itself.
Distribution is half the work
Great content that nobody sees isn't great content. Publishing is the midpoint, not the finish line — yet most teams stop there.
E-E-A-T in plain English
Experience, Expertise, Authoritativeness, Trust. Behind the acronym is a simple question: why should anyone believe this page?
The myth of set-and-forget automation
Automation isn't a thing you build once and walk away from. The systems that keep working are the ones someone keeps an eye on.
Why proof beats promises in B2B content
Every competitor promises the same outcomes. What's scarce — and persuasive — is showing the work, the numbers, and the method.
The compounding cost of "we'll fix it later"
Deferring a fix feels free in the moment. Like debt, it isn't — it accrues interest, and later costs far more than now.
The cost of premature standardization
Standardizing too early locks in the wrong shape. Better to let three teams diverge for six months and then unify the version that actually worked.
When your codebase becomes a museum
Every layer of a long-lived codebase tells a story. The problem is the docents have all left, and visitors keep tripping on the exhibits.
Why deletion is the highest leverage
Every feature, page, and config that gets removed pays a permanent dividend. Nothing else in software compounds like deletion.
The PR that's actually a meeting
Some pull requests are code. Others are organizational disputes written in TypeScript. Knowing which is which saves whole afternoons.
Estimating in ranges, not points
Story points pretend to be precise. They aren't. Ranges admit what you actually know — and the math gets honest.
The interview question that predicts what no test does
Coding tests measure coding under pressure. They miss the thing that actually predicts performance: how someone thinks about a system they didn't design.
Onboarding as an architecture exercise
How long it takes a new engineer to ship their first real change is a measurement of your architecture, not their talent.
The senior who writes the most boring code
The clearest sign of a great senior engineer isn't clever code. It's how unremarkable their code looks — and how rarely anyone has to touch it.
Why code review fixes the wrong things
Most review comments are about style and bikeshed details. The expensive bugs slip through because nobody's looking at the right altitude.
Hiring for taste
Skills can be taught. Speed can be coached. Taste — the instinct for what's good — is what separates teams that compound from teams that churn.
The first 10 users problem
Most product advice assumes you already have product-market fit. The truly hard part — finding your first 10 real users — gets surprisingly little attention.
Pricing as a product
Most teams treat pricing as a number to set once and revisit annually. Companies that compound treat it as a product surface that ships and iterates.
The trap of feature parity
Chasing feature parity with a bigger competitor is a way to lose slowly. You'll never catch up, and you stop being interesting along the way.
When to copy a competitor (and when not to)
There's a respectable case for copying. There's also a way to do it that quietly kills your product. The line is more useful than the slogans about it.
The roadmap that survives a quarter
Most roadmaps are obsolete by week six. The few that survive aren't more accurate — they're built around a different unit.
Stop building dashboards for executives
Most executive dashboards get opened once at the all-hands and never again. Better to build the question, not the chart.
Why your "data team" is a request queue
If every chart goes through a central team, your data team isn't a team — it's a bottleneck with a Slack channel.
Reverse-engineering your own funnel
Most teams look at funnels top-down: how many visit, how many sign up, how many convert. The interesting story is told reading them backwards.
The customer-success motion most B2B miss
Most CS teams firefight churn. The high-leverage move is making sure the customer became successful in the first 30 days — and proving it to them.
Outbound that doesn't feel like outbound
The reason your outbound feels icky is that it is. The fix isn't better templates — it's outbound that earns its own attention.
The pricing page is your real homepage
Your homepage gets the design budget. Your pricing page gets the conversion. The mismatch costs you most of what your marketing was trying to do.
Free trials vs free plans vs proofs of concept
These three are not interchangeable. Pick the wrong one and you're optimizing for a customer you don't actually want.
The product-led handoff to sales
Product-led growth is wonderful until a $200,000 deal lands in self-serve. The handoff to humans is where most PLG companies leak money.
Cold email that ships
Most cold email reads like it was generated. Even the human-written ones. There's a small set of moves that make a cold email actually arrive.
Why your form converts and your landing doesn't
Landing pages get the design effort. Forms get the conversions. The reason is structural, and worth understanding before you redo the landing.
The CTA you stopped testing
Every team obsesses over the homepage hero CTA. Almost nobody tests the CTA at the bottom of the case study — which converts at 4x the rate.
Live chat: when it earns its salary
Live chat is either your highest-converting surface or your most expensive theater. The difference is who's behind it and when it's offered.
The customer interview question that actually works
Forget "would you pay for this." Forget "what would you change." There's one question that consistently surfaces the real story.
Churn is a leading indicator of your honesty
High churn isn't always a product problem. Sometimes it's a sales problem — you sold the product as something it isn't.
Why "best practices" are often the worst advice
"Best practice" is what worked for someone else, in their context, captured into a slogan. Following it without context is how teams ship the wrong thing on time.
The compounding cost of YAGNI violations
Every "we might need this someday" feature is a small loan against future maintenance. Across years, the interest is enormous.
When microservices stop being microservices
Most "microservices" architectures end up as distributed monoliths — all the deployment overhead, none of the independence. Spot it early.
The CAP theorem in plain English
CAP theorem gets used to justify all kinds of decisions, often by people who can't quite explain it. Here's the version that actually matters at runtime.
Event sourcing without the cult
Event sourcing is a useful pattern that has acquired the energy of a religion. There's a sober version that actually pays off.
Why your queue depth is the only chart you need
If you can only have one operational dashboard, make it the queue depth across every async system. Everything else is downstream of that one number.
Database choices that lock you in for a decade
Almost every other architectural decision can be revisited. Your database choice usually can't — not because it's impossible, but because nobody ever has time.
The migration you'll wish you started in year one
Every codebase ends up with a migration the team avoids until it can't. The teams that did it early always wish they'd done it earlier still.
Caching invalidation: just say no
If you can solve a performance problem without adding a cache, do that. Caches are the source of more outages than the problems they solved.
Why background jobs are quietly your most critical system
When background jobs fail, customers don't see errors — but downstream, everything quietly breaks. They deserve the same scrutiny as your API.
The serverless promise and its bill
Serverless really does eliminate ops overhead — until the bill shows up at 5x what you expected. Knowing where it bites helps you choose deliberately.
Vendor lock-in is a cost of doing business
You can spend a year designing around vendor lock-in. Or you can use the best tool, ship faster, and accept that switching costs are part of the trade.
The platform team trap
Every growing engineering org builds a platform team. Most of them end up serving themselves more than the rest of the company.
Self-service infra you'll actually use
Most internal platforms ship a self-service portal that nobody uses, because the path through it is harder than asking for help directly.
The on-call rotation that doesn't burn you out
On-call doesn't have to ruin your week. The teams who get it right share a few habits that most others don't.
When SLAs become hostile takeovers
An SLA is supposed to align teams on expectations. Often it just creates an adversarial relationship between two teams who were supposed to be on the same side.
Why incident retros lie to themselves
Most incident retros end with action items that everyone agrees to, almost nobody does, and nobody follows up on. The format is mostly to blame.
The maintenance window nobody schedules
Every production system needs maintenance. Most teams never schedule it — until the system schedules itself, at a worse time.
Documentation that gets read because it's tested
Documentation rots because nobody catches it rotting. Test your docs the same way you test your code — and they'll actually stay useful.
The bug bounty that's worth running
Most bug bounty programs produce a flood of low-quality reports and almost nothing useful. The few that work share a small number of design choices.
The bug nobody fixes
Every team has one — a known bug that's been in the tracker for years, that nobody is wrong for ignoring, and that nobody is right enough to fix.
Most operations are behind where they could be.
Book a strategy call. We'll map one system worth automating in the next 30 days. No pitch, just the plan.