June 28, 2026 · StartupQuickstart

A website that (almost) edits itself

The expensive part of a marketing site is every change after launch. Here is the structured-content platform this site runs on, and how its agent edit loop works.

A close-up of code on a screen

Ask anyone who owns a company website what it cost, and they'll quote the build. Ask what it costs today, and you get the real answer: every change is a ticket to an agency with a three-to-five-day turnaround and a minimum billing increment, or a Friday-afternoon favor from an engineer who has better things to do. So changes stop happening. The pricing page falls a quarter behind the actual pricing. The site rots politely.

We think the fix lives in the architecture of the site, more than in anyone's process. Full disclosure: this article describes our own product, the managed-website platform we build and run client sites on.

Why edits are scary on a traditional site

On a page-builder or WordPress site, a page tends to be one big blob: markup, styling and content tangled together, often authored by a plugin that's two major versions behind. Editing the blob is risky in specific ways:

  • No structure. Changing a headline means finding it inside nested builder markup. It's easy to break layout with a copy change, so every edit needs a careful human.
  • Partial history. To be fair, WordPress core keeps revisions of each post and page and lets you compare and restore them. But by default those revisions track the title, author, content and excerpt. Theme options, plugin settings and builder configuration live elsewhere, and on a builder-heavy page the diff is a wall of markup. When Tuesday's edit breaks the hero on mobile, someone still ends up reconstructing what changed.
  • Plugin entropy. Each plugin is someone else's code with database access and its own update schedule. Patchstack's annual report counted 11,334 new vulnerabilities in the WordPress ecosystem in 2025, 91% of them in plugins, and found that heavily exploited flaws were typically attacked within hours of disclosure. Owners aren't careless; the attack surface just grows with every plugin, which is why software supply chain failures now rank third on the OWASP Top 10.

Structured content changes the risk math

On our platform, a page is a typed document: an ordered list of sections (hero, feature grid, pricing table, FAQ, prose), each with a schema that says exactly which fields it has and what shapes they take. If you've used JSON Schema, it's the same idea: a declarative description of valid data that software can check. That single decision buys three properties that compound:

  • Safe edits. A copy change is a change to one named field in one section. It cannot break layout, because the layout isn't in the content.
  • Versioned everything. Every save is an immutable revision with an author and a timestamp, for every section on the page. "What changed and who changed it" is a query, and rollback is one click.
  • Machine-checkable diffs. Because content is data, software can classify an edit ("this changes two text fields" versus "this deletes a section") before it lands. That is the piece that makes the next part safe.

The 24/7 edit loop, concretely

Here's the flow for a real request. Say you email: "Our intro pricing ends Friday; update the pricing page and the FAQ to show the 3-month term."

  1. The request lands in a queue with a paper trail, whether it arrived by email or the site's own request box.
  2. An agent claims it and drafts the edit through the same structured-content API a human editor uses. It never hand-edits markup.
  3. The draft passes through a server-side allowlist. A request classified as a copy edit may only change text fields. If the draft tries to add, remove or reorder sections, the server rejects it, regardless of what the request claimed to be.
  4. A human reviews the diff, old text and new text side by side, and approves or rejects. Approval publishes a new revision; nothing ships without that click.
  5. The change is live minutes later, and revertible forever.

The agent handles the long tail of small changes that make up most website work: copy tweaks, pricing updates, new testimonials, seasonal banners, a new blog post from your draft. It escalates what it shouldn't touch (new page layouts, brand changes, anything ambiguous) to us, and a human does it. That's why the honest description is "almost edits itself": machines do the typing, and people keep the judgment.

What you should demand from any provider

Whether or not you work with us, these questions separate a managed platform from a retainer-shaped ticket queue:

  • Can I see a full history of every change, with authors, and revert any of them myself?
  • What is the median time from "change requested" to "change live"? Minutes or days?
  • Is every edit validated against a schema, or can a typo in the wrong place take down a page?
  • What's the plugin and dependency surface, and who patches it?
  • Do I get performance and analytics numbers without bolting on three trackers? At minimum that means Core Web Vitals from real visitors (Google's "good" thresholds are LCP within 2.5 seconds, INP within 200 milliseconds and CLS under 0.1) plus real traffic.

Our answers: yes; minutes for allowlisted edits and same-day for escalations; yes, on every write; close to zero, because we own the stack end to end; and yes, first-party, cookieless analytics are built in. The build fee gets you the site. The retainer is what keeps it accurate.

Sources

Want systems like this built for you?

We build and run data pipelines, websites, and AI automation for startups.