{
  "version": "https://jsonfeed.org/version/1.1",
  "title": "SaaSCron: Building SaaS",
  "home_page_url": "https://saascron.com/category/building-saas/",
  "feed_url": "https://saascron.com/category/building-saas/feed.json",
  "description": "How SaaS products are built: architecture, multi-tenancy, development practices and the tools behind them.",
  "icon": "https://saascron.com/icon-512.png",
  "language": "en-US",
  "items": [
    {
      "id": "https://saascron.com/multi-tenant-saas-architecture/",
      "url": "https://saascron.com/multi-tenant-saas-architecture/",
      "title": "Multi-tenant SaaS architecture: tenancy models, data isolation and trade-offs",
      "summary": "Silo, pool and bridge tenancy explained, three ways to isolate tenant data, and the cost of 200 tenants on shared and dedicated databases worked through.",
      "content_html": "<p>You are designing a SaaS product, or rebuilding one, and you have to decide whether customers share a database. A large prospect asks whether their data sits next to anyone else’s. Your cloud bill depends on the answer, and so does your next security review.</p>\n<p>A tenant is one customer account in a SaaS product: in business software, a company and all of its users. Running many tenants on one shared system is a large part of what makes SaaS cheaper to operate than one installation per customer, as explained in <a href=\"https://saascron.com/what-is-saas/\">What is SaaS?</a>. How much you share, and how you keep tenants apart, is the architecture decision this guide covers.</p>\n<h2 id=\"multi-tenancy-in-plain-terms\">Multi-tenancy in plain terms</h2>\n<p>Think of housing. In a street of detached houses, each family has its own walls, pipes and bills. In an apartment building, families share the foundation and the plumbing, and each has a locked door. Some buildings mix the two: most flats share everything, a few penthouses have a private lift. Detached houses are private and expensive. Apartments are cheap, and only as safe as their locks.</p>\n<p>Cloud vendors use names for the same three choices. In AWS’s terms, the <strong>silo</strong> model gives a tenant dedicated resources, the <strong>pool</strong> model shares resources among tenants, and the <strong>bridge</strong> model mixes the two. AWS adds that a silo still shares one identity, onboarding and operations layer for all tenants. Without that layer, you are running a managed service, not SaaS.</p>\n<h2 id=\"the-tenancy-models-compared\">The tenancy models compared</h2>\n<p>Microsoft’s Azure Architecture Center splits the middle ground in two. The table maps both vendors’ terms.</p>\n<table>\n<thead>\n<tr>\n<th>Model (AWS / Microsoft)</th>\n<th>What is shared</th>\n<th>How tenants are kept apart</th>\n<th>Cost per tenant</th>\n<th>Main risk</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Silo / automated single-tenant</td>\n<td>Identity, onboarding, operations</td>\n<td>Separate infrastructure per tenant</td>\n<td>Highest: Microsoft notes 100 tenants “probably require 100 times that cost”</td>\n<td>Updates and fixes across many deployments</td>\n</tr>\n<tr>\n<td>Pool / fully multitenant</td>\n<td>Everything</td>\n<td>Application code and a tenant ID</td>\n<td>Lowest</td>\n<td>A bug leaks data; one heavy tenant slows the rest; one bad change hits everyone</td>\n</tr>\n<tr>\n<td>Bridge / vertically partitioned</td>\n<td>Most tenants pooled, some on dedicated deployments</td>\n<td>Both, depending on the tenant</td>\n<td>Middle</td>\n<td>Code must support both modes, and moving a tenant is a migration</td>\n</tr>\n<tr>\n<td>Bridge / horizontally partitioned</td>\n<td>The application tier; each tenant gets its own database</td>\n<td>Separate data, shared compute</td>\n<td>Middle</td>\n<td>Automating many per-tenant components</td>\n</tr>\n</tbody>\n</table>\n<p>The vertical split is often a pricing decision too. Microsoft points out that you can charge more for a single-tenant deployment to recover its cost.</p>\n<h2 id=\"three-ways-to-isolate-data-in-a-database\">Three ways to isolate data in a database</h2>\n<ol>\n<li><strong>Row level.</strong> All tenants share the same tables, and every row carries a tenant ID. This is the cheapest option and the easiest to get wrong, because one query without the tenant filter returns everyone’s data.</li>\n<li><strong>Schema per tenant.</strong> One database holds a separate set of tables for each tenant. A missing filter no longer leaks data, but every schema change runs once per tenant.</li>\n<li><strong>Database per tenant.</strong> Each tenant has its own database, the horizontally partitioned model above. Isolation and per-tenant backups are simple; the fleet of databases is not.</li>\n</ol>\n<p>For row-level isolation, the database can enforce the filter for you. PostgreSQL’s row security policies restrict which rows normal queries return. With row security enabled and no policy defined, PostgreSQL applies “a default-deny policy”, so no rows are visible. But superusers and roles with the <code>BYPASSRLS</code> attribute always bypass it, and table owners normally do too, unless the table is set to <code>FORCE ROW LEVEL SECURITY</code>. If your application connects as the table owner, the policies may not apply to it.</p>\n<h2 id=\"login-is-not-isolation\">Login is not isolation</h2>\n<p>AWS makes a point that many teams miss. Authentication tells you who the user is, and authorization tells you what they may do. Neither stops a request from reaching another tenant’s data. In AWS’s words, “a user could be authenticated and authorized, and still access the resources of another tenant.” Isolation means every data access is scoped by the current tenant’s context, enforced separately from login.</p>\n<h2 id=\"noisy-neighbors\">Noisy neighbors</h2>\n<p>In a shared system, one tenant’s load becomes everyone’s problem. Microsoft’s example: if a large tenant runs a heavy query or operation, “it might affect other tenants.” The usual controls start with per-tenant rate limits and quotas. Beyond that, you can move the heaviest tenants to dedicated resources (the vertical split). Or you can give each tenant its own copy of the component under the most load (the horizontal split).</p>\n<h2 id=\"worked-example-200-tenants-three-designs\">Worked example: 200 tenants, three designs</h2>\n<p><strong>Example:</strong> a labeled hypothetical with round prices. You have 200 tenants. A shared database cluster that serves all of them costs $1,500 a month. The smallest dedicated database costs $25 a month. Each schema migration takes 3 minutes to run and check per database.</p>\n<ul>\n<li><strong>Pool:</strong> $1,500 / 200 = $7.50 per tenant a month. One migration run per release.</li>\n<li><strong>Database per tenant:</strong> 200 x $25 = $5,000 a month, or $25 per tenant. Each release runs 200 migrations: 200 x 3 = 600 minutes, or 10 hours of pipeline time.</li>\n<li><strong>Bridge:</strong> 190 tenants stay on the $1,500 cluster, and 10 enterprise tenants get a dedicated $400 database each. Cost: $1,500 + 10 x $400 = $5,500 a month. If each of the 10 pays a $1,000 monthly isolation premium, that is $10,000 a month of revenue against $4,000 of dedicated cost.</li>\n</ul>\n<p>The pool is cheapest by a wide margin: $1,500 against $5,000. Database per tenant costs 3.3 times as much ($5,000 / $1,500) and adds 10 hours to every release. The bridge keeps the pool’s economics for 190 tenants ($1,500 / 190 = $7.89 each) and turns isolation into a product the 10 large tenants pay for.</p>\n<h2 id=\"which-model-to-start-with\">Which model to start with</h2>\n<ul>\n<li><strong>Many small customers who sign up on their own:</strong> pool, with row-level isolation enforced in the database and tested.</li>\n<li><strong>A few customers ask for isolation in security reviews:</strong> bridge. Keep the pool and sell dedicated databases or deployments as a higher tier.</li>\n<li><strong>Regulated customers who require dedicated infrastructure:</strong> silo, automated from day one. Microsoft’s example is software for legal firms whose customers insist on their own infrastructure.</li>\n<li><strong>A handful of very large customers:</strong> silo can be fine, because the per-tenant cost is small next to each contract.</li>\n</ul>\n<p>Where the infrastructure runs matters as well. For the AWS building blocks, see <a href=\"https://saascron.com/aws-saas/\">SaaS on AWS</a>. For serving each tenant on its own domain, see <a href=\"https://saascron.com/cloudflare-for-saas/\">Cloudflare for SaaS</a>. If a customer asks for a copy in their own data center, that is a different model, covered in <a href=\"https://saascron.com/saas-vs-on-premise/\">SaaS vs on-premise</a>.</p>\n<h2 id=\"common-mistakes\">Common mistakes</h2>\n<ol>\n<li><strong>Treating login as isolation.</strong> An authenticated user with the right role can still reach another tenant’s rows if a query forgets the filter. Why it happens: the identity provider feels like the security layer. Instead: scope every data access by tenant, and enforce it in the database where you can.</li>\n<li><strong>Running the application as the table owner.</strong> In PostgreSQL, owners normally bypass row security, so the policies you wrote may never run. Why it happens: the migration user and the app user are the same account. Instead: give the application its own role, or force row security on the table.</li>\n<li><strong>Choosing silo without automation.</strong> Every deployment needs updates, and Microsoft warns that maintenance “can be time consuming”. Why it happens: the first five tenants are easy to manage by hand. Instead: script provisioning and upgrades before tenant number ten.</li>\n<li><strong>Never testing isolation.</strong> A leak shows up in a customer’s screenshot, not in your logs. Why it happens: tests use one tenant at a time. Instead: add automated tests that log in as tenant A and try to read tenant B, as Microsoft’s guide advises.</li>\n</ol>\n<h2 id=\"sources\">Sources</h2>\n<ul>\n<li>AWS Well-Architected SaaS Lens, <a href=\"https://docs.aws.amazon.com/wellarchitected/latest/saas-lens/silo-pool-and-bridge-models.html\">Silo, pool, and bridge models</a>, checked October 17, 2026.</li>\n<li>AWS whitepaper, <a href=\"https://docs.aws.amazon.com/whitepapers/latest/saas-architecture-fundamentals/tenant-isolation.html\">SaaS Architecture Fundamentals: Tenant isolation</a>, marked “for historical reference only” by AWS, checked October 17, 2026.</li>\n<li>Microsoft Azure Architecture Center, <a href=\"https://learn.microsoft.com/en-us/azure/architecture/guide/multitenant/considerations/tenancy-models\">Tenancy models for a multitenant solution</a>, checked October 17, 2026.</li>\n<li>PostgreSQL documentation, <a href=\"https://www.postgresql.org/docs/current/ddl-rowsecurity.html\">Row security policies</a>, checked October 17, 2026.</li>\n</ul>\n<h2 id=\"in-three-sentences\">In three sentences</h2>\n<p>Multi-tenant SaaS runs many customers on shared infrastructure, and the choice is how much to share: everything (pool), nothing but identity and operations (silo), or a mix (bridge). In the example, 200 tenants cost $1,500 a month pooled and $5,000 on dedicated databases, while a bridge keeps pooled costs and charges 10 large tenants for isolation. Whatever you choose, enforce tenant scope on every data access, keep the app from bypassing database policies, and test that one tenant cannot read another’s data.</p>\n",
      "image": "https://saascron.com/media/multi-tenant-saas-architecture/16x9.jpg",
      "date_published": "2026-10-28T12:00:00-04:00",
      "date_modified": "2026-10-28T12:00:00-04:00",
      "authors": [
        {
          "name": "Ricardo Machado",
          "url": "https://saascron.com/author/ricardo-machado/"
        }
      ],
      "tags": [
        "Building SaaS",
        "Multi tenancy",
        "Architecture",
        "Data isolation",
        "Databases"
      ],
      "language": "en-US"
    },
    {
      "id": "https://saascron.com/headless-saas/",
      "url": "https://saascron.com/headless-saas/",
      "title": "Headless SaaS: what API-first software means for builders",
      "summary": "What headless and API-first SaaS mean for content, commerce and payments, what you gain and what it costs to build and run, with a caching example and a checklist.",
      "content_html": "<p>A vendor has told you its product is “headless” or “API-first”, and you need to know whether that helps your team or just adds work. The terms describe one design choice. Headless SaaS is a hosted service that runs the back end (data, rules, checkout, accounts) and hands you an API instead of a finished front end. You build the screens your customers see.</p>\n<p>That choice moves cost and control from the vendor to you. This guide explains what headless means for content, commerce and payments, what you gain, what it costs, and how to tell whether it fits. For the basics of software delivered as a service, see <a href=\"https://saascron.com/what-is-saas/\">What is SaaS?</a>. For the difference between a SaaS product and a platform you build on, see <a href=\"https://saascron.com/saas-platform/\">SaaS platform</a>.</p>\n<h2 id=\"headless-in-plain-terms\">Headless in plain terms</h2>\n<p>Think of a restaurant kitchen that does not have a dining room. It cooks for anyone who orders: a delivery app, a food truck, a stand at a stadium. Each outlet has its own look and its own menu board. The kitchen only promises that when an order comes in, the food goes out.</p>\n<p>A traditional SaaS product is the restaurant with the dining room: the kitchen and the tables come together, and the tables look the way the owner decided. A headless product is the kitchen alone. The “head” is the front end, the part people see and click. The API (application programming interface) is the order window: a defined way for your code to ask the service for data or to make it do something.</p>\n<p>Shopify’s developer documentation puts it in one line: “Headless commerce separates your storefront’s frontend from its backend” (<a href=\"https://shopify.dev/docs/storefronts/headless\">Shopify, headless</a>).</p>\n<p>API-first is the design habit behind it. The vendor designs the API as the main product, and any screens it ships are built on that same API.</p>\n<h2 id=\"where-you-meet-headless-saas\">Where you meet headless SaaS</h2>\n<ul>\n<li><strong>Content.</strong> A headless content management system (CMS) stores articles, product copy and images, and returns them as structured data. The same entry can feed your website, your app and an in-store screen.</li>\n<li><strong>Commerce.</strong> Shopify’s Storefront API “serves products, collections, search, and the cart, and hands customers off to checkout”. Shopify offers Hydrogen, its toolkit for building the storefront in JavaScript, and Oxygen to host it, or you host it elsewhere.</li>\n<li><strong>Payments.</strong> Stripe’s <a href=\"https://docs.stripe.com/payments/online-payments\">online payments guide</a> offers a spectrum. At one end is a prebuilt payment page it hosts. At the other is a lower-level API, Payment Intents, where you build the checkout yourself. Stripe recommends its Checkout Sessions API for most integrations. It warns that the lower-level path means much more code and ongoing maintenance, because you rebuild discounts, tax and currency logic yourself.</li>\n<li><strong>Accounts and search.</strong> Sign-in, permissions and search are also sold as services you call from your own screens.</li>\n</ul>\n<p>The pattern is the same each time. The vendor runs the hard back-end parts, and the more of the front end you take on, the more control and the more work you get.</p>\n<h2 id=\"coupled-vs-headless\">Coupled vs headless</h2>\n<table>\n<thead>\n<tr>\n<th>Question</th>\n<th>Coupled SaaS (vendor’s front end)</th>\n<th>Headless SaaS (your front end)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Who builds what customers see</td>\n<td>The vendor, through themes and templates</td>\n<td>Your developers</td>\n</tr>\n<tr>\n<td>Time to launch</td>\n<td>Days to weeks</td>\n<td>Longer: you build and test every screen</td>\n</tr>\n<tr>\n<td>Design freedom</td>\n<td>Within the vendor’s templates</td>\n<td>Anything your team can build</td>\n</tr>\n<tr>\n<td>Channels</td>\n<td>Usually one: the vendor’s site</td>\n<td>Any: web, app, kiosk, partner sites</td>\n</tr>\n<tr>\n<td>Hosting the front end</td>\n<td>Included</td>\n<td>Yours, or the vendor’s add-on</td>\n</tr>\n<tr>\n<td>Who fixes a broken page</td>\n<td>The vendor</td>\n<td>You</td>\n</tr>\n<tr>\n<td>Cost profile</td>\n<td>Mostly the subscription</td>\n<td>Subscription plus build, hosting and maintenance</td>\n</tr>\n</tbody>\n</table>\n<p>Shopify is unusually candid about the last row: “A headless storefront costs more to build and run than a theme.” It says to confirm the merchant accepts the added cost and complexity, and has developers to maintain the storefront after launch.</p>\n<h2 id=\"the-cost-worked-through\">The cost, worked through</h2>\n<p>Two costs surprise teams that move to headless: API traffic and maintenance hours.</p>\n<p><strong>Example:</strong> a hypothetical store with 300,000 page views a month. Each page makes 3 API calls to the commerce and content services.</p>\n<ul>\n<li>Calls before caching: 300,000 x 3 = 900,000 a month.</li>\n<li>With a cache in front that answers 95% of calls, the services receive 900,000 x 5% = 45,000 calls.</li>\n<li>If a bug turns the cache off, the services suddenly receive all 900,000, 20 times the usual load.</li>\n</ul>\n<p>Check each vendor’s rate limits and pricing against the uncached number, not only the cached one.</p>\n<p>Maintenance is the second cost. Suppose the front end needs 12 developer hours a month for fixes, framework upgrades and new campaign pages, at a loaded cost of $90 an hour.</p>\n<ul>\n<li>Monthly: 12 x $90 = $1,080.</li>\n<li>Yearly: $1,080 x 12 = $12,960.</li>\n</ul>\n<p>With a coupled product, most of that work is the vendor’s, priced into the subscription. With headless, it is a line in your budget for as long as the storefront exists.</p>\n<h2 id=\"checklist\">Checklist</h2>\n<p>Tick each line before you choose a headless product:</p>\n<ul>\n<li>You need a channel or a design the vendor’s templates cannot deliver.</li>\n<li>You have developers who will own the front end after launch, not only build it.</li>\n<li>You know which features the vendor’s front end gave you for free (search pages, account pages, checkout) and who rebuilds them.</li>\n<li>You have priced front-end hosting, monitoring and a cache.</li>\n<li>You have checked API rate limits against traffic with the cache off.</li>\n<li>You know how you will preview content before it goes live.</li>\n</ul>\n<p>If you tick fewer than four, a coupled product with an API for the parts you need is usually the safer start. Connecting it to the rest of your stack is covered in <a href=\"https://saascron.com/saas-integration/\">SaaS integration</a>. For online stores in particular, see <a href=\"https://saascron.com/ecommerce-saas/\">ecommerce SaaS</a>.</p>\n<h2 id=\"common-mistakes\">Common mistakes</h2>\n<ol>\n<li><strong>Choosing headless for speed.</strong> A headless launch is slower because you build every screen. Why it happens: “modern” sounds faster. Instead: choose it for control or channels, and plan a longer first release.</li>\n<li><strong>Budgeting only for the build.</strong> The front end keeps needing upgrades and fixes. Why it happens: the project ends, the code does not. Instead: put monthly maintenance hours in the budget before you sign.</li>\n<li><strong>Forgetting what the vendor’s front end did.</strong> Search pages, account pages and checkout edge cases vanish with the theme. Why it happens: nobody listed them because they just worked. Instead: inventory the vendor’s pages and decide which you rebuild and which you keep hosted.</li>\n<li><strong>Dropping to the lowest-level API too early.</strong> Stripe’s own guidance says the lower-level path means rebuilding tax, discount and currency logic. Why it happens: full control looks attractive on day one. Instead: start with the highest-level API that meets your needs and go lower only for a specific gap.</li>\n</ol>\n<h2 id=\"sources\">Sources</h2>\n<ul>\n<li>Shopify, <a href=\"https://shopify.dev/docs/storefronts/headless\">Headless storefronts</a>, checked October 2026.</li>\n<li>Stripe, <a href=\"https://docs.stripe.com/payments/online-payments\">Online payments</a>, checked October 2026.</li>\n</ul>\n<h2 id=\"in-three-sentences\">In three sentences</h2>\n<p>Headless SaaS runs the back end, such as content, commerce, payments or accounts, and gives you an API instead of a finished front end, so you build every screen your customers see. You gain design freedom and any number of channels, and you take on the build, the hosting and every fix after launch. Choose it when templates cannot do what you need and you have developers to own the front end; otherwise, start coupled and use the API only where you need it.</p>\n",
      "image": "https://saascron.com/media/headless-saas/16x9.jpg",
      "date_published": "2026-10-25T17:00:00-04:00",
      "date_modified": "2026-10-25T17:00:00-04:00",
      "authors": [
        {
          "name": "Ricardo Machado",
          "url": "https://saascron.com/author/ricardo-machado/"
        }
      ],
      "tags": [
        "Building SaaS",
        "Headless",
        "API first",
        "Cms",
        "Ecommerce",
        "Architecture"
      ],
      "language": "en-US"
    },
    {
      "id": "https://saascron.com/cloudflare-for-saas/",
      "url": "https://saascron.com/cloudflare-for-saas/",
      "title": "Cloudflare for SaaS: custom hostnames, customer SSL and pricing explained",
      "summary": "How Cloudflare for SaaS puts your customers' own domains on your app with managed certificates, and what it costs at 50, 500 and 5,000 hostnames.",
      "content_html": "<p>You run a SaaS product, and a customer asks to reach their account at <code>app.theircompany.com</code> instead of <code>theircompany.yourapp.com</code>, with a valid padlock in the browser. Then ten more customers ask. Cloudflare for SaaS is the Cloudflare feature built for this: it accepts traffic for your customers’ domains, gets a TLS certificate for each one and forwards the requests to your application.</p>\n<p>Custom domains are one of the first “enterprise” requests a young SaaS product receives, because a customer’s brand on the address bar matters to them. This guide explains the moving parts, the setup and the price. For the bigger picture of how a request travels from a browser to a SaaS vendor’s servers, see <a href=\"https://saascron.com/saas-in-cloud-computing/\">SaaS in cloud computing</a>; for the basic model, <a href=\"https://saascron.com/what-is-saas/\">What is SaaS?</a>.</p>\n<h2 id=\"custom-hostnames-in-plain-terms\">Custom hostnames in plain terms</h2>\n<p>Think of the reception desk in a shared office building. Letters arrive addressed to forty different companies, and the desk accepts all of them, checks each one, and carries it to the right floor. Nobody outside needs to know that the forty companies share one building.</p>\n<p>Cloudflare for SaaS is that desk for web traffic. The vocabulary is short:</p>\n<ul>\n<li><strong>Custom hostname:</strong> a domain your customer owns, such as <code>app.theircompany.com</code>, that you add to your own Cloudflare zone.</li>\n<li><strong>Fallback origin:</strong> the server where Cloudflare sends traffic for all custom hostnames by default. Cloudflare’s documentation says custom hostnames “are routed to a default origin server called fallback origin.”</li>\n<li><strong>CNAME target:</strong> a hostname on your domain, such as <code>customers.yourapp.com</code>, that your customers point their DNS at.</li>\n<li><strong>Domain control validation (DCV):</strong> the check a certificate authority runs to confirm the domain really points at you before it issues a certificate.</li>\n</ul>\n<p>The customer keeps their domain and their DNS provider. They add one record. You do the rest from your Cloudflare account or its API.</p>\n<h2 id=\"how-the-setup-works\">How the setup works</h2>\n<p>Cloudflare’s <a href=\"https://developers.cloudflare.com/cloudflare-for-platforms/cloudflare-for-saas/start/getting-started/\">getting started guide</a> describes four steps, in this order.</p>\n<ol>\n<li><strong>Create the fallback origin.</strong> Add a proxied DNS record (A, AAAA or CNAME) that points at your application, and mark it as the fallback origin. The docs say it “must be proxied.”</li>\n<li><strong>Create a CNAME target.</strong> Add a proxied CNAME, often a wildcard such as <code>*.customers.yourapp.com</code>, that points at the fallback origin. Cloudflare calls this step “optional, but highly encouraged,” because it gives customers a stable name to point at.</li>\n<li><strong>Add the custom hostname.</strong> In the dashboard or through the API, enter the customer’s hostname and choose options such as the minimum TLS version and the validation method.</li>\n<li><strong>Ask the customer to add a CNAME.</strong> At their DNS provider, the customer points <code>app.theircompany.com</code> to your CNAME target.</li>\n</ol>\n<p>Before the customer switches DNS, check that the hostname’s status and its SSL status both read <code>active</code>. Switching earlier sends their users to a page with a certificate error.</p>\n<h2 id=\"who-handles-the-certificates\">Who handles the certificates</h2>\n<p>You have two options, per Cloudflare’s <a href=\"https://developers.cloudflare.com/cloudflare-for-platforms/cloudflare-for-saas/security/certificate-management/\">certificate management page</a>. Cloudflare can manage “all the certificate issuance and renewals on your behalf,” or you can upload certificates you already hold when you need to control the private keys.</p>\n<p>With managed certificates, the certificate authority still has to validate each domain. The API offers three methods: <code>http</code>, <code>txt</code> and <code>email</code>. HTTP validation works once the hostname already points at your CNAME target. TXT validation means the customer adds a DNS text record, and it is required for wildcard hostnames. A third option, delegated DCV, has the customer add a one-time DNS record so that future renewals validate without them (<a href=\"https://developers.cloudflare.com/cloudflare-for-platforms/cloudflare-for-saas/security/certificate-management/issue-and-validate/validate-certificates/\">validation methods</a>).</p>\n<p>The choice shapes your onboarding email. HTTP validation asks the customer for one record, but only after they point their domain at you. TXT validation asks for two records, but you can have the certificate ready before the switch.</p>\n<h2 id=\"what-it-costs\">What it costs</h2>\n<p>Cloudflare publishes the price on its <a href=\"https://developers.cloudflare.com/cloudflare-for-platforms/cloudflare-for-saas/plans/\">plans page</a>, as of October 2026:</p>\n<table>\n<thead>\n<tr>\n<th>Zone plan</th>\n<th>Custom hostnames included</th>\n<th>Each additional hostname</th>\n<th>Maximum</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Free, Pro, Business</td>\n<td>100</td>\n<td>$0.10</td>\n<td>50,000</td>\n</tr>\n<tr>\n<td>Enterprise</td>\n<td>Custom</td>\n<td>Custom pricing</td>\n<td>Unlimited (contact sales above 50,000)</td>\n</tr>\n</tbody>\n</table>\n<p>So the price is $0.10 per additional custom hostname (Cloudflare plans page), on top of whatever plan your zone is on. The plans page does not state a billing period for that fee, so check how it appears on your own Cloudflare invoice before you budget.</p>\n<p><strong>Example:</strong> every customer of your SaaS product uses one custom hostname. On a Free, Pro or Business zone, the first 100 hostnames are included and each one after that is $0.10:</p>\n<table>\n<thead>\n<tr>\n<th>Customers with a custom domain</th>\n<th>Billable hostnames</th>\n<th>Hostname fee</th>\n<th>Fee averaged over all customers</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>50</td>\n<td>0 (inside the 100 included)</td>\n<td>$0</td>\n<td>$0</td>\n</tr>\n<tr>\n<td>500</td>\n<td>500 - 100 = 400</td>\n<td>400 x $0.10 = $40</td>\n<td>$40 / 500 = $0.08</td>\n</tr>\n<tr>\n<td>5,000</td>\n<td>5,000 - 100 = 4,900</td>\n<td>4,900 x $0.10 = $490</td>\n<td>$490 / 5,000 = $0.098</td>\n</tr>\n</tbody>\n</table>\n<p>The average fee per customer approaches $0.10 as you grow, because the 100 free hostnames matter less each time. At 5,000 customers it is just under 10 cents per customer, whatever the billing period turns out to be on your invoice. The real limits are elsewhere. Above 50,000 hostnames you need an Enterprise contract, and each hostname adds support work when a customer’s DNS is wrong.</p>\n<h2 id=\"when-to-use-it-and-the-alternatives\">When to use it, and the alternatives</h2>\n<p>Cloudflare for SaaS fits when you have, or expect, dozens to thousands of customer domains and do not want to run certificate issuance yourself. It also puts Cloudflare’s network in front of every customer domain, which is the “reception desk” doing its other job: filtering traffic before it reaches your servers.</p>\n<p>You have other routes. You can run your own reverse proxy and request certificates from a public certificate authority such as <a href=\"https://letsencrypt.org/\">Let’s Encrypt</a> through the ACME protocol. Several CDNs and hosting platforms sell their own custom-domain features. The trade-off is the usual one for a <a href=\"https://saascron.com/saas-pricing-models/\">SaaS buyer</a>: a per-unit fee in exchange for not owning the operational work. With fewer than 100 custom domains on a Cloudflare zone, the per-hostname fee is zero, so the question is mostly about lock-in and operations, not cost.</p>\n<h2 id=\"common-mistakes\">Common mistakes</h2>\n<ol>\n<li><strong>Adding your own zone name as a custom hostname.</strong> Cloudflare’s docs say plainly: “Do not configure a custom hostname which matches the zone name.” Why it happens: you test with your own domain first. Instead: test with a second domain you own.</li>\n<li><strong>Telling the customer to switch DNS too early.</strong> Their users see a certificate warning until validation finishes. Why it happens: the onboarding email lists the CNAME first. Instead: wait until both statuses read <code>active</code>, or use TXT or delegated validation so the certificate exists before the switch.</li>\n<li><strong>Choosing HTTP validation for a wildcard.</strong> Wildcard hostnames require TXT validation. Why it happens: HTTP is the default you clicked through. Instead: decide per hostname type, and document it in your onboarding guide.</li>\n<li><strong>Leaving hostnames of departed customers in place.</strong> You keep paying for them, and a customer domain that still points at you after they leave is a support and security loose end. Why it happens: offboarding scripts delete the account, not the hostname. Instead: remove the custom hostname in the same offboarding step and tell the customer to remove their CNAME.</li>\n</ol>\n<h2 id=\"sources\">Sources</h2>\n<ul>\n<li>Cloudflare, <a href=\"https://developers.cloudflare.com/cloudflare-for-platforms/cloudflare-for-saas/plans/\">Cloudflare for SaaS: plans</a>, checked October 2026.</li>\n<li>Cloudflare, <a href=\"https://developers.cloudflare.com/cloudflare-for-platforms/cloudflare-for-saas/start/getting-started/\">Get started with Cloudflare for SaaS</a>, checked October 2026.</li>\n<li>Cloudflare, <a href=\"https://developers.cloudflare.com/cloudflare-for-platforms/cloudflare-for-saas/security/certificate-management/\">Certificate management</a> and <a href=\"https://developers.cloudflare.com/cloudflare-for-platforms/cloudflare-for-saas/security/certificate-management/issue-and-validate/validate-certificates/\">Validate certificates</a>, checked October 2026.</li>\n</ul>\n<h2 id=\"in-three-sentences\">In three sentences</h2>\n<p>Cloudflare for SaaS lets your customers point their own domains at your application while Cloudflare validates, issues and renews a certificate for each one. Setup is a fallback origin, a CNAME target, one custom hostname per customer and one DNS record on the customer’s side. On Free, Pro and Business zones the first 100 hostnames are included and each extra one costs $0.10, so 5,000 customer domains mean 4,900 billable hostnames and a $490 fee.</p>\n",
      "image": "https://saascron.com/media/cloudflare-for-saas/16x9.jpg",
      "date_published": "2026-10-17T07:00:00-04:00",
      "date_modified": "2026-10-17T07:00:00-04:00",
      "authors": [
        {
          "name": "Ricardo Machado",
          "url": "https://saascron.com/author/ricardo-machado/"
        }
      ],
      "tags": [
        "Building SaaS",
        "Cloudflare",
        "Custom domains",
        "Ssl",
        "Multi tenant"
      ],
      "language": "en-US"
    }
  ]
}
