Every page, in one place

Managed hosting for any app, run like a utility — static sites, dedicated compute, and everything in between.

Answer a few questions, get a hosting-shape recommendation — no sales call required.

The estimator's mirror image — put your own hours and rate in, and see what running it yourself actually costs.

The first week, hour by hour, and exactly how much of it is your own time.

The full rate card — plans, add-ons, and a self-serve estimator with a live monthly total.

What a month actually looks like: the invoice cycle, a specimen invoice, what moves the number and what never does, fair use in numbers, and the CodeHerder iteration line explained from the invoice's side.

A shareable, printable spec sheet for any configuration from the estimator or selector — line items, one total, and a permalink to hand off.

Describe the workload, get one fixed monthly rate in writing within a business day.

What the global edge network, durable storage, and dedicated compute actually are.

Static-site hosting on the global edge network — what it includes and what it costs.

Fixed-price dedicated compute sized to the workload, with a static IP and full control.

Managed Postgres tiers, how an app connects, how a schema change ships, and what happens when one fails halfway.

Anything that doesn't fit a fixed tier — designed and quoted flat.

CustomHosted next to rolling it yourself, a self-serve deploy platform, a traditional host, and an agency on retainer — dimension by dimension, honestly.

The measured page-weight budget behind the "fast on the edge" claim — real numbers from this build, enforced on every deploy.

Already hosted elsewhere? A rehearsed cutover with little-to-no downtime.

What a handover actually contains: the pack manifest, the procedure with real minutes attached, and what honestly stops when you go.

What's actually in a backup, how a restore works, how far back you can go by tier, and what a tested restore means in practice.

The watch list, what fixes itself automatically, who gets woken for the rest, and what a code bug that no monitor can catch turns into.

The record of what happened: the three things people call "logs", where a line goes hop by hop, what is kept and for how long, and how a log line becomes a briefed change.

What gets patched layer by layer, the standing window and the out-of-band path, whether it takes the app down, and where a dependency bump becomes a briefed CodeHerder pull request instead.

The work your app does when no browser is waiting for it: the three kinds, where each runs by hosting shape, how the clock is wired, what happens when a job fails, and who owns whether it is safe to run twice.

The files your app keeps: the three kinds of file, where one goes hop by hop, what holds it by hosting shape, what happens when the disk fills, and what survives a deploy, a resize, a restore, and an exit.

Who owns the domain, the records, and the certificate — the record sheet, why your mail never moves, the propagation window, and what changing something later costs.

The rules a request meets once DNS resolves — redirects, trailing slashes, a real 404, the cache, and the response headers you get by default.

Who can touch your production: the four principals, the capability matrix, secrets, least privilege, and what the CodeHerder agent can and cannot do.

The perimeter: what stands between the internet's junk traffic and your app, the four kinds of attack, and the honest line where it stops.

What a staging environment actually is here — the address, who can reach it, what data it holds, how a change gets promoted out of it, how to go back, and what it costs.

The mail your app sends, not mail addressed to your domain — the sending path hop by hop, the records the zone needs, and the honest limits on deliverability.

The tier ladder, how a capacity signal turns into a scheduled move, what visitors see during it, when a bigger box is the wrong answer, and what this platform deliberately does not do.

Every stack we host in one compatibility register, plus deep pages for the frameworks asked about most.

Managed hosting for Next.js: a dedicated instance for server-rendered routes and API handlers, a static-export path priced down to Static Starter when there’s no server-side work at all, and CodeHerder for the steady stream of small changes.

Managed WordPress hosting: PHP and a managed database on a dedicated instance, the uploads directory and database moved as one unit, and CodeHerder for theme and content changes briefed in plain language instead of waiting on an agency retainer.

Managed Python hosting: a WSGI or ASGI process on a dedicated instance, a managed Postgres database for the migrations you already have, and CodeHerder for the small endpoints and fixes that come up between releases.

Managed Laravel hosting: PHP-FPM, a managed database, a queue worker, and the scheduler cron all run on one dedicated instance, deployed on a push — with CodeHerder shipping the small feature requests in between.

Managed hosting for containerised apps: a single image runs on a dedicated instance at a fixed rate, and multi-service Compose stacks get designed and quoted flat instead of forced into one tier — plus CodeHerder for ongoing changes to the images themselves.

The same platform and loop, organised by situation instead of by product shape.

Managed hosting for design and dev studios: one flat per-site rate to pass through or resell, per-client staging, no console for the client, and an iteration add-on that absorbs the endless small change requests.

Managed hosting for founders: CustomLabs builds or finishes the first version, dedicated compute plus a managed database keeps it running at a flat rate, and CodeHerder ships the small stuff while the team sells.

Managed hosting for sites without an in-house developer: the loop stands in for a hire — brief a change in plain language, an agent opens a pull request, it's reviewed and shipped.

Build → Iterate → Run — the loop that keeps a site shipping after launch.

The five parts a good brief needs, a composer that assembles one for you, and three real examples.

The real pull-request ledger behind this site — the loop, run on ourselves.

Three of those ledger rows, followed end to end — the brief, the review, and the real diff stats behind each.

A spec-sheet register of representative deployments we actually run.

Long-form, no-pitch guides on the decisions behind hosting a site.

A decision guide to the one question that decides most of your hosting bill.

The operational work managed hosting quietly removes from your week.

The Build → Iterate → Run loop, as a how-to for sites that need to keep moving after launch.

You've got a working build. Turning it into something that stays up, stays secure, and keeps improving is a different job — here's what it takes, and who does it.

Usage-based pricing turns every visitor into a variable cost. Here is why the bill spikes, what a flat monthly rate changes, and when each model actually wins.

Self-hosting looks almost free — until you price the hours it quietly costs. Here's the real build-vs-buy math, when DIY genuinely wins, and the line where handing it over pays for itself.

Hosting is the small number. The real cost of a website is building it, running it, and shipping the changes it needs after launch — here's the three-year math, in the open, and where the hours actually go.

Plain-English definitions for every hosting term on this site — and who handles each one.

Who runs CustomHosted, and how it connects to CustomLabs and CodeHerder.

Backups, patching, TLS/DNS, and portability — the security posture, in writing.

How to reach us, and what response times to expect.

Live system status and incident history.

A WCAG 2.1 AA self-assessment, checked with an automated crawl of every route.

Every page on the site, grouped and described — the back-of-manual index.

Look up any page, glossary term, guide section or answer on the site by keyword.

The agreement that governs your use of the service.

What we collect, why, and how it's handled.

Our availability commitment and what happens if we miss it.

What you can and can't run on the grid.

Subscribe to the Field Manual guides in a feed reader.