№ 01 Lookup
Find anything on the site.
265 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
87 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.
- The quotePageWhat 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.
- 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.
- LimitsPageEvery published limit on the site, in one list — what we do not do, collected from the page that owns each one.
- 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.
- RepositoryPageThe one copy of your code every other promise on this site depends on: who owns it, and the four states you can start in.
- 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.
- IncidentsPageWhat happens when something breaks: what counts as one, the first hour step by step, first response by symptom, and what it costs.
- What visitors seePageWhat the person using your app gets during a failure or a planned change, and the three pages you can put there.
- 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.
- Your dataPageThe personal data your app keeps here: where it sits, who can reach it, how long a copy lives, and what deleting it actually does.
- 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.
- Under loadPageThe 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.
- Without usPageWhat keeps running when nobody here is awake, what waits for a person, and what you hold if CustomHosted stops.
- Outside servicesPageThe 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.
- 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.
- DeploysPageWhat 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.
- ChecksPageThe 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.
- ReviewPageThe pull request itself and the approval decision — what you see, how to review it without reading code, the three answers, and who may approve.
- ConfigurationPageThe 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.
- 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.
- FormsPageA 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.
- LoginsPageThe 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.
- ContentPageA 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.
- ImagesPageThe 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.
- Being foundPageThe half of search we own: the address, the sitemap, crawlability, structured data, and speed — and the half that stays yours.
- 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.
- AnalyticsPageThe numbers that say it worked: who visited, how much traffic the plan moved, and how a number turns into a briefed change.
- What we hostPageEvery stack we host in one compatibility register, plus deep pages for the frameworks asked about most.
- Next.jsPageManaged Next.js hosting. Server-rendered routes run on a dedicated server. A static export runs on Static Starter. CodeHerder ships small changes.
- WordPressPageManaged WordPress hosting. PHP and a managed database run on a dedicated server. CodeHerder ships theme and content changes you brief in plain words.
- PythonPageManaged Python hosting. Your WSGI or ASGI app runs on a dedicated server with managed Postgres. CodeHerder ships small endpoints and fixes.
- LaravelPageManaged Laravel hosting. PHP, a queue worker and a managed database run on a dedicated server. CodeHerder ships the changes you brief.
- DockerPageManaged 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.
- Node.jsPageManaged hosting for Node, Express and Nest APIs. One long-lived process runs on a dedicated server. CodeHerder ships routes and fixes after launch.
- 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 rate per site, staging for each client, and CodeHerder to absorb small change requests.
- FoundersPageManaged hosting for founders. CustomLabs builds or finishes version one, dedicated compute runs it at a flat rate, and CodeHerder ships small changes.
- No dev teamPageManaged hosting for sites with no developer. Brief a change in plain words, a CodeHerder agent opens a pull request, and you approve it.
- 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.
- In flightPageThe 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.
- 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 servicePageFive worked examples of the Build → Iterate → Run loop, plus one measured entry: this site.
- GuidesPageLong-form, no-pitch guides on the decisions behind hosting a site.
- Static site or dedicated server: which do you actually need?PageOne question decides most of your hosting bill: does your site need a server? This guide gives you a checklist to answer it.
- What “managed” actually means — and the hours it gives backPageSee the work managed hosting takes off your week: patching, backups, monitoring and a human who answers. Each task comes with the hours it saves.
- How to keep shipping changes to a live site — without hiring a dev teamPageSites decay after launch. Learn how the Build, Iterate, Run loop keeps a live site changing when you have no developer on staff.
- From prototype to production — hosting an app you built fastPageA working build is not a hosted product. See what it takes to keep an app up, secure and improving, and who does each job.
- Flat-rate vs. usage-based hosting: why your bill keeps surprising youPageUsage-based pricing turns every visitor into a cost. See why bills spike, what a flat rate changes, and when each model wins.
- Should you host it yourself? The hidden cost of rolling your ownPageSelf-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.
- The real cost of a website: build it, run it, keep it movingPageHosting is the small number. See the three-year cost of building, running and changing a site, and where the hours really 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.
- SecurityPageA pre-filled security questionnaire: who can reach production, how fast we patch, what a delete does to backups, and what we cannot promise.
- SupportPageWhere a message goes once you send it: who picks it up, what it costs, and when you hear back.
- StatusPageA posted summary of the current system state.
- 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 CustomHosted. It covers the service, accounts, billing, liability, termination and data portability.
- Privacy PolicyPageWhat 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.
- Service Level AgreementPageOur availability commitment, the terms it uses, and the service credit schedule. It also lists what is excluded and how to claim a credit.
- Acceptable Use PolicyPageWhat 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.
- RSSPageSubscribe to the Field Manual guides in a feed reader.
№ 03 Glossary terms
Glossary terms
134 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.
- Not-found page (404)Glossary termThe page a visitor gets for an address that genuinely does not exist, with a real 404 status code attached.
- Maintenance pageGlossary termA "we'll be back" page swapped in for the length of a planned change, then swapped back out.
- Error page (5xx)Glossary termThe page shown when your app is up but answering wrong, rather than a page that simply does not exist.
- Measurement tagGlossary termA snippet a visitor-analytics tool adds to a page so it can count a visit — a tool you choose, not one the platform runs for you.
- Page viewGlossary termOne visitor loading one page — the unit a visitor-analytics tool counts up into traffic figures.
- CookieGlossary termA small value a browser stores and sends back on later requests — how a tool tells one visitor's repeat visits apart from another's.
- Lab vs. field measurementGlossary termA lab number comes from measuring a build by itself; a field number comes from a real visitor's own device and connection.
- Canonical URLGlossary termThe one web address a page names as its own — the address a search engine keeps, when more than one URL could show the same content.
- SitemapGlossary termA machine-readable list of every page on a site, so a crawler can find one without following every link by hand.
- Structured dataGlossary termMarkup added to a page that states a fact in a form a machine reader can parse directly, instead of inferring it from prose.
- CrawlerGlossary termA program that fetches pages the way a browser does, then follows their links, to build up an index of what a site contains.
- Client-side validationGlossary termA form check that runs in the visitor's own browser, before a submission is sent.
- 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.
- ConcurrencyGlossary termHow many requests a workload answers at the same moment, as opposed to how many it answers over a whole month.
- Load testGlossary termA rehearsal that sends a rising amount of traffic at a standing copy of an app to find out where it starts to strain.
- KneeGlossary termThe point on a graph where a workload stops answering normally and starts queueing, slowing, or failing.
- 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.
- Form endpointGlossary termA small managed endpoint that catches a form submission — the one thing a static site needs briefed in to receive anything at all.
- Content changeGlossary termA word, a picture, or a whole new page — the three things people ask to change on a site after launch.
- Headless CMSGlossary termA service that holds your content and hands it to your site over its own API, instead of a database or a file in the repository.
- Alt textGlossary termThe words a screen reader speaks in place of a picture — written once, alongside the picture itself.
- Lazy loadingGlossary termTelling the browser to fetch a picture only once a visitor scrolls near it, instead of on first paint.
- Responsive imagesGlossary termServing a picture sized to the space it fills, rather than one large file every visitor downloads in full.
- Layout shiftGlossary termThe page jumping as a picture finishes loading, because nothing reserved its space in advance.
- 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.
- OutageGlossary termThe site or a core function down, or badly degraded, for real users — the top tier of an incident.
- Service creditGlossary termA credit toward a future invoice, issued when monthly uptime falls short of the SLA target.
- EscalationGlossary termThe path an incident takes from a first automated signal to the humans who decide what to do about it.
- 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.
- Source-code escrowGlossary termA copy of the source code held by a neutral third party, released to a customer only if the vendor fails — something this platform does not offer.
- Key-person riskGlossary termThe risk that a service depends on one specific person, so their absence stops the work.
- RunbookGlossary termA written document saying what each piece of a stack is and how it fits together, for whoever picks it up next.
- 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.
- Environment variableGlossary termA named value an app reads from the environment it runs in, instead of from a line written into its own code.
- ConfigurationGlossary termThe settings, environment variables, and secrets an app reads at startup — as distinct from the code itself.
- Build-time valueGlossary termA configuration value read in while a static site or app is being built, not while it is running.
- Config driftGlossary termWhen two environments meant to match end up with different configuration values, quietly.
- Third-party serviceGlossary termAnything an app calls, loads, or stores data in — a service somebody else runs, not us, not you.
- WebhookGlossary termA request a third-party service sends to your app on its own, when something happens on its side.
- Sandbox keyGlossary termA test credential issued alongside the real one, so a check never touches a live customer.
- 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.
- Honeypot fieldGlossary termA form field real visitors never see or fill in — a submission that fills it is treated as spam.
- SessionGlossary termThe record that keeps a signed-in user signed in between requests.
- Session cookieGlossary termA cookie that carries a session, or a signed session itself, back to the browser that holds it.
- Identity providerGlossary termAn outside service that checks a login for your app — single sign-on, or a social login, instead of your app checking a password itself.
- Data controllerGlossary termThe party that decides why personal data is collected and what happens to it.
- Data processorGlossary termThe party that handles personal data on a controller's instructions, without deciding why it is collected.
- Sub-processorGlossary termA party a processor brings in to help handle personal data, one step further from the controller.
- Data residencyGlossary termThe country or region where a copy of data actually sits.
- 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.
- EstimateGlossary termA number you build yourself, on the spot, from the posted rate card — not a quote.
- Discovery callGlossary termA scheduled conversation some hosts require before they will price a workload. This one does not.
- 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.
- RepositoryGlossary termThe one copy of your code that keeps a full history — every change, in order, with who made it and why.
- CommitGlossary termOne recorded change to a repository — what changed, when, and by whom.
- Version controlGlossary termThe system that records every commit to a repository, so a project has a full history instead of a single, overwritten copy.
- 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.
- DiffGlossary termThe exact lines a pull request adds or removes, shown next to the current code — the change itself, not a description of it.
- BranchGlossary termA separate copy of the code a change is written on, so nothing it contains reaches production until it merges.
- CIGlossary termThe pipeline that automatically builds and checks a change the moment it is pushed, before a human even looks at it.
- Status checkGlossary termA pass-or-fail result shown on a pull request, set by an automated check before a person reviews the change.
- Test suiteGlossary termThe tests your own application carries — what to assert is your call, checked automatically on every change.
- RegressionGlossary termA change that breaks something that used to work.
- Flaky testGlossary termA test that fails on and off, for no real code reason, rather than every time or never.
- 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.
- DeployGlossary termTaking a merged change from a build all the way to serving real traffic — publishing new files, or replacing a running process.
- Build failureGlossary termA build that stops partway and produces no artifact — so there is nothing new to publish.
- RevertGlossary termUndoing a merged change in code — as opposed to a restore, which brings data back.
- In flightGlossary termA briefed change that has started and has not yet merged — the one thing moving through the loop right now.
- Work in progress limitGlossary termA cap on how many changes move through a pipeline at once — here, one.
- Change queueGlossary termThe order a set of briefed changes ships in — set by you, not re-ranked here.
№ 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. Once a person reviews it, the same pipeline ships the merge.
- Am I locked in?AnswerNo. Either side can end the service at any time, with no early-termination fee. A documented handover is free. The Portability page lists what moves with you and what stops.
- What do I have to manage?AnswerAbout 55 minutes of your own time at move-in. That covers DNS access, your secrets, and a sign-off on the go-live window. After that we manage the infrastructure: TLS, backups, monitoring, and patching. Your application code stays yours to run.
- How does pricing work?AnswerOne flat number per month. The rate card lists a fair-use transfer allowance.
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.