base44 Guide: Vibe Coding Platform, Workflows, and Limits

Base44 is a browser-based app builder that turns a plain-English request into a hosted web application. It supplies the database, user accounts, server functions, and deployment within one managed service. That bundled setup is why the platform attracts beginners and small teams comparing prompt-to-app tools.

The important questions concern its two credit balances and the code handoff paths that affect a long-lived project. This page was checked against official Base44 and Wix pages on July 28, 2026.

What Base44 Is and Who It's For

Base44 generates a live web application from a plain-English description. Its developer documentation lists React and Vite for the screens, a managed record database, user authentication, server functions, and realtime updates.

Base44 handles the service setup that often stops a non-technical builder after the first polished screen. The generated app can use data, login flows, email, files, and analytics without requiring a separate account for each service.

Common project shapes include dashboards, internal tools, CRMs, schedulers, and small marketplaces. These apps fit the platform's record-based data model and managed services better than a system with unusual infrastructure or a large existing backend.

Wix acquired Base44 on June 18, 2025 and said it would remain a distinct product.

A downstream developer workflow needs more planning. Builder and higher can keep app code in two-way GitHub sync, while the Base44 CLI can copy code and backend resource definitions into a separate project.

The Managed Stack

The generation loop works as a conversation. Describe the application, review the result, and use follow-up instructions for behavior changes. The Code tab also exposes generated files for manual edits, a split preview, and direct debugging.

Base44's managed services cover data storage, user authentication, email delivery, file storage, analytics, and hosting. The builder can generate a data model, access rules, and UI without asking you to provision each service separately.

Review those access rules with separate user accounts before launch. A generated login screen does not prove that every user can read only the records they are authorized to see.

Builder and higher support two-way GitHub sync. Changes merged into the repository's main branch sync back to Base44, and publishing remains a separate action.

Base44 documents several constraints for its GitHub connection. Sync starts on Builder, the supported base branch is named main, and Version History states from before the connection cannot be restored through the repository.

From Prompt to Maintained Project

A bounded first build gives the cleanest test of Base44. Start with one user role, one core record type, and one action that changes data. A client tracker could begin with contacts and a status update before adding email, files, or AI features.

Write the prompt as an acceptance check instead of a product wish list. State who signs in, which records that person may read, and what success looks like after the main action. This gives you a result that can be tested with two separate accounts.

• Create one owner account and one restricted test account.
• Try direct URLs for records the restricted account should never read.
• Inspect failed requests in the Activity Monitor before publishing.
• Connect GitHub before broad visual or data-model changes.

The code handoff has two different meanings. GitHub sync keeps a Base44 app connected to a repository, while base44 eject creates an independent local project with a new app ID.

The eject documentation says schemas move and existing records stay behind, leaving the new database empty. A handoff plan therefore needs a data export, secret inventory, service map, and a test run outside the original workspace.

Local development has its own service boundary to check. Base44's CLI runs functions, entities, media, and email/password authentication locally, while OAuth and core integrations may still forward to the deployed service. Read those warnings before treating a local preview as an isolated copy.

Data, Access, and Service Boundaries

Base44 entities are records in its managed NoSQL database. The schema defines fields and relationships, while access rules decide which signed-in users can read or change each record. Treat those rules as application logic, even when the builder created them from a prompt.

A useful review begins with an access matrix. Put each user role in one column and the allowed read, create, update, and delete actions in the others. Translate every row into a test using accounts with different roles and different record ownership.

Role	Record	Allowed action	Denied action
Member	Own contact	Read and update	Delete another user's
Manager	Team contact	Read and assign	Change workspace owner

Test the rule through both the interface and a direct record URL. The interface may hide a control correctly while the backend still accepts an unauthorized request. Repeat the test after changing an entity, role, or generated server function.

Integration credits introduce a second production boundary. An app may continue loading after its email, file, image, or AI allowance is exhausted. Identify the user-facing result for each failed integration and make sure a retry cannot create duplicate records or messages.

Keep an inventory of services that remain attached to Base44. Include authentication methods, entities, files, email senders, scheduled work, custom domains, and every secret used by a function. The inventory turns an abstract portability concern into a migration checklist.

The Activity Monitor is useful evidence during review because it shows live application requests and errors. Capture the failed authorization and exhausted-credit cases there before publishing, then record which account, action, and entity produced each result.

Server functions need the same boundary checks as screens and entity rules. Review which values arrive from the browser, which user identity the function trusts, and which service credential it can reach. Trigger the function with missing, duplicate, and unauthorized input, then confirm that errors reveal no secrets or private records.

Backups and Local Testing

If a prompt breaks a working app, do not spend more credits asking the chat to undo itself. Open Version History, preview the last working version, and use Revert to this version. You can also use the Revert icon under the prompt that caused the problem.

After restoring, test the broken path again. Narrow the next request to one page, entity, or function and state what must stay unchanged. Stop prompting when two focused attempts fail or when the issue involves access rules, payments, or data loss; keep the restored version live while a qualified reviewer checks that path.

Backups also belong in the launch plan. Decide how frequently important records and files need an independent copy, who can restore them, and how long restoration may take. Run one recovery exercise before users depend on the app, because an export file has little value until another system can read it.

The local emulator deserves its own test record. Base44 documents local support for entities, functions, media, and email/password authentication, while OAuth and some core integrations may contact the deployed app. Mark each test as local, forwarded, or unavailable so a passing local run does not imply complete isolation.

Keep production credentials out of that exercise. Use separate service accounts and disposable data for any integration that must leave the machine, then inspect the deployed Activity Monitor for unexpected calls. This matters most when a function sends email, writes files, or invokes an external model.

