You are about to launch. Maybe it is Product Hunt, a newsletter mention, a TikTok or a press piece. Your app was built with Lovable, Bolt, Cursor or Replit. It works fine for you and three friends. Now hundreds of people may arrive within minutes, and you wonder if it will fall over. Vendor facts below come from each vendor's own docs, checked in November 2026.
Short answer: Most AI-built apps do not break because the host is too small. They break at one weak spot: a database that runs out of connections, a slow function that times out, a free email limit, or a paid service that stops answering. Find those spots before launch. Serve as much as you can as static pages. Protect anything that costs money. Run a small test on a copy. Then watch the right dashboards on launch day.
1. What usually breaks first
A spike is not one big problem. It is many small limits that all get hit at the same time. These are the usual suspects, roughly in the order they show up:
- Database connections. Every visitor can cause a new connection to your database. A database accepts only so many at once. When it is full, new requests fail.
- Slow queries. A query that takes half a second for one user is fine. For two hundred users at once, the database queues up and everything gets slow.
- Function timeouts. Server code on Netlify or Vercel has a time limit. If the database is slow, the function runs out of time before it can answer.
- Third-party limits. Payment, maps, analytics or any other service you call may limit how many requests you can send per minute.
- Email limits. Sign-up emails, magic links and password resets all go through an email provider. Providers cap how many emails you can send.
- Images. A hero image of several megabytes, times hundreds of visitors, is slow for everyone and can cost bandwidth.
The good news: you can check each of these in an afternoon. The rest of this post goes through them.
2. Supabase: connections and the sign-up email limit
Connections and the pooler
Supabase's connection management page says: "Every Compute Add-On has a pre-configured direct connection count and pool size." So the number of connections depends on the size of your database. The compute and disk page lists them. Today it shows, for example, Nano (free) and Micro at 60 database connections and 200 pooler clients, and Small at 90 and 400. The page also says the database values "are recommended and can be customized". Check your own size in the dashboard, because these numbers can change.
What is the pooler? It is a middle layer. Many short connections from your app go into the pooler. The pooler talks to the database with a smaller number of real connections. That is why the pooler allows more clients than the database allows direct connections.
When should you use it? The connecting to Postgres page says to use the shared pooler in transaction mode "for serverless and edge functions, which open many short-lived connections." For direct connections it says "Use it for persistent backends, such as virtual machines (VMs) and long-running containers." A Netlify or Vercel function is serverless. So if your function connects to the database itself, check that it uses the pooler connection string, not the direct one.
The same page notes that transaction mode does not support prepared statements, so your database library may need a setting turned off. Ask your AI tool: "Which connection string does this function use, direct or pooler? Show me the line." If your app only uses the Supabase JavaScript client in the browser, this matters less. It matters most when you have your own server code that connects straight to Postgres.
One more note from the connection management page: the pool size "applies per database user (role), not as a single total for the whole project." Do not assume one big shared number.
The Auth email limit is a launch blocker
This one catches many founders. Supabase's Auth rate limits page lists the built-in email limit as "2 emails per hour with the built-in email provider." It adds: "You can configure this limit when you use custom SMTP or the Send Email hook."
Think about what that means. If your sign-up flow sends a confirmation email, and fifty people sign up in ten minutes, almost nobody gets their email. They see "check your inbox" and nothing arrives. That looks like a broken app. Before launch, set up your own email provider (custom SMTP) and send a real test sign-up.
The same page lists other limits that apply to a busy launch. Sign-up, sign-in and OTP requests from one IP address default to "30 requests per 5 minutes". A new OTP or magic link for the same user needs a "60 seconds window" between requests. These protect you from abuse, but a whole office on one network can hit the IP limit. For more on login, see hardening login in an AI-built app.
3. Netlify and Vercel functions: time limits and what users see
Functions are your server code. They start when a request comes in and must finish in time.
Netlify. The functions configuration page lists a "Synchronous execution limit" of 60 seconds, a "Scheduled execution limit" of 30 seconds and a "Background execution limit" of 15 minutes. It marks all three as not configurable. It also lists a buffered request or response payload of 6 MB. On concurrency, the functions overview says the infrastructure "automatically scales according to the volume of traffic to your site." The docs checked for this post do not give a fixed concurrency number there.
Vercel. The functions limits page says "If a Vercel Function doesn't complete within the duration, a 504 error code (FUNCTION_INVOCATION_TIMEOUT) is returned." Today the table (for Fluid compute, which the docs say is on by default for new projects) shows a default and maximum of 300 seconds on the Hobby plan, and a default of 300 seconds with a maximum of 800 seconds on Pro. For concurrency it says functions auto-scale, with an upper limit that depends on the plan.
Notice the point: both platforms scale the function itself. The function is rarely the bottleneck. The things the function waits for are: the database, an email service, a payment service. If those are slow, the function sits and waits until the clock runs out.
What does a timeout look like to a user? A spinner that never stops, then a blank screen or a "something went wrong" message. On Vercel the status is 504. In the browser it often looks like a failed request in the Network tab. Users do not say "the function timed out". They say "your app is broken" and leave. So a long wait is a real outage, even if the server is technically fine.
4. Serve what you can as static pages
A static page is a ready-made file. The host can hand it out to thousands of people without running any code and without touching your database. That is the cheapest and safest way to survive a spike. Your landing page, pricing page, blog and docs should be static wherever possible.
Netlify's caching overview says: "Static asset responses on Netlify are cached on Netlify's global edge nodes and automatically invalidated whenever a deploy changes the content." Vercel's CDN cache page says: "Static files are automatically cached on Vercel's global network for the lifetime of the deployment after the first request."
The catch is that many AI-built apps render everything in the visitor's browser. The page is an empty shell, then it calls your database for content. Every visitor means database calls. Prerendering turns the public pages into real files. See prerendering a Lovable or Bolt app. It helps Google too.
Two more quick wins:
- Images. Compress them and use sensible sizes. See fixing a slow AI-built app.
- Slow queries. The same post covers missing indexes and queries that load too much. Fix the slowest ones on your home page and sign-up path first.
5. Protect anything paid or limited
A launch brings real users, and it also brings bots and curious people who click a button forty times. Anything that costs money or has a limit needs a guard.
- Rate limit your own functions. A function that sends an email, creates a record or calls a paid service should refuse too many requests from one person or one IP address.
- Protect sign-up. Fake sign-ups burn through your email limit and fill your database. See stopping fake bot sign-ups.
- Set spend caps and alerts. Put a budget alert on your host, your database and any paid API. A spike that goes well should not become a surprise bill. See avoiding a surprise bill on Vercel, Netlify, Supabase or Firebase.
- Know the third-party limits. Open the pricing or limits page of each service your app calls. Write down the per-minute or per-month limit and what happens when you pass it.
6. Run a small load test before launch
A load test sends many fake visitors to your app at the same time and shows you where it slows down or fails. You do not need a huge test. You need a small one that finds the first weak spot.
Test a copy, not production. Use a staging copy with its own test database, so that fake sign-ups do not fill your real data and fake emails do not reach real people. See making a staging copy with a test database.
One free tool is k6. Grafana's k6 docs describe it as "an open-source, developer-friendly, and extensible performance testing tool." Its guide "Run your first k6 test" covers how to install the k6 CLI, run a first test and read the results in the terminal. A simple first test: ask for your home page and your main API call with 20 virtual users for one minute, then slowly raise the number. Watch for error rates and slow response times.
Check your host's rules first. Netlify's acceptable use policy does not mention load testing by name. It does prohibit actions that "create an undue burden on the website or the networks or services connected to the website", and it forbids benchmark tests of Netlify's own services "without express permission." So keep your test small and short, hit only your own staging site, and ask the host's support if you plan anything big. For Vercel, Supabase and any third-party service your app calls, read their terms and ask before you send heavy traffic. Never point a load test at someone else's API.
7. Launch-day watch list
- Uptime check and error alerts. You should hear about a problem before your users tell you. See uptime monitoring and error alerts.
- Database dashboard. Watch the number of connections and the slow queries. Keep it open in a tab.
- Function dashboard. Watch the error count and the run time of your functions in the Netlify or Vercel dashboard.
- Email provider dashboard. Watch for bounces and for hitting your daily send limit.
- A rollback plan. Know which deploy was the last good one and how to go back to it in one click. See rolling back a broken deploy. Do not push new changes during the rush unless you have to.
- A simple "we're busy" message. Prepare a short banner or a status page: "We are getting a lot of visitors. Some things may be slow. Please try again in a few minutes." It costs nothing, and people are far kinder when they know you are aware.
8. Checklist
- I know my Supabase compute size and its connection limits.
- Server functions that talk to Postgres use the pooler connection string.
- Custom SMTP is set up, and a real sign-up email arrived in a real inbox.
- I know the Auth limits for sign-up, OTP and magic links.
- I know the function time limit on my host, and my slowest function finishes well under it.
- Public pages are prerendered or static, so visitors do not hit the database.
- Images are compressed and the slowest queries are fixed.
- Sign-up and expensive functions have rate limits.
- Spend caps and budget alerts are on for host, database and paid APIs.
- I ran a small load test on a staging copy and read my host's terms first.
- Uptime check and error alerts are on, and they reach my phone.
- Dashboards for database and functions are open on launch day.
- I know how to roll back, and a "we're busy" message is ready.
Want this fixed for you?
I finish and fix apps built with Lovable, Bolt, Cursor or Replit, including getting them ready for a launch-day rush. Send me the details and I'll reply within 24 hours.