№ 01 Lookup
Find anything on the site.
184 pages, terms, guide sections and answers, all in one place. Type below to filter live — or browse the full index with JavaScript off.
Nothing matches — try a different word, or:
Results
Best matches
Ranked across every kind — the same rows below, reordered.
№ 02 Pages
Pages
66 entries.
- HomePageManaged hosting for any app, run like a utility — static sites, dedicated compute, and everything in between.
- Which do I need?PageAnswer a few questions, get a hosting-shape recommendation — no sales call required.
- The hours ledgerPageThe estimator's mirror image — put your own hours and rate in, and see what running it yourself actually costs.
- OnboardingPageThe first week, hour by hour, and exactly how much of it is your own time.
- PricingPageThe full rate card — plans, add-ons, and a self-serve estimator with a live monthly total.
- BillingPageWhat 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.
- Spec sheetPageA shareable, printable spec sheet for any configuration from the estimator or selector — line items, one total, and a permalink to hand off.
- Get a quotePageDescribe the workload, get one fixed monthly rate in writing within a business day.
- PlatformPageWhat the global edge network, durable storage, and dedicated compute actually are.
- StaticPageStatic-site hosting on the global edge network — what it includes and what it costs.
- DedicatedPageFixed-price dedicated compute sized to the workload, with a static IP and full control.
- DatabasesPageManaged Postgres tiers, how an app connects, how a schema change ships, and what happens when one fails halfway.
- CustomPageAnything that doesn't fit a fixed tier — designed and quoted flat.
- ComparePageCustomHosted next to rolling it yourself, a self-serve deploy platform, a traditional host, and an agency on retainer — dimension by dimension, honestly.
- PerformancePageThe measured page-weight budget behind the "fast on the edge" claim — real numbers from this build, enforced on every deploy.
- MigrationsPageAlready hosted elsewhere? A rehearsed cutover with little-to-no downtime.
- PortabilityPageWhat a handover actually contains: the pack manifest, the procedure with real minutes attached, and what honestly stops when you go.
- RecoveryPageWhat'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.
- MonitoringPageThe watch list, what fixes itself automatically, who gets woken for the rest, and what a code bug that no monitor can catch turns into.
- LogsPageThe 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.
- PatchingPageWhat 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.
- Background jobsPageThe 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.
- FilesPageThe 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.
- DomainsPageWho 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.
- DeliveryPageThe rules a request meets once DNS resolves — redirects, trailing slashes, a real 404, the cache, and the response headers you get by default.
- AccessPageWho can touch your production: the four principals, the capability matrix, secrets, least privilege, and what the CodeHerder agent can and cannot do.
- Under attackPageThe perimeter: what stands between the internet's junk traffic and your app, the four kinds of attack, and the honest line where it stops.
- EnvironmentsPageWhat 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.
- EmailPageThe 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.
- ScalingPageThe 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.
- What we hostPageEvery stack we host in one compatibility register, plus deep pages for the frameworks asked about most.
- Next.jsPageManaged 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.
- WordPressPageManaged 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.
- PythonPageManaged 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.
- LaravelPageManaged 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.
- DockerPageManaged 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.
- Who it's forPageThe same platform and loop, organised by situation instead of by product shape.
- AgenciesPageManaged 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.
- FoundersPageManaged 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.
- No dev teamPageManaged 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.
- The LoopPageBuild → Iterate → Run — the loop that keeps a site shipping after launch.
- Brief a changePageThe five parts a good brief needs, a composer that assembles one for you, and three real examples.
- Built in the openPageThe real pull-request ledger behind this site — the loop, run on ourselves.
- Case filesPageThree of those ledger rows, followed end to end — the brief, the review, and the real diff stats behind each.
- In servicePageA spec-sheet register of representative deployments we actually run.
- GuidesPageLong-form, no-pitch guides on the decisions behind hosting a site.
- Static site or dedicated server: which do you actually need?PageA decision guide to the one question that decides most of your hosting bill.
- What “managed” actually means — and the hours it gives backPageThe operational work managed hosting quietly removes from your week.
- How to keep shipping changes to a live site — without hiring a dev teamPageThe Build → Iterate → Run loop, as a how-to for sites that need to keep moving after launch.
- From prototype to production — hosting an app you built fastPageYou'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.
- Flat-rate vs. usage-based hosting: why your bill keeps surprising youPageUsage-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.
- Should you host it yourself? The hidden cost of rolling your ownPageSelf-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.
- The real cost of a website: build it, run it, keep it movingPageHosting 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.
- GlossaryPagePlain-English definitions for every hosting term on this site — and who handles each one.
- AboutPageWho runs CustomHosted, and how it connects to CustomLabs and CodeHerder.
- SecurityPageBackups, patching, TLS/DNS, and portability — the security posture, in writing.
- SupportPageHow to reach us, and what response times to expect.
- StatusPageLive system status and incident history.
- AccessibilityPageA WCAG 2.1 AA self-assessment, checked with an automated crawl of every route.
- DirectoryPageEvery page on the site, grouped and described — the back-of-manual index.
- SearchPageLook up any page, glossary term, guide section or answer on the site by keyword.
- Terms of ServicePageThe agreement that governs your use of the service.
- Privacy PolicyPageWhat we collect, why, and how it's handled.
- Service Level AgreementPageOur availability commitment and what happens if we miss it.
- Acceptable Use PolicyPageWhat you can and can't run on the grid.
- RSSPageSubscribe to the Field Manual guides in a feed reader.
№ 03 Glossary terms
Glossary terms
74 entries.
- CDN (edge network)Glossary termA network of servers positioned close to visitors around the world, so a page loads from whichever one is nearest instead of one far-away server.
- OriginGlossary termThe one real server behind the edge network — where a request goes when nothing cached can answer it.
- LatencyGlossary termHow long a request takes to get an answer back, measured in milliseconds — the thing an edge network exists to shrink.
- EgressGlossary termData leaving our network on its way to a visitor — the traffic a usage-based host would meter and bill for.
- Cache purgeGlossary termTelling the edge network to drop a stale copy of a file so the next visitor gets the current version.
- Static assetGlossary termA file that is the same for every visitor — HTML, CSS, an image, a font — as opposed to a page a server builds fresh per request.
- Redirect (301/302)Glossary termAn instruction that sends a visitor — and a search engine — from one address to another instead of a page.
- Security headerGlossary termAn instruction sent alongside a page that tells a browser to switch on a specific protection, rather than code the page itself has to run.
- SPA fallbackGlossary termA rule that serves a single-page app's own starting page for any address its own router handles, instead of a 404.
- Static siteGlossary termA site built once into plain files and served as-is — no server computing a response per visitor.
- Dedicated instanceGlossary termA fixed slice of compute — CPU, memory, a static IP — that runs your app continuously, not shared unpredictably with anyone else’s traffic.
- Managed databaseGlossary termA database CustomHosted provisions, patches, backs up, and watches for you, sized into one of a few fixed tiers.
- ContainerGlossary termAn app packaged with everything it needs to run, so it behaves the same wherever it is deployed.
- Process managerGlossary termThe thing on a dedicated instance that keeps your app’s process running, restarting it automatically if it crashes or on every deploy.
- Build artifactGlossary termThe output of a build step — the actual files or image that get deployed, as opposed to the source code that produced them.
- Object storageGlossary termDurable storage for files — a built static site, an uploaded image, a backup — that is not tied to any one running server.
- Background workerGlossary termA process that runs jobs — sending emails, generating a report, working a queue — with no browser ever waiting on it directly.
- QueueGlossary termA waiting line for jobs, so a background worker takes each one in turn instead of dropping work that arrives faster than it can run.
- Scheduled job (cron)Glossary termA job that runs on a clock instead of a request — once a night, once an hour, on a fixed timetable.
- IdempotencyGlossary termWhether running the same job twice does the same thing as running it once, instead of double-charging a card or sending a second email.
- Vertical resizeGlossary termMoving a workload to a bigger (or smaller) tier of the same shape — more CPU and memory on the same instance, not a different architecture.
- HeadroomGlossary termThe gap between what a workload is actually using and the limit of its current tier — disk, memory, or connections still spare.
- AutoscalingGlossary termCompute or storage that grows and shrinks on its own, without anyone asking for it — a capability this platform deliberately does not offer.
- Uploads directoryGlossary termThe folder on an app's own disk where a visitor's upload lands — not in git, and not rebuilt by a deploy.
- Persistent diskGlossary termThe disk attached to a dedicated instance — it survives a restart and a resize, sized into the tier it runs on.
- Ephemeral filesystemGlossary termDisk space that resets on every restart or redeploy — the wrong place to keep a file you need back.
- DNSGlossary termThe system that turns a domain name into the address a browser actually connects to.
- DNS recordGlossary termA single entry in DNS — an A record pointing a domain at an address, a CNAME pointing one name at another, and so on.
- TLS certificateGlossary termThe credential that lets a browser confirm a site is really who it says it is, and encrypts the connection to it.
- Domain registrarGlossary termThe company you actually bought the domain name from — a separate thing from whoever hosts the site it points to.
- NameserverGlossary termThe setting at your domain registrar that tells the internet whose DNS to trust for your domain.
- HTTPS redirectGlossary termAutomatically sending anyone who types the plain http:// address to the secure https:// one instead.
- SPFGlossary termA DNS record naming which mail systems are allowed to send as your domain.
- DKIMGlossary termA signature added to outgoing mail that lets a receiving server confirm it really came from your domain's own key.
- DMARCGlossary termA DNS record telling a receiving server what to do with mail that fails the SPF or DKIM checks.
- Mail relayGlossary termAn authenticated service an app sends mail through, instead of calling a mail server directly.
- Transactional emailGlossary termMail triggered by one person's own action — a password reset, a receipt, an invitation — as opposed to bulk or marketing mail.
- BounceGlossary termA message that a receiving server refuses or fails to deliver, reported back to the sender.
- UptimeGlossary termThe share of time a site or app is actually reachable and working, usually quoted as a percentage.
- SLAGlossary termA written commitment about uptime and response time, with a real consequence if it is missed.
- BackupGlossary termA copy of your data and files, taken on a schedule, that a restore can be pulled from if something goes wrong.
- Point-in-time recoveryGlossary termRestoring a database to exactly how it looked at a specific moment, not just to last night’s backup.
- Connection poolGlossary termA small set of open connections an app reuses, instead of opening and closing a new one for every query — and the thing that has a limit.
- RollbackGlossary termReverting a deploy back to the previous working version, fast, when a new one turns out to be broken.
- IncidentGlossary termA real, ongoing problem affecting a site or app — as opposed to a blip nobody but a monitor noticed.
- Health checkGlossary termAn automatic, repeated check that a running app is actually responding correctly, not just that the server is technically on.
- Request logGlossary termA line written automatically for every request at the edge — who asked for what, and what the answer was.
- Application logGlossary termA line your own code chose to write down — a caught error, a warning, a debug message.
- Retention windowGlossary termHow long a record is kept before it ages out on its own — a window, not a permanent archive.
- PatchingGlossary termKeeping the operating system and runtime a site or app runs on updated against known security vulnerabilities.
- FirewallGlossary termA layer that only lets through the network traffic a server is actually supposed to receive, blocking the rest by default.
- Secrets managementGlossary termKeeping API keys, passwords, and tokens out of source code and injected in at runtime instead.
- Connection stringGlossary termThe one secret an app holds to reach its database — address, credentials, and database name in a single value.
- Principle of least privilegeGlossary termGiving a person, process, or key only the access it actually needs, and nothing more.
- Break-glass accessGlossary termA deliberate, logged use of elevated access to stop or fix a live incident — the exception, not the daily routine.
- DDoS mitigationGlossary termAbsorbing or filtering a flood of junk traffic aimed at taking a site offline, before it reaches your app at all.
- Rate limitingGlossary termCapping how many requests a single visitor or address can make in a given window.
- Bot trafficGlossary termAutomated requests, not a person in a browser — from a search engine indexing a page to a script pulling every price on the site.
- Responsible disclosureGlossary termReporting a security hole privately, through a stated channel, before it becomes public.
- Encryption at restGlossary termData encrypted while it is sitting in storage, not just while it is moving over the network.
- Flat-rate pricingGlossary termOne fixed monthly number for a plan, agreed up front, that does not move with traffic.
- Usage-based pricingGlossary termA pricing model that charges by what actually gets used — requests, bandwidth, compute-seconds — instead of a fixed monthly number.
- Add-onGlossary termAn optional extra layered onto a base plan — CodeHerder’s iteration service, for instance — priced and named on its own line.
- QuoteGlossary termA specific fixed monthly rate, given in writing, for a workload described on the contact form.
- OverageGlossary termAn extra charge that lands on a bill because usage crossed a limit built into a usage-based plan.
- Tier / planGlossary termA named, fixed configuration — Static Starter, Dedicated M, and so on — with a set price and a set specification.
- BriefGlossary termA plain-language description of a change you want made — a new page, a copy tweak, a small feature — written the way you would explain it to a person.
- Pull requestGlossary termA proposed change to a codebase, shown as a diff, waiting for someone to review it before it merges.
- CIGlossary termThe pipeline that automatically builds and checks a change the moment it is pushed, before a human even looks at it.
- Agentic iterationGlossary termAn AI agent reading a brief, making the change in a real codebase, and opening a pull request — without anyone hand-writing the diff.
- Staging environmentGlossary termA copy of a site or app, running for real, that is not the live version visitors see — where a change gets checked before it is.
- Schema migrationGlossary termA change to a database's structure — a new column, a new table, a changed constraint — run as code, not clicked together by hand.
- Infrastructure as codeGlossary termDefining servers, DNS records, and configuration as versioned files instead of clicking them together by hand in a dashboard.
- MergeGlossary termApproving a pull request and folding its change into the real codebase — the step that turns a proposed diff into what actually ships.
№ 04 Guide sections
Guide sections
37 entries.
- The real questionGuide sectionStatic site or dedicated server: which do you actually need?
- What static handlesGuide sectionStatic site or dedicated server: which do you actually need?
- What forces dedicatedGuide sectionStatic site or dedicated server: which do you actually need?
- The grey areaGuide sectionStatic site or dedicated server: which do you actually need?
- Decision checklistGuide sectionStatic site or dedicated server: which do you actually need?
- The cost angleGuide sectionStatic site or dedicated server: which do you actually need?
- What "managed" meansGuide sectionWhat “managed” actually means — and the hours it gives back
- The maintenance listGuide sectionWhat “managed” actually means — and the hours it gives back
- A human answersGuide sectionWhat “managed” actually means — and the hours it gives back
- Hours it gives backGuide sectionWhat “managed” actually means — and the hours it gives back
- Where to lookGuide sectionWhat “managed” actually means — and the hours it gives back
- Why sites rotGuide sectionHow to keep shipping changes to a live site — without hiring a dev team
- Build, iterate, runGuide sectionHow to keep shipping changes to a live site — without hiring a dev team
- How a change shipsGuide sectionHow to keep shipping changes to a live site — without hiring a dev team
- What still needs a humanGuide sectionHow to keep shipping changes to a live site — without hiring a dev team
- The prototype problemGuide sectionFrom prototype to production — hosting an app you built fast
- Hosting it properlyGuide sectionFrom prototype to production — hosting an app you built fast
- Where your app fitsGuide sectionFrom prototype to production — hosting an app you built fast
- Keeping it improvingGuide sectionFrom prototype to production — hosting an app you built fast
- When to rebuildGuide sectionFrom prototype to production — hosting an app you built fast
- The meter problemGuide sectionFlat-rate vs. usage-based hosting: why your bill keeps surprising you
- Where surprises hideGuide sectionFlat-rate vs. usage-based hosting: why your bill keeps surprising you
- What flat rate changesGuide sectionFlat-rate vs. usage-based hosting: why your bill keeps surprising you
- When usage-based winsGuide sectionFlat-rate vs. usage-based hosting: why your bill keeps surprising you
- Iterate without the meterGuide sectionFlat-rate vs. usage-based hosting: why your bill keeps surprising you
- The "free" trapGuide sectionShould you host it yourself? The hidden cost of rolling your own
- What you're signing up forGuide sectionShould you host it yourself? The hidden cost of rolling your own
- Pricing the hoursGuide sectionShould you host it yourself? The hidden cost of rolling your own
- When DIY winsGuide sectionShould you host it yourself? The hidden cost of rolling your own
- When to hand it overGuide sectionShould you host it yourself? The hidden cost of rolling your own
- Ops and iterationGuide sectionShould you host it yourself? The hidden cost of rolling your own
- Three costs, not oneGuide sectionThe real cost of a website: build it, run it, keep it moving
- The buildGuide sectionThe real cost of a website: build it, run it, keep it moving
- The runGuide sectionThe real cost of a website: build it, run it, keep it moving
- Keeping it movingGuide sectionThe real cost of a website: build it, run it, keep it moving
- Three years, added upGuide sectionThe real cost of a website: build it, run it, keep it moving
- Where the hours goGuide sectionThe real cost of a website: build it, run it, keep it moving
№ 05 Answers
Answers
7 entries.
- What can you actually host?AnswerAny app. Two standard shapes cover most work: static sites on a global edge network, and dedicated compute at a flat monthly rate. Anything else — APIs, databases, queues, background workers, full stacks — we design and quote flat. If it runs on a server, we can run it.
- How fast can we be live?AnswerStatic sites go live in minutes. Most stacks are live within days of the brief. A fixed monthly quote lands within one business day.
- How do CustomLabs and CustomHosted fit together?AnswerCustomLabs builds the first version, CustomHosted keeps it on. One team, brief to production, nothing lost in a handoff.
- What is CodeHerder and how does it help?AnswerCodeHerder is agentic iteration on code already hosted with us: brief a change in plain language, an agent opens a pull request, the same pipeline ships the merge. Human-reviewed, versioned — first iteration in hours, not sprints.
- Am I locked in?AnswerNo. Every stack is defined as code and fully portable; export or a documented handover is free, any time.
- What do I have to manage?AnswerNothing. No consoles. TLS, DNS, daily backups, monitoring, and patching are included, and a human answers.
- How does pricing work?AnswerOne flat number per month, everything included — no per-request billing, no egress arithmetic.
Still didn't find it?
Describe what you're trying to run on the quote form — one fixed monthly rate, in writing, within a business day.