After every schema change, repeat the two-account access test and a sample export. The combination catches permissions that drifted during regeneration and records that no longer match the planned handoff format.

Pricing

Base44's official pricing article lists the figures below.

Plan	Price	Message credits	Integration credits
Free	$0	25 monthly, capped at 5 daily	100 monthly
Starter	$20/mo, or $16/mo annual	100 monthly	2,000 monthly
Builder	$50/mo, or $40/mo annual	250 monthly	10,000 monthly
Pro	$100/mo, or $80/mo annual	500 monthly	20,000 monthly
Elite	$200/mo, or $160/mo annual	1,200 monthly	50,000 monthly

Starter includes unlimited apps and in-app code editing. Builder is the first tier with backend functions, custom domains, GitHub integration, and model selection. Compare this public table with the plan shown in the workspace before subscribing.

Message credits pay for AI prompts while you build, while integration credits pay for live actions such as email, file operations, image generation, and LLM calls. Credit use varies by the work performed, and paid balances reset each billing cycle without rolling over. Check both balances before a public launch.

Compared with Lovable, Base44 splits building messages from live integration activity. Lovable Pro costs $25 monthly, while Base44 Builder costs $50 monthly or $40 monthly on annual billing. Base44's running backend and data remain managed services even when GitHub sync exposes the app code.

Where Base44 Works Well

The unified architecture avoids separate initial setup for authentication, data, email, files, analytics, and hosting. A bounded internal tool can therefore reach a shareable URL before those services need individual provider accounts and deployment work.

The low-setup experience fits the target audience. A beginner can create a record-based application without first choosing a database provider, configuring authentication, or writing a deployment pipeline.

A solo founder can put a clickable prototype in front of an early tester without first assembling a database and deployment stack. The result still needs access testing, yet the initial service setup is already present.

The Code tab exposes React and Vite files, GitHub sync accepts local edits, and the CLI can create a separate project. Each route still depends on Base44 services unless you replace those services yourself.

Where Base44 Falls Short

The managed-backend boundary matters once the app stores valuable records. GitHub sync provides an ongoing code workflow, while eject copies schemas, functions, configuration, and frontend code into a separate Base44 project.

The production database stays on the original Base44 app. Moving to another backend provider requires a data export and service migration alongside the code handoff.

The credit system has two separate failure points. Free users receive 25 monthly message credits with a five-credit daily cap, and every plan has a separate integration allowance for live app actions. Track both in the workspace usage screen and set a launch budget from expected email, file, image, and AI activity.

GitHub sync and eject expose frontend and backend resource files. The hosted database and platform services remain Base44 runtime concerns, so developers should inventory those dependencies before any handoff.

Base44 documents a managed NoSQL database, entity schemas, and row-level access rules. A brief that needs several tenants, linked record types, or unusual infrastructure should be mapped as entities and permissions before any build. The documentation establishes the available tools without measuring how well the generator will implement a given design.

Base44 vs Lovable

Lovable and Base44 both target a builder who wants a managed full-stack start. Lovable can connect an external Supabase project, while Base44 supplies its own managed NoSQL backend.

Base44 now provides GitHub sync and an eject workflow, although the original running backend and existing records remain on Base44 infrastructure.

Base44 keeps its own managed NoSQL backend at the center. Lovable supports Lovable Cloud and an external Supabase project, which changes how data, server functions, and payment features are handed over.

In either case, connect the repository, inspect the generated code, and test the data handoff before treating the prototype as a long-term product.

Both platforms have a free tier, but the paid entry points and billing units differ. Lovable Pro has a published price of $25 monthly. Base44 Starter costs $20 monthly or $16 monthly on annual billing, while Builder costs $50 monthly or $40 monthly on annual billing.

Compare Across Platforms

The vibe-coding comparisons hub places the major tools beside each other. The vibe-coding platforms overview summarizes the workflow, billing unit, and handoff boundary for each category.

Base44 Verdict

Base44 is the strongest fit in this group for a beginner building a small record-based prototype with the fewest service choices. Use its managed stack for that advantage, connect GitHub early, and treat the empty-database eject behavior as a firm migration boundary before the app becomes a system of record.

FAQ

What stack does Base44 generate?

Base44 documents a React and Vite frontend with Tailwind CSS and shadcn/ui. Its managed backend provides a NoSQL database, built-in authentication, Deno serverless functions, and realtime updates through WebSocket, with the Base44 SDK connecting the generated frontend and backend services.

How much does Base44 cost?

Free costs $0 while Starter costs $20 monthly or $16 monthly on annual billing. Builder costs $50 monthly or $40 monthly on annual billing, while Pro costs $100 monthly or $80 monthly on annual billing. Elite starts at $200 monthly or $160 monthly on annual billing, with different credit allowances on every tier.

How do Base44 credits work?

Message credits pay for AI building prompts, while integration credits pay for live app actions such as email, file operations, image generation, and LLM calls. Free includes 25 monthly message credits with a five-credit daily cap plus 100 integration credits. Paid credits reset each billing cycle and do not roll over, so monitor both balances before launch.

Can I export a Base44 app?

Base44 provides two code handoff paths: Builder and higher support two-way GitHub sync for the app code. The Base44 CLI eject command creates a separate local project with frontend code, entity schemas, functions, and configuration, but the new Base44 backend starts with an empty database. Plan a separate data migration and test the local project before relying on the handoff.

Does Base44 include a backend?

Yes, Base44 documents a managed NoSQL database, built-in authentication, Deno serverless functions, realtime updates, hosting, and integrations for services such as email and files. The backend is convenient because it needs little setup, but it is still a Base44 service. Review data permissions and document a migration path before storing important production records.