Application engineering / Bubble
Bubble app development.
Data, workflows and a deliberate platform choice.
Plan marketplaces, SaaS dashboards, booking tools and internal operations around the people, records and actions that matter. Visual editing does not remove access, payment, performance or migration decisions.
Discuss Bubble requirements โContents ยท Bubble
Design the product rules before assembling the screens.
A Bubble scope can combine pages, data types, user accounts, visual workflows and external integrations. Start with who does what to which record, then design the UI around those rules. A marketplace customer, vendor and administrator need different searches, actions and private fields; a dashboard that hides a button is not the same as a permitted backend operation.
Map forms, lists, states and error recovery before choosing a template. Identify booking/inventory consistency, payment reconciliation, sensitive files and external services early. Visual development may reduce some implementation work, but it does not remove schema design, QA, operational responsibility or custom code when the product needs it.
- MVPs: a bounded user journey with real acceptance criteria and a path to change.
- Marketplaces/booking: participants, inventory, orders, fees, disputes and settlement states.
- SaaS dashboards/portals: tenant membership, subscriptions, access and administration.
- Internal tools/CRM: import, assignment, approval, audit and source-of-truth ownership.
The original describes template-based and custom work. Template counts, staffing, deployments, fixed delivery windows and guaranteed outcomes are not independently established here. Inspect the actual reusable base and its dependencies before treating it as available or suitable.
App control, custom code and platform portability are different.
Agree the intended owner account, collaborator roles, billing responsibility, app transfer route, data exports, workflow map and custom plugin/script repository. Name who controls provider accounts, domains and ongoing updates. A collaborator invitation is access, not proof of contractual IP assignment or complete handover.
Separate custom work from Bubble infrastructure, marketplace templates/plugins, fonts/assets and external-service licences. Confirm modification, transfer, white-label and maintenance rights in writing. Do not promise that every dependency becomes owned source code or that another builder can take over without documentation and access checks.
The source repeatedly says Bubble cannot export code. Current official help now describes a beta-assisted process that reads app structure and recreates it in a chosen code stack. It explicitly does not guarantee perfect fidelity or a finished application. That is different from downloading the existing Bubble runtime as a self-hostable, equivalent codebase. Plan and test a rebuild rather than repeat either absolute.
Compare the same product on Bubble, a site builder and custom code.
Bubble, Webflow and a custom stack organise design, data, logic and operation differently. Use a representative user journey and workload rather than rank them as automatically fastest, cheapest or most scalable. Webflow or Wix may fit the public content site while another system owns authenticated application rules.
- Build/edit: forms, reusable screens, user roles, editorial needs and extension code.
- Backend/data: schema, queries, external sources, tenant access and transaction constraints.
- Cost: scoped build work, platform plan, workload, plugins/services and maintenance.
- Customisation: available elements/APIs, supported mobile features and integration tests.
- Operation/exit: hosting control, debugging, backup, user migration and receiving-team skills.
Evaluate Webflow and Wix for content/site tasks; evaluate custom web development when infrastructure, complex concurrency, processing or portability requirements call for it. These are fit questions, not universal platform ceilings or cost rankings.
Seven decisions before a Bubble engagement.
What is a sensible first product?
Select a complete but bounded journey: sign in, find or create a record, perform the core action, handle failure and administer the result. Forms, lists, portals and approval flows are useful candidates. Prototype the hardest data, access or integration requirement, not only a polished homepage.
What changes as usage grows?
Measure representative query shapes, records, concurrency, repeated workflows and external limits. A user count alone does not predict workload or latency. Separate the cost of page/data loading, conditions, scheduling and provider calls. Agree thresholds for investigation and a recovery route rather than promise unlimited scaling.
Can this become native mobile?
Bubble announced native mobile general availability on 12 November 2026. Do not repeat the source implication that the whole mobile editor is still beta. Web and native can share the backend/data, but native UI elements and plugin compatibility need separate checks. Validate device permissions, offline expectations, location/camera tasks and release requirements on actual devices.
How are gaps filled?
Compare maintained marketplace plugins, the API Connector, custom JavaScript and server actions with the exact requirement. Inventory licences, API versions, rate limits, support and failure behaviour. A plugin listing or a successful editor preview is not proof of a maintained, secure integration.
When should the platform change?
Use measured limitations, infrastructure requirements and total ongoing cost. First compare targeted query/workflow improvements with a different backend or full rebuild. Moving to code requires user/access, data/files, jobs, integrations and operating responsibility, even with current beta recreation tools.
Bubble, site builder or a combined system?
Separate public content and editing from logged-in records and mutations. A marketing site may link to a Bubble app, but cross-domain identity, cookies, analytics and data ownership require explicit design. Avoid duplicate customer records and conflicting subscription states across the two.
Specialist or delivery team, and what budget?
Match data/privacy, visual design, workflows, payments, APIs, QA and operation skills to scope. Request an itemised current quote, dependencies, acceptance and named handover responsibilities. Builder type alone does not prove capability; source price ranges, timelines and team counts are not current offers.
Separate data visibility from permission to perform an action.
Model records and tenant boundaries
Define data types, relationships, status transitions and source-of-truth identifiers. A marketplace may need User, Organisation, Membership, Vendor, Product, Order and PaymentEvent records. Decide which fields are public, personal, tenant-private or administrative. Custom states are temporary client state; option sets should hold non-secret fixed choices, not credentials or private business records.
Privacy rules are not a universal write firewall
Official documentation distinguishes fields/search/file visibility and auto-binding from workflow actions. A Make changes action is not automatically blocked by a field visibility or auto-binding restriction. Workflow API create/modify/delete permissions are not the Data API toggles. Validate actor, tenant, role, target record and allowed state in the workflow/action conditions.
Hiding elements, disabling buttons or filtering a downloaded list is not server-side protection. Private files need the relevant upload and privacy configuration. Current search privacy modes also control allowed constraints: hidden field values can otherwise leak by inference. Test intended field/constraint permissions and representative searches before changing a mode.
API and administrative execution
Select endpoint authentication deliberately. An authenticated user is not automatically entitled to change every record. Public webhooks need verified sender/transaction evidence before mutation. Ignore privacy rules is a privileged bypass; database triggers run with administrative access, so their actions and expressions do not gain tenant safety from ordinary privacy rules.
Write negative tests: anonymous visitor, wrong tenant, removed membership, direct record reference, guessed endpoint, altered price/status and restricted file URL. Test read and mutation separately. No compliance, penetration-test result or secure running app is claimed here.
A paid-status trigger is not an exactly-once payout.
The source illustrates an Order transition to paid, commission calculation, vendor balance increment, a transaction record and notification. Its before/after condition narrows when the trigger runs. It does not verify the payment provider, make a balance increment atomic, deduplicate concurrent retries or prove that money reached a bank account.
- Verify the provider event and map it to the intended payment, order, currency, amount and account.
- Track provider event/object identity and supported processing state; design duplicate and out-of-order handling.
- Separate order payment, fee calculation, internal payable, transfer and bank payout states.
- Reconcile partial failure, refund, dispute, reversal and failed transfer/payout.
- Use a supported transactional/idempotent backend where the required consistency cannot be established in the selected workflow.
- Notify from confirmed state without treating a scheduled email as financial completion.
Stripe documents duplicate and unordered webhook deliveries and requires signature verification against the raw payload. A chosen Bubble plugin or verification service must demonstrate the supported verification route; a public endpoint with an Only when paid condition is insufficient. Do not invent a complete secure integration from this planning example.
Connect event scope depends on charge type and account ownership. Verify seller onboarding, country/currency eligibility, fee/refund responsibility and payout capability for the actual business before promising multi-currency settlement. No commission percentage, escrow status, regulatory approval or payment configuration is established here.
An API Connector Private checkbox needs the right configuration.
Current Bubble help warns that Private values can be exposed when a collection uses None or self-handled or OAuth2 User-Agent Flow authentication. The checkbox alone is not a server-secret guarantee. Use the documented secure collection authentication pattern and verify the resulting published app does not expose credentials; remove sensitive initialization/test values.
Most Connector calls route through Bubble servers, but descriptions of calls can reach the browser. Eligible public data calls can be configured client-side. Keep secrets out of page elements, option sets, states, labels, URLs and default fields. Use least-privilege provider credentials and separate development/live configuration, stored through an appropriate secure route.
Document data versus action calls, schemas, validation, pagination, timeouts, rate limits and retry policy. Repeated actions must not duplicate orders, subscriptions or emails. External data returned to a page needs its own visibility boundary. A server-mediated request does not automatically authorise the requested business operation.
For custom plugins, separate element/client code from server actions, validate inputs and package dependencies with maintenance ownership. Check native mobile support separately from web support. A source claim about vetting plugins is a proposed acceptance task, not evidence that every dependency has been audited.
Measure real operations, including conditions and scheduling.
Bubble workload represents server work, not a fixed cost per workflow or user. The inspected guidance includes API scheduling, conditions, action processing and database-trigger condition checks. Moving work to the backend can avoid blocking a page but does not make it free or prove that it will finish in a particular order.
Constrain searches to needed records, paginate lists and inspect unnecessary data refreshes. Do not assume every filtered expression has the same execution path. Measure actual queries and server traffic. Compare development tests with representative live-version metrics using authorised test data; never benchmark by making uncontrolled changes to customer records.
Numbered actions do not always finish sequentially across browser/server boundaries. Use documented results from earlier steps and supported sequencing rather than a fresh search that may lag. Scheduled workflows and parallel list processing need explicit consistency, retry and cancellation design.
Development and Live have separate databases. Version-control savepoints snapshot a branch; they are not a substitute for data/files backups or reversal of external payments. Confirm plan-specific branches, history and restore coverage. Document deployment, backward compatibility, recovery and the effect on already scheduled jobs.
Three ways to scope work without mixing deliverables.
- Catalogue platform beside Bubble: identify the actual stack and every integration boundary.
- Custom Bubble build: records, privacy, workflows, pages, plugins/APIs and acceptance around the brief.
- Continuing development: prioritised changes, plugin/API maintenance, workload review and incidents under written terms.
Agree review cadence, milestones, capacity, billing, cancellations and scope changes. No assigned specialist count, automatic weekly output, fixed-price catalogue inclusion or default free support is promised. Keep ownership/account choices visible throughout the work.
Six acceptance areas for the application and its operation.
- Review: data model, privacy/constraint rules, workflow conditions, plugins and privileged paths.
- Task QA: role/tenant negative tests, device/keyboard access, empty/error states and interrupted journeys.
- Performance: representative live-version metrics, workload and third-party call limits.
- Handover: owner access, schema/workflow map, custom-code history, dependency inventory and secure credential route.
- Release: authorised plan/domain/payment destinations, environment separation and tested recovery.
- Operation: workflow failures, event reconciliation, logs, workload alerts, ownership and agreed support.
Record test evidence and unresolved exceptions. A no-code stack, security dashboard or six-part checklist is not independent certification, proof of no vulnerabilities or a commitment to particular uptime. Activate monitoring or data disclosure only within its agreed scope.
Select dependencies by responsibility, not a default bundle.
- Bubble: data types, visual editor, responsive web UI and selected native app features.
- Workflows/repeating groups: actions, conditions and paged web presentation.
- Option sets/custom states: non-secret fixed choices and transient UI state.
- API Connector/plugins/JavaScript: selected integrations with explicit server/client boundaries.
- Stripe: supported payments, subscriptions or Connect flow with verified events.
- Supabase or another backend: separately designed authentication, database or realtime boundary.
- Airtable/Zapier: optional catalogue/automation integrations with identity and sync rules.
- SendGrid or another mail provider: approved delivery, templates and failure handling.
- S3 or another storage service: private/public files, access and lifecycle rules.
- Cloudflare/domain provider: authorize and verify the actual DNS/TLS configuration separately from application changes.
- Git: custom plugin/script source, not a complete version of Bubble app data and runtime.
No listed provider is connected or bought here. External systems add security, retention, billing and maintenance work; they do not automatically remove Bubble workload or platform dependencies.
From product brief to an operable handover.
- Brief: users, core task, data sensitivity, target devices, evidence and confidentiality.
- Scope: data/rules, integration/plan fit, acceptance, ownership and dependencies.
- Build/demo: isolated environment, representative records and the difficult end-to-end workflow.
- QA: roles/tenants, transaction recovery, workload, devices and backup/restore.
- Release/handover: owner-approved changes, reconciliation, docs and receiving-team operation.
Readiness of content, provider onboarding, app-store accounts and review are dependencies. Agree current milestones instead of promising a first preview, fixed launch day, instant NDA or guaranteed provider approval. Obtain the account owner's approval before a Bubble release, DNS change or payment switch.
Separate build effort from platform and service usage.
- User roles, tenants, access conditions and administrative workflows.
- Data model, searches, imports, files and migration/reconciliation.
- Payments, subscriptions, seller onboarding, refunds and provider webhooks.
- Responsive/native interfaces, device permissions and store submission requirements.
- Plugin/API work, workload profiling, QA, recovery and documentation.
- Bubble plan/workload, storage, paid plugins, external providers and continuing work.
Use expected operations and current plan terms to size a budget. A catalogue price does not price a custom Bubble build. Source starting prices, retainers, cancellation periods and delivery/support durations are not current commitments. Request a written itemised scope with exclusions and operating costs.
A recreated codebase still needs a migration and operating plan.
Inventory data types/IDs, option sets, pages, workflows, privacy rules, files, scheduled jobs, plugins and provider connections. Current beta-assisted recreation is a starting point, not proof of faithful runtime behaviour. Compare a representative part on the target stack before committing to a complete exit.
Export the intended Live records, not merely Development samples. Editor exports work per data type; larger migrations can use the Data API with pagination and controlled access. Admin API tokens bypass privacy rules and must remain secret. Exports contain file URLs, not assurance that every file has moved or will remain accessible after deletion.
Preserve IDs/references and reconcile counts, relationships, currencies, timestamps and private-file access. Recreate permissions and workflow conditions in the target backend, with tests for endpoints/downloads as well as screens. Establish secure login migration: Bubble does not export passwords; reset or a deliberately supported identity bridge needs its own plan.
Handle new writes during parallel operation, outstanding payments, scheduled work and external webhook/OAuth destinations. Rehearse final sync, approved cutover and rollback. Keep the old system until data, files, users and integrations are verified.
An illustrative marketplace, not a claimed client launch.
Consider a founder needing vendor onboarding, a marketplace catalogue, inventory sync, Stripe Connect, multi-currency presentation and an admin dashboard. The source names Airtable as a secondary catalogue source and JavaScript for integration. Preserve those as requirements, not proof of a delivered deployment, launch date or vendor/user growth.
- Model customer, vendor and staff roles with tenant-specific record/action tests.
- Choose which system owns products, stock, price and order state; define conflict/retry behaviour.
- Verify currency display separately from charging, transfer and payout eligibility.
- Design a provider-verified payment event ledger and reconciliation, not only a paid-status trigger.
- Test vendor onboarding failure, stale inventory, repeated events, partial refund and payout failure.
- Deliver workflow/privacy maps, custom-code history, dependency terms and recovery notes.
The source gives delivery, vendor onboarding, user and rating outcomes. None is independently established here. Treat scale as a workload and acceptance scenario, not a client result or a promise that every marketplace can remain entirely no-code.
Bubble delivery review and handover.
Request permitted app access, the actual Bubble editor/dependency boundary, role tests, workload records and handover examples. Coaching, creator and property-platform testimonials on other stacks do not demonstrate a Bubble implementation. A screenshot, project count or agency badge is not a payment/access test.
Agree the implementation boundary, deliverables and acceptance checks in the project scope. Include the source and configuration to be handed over, third-party dependencies, account ownership and the receiving owner's installation and operating walkthrough. Review the selected work at the agreed milestones, with unresolved items recorded before release.
Translate sector labels into data and workflow duties.
- Healthcare/life sciences: minimum necessary data, consent/access, approved content and independent compliance review.
- Telemedicine: provider/appointment workflows distinct from secure clinical delivery.
- Fintech: customer records and authoritative onboarding/payment/reporting systems.
- Retail: catalogue, inventory, orders, refund and settlement ownership.
- Media: libraries, subscriptions and permitted content access.
- Creators: profiles, membership, moderation and recurring entitlement.
- Transportation: booking, dispatch, location consent and current operational status.
- Food/beverage: branch menus, order states, fulfilment and provider reconciliation.
A sector page or Bubble plan does not establish regulatory approval, data residency, offline capability or an implemented transaction engine. Agree the jurisdiction, data class, provider terms and acceptance evidence.
Questions to settle before Bubble work.
Can another builder take over an existing app?
Audit collaborator/owner access, schema, privacy, workflow conditions, privileged triggers, exposed secrets, plugin/API health and workload before pricing changes. Provide an attributable fix list and dependency inventory. Never infer ownership merely from an editor login.
What should the admin panel include?
Define permitted user management, moderation, order/booking changes, payout review, configuration and reporting for each staff role. Restrict backend actions independently of navigation. An admin label does not authorise unrestricted data export or payment operation.
Do mobile updates always avoid store review?
No. OTA updates cover eligible changes on the latest built version; new native configuration and larger changes require a new build and store process. Older supported builds need deliberate compatibility and deprecation management. Check the actual change rather than promise every edit instantly reaches every user.
Does the app account settle every ownership question?
Owner-controlled billing/access helps continuity, but licences, custom-code rights, third-party accounts and data-processing duties need written terms. No source IP or NDA promise substitutes for the actual agreement.
Who handles bugs and ongoing work?
Define incident ownership, delivered-scope defects, new features, plugin/API changes, monitoring and response coverage. A source free-support window or cancellation notice is not an agreed service term.
Primary references for the technical checks.
Official documentation and the dated native-mobile announcement checked on 17 November 2026. Beta-assisted code recreation is not a completed faithful export; current app/plan/plugin and provider terms still need implementation-level verification.
- API Connector security | Bubble Docs โ manual.bubble.io
- Exporting your Bubble app | Bubble Docs โ manual.bubble.io
- Workflow API privacy rules | Bubble Docs โ manual.bubble.io
- Protecting data with privacy rules | Bubble Docs โ manual.bubble.io
- The Workflow API | Bubble Docs โ manual.bubble.io
- Actions | Bubble Docs โ manual.bubble.io
- Database trigger event | Bubble Docs โ manual.bubble.io
- Native Mobile Out of Beta, Faster, & More Reliable | Bubble โ bubble.io (2026-11-12)
- Backend workflows | Bubble Docs โ manual.bubble.io
- Native mobile app | Bubble Docs โ manual.bubble.io
- Native mobile vs. web development | Bubble Docs โ manual.bubble.io
- Version control | Bubble Docs โ manual.bubble.io
- The API Connector | Bubble Docs โ manual.bubble.io
- Receive Stripe events in your webhook endpoint | Stripe Documentation โ docs.stripe.com
- Connect webhooks | Stripe Documentation โ docs.stripe.com
Bring the workflow, record and access problem.
Describe the users, core task, sensitive data, payment/integration needs and target devices. Agree platform fit, access, evidence, migration and handover before implementation.
Discuss your Bubble scope โ