Taking a Bubble app to production means getting the app you already have through real traffic, a real monthly bill and a customer's security questionnaire, without rebuilding it. Keep the Bubble editor and pages, harden privacy rules, API keys and backend workflows where they live, and move only the logic or data that Bubble's limits or workload pricing make expensive into a small API you own. The thing that decides success on Bubble is privacy rules: every data type, field and API endpoint is only as protected as the rules someone wrote for it.
Bubble is one hosted, visual stack. Database, page editor, server-side logic and hosting live in one app, and Bubble operates every layer. Data protection comes from privacy rules, and the manual states that "Privacy rules are applied on the server." An app can also expose the Data API, which "allows other systems to search for, read, create, modify and delete data", and the Workflow API, which "accepts incoming requests to trigger workflows" (both from the Bubble API overview). Outbound calls go through the API Connector, and logic that must not run in the browser belongs in backend (API) workflows, which Bubble calls server-side workflows.
Billing is metered. Bubble charges in workload units (WU), which its pricing FAQ defines as a measure of the work Bubble does to power your application. The pricing page lists 50K WU a month on Free, 175K on Starter, 250K on Growth and 500K on Team, with Enterprise custom. Past the allowance, the same FAQ gives an overage rate of $0.30 per 1,000 WU. Free and Agency plans can't incur overages, and if you turn overages off on a paid plan, the app goes offline when it reaches its limit and Bubble sends an email. That toggle chooses between a surprise invoice and a surprise outage.
Portability is the other fixed fact. Bubble's page on application and data ownership says "there's no way of exporting your application as code," while user-created data can be exported as CSV files. So this runbook hardens in place; the full rebuild is covered in our Bubble to custom code migration runbook.
Production starts when strangers probe your URLs and APIs, WU climbs with every customer, and a security review asks who can read which records, where secrets live and how changes reach Live. Bubble ships controls for all three; the work is configuring them on purpose.
What it looks like. In the privacy rules screen, a data type with no rules carries the status label Publicly visible. The page that lists it checks that the user is logged in, but page conditions hide elements; they do not protect records. Data API access is "controlled by the privacy rules applied to that particular data type" (Data API docs), so treat any type without rules as readable by anyone who can reach a search or an endpoint.
How to detect it. List every type and its rules. With two test accounts in different organizations, sign in as the second and try to view, search and change the first one's records through pages and, if enabled, the Data API. Anything returned is a finding.
The fix. A default "everyone else" rule that hides all fields and blocks searching, then explicit rules keyed to ownership (the record's Creator is the current user, or the record's Company is the current user's Company) rather than to being logged in. Set field-level and file visibility too. This is Bubble's version of what OWASP lists as Broken Object Level Authorization.
What it looks like. Bubble's API Connector security guide notes that "API calls by default are routed through Bubble's server," and a parameter marked Private is stored and attached on the server instead of shipping in the app's code. The same guide carries a caveat: when an API's authentication is set to None or self-handled, or to the OAuth2 user-agent flow, values marked Private can still be exposed. Prototypes often pick None or self-handled and paste a secret into a header.
How to detect it. List every connector API with its authentication mode. Then use each feature in the live app with developer tools open and search scripts and network traffic for the start of each key.
The fix. Move every secret to an authentication mode that keeps it server-side, rotate any key that ever sat in a None or self-handled call, and swap broad keys for restricted keys with the narrowest scope each vendor allows.
What it looks like. Most WU growth traces back to a few patterns: searches that run on page load across a large type and then filter in the page, repeating groups that run a search per row, timer-driven page workflows that poll an external API from every open tab, recursive backend workflows that reschedule themselves, and nightly jobs that touch every user.
How to detect it. On a test branch, disable one suspect at a time, replay the same scripted session and compare WU consumed. Keep the top ten in a table.
The fix. Constrain searches instead of filtering afterward, paginate, store computed totals on a parent record, replace polling with inbound webhooks, and process only changed records.
What it looks like. Bubble's hard limits page says "Workflows that take more than 300 seconds (5 minutes) will time out," and caps scheduling a workflow on a list at 100K items unsorted or 50K sorted. An import or billing loop that fits today fails quietly as data grows. Also, changes to a workflow "will not be reflected in workflows that were already scheduled."
How to detect it. Inventory every backend workflow with its trigger, what it iterates over and the current row count of that type. Compare each with the limits.
The fix. Chunk long jobs into batches with a cursor saved on a job record, make every step safe to run twice (check a status field before charging, emailing or creating), and plan releases around scheduled runs: cancel and reschedule pending ones after a change, or let them drain first.
What it looks like. The Data API was switched on for every type so a Zap or a partner could read orders. Workflow API endpoints run unauthenticated and trust a user id in the body. Paging makes the exposure larger than it looks: the API returns 100 records by default and pages with cursor and limit, so a short loop can walk an entire table. The hard limits page also sets per-minute API request ceilings by plan (15K on Starter, 25K on Growth, 35K on Team), which an abusive client can spend on your behalf.
How to detect it. List which types the Data API exposes and which workflows the Workflow API exposes. Call each with no token, then with a low-privilege token.
The fix. Expose only the types and endpoints a named integration uses, require authentication on all of them, derive the acting user from the token rather than the payload, verify webhook signatures from payment providers before acting, and give each integration its own credential.
What it looks like. Bubble's version control is built on branches ("A branch is an independent iteration of your application"), and only Main or a hotfix branch can deploy to Live; the manual advises that "Main should be preserved solely for deployment." The Team plan lists 25 custom branches. In prototypes, people edit Main directly and nobody can say what the last release changed.
How to detect it. Ask who deployed last, what changed and how it was tested. If the answer is memory, it applies.
The fix. One branch per change, a second person who reviews privacy rule and workflow changes before merge, a release note per deploy, a scripted smoke test after each push to Live, and a hotfix branch reserved for emergencies.
What it looks like. A Company record holding a list field of every Order, or an activity log stored as a list on User. The hard limits page caps a single thing at 20 MB of data (files excluded), a list on a thing at 10,000 items, and sorted searches at 50,000 results.
How to detect it. Find every list field on a type that grows with usage and measure its longest list today.
The fix. Reverse the reference (each Order points to its Company) and search by constraint. Data that grows without bound, such as events, audit trails and ledger lines, is the first candidate to live in Postgres instead.
Pause feature work on Main. Export critical types as CSV, record privacy rules, API settings, connector calls and plugins, capture WU usage as a baseline, and open a hardening branch. Exit criteria: a dated snapshot a second engineer can work from.
Type by type: default-deny and ownership rules, then the two-account test. Fix connector authentication modes, rotate keys, narrow both APIs and verify webhook signatures. Exit criteria: the cross-tenant test suite returns nothing, no secret appears in the browser, and every exposed endpoint is on a written list with an owner.
Fix the ranked WU table from the top, reshape growth-bound list fields, and chunk any backend workflow near the five-minute limit. Exit criteria: the same scripted weekday session costs measurably less WU than the baseline, and no workflow is within reach of a hard limit at ten times today's data.
With no repository to unit test, test from outside: browser tests (Playwright or Cypress) for signup, login, checkout and the flows customers pay for, plus API tests on Workflow API endpoints. Run them before every merge and after every deploy, with the branch routine from failure mode 6. Exit criteria: no change reaches Live without a reviewed branch and a passing test run.
Write down the overage decision, alert on WU against the allowance, have critical workflows write failures to an error log type that pages on-call, and copy critical types to Postgres through the Data API on a schedule (which also moves reporting off Bubble). Write a runbook for hotfix rollbacks, key rotation and pausing a runaway workflow. Exit criteria: an alert has fired in a drill and someone followed the runbook to resolve it.
This is the hybrid: Bubble stays the front end and keeps its pages and simple workflows, while heavy logic and unbounded data move to a small API (Python or Node) backed by Postgres that you own. Bubble calls it through the API Connector with server-side auth, and it calls back through the Workflow API. Start with costly batch jobs, ledger and event tables, reporting, and calls that hold sensitive secrets. On the Postgres side, put access rules in the database with row-level security policies and data integrity in foreign keys and CHECK constraints. Exit criteria: each extracted piece has one system of record, its own tests, and a measurable drop in WU. If Bubble shrinks to a skin, plan the full exit with the migration runbook instead.
Our AI pod teams lean on coding assistants for grunt work: drafting privacy rule matrices, generating test cases, extraction boilerplate and log triage. A human still reviews each change, and tests must pass before Live.
Don't bring in a team if you are still searching for product-market fit, if the app serves a handful of internal users with no sensitive data, or if the only gap is a few privacy rules your builder can fix over a weekend. Use the checklist yourself and revisit later.
A Bubble hardening project needs a tech lead who reads privacy rules and workflows fluently, one to three senior engineers (a Bubble specialist and, for Phase 5, a Python or Node and Postgres engineer), part-time security engineering for the threat model and review, and QA automation if checkout and billing flows are complex. Many teams begin with a pod of 3 to 5 senior engineers (a tech lead plus engineers), and a full pod is about seven. Smaller rescues can start with a tech lead plus one or two engineers.
Ryz engineers on your team start from $7,000 per month (our published range is $7,000–$15,000 per engineer per month, mostly mid-level to senior), quoted per team. Project cost is team size × months × monthly rate. Once you say go, engineers can typically start in under two weeks. Ryz engineers work on your team, reporting to your leads. Scope your team with us.
Yes, within its documented limits. The pressure points are workload units, the five-minute backend workflow timeout, list and search caps, and plan-based API rate limits. Most struggling apps spend workload on a few inefficient searches and jobs, which can be fixed in place.
Usually not. The answers reviewers want live in privacy rules, API Connector settings, API exposure and branch discipline, all of which can be hardened in Bubble. Rewrite only if a buyer requires source code you own.
It depends on how many data types, privacy rules, backend workflows and connector calls exist, whether a security review has a deadline, and whether you also extract a backend. The first two weeks produce an audit, the first merged fixes and a plan for the rest.
Multiply the number of engineers by the months of work and by each engineer's monthly rate, which at Ryz begins at $7,000 and tops out around $15,000, quoted per team. Bubble plan fees are separate.
No. Bubble stays your front end, edited through reviewed branches. With an extracted backend, Bubble pages simply call the new API.
Questions we didn't answer? Email info@ryzlabs.com.
Thanks — your message has been sent. We’ll get back to you soon.
Something went wrong while sending your message. Please try again or email info@ryzlabs.com.