The “Cold Start” Renewal: Tracking Headless CMS and Serverless Database Tier Expirations Before Client Sites Break

For years, agency infrastructure followed a predictable annual rhythm. You tracked domain expirations, renewed SSL certificates (before Let’s Encrypt and ACME automation made that routine), and paid an annual invoice for a cPanel shared server or a managed VPS. If a client forgot to pay, you usually had a grace period before a suspension page appeared.

Modern web architecture has broken that predictability.

A single client marketing site or web app might now run on a composable stack: a Next.js frontend on Vercel, authentication through Clerk, media served by Cloudinary, content managed in Strapi Cloud or Sanity, and data stored in Supabase, Neon or PlanetScale.

That stack delivers speed and developer velocity, but it adds a quiet operational hazard: usage-based, inactivity-triggered and plan-change-driven infrastructure failure.

A traditional server fails loudly on a known date. A serverless database or headless CMS can fail quietly, often mid-week and with no date on any calendar. To visitors it looks like a broken API fetch, a 500 or 504 error, or a homepage that renders with no content.

This article covers how modern serverless tiers actually stop working, why calendar-based renewal tracking misses them, and how agencies can build a tracking system that catches problems before clients do. Vendor limits and prices below were checked against official documentation in November 2026. They change often, so re-verify before you quote them to a client.

The Anatomy of a Modern “Silent” Outage

When a traditional VPS runs out of disk space or expires, the whole machine goes offline. In a decoupled architecture, the frontend can stay healthy while a backend dependency goes dark.

When a database is paused, a CMS project is suspended, or an API quota is exhausted, the frontend’s server-side rendering (SSR) or Incremental Static Regeneration (ISR) code gets a refused connection, an error response or a timeout. What the visitor sees depends on how the app handles that failure:

• 500: Vercel returns FUNCTION_INVOCATION_FAILED when a function throws an unhandled error, such as a failed database query.
• 504: Vercel returns FUNCTION_INVOCATION_TIMEOUT when a function exceeds its allowed duration.
• 502 Bad Gateway: This appears mainly when a proxy or rewrite sits in front of an upstream that fails. Vercel’s 502 codes, for example, relate to external rewrites and DNS resolution.
• An empty page with a 200: This happens when the code catches the error and renders nothing.

In every case the Vercel deployment still shows green. The client’s site is effectively down while the hosting dashboard says everything is fine.

Four Ways Serverless and Headless Tiers Fail Quietly

1. Inactivity pausing and scale-to-zero (the “low-traffic client” trap). Providers handle idle projects in two very different ways:
   • Pause, manual restore: Supabase pauses Free plan projects that show low activity over a 7-day period, and they do not wake on incoming traffic. Someone must resume the project from the dashboard.
   • Scale to zero, automatic wake: Neon suspends compute after 5 minutes without queries and reactivates it on the next connection, typically in a few hundred milliseconds. Strapi Cloud’s entry-level Starter plan is listed as “sleeps when idle,” while Pro and Business are always on.A seasonal microsite, investor portal or boutique brochure site with sporadic traffic is exactly the project that hits these behaviors.
2. Plan changes and deprecations. Free tiers and plan limits change more often than most agencies track:
   • PlanetScale retired its free Hobby plan on April 8, 2024, and databases that were not upgraded by then were put into sleep mode.
   • Contentful cut its Free plan from 1 million to 100,000 API calls per month and added a 50 GB bandwidth limit, in a change that took effect around January 2025.
   • Strapi cut the Free plan’s allowance to 2,500 API requests per month in December 2025, and its current Cloud pricing page lists only paid plans.A project built on a free tier two years ago may be on a plan that no longer exists, with notices going to whoever signed up.
3. Hard quotas versus overage billing. Platforms handle limits in two ways, and the difference decides whether you get an outage or a surprise bill:
   • Hard stop: Neon’s Free plan suspends compute until the next billing month once a monthly limit is reached. Sanity’s Free plan has hard quotas with no overages, so functionality blocks at the quota.
   • Overage billing: Paid plans on Strapi Cloud, Sanity Growth and Contentful Lite generally bill for usage above the plan allowance. These plans fail through billing, not quota.
4. Unpaid invoices and orphaned billing owners. A project started on a developer’s personal account or card keeps running until the payment method fails or the notice emails go unread. On Strapi Cloud, a project with an unpaid invoice has its subscription canceled and is suspended. If the issue is not resolved within 30 days, the project and its data are deleted.

Platform-by-Platform Breakdown

Deep Dive into the Major Culprits

Supabase: The 7-Day Inactivity Pause

Supabase is a popular Postgres backend for Next.js and React apps. On the Free plan, projects with low activity over a 7-day period are paused. Supabase says a few database requests per day over the previous week is typically enough to prevent it. Paid plans are never paused for inactivity.

