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 we need to make one, how a brief becomes a fixed number, what it contains, what it does not, and what accepting it commits you to.

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.

Every published limit on the site, in one list — what we do not do, collected from the page that owns each one.

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.

The one copy of your code every other promise on this site depends on: who owns it, and the four states you can start in.

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.

What happens when something breaks: what counts as one, the first hour step by step, first response by symptom, and what it costs.

What the person using your app gets during a failure or a planned change, and the three pages you can put there.

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 personal data your app keeps here: where it sits, who can reach it, how long a copy lives, and what deleting it actually does.

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.

The day the crowd arrives: what runs out first, how a static site and a dedicated instance fail differently, and the rehearsal that finds your own number.

What keeps running when nobody here is awake, what waits for a person, and what you hold if CustomHosted stops.

The parts we don't run: a payment gateway, a mail sender, a customer-messaging tool — where they connect, what changes by hosting shape, and what happens when one breaks.

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.

What a deploy actually is, the hops from merge to serving traffic, what it takes down by hosting shape, what survives it, and what happens when a build fails.

The proof a change works: what runs before it ships, whose checks they are, what a failure does, and what happens when a repository has no tests at all.

The pull request itself and the approval decision — what you see, how to review it without reading code, the three answers, and who may approve.

The values your app reads — a setting against a secret, where a value lives hop by hop, the build-time-versus-run-time trap, and the honest limits.

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.

A static site has no server, and a form needs one thing that runs — where a submission goes, what catches it by hosting shape, and this site's own quote form as the worked artifact.

The people who sign in to your app, not to production — what a login needs and who supplies it, where a session lives, what a release does to it, and this site's own login: there isn't one.

A typo, a price, or a whole new page — a static site has no admin screen, so a content change is a briefed pull request instead.

The picture as bytes: its dimensions, its format, its weight, and what it costs the page budget — what makes a picture light, and how it ships.

The half of search we own: the address, the sitemap, crawlability, structured data, and speed — and the half that stays yours.

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.

The numbers that say it worked: who visited, how much traffic the plan moved, and how a number turns into a briefed change.

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

Managed Next.js hosting. Server-rendered routes run on a dedicated server. A static export runs on Static Starter. CodeHerder ships small changes.

Managed WordPress hosting. PHP and a managed database run on a dedicated server. CodeHerder ships theme and content changes you brief in plain words.

Managed Python hosting. Your WSGI or ASGI app runs on a dedicated server with managed Postgres. CodeHerder ships small endpoints and fixes.

Managed Laravel hosting. PHP, a queue worker and a managed database run on a dedicated server. CodeHerder ships the changes you brief.

Managed hosting for containerised apps. One image runs on a dedicated server at a fixed rate. A Compose stack gets a flat quote. CodeHerder ships image changes.

Managed hosting for Node, Express and Nest APIs. One long-lived process runs on a dedicated server. CodeHerder ships routes and fixes after launch.

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

Managed hosting for design and dev studios. One flat rate per site, staging for each client, and CodeHerder to absorb small change requests.

Managed hosting for founders. CustomLabs builds or finishes version one, dedicated compute runs it at a flat rate, and CodeHerder ships small changes.

Managed hosting for sites with no developer. Brief a change in plain words, a CodeHerder agent opens a pull request, and you approve it.

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 changes you have in the air: what one change is, why one runs at a time, what sets the order, what slows one down, and this site's own shipping cadence.

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.

Five worked examples of the Build → Iterate → Run loop, plus one measured entry: this site.

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

One question decides most of your hosting bill: does your site need a server? This guide gives you a checklist to answer it.

See the work managed hosting takes off your week: patching, backups, monitoring and a human who answers. Each task comes with the hours it saves.

Sites decay after launch. Learn how the Build, Iterate, Run loop keeps a live site changing when you have no developer on staff.

A working build is not a hosted product. See what it takes to keep an app up, secure and improving, and who does each job.

Usage-based pricing turns every visitor into a cost. See why bills spike, what a flat rate changes, and when each model wins.

Self-hosting looks almost free until you price the hours. See the build-versus-buy math, when doing it yourself wins, and when to hand it over.

Hosting is the small number. See the three-year cost of building, running and changing a site, and where the hours really 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.

A pre-filled security questionnaire: who can reach production, how fast we patch, what a delete does to backups, and what we cannot promise.

Where a message goes once you send it: who picks it up, what it costs, and when you hear back.

A posted summary of the current system state.

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 CustomHosted. It covers the service, accounts, billing, liability, termination and data portability.

What we collect through this site, why we collect it, and how long we keep it. It also covers analytics cookies and how to ask for deletion.

Our availability commitment, the terms it uses, and the service credit schedule. It also lists what is excluded and how to claim a credit.

What you may not run on our servers and the fair-use limits on resources. It also covers how to report abuse and how we enforce the rules.

Subscribe to the Field Manual guides in a feed reader.