Supabase emails the project owner about a week before the pause and again once it happens. The owner is often a contractor or the developer who first set up the project. A paused project is brought back with Resume project in the dashboard. The restore window was recently extended, and Supabase’s current documentation gives one year from the pause date. It was 90 days under the earlier policy, so check the live docs.

Neon: Compute-Hour Caps and Scale-to-Zero

Neon separates storage from compute. On the Free plan, each project gets 100 CU-hours of compute per month, and compute scales to zero after 5 minutes of inactivity. That setting is fixed on Free. When a connection arrives, compute reactivates on its own. Wake-up is usually a few hundred milliseconds, so cold starts alone rarely cause timeouts on current Vercel defaults.

The real risk is the cap. Neon’s docs say that hitting any Free monthly limit, whether compute hours, storage or transfer, suspends compute until the next billing month. Upgrading to the usage-based Launch plan resumes it immediately. Launch has no monthly minimum and bills compute at $0.106 per CU-hour and storage at $0.35 per GB-month. Neon’s Free plan is positioned for prototypes, and the hard cutoff makes it a poor fit for client production sites.

PlanetScale: After the Free Tier

PlanetScale told Hobby users in March 2024 that databases not upgraded by April 8 would be put into sleep mode. Its current pricing has no free tier. Postgres single-node clusters start at $5 per month, and the Vitess/MySQL three-node plan starts at $39 per month. Agencies inheriting older Jamstack builds should confirm which plan a PlanetScale database is on, who owns the account and which card is attached.

Strapi Cloud: Hosting Plans, Overages and Suspension

Strapi Cloud’s current pricing lists Starter ($35), Pro ($90) and Business ($450) per project per month. Starter includes 100,000 API requests per month, 50 GB of asset storage and 50 GB of asset bandwidth. Overages are billed, not blocked: $1.50 per additional 25,000 API requests and $30 per additional 100 GB of bandwidth.

Strapi counts all GraphQL and REST API requests regardless of response type. A frontend that calls the CMS on every uncached page view can therefore burn through a plan allowance quickly. The cost of that is usually an invoice, but an unpaid invoice leads to suspension and eventual deletion after 30 days. For Strapi, billing ownership matters more than quota alerts.

Sanity and Contentful: Free-Tier Ceilings

Sanity’s Free plan includes 20 seats, 10,000 documents, 2 public datasets, 250,000 API requests per month, 1 million API CDN requests per month and 100 GB of bandwidth. It has no overages: once a quota is reached, the affected functionality is blocked. The Growth plan, at $15 per seat per month, switches to pay-as-you-go overages.

Contentful’s Free plan changes reduced it to 100,000 API calls and 50 GB of asset bandwidth per month. The jump to the Lite plan, listed at $300 per month with 1 million API calls and 100 GB of bandwidth, is large. A busy ISR site on Free can reach the cap through short revalidation windows alone.

Why Traditional Renewal Spreadsheets Fail

Most agencies track client assets in a master spreadsheet, a Notion database or a PSA tool built around fixed calendar dates:

• Domain: example.com | Registrar: Namecheap | Renews: 2027-03-15
• Hosting: WP Engine | Renews: 2027-01-10

That model breaks down on composable stacks for four reasons:

1. Invisible micro-dependencies. One website is now seven line items: the domain at Cloudflare, the frontend on Vercel, the CMS in Strapi Cloud, the database on Neon, email through Resend, search on Algolia and media in Cloudinary. Tracking only the domain and the frontend covers two of the seven.
2. Consumption instead of dates. A Neon project or Sanity workspace doesn’t expire on an anniversary. It stops, or starts billing, when usage crosses a threshold. A date-based spreadsheet can’t show that a crawler consumed most of a client’s monthly quota yesterday.
3. Fragmented ownership. Developers often create backend services under personal logins during prototyping. When they leave, billing notices, pause warnings and quota emails go to an inbox nobody reads.
4. Silent failure modes. An expired SSL certificate triggers a browser warning. A paused database often doesn’t. If data-fetching code catches the error and returns an empty array, ISR can cache that empty result, and the client’s store or blog looks empty while an uptime monitor checking the homepage reports 200 OK.

How to Audit and Track Serverless Dependencies Before They Fail

Preventing surprise outages means moving from passive calendar tracking to dependency mapping and threshold monitoring.

1. Create a Composable Infrastructure Bill of Materials

Every client site, whether you launched it or inherited it, should have a standard bill of materials. Instead of one “Hosting” row, document each runtime dependency across five layers:

• Edge and compute: Vercel, Netlify, Cloudflare, AWS Amplify
• Data persistence: Supabase, Neon, PlanetScale, MongoDB Atlas, Upstash
• Content and media: Strapi Cloud, Sanity, Contentful, Cloudinary, Mux
• Identity and auth: Clerk, Auth0, Supabase Auth, Kinde
• Messaging and search: Resend, Postmark, Algolia, Typesense

For each item, record four fields:

1. Plan tier and billing model (for example, Free: pauses after a week of low activity, Pro: usage-based)
2. Hard quota limit (for example, 100 CU-hours/month, 250k API requests/month)
3. Billing owner email (a shared alias such as billing@agency.com or ops@client.com, never a personal developer address)
4. Limit behavior (does it hard-stop, bill overages, or suspend on an unpaid invoice?)

2. Eliminate Personal Accounts for Production Infrastructure

Production databases and CMS projects should not live in a developer’s personal account. Require every production service to sit in an organization or team workspace owned by an agency operations email or by the client directly. Make “workspace ownership transfer” a mandatory item on your pre-launch checklist for anything that started as a prototype.

3. Build Deep Health-Check Endpoints

Standard uptime monitors such as UptimeRobot or Pingdom usually check the homepage. If the homepage is statically cached at the CDN, the monitor reports 200 OK even while the database is paused and every dynamic route fails.

Add a dedicated /api/health route that performs a lightweight, uncached check against each critical dependency:

// Example Next.js App Router health check (app/api/health/route.ts) import { NextResponse } from 'next/server'; import { createClient } from '@supabase/supabase-js'; export const dynamic = 'force-dynamic'; // Prevent caching export async function GET() { const start = Date.now(); try { // 1. Verify database connectivity. // Prefer a least-privilege key and a dedicated health_check table. const supabase = createClient( process.env.NEXT_PUBLIC_SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY! ); const { error: dbError } = await supabase .from('health_check') .select('id') .limit(1); if (dbError) throw new Error('database check failed'); // 2. Verify CMS API reachability (use any lightweight endpoint you have) const cmsRes = await fetch(`${process.env.STRAPI_API_URL}/api/global`, { headers: { Authorization: `Bearer ${process.env.STRAPI_API_TOKEN}` }, cache: 'no-store', }); if (!cmsRes.ok) throw new Error(`CMS check failed: HTTP ${cmsRes.status}`); return NextResponse.json( { status: 'healthy', latencyMs: Date.now() - start }, { status: 200 } ); } catch (err) { console.error('Health check failed:', err); // Log details server-side only return NextResponse.json( { status: 'degraded', latencyMs: Date.now() - start }, { status: 503 } ); } } 

A few cautions about how you use it:

• Don’t expose error details publicly. The example logs the real error server-side and returns only a generic status.
• Match check frequency to the platform. A frequent monitor, running every few minutes, gives fast alerts. On Supabase, a database query a few times a day is typically enough to avoid the inactivity pause. On Neon’s Free plan, checks that hit the database more often than every 5 minutes keep compute awake around the clock. At the smallest 0.25 CU size, that is roughly 180 CU-hours a month against a 100-hour allowance. Use a shallow frequent check for alerting and a deep database check on a slower schedule.
• Treat keep-alive pings as a stopgap. For a paying client’s production site, moving off a free tier is the durable fix. A heartbeat only masks the underlying risk.

Monitoring services such as Better Stack, Checkly and Cronitor can run these checks and alert your team.

4. Set Usage and Spend Alerts Where Platforms Offer Them

Where a provider offers usage or spend alerts, configure them. Neon’s documentation, for example, recommends setting a spending alert. Where it doesn’t, record the limit in your bill of materials and review usage on a schedule. A staged approach works well:

• 50% of quota: an informational Slack message. It may signal abnormal traffic or an unoptimized query.
• 75% of quota: a ticket for the account manager to review traffic or upgrade the tier before the billing cycle ends.
• 90% of quota: an urgent alert. Check whether the plan hard-stops or bills overages.

5. Use Defensive Caching to Protect Quotas

Many quota problems are self-inflicted. A Next.js site that fetches from Strapi or Sanity on every page view without caching can burn through an API allowance after a viral post or a crawler surge. Layer your caching:

• On-demand revalidation: Have the CMS send a webhook to a revalidation route only when an editor publishes, instead of refetching on every visit.
• Stale-while-revalidate: Serve cached responses from the CDN while refreshing in the background. This reduces how often visitors hit a slow or failing origin, though it can’t help if the cache is empty.
• Don’t cache errors as content: Make sure failed fetches throw or fall back to the last good data. Don’t return an empty array that ISR can store.
• Connection pooling: Route serverless function queries through a pooler so bursts don’t exhaust Postgres connection limits. Neon includes PgBouncer on every compute (add -pooler to the hostname). Supabase includes the Supavisor pooler.

Moving From Reactive Firefighting to Proactive Asset Governance

Serverless databases and headless CMS platforms have removed the work of patching Linux servers and scaling monolithic databases. Abstraction doesn’t remove responsibility, though. It spreads it across more vendors, billing cycles and usage meters, each with its own pause rules, quota behavior and suspension policy.

Agencies that give serverless tiers, inactivity windows and API quotas the same discipline they give domains and SSL certificates will catch problems earlier. In practice that means a documented bill of materials, shared billing ownership, deep health checks and usage reviews.

Originally published at https://instarenewal.com/blog/the-cold-start-renewal-tracking-headless-cms-and-serverless-database-tier