Base44 is a conversational AI app builder that combines interface generation with a managed database, authentication, backend functions, integrations and hosting. Instead of starting with an empty repository and selecting infrastructure component by component, a builder describes the product in plain language, reviews what the agent creates and keeps refining the same live project.
Used this tool? Rate it
Used this tool? Rate it
Base44 is a conversational AI app builder that combines interface generation with a managed database, authentication, backend functions, integrations and hosting. Instead of starting with an empty repository and selecting infrastructure component by component, a builder describes the product in plain language, reviews what the agent creates and keeps refining the same live project. The result can be a public website, a signed-in business app, an internal workflow tool, a customer portal, an AI-enabled service or a mobile-store package built around the published web app.
That all-in-one model is Base44's defining advantage and its main trade-off. It removes a large amount of setup, but it does not remove product specification, data modeling, access-control design, testing, cost management or operational responsibility. The fastest path to a useful result is therefore not a one-sentence prompt followed by blind publication. It is a staged process: define the users and data, generate a narrow first version, inspect the schema and permissions, test every role, review the generated code and integrations, then publish only after security and failure-path checks.
This guide reflects the documented product as reviewed on 2026-08-08. Base44 changes quickly, so plan entitlements, credit consumption, model availability and beta features should always be confirmed in the live workspace before a purchase or production release. Current capabilities, announced transitions and independent user observations are separated throughout the article.
Base44 turns a natural-language product description into a working application and places that application inside a managed environment. Its editor centers on an AI chat, a live preview and a dashboard. The chat can create pages, entities, forms, permissions, integrations and application logic; the preview lets the builder exercise the interface; the dashboard exposes users, data, domains, logs, analytics, security and publishing controls.
This makes Base44 broader than a landing-page generator. A generated project can include persistent records, sign-in, roles, server-side work, scheduled or event-driven workflows, email, connected services and a hosted URL. The official developer documentation also presents Base44 as a backend service that can support an externally built frontend through its JavaScript SDK and CLI. In other words, the product spans a no-code conversational editor and a more developer-oriented backend platform.
The documented workflow covers full-stack web applications, websites and AI-enabled apps. In the official quick-start flow, a builder describes an app in the AI chat, reviews generated pages and data in the live preview, configures the app through the dashboard and publishes it to a Base44-hosted address. The broader developer documentation also covers managed data, authentication, functions, integrations and hosting.
The generated app is not merely a static mockup. Published applications can collect and update data, authenticate users, enforce roles, invoke server-side integrations and run automated work. Base44 also exposes the file structure and code view, supports ZIP export and GitHub workflows on eligible plans, and documents a CLI and SDK for teams that need more direct control.
Base44 can generate an implementation from intent, but it cannot decide whether a business rule is correct, whether a permission exposes sensitive data, whether an external API contract is lawful to use or whether an AI-generated workflow handles every failure mode. The official security documentation explicitly makes the app owner responsible for reviewing permissions and running the security scan.
The same applies to quality. A generated checkout can look complete while missing refund handling; a multi-tenant table can work for an admin while exposing records to another tenant; an integration can succeed in a happy-path test while failing under rate limits. Base44 accelerates implementation, not accountability. Treat the agent as a productive implementation partner whose output still needs a product owner, tester and security reviewer.
Wix announced its acquisition of Base44 on June 18, 2025 and said Base44 would continue to operate as a distinct product and business. That is a completed corporate event, not evidence that every Wix service is integrated with Base44 or that a particular Wix-powered feature is available in every account. Current feature availability should be checked in Base44's own documentation and live workspace.
Third-party reporting in June 2026 also described Base44 as beginning to roll out a specialized model called Base1. Because model rollouts can be gradual and account-dependent, this should not be read as a promise that every workspace exposes the same selector. The live editor remains the authority for which models an account can use and what each model costs in credits.
The AI chat is the main build surface. Default mode applies a request to the app, so it suits deliberate feature changes. Discuss mode supports planning without changing the project and is useful for comparing data models, clarifying scope or asking the agent to identify risks before implementation. Edit mode supports visual adjustments by selecting elements in the preview; manual visual changes and AI-assisted element changes have different credit implications.
These modes are operationally important. Discussing an ambiguous requirement before applying it can prevent a costly chain of corrections. Visual Edit is better suited to spacing, color, typography and element-level presentation than a broad prompt that invites unrelated code changes. Default mode is most effective when a request includes acceptance criteria, affected roles, data rules and explicit exclusions.
Base44 can generate pages and components and lets builders refine visual presentation through its AI chat and Edit mode. The documented editor includes a live preview, while the mobile guidance covers checking and editing the app from supported mobile surfaces. Treat any broader design-system or cross-app reuse requirement as something to verify in the current workspace rather than an assumed platform entitlement.
Generated design should still be reviewed as a system. Check empty states, loading states, validation errors, long labels, narrow screens, keyboard navigation and contrast. An attractive first screen does not prove that a ten-row form, a dense table or a multilingual navigation menu works. Use the preview to exercise realistic content rather than approving a design from placeholder cards.
Base44 supplies persistent data entities and a dashboard for viewing and managing records. In the main builder, the AI can add or change fields and connect forms and views to those entities. Builders can export collection data for review or migration. The developer backend documentation describes a flexible NoSQL layer, real-time updates and security rules around entity access.
Data modeling deserves an explicit pass before the interface expands. Name entities for durable business concepts, separate user identity from public profile data, define ownership fields and decide which states are valid. For multi-tenant apps, include the organization or tenant relationship in every private business record. It is cheaper to correct the model before dashboards, workflows and integrations depend on it.
Base44's documented build flow includes managed authentication, app visibility, invited users, user and admin roles, and data permissions. The quick-start guide also documents testing as another user. The current login guide says a fully custom authentication flow and fully white-labeled built-in authentication screens are not supported, so a project that depends on a particular identity provider or SSO arrangement should verify that exact option and plan in the live documentation before committing to it.
Authentication is not the same as authorization. Requiring login proves who a visitor is; entity permissions decide what that person can read or change. Test both. Create dummy users for each role, use the documented “act as a user” workflow and attempt direct access to records outside each user's scope. Do not assume a hidden button protects the underlying data operation.
Eligible plans expose backend functions for logic that should not run in the browser. This is the right place for sensitive API calls, privileged data operations, webhooks, payment verification and transformations that require secrets. Base44's integrations and backend execution model keep managed credentials out of frontend code when configured correctly.
Inspect generated functions for input validation, authentication, authorization, idempotency and useful error responses. Store API keys in the platform's secret facilities rather than fields, prompts or client code. If a function uses a service role, narrow what it can do and never trust a client-provided user ID as proof of identity.
Base44 documents three integration layers. Built-in integrations cover common actions such as AI generation, file handling and email. Connectors provide managed authorization to services such as Google Workspace, Slack and other supported systems. Custom workspace integrations let an administrator import an OpenAPI specification, select approved operations and expose the resulting integration to apps in the workspace.
This variety makes Base44 useful for operational applications, but integrations consume credits and inherit third-party constraints. Record which account owns each connection, which scopes were granted, what happens when authorization expires and how failed calls are retried. A generated “sync” is incomplete until duplicate handling, pagination, rate limits and partial failure are tested.
The current documentation says Workflows replaces Automations for apps created from July 6, 2026, while older apps may still expose the earlier Automation system. A workspace has one or the other. Workflows can start on a schedule, an entity change, an in-app agent conversation or a supported connector event. They can chain actions, branch on conditions, wait between steps and expose per-run progress.
That transition matters when reading older tutorials. Instructions written for Automation may not match a new project's dashboard. In a new app, design a workflow around an explicit trigger and terminal outcome, prevent updates from retriggering the same flow indefinitely and give every external side effect an idempotency strategy. For legacy apps, confirm which automation surface is actually present before copying steps.
Every created app receives a Base44-hosted address and can be published from the editor. Builders can control visibility, share the live link and connect a custom domain on eligible plans. Base44 handles HTTPS for connected domains. The developer backend documentation also allows an external frontend to keep its own host while connecting to Base44 data and functions.
Publishing is a release action, not a substitute for release management. Maintain a short checklist: version or branch reviewed, roles tested, security scan current, secrets valid, critical integrations exercised, analytics configured and rollback or unpublish steps known. If a release changes the data model, test existing records rather than only newly created examples.
Base44 exposes project files and components in its code view. Current documentation says Builder or higher can download code as a ZIP or connect a project to GitHub. The newer GitHub workflow supports two-way synchronization, local development and standard review practices such as branches and pull requests; plan eligibility and ownership requirements apply.
Export reduces frontend lock-in but does not automatically reproduce the managed runtime elsewhere. Base44's mobile documentation states that frontend code and backend functions can be exported, and data collections can be exported as CSV, but managed hosting, authentication and database infrastructure are not exportable as equivalent self-hosted components. A migration plan must account for those services separately.
Base44 documents branches for developing and testing changes without immediately altering the main version. The AI can help reconcile updates from main and ask when changes genuinely conflict. Version history and prompt-level revert controls provide additional recovery paths during editing.
Use these tools before a wide schema change, authentication redesign or major interface rewrite. A clone or branch is especially valuable when production data and users already exist. Recovery features are not a reason to skip backups: export important data and code before destructive work, and verify that the restored version still matches the current schema and integrations.
The official quick-start flow documents previewing an app and using “act as a user” to test role-dependent behavior. That is the evidence-backed baseline for testing in this guide. Availability of additional testing agents, generated test data, analytics or specialized operational tooling should be confirmed in the current workspace and plan rather than assumed from a secondary mention.
Observability should answer more than “did the page load?” Define success events for the app, track failed backend calls and review workflow runs. For a booking app, measure completed bookings and payment failures; for an internal approval tool, measure queue age and rejected transitions. Logs are most valuable when a builder knows which identifiers, states and timestamps to inspect.
Base44 can be used from mobile browsers and provides iOS and Android builder apps. A published app can run in a mobile browser and be added to a home screen. The current editor also documents a process for scanning an app against store guidelines and generating iOS and Android submission files on an eligible plan.
The store package is a secure web-view wrapper around the published Base44 app, not a fully independent native rewrite. The documentation says native-only push notifications and full offline mode are not currently supported. Apple and Google developer accounts, listing management, policy compliance and final submission remain the app owner's responsibility.
A founder can turn a product hypothesis into a hosted application with sign-in, forms, records and a narrow workflow before funding a conventional build. Base44 is especially effective when the hypothesis depends on interaction rather than a static slide deck: a user completes onboarding, enters data, receives a result and returns later to see saved history.
Keep the first version intentionally small. Prove one user journey and one business outcome. If the product needs a marketplace, start with one side managed manually; if it needs recommendations, begin with an auditable rule before adding an AI model. The goal is evidence, not an instant imitation of a mature platform.
Operations teams can build inventory trackers, approval queues, onboarding checklists, issue registers, service dashboards and other tools that are too specific for generic SaaS. Entities hold operational records, roles separate staff responsibilities and workflows can send alerts or advance a process when data changes.
Internal does not mean low risk. Employee, customer and financial data still require access rules and retention decisions. Define the system of record before connecting Base44: decide whether the app owns the data or mirrors another platform, and document how conflicts are resolved.
Base44's authentication, role and data features can support a portal where customers view orders, submit documents, follow requests or exchange messages with a team. A partner portal can expose account-specific opportunities, assets and performance summaries without giving every participant administrative access.
Portal quality depends on permission design. Every record needs an ownership or tenant relationship, and every list and function must enforce it. Test with accounts from two organizations and attempt to cross the boundary. A visually personalized dashboard is not sufficient if an underlying query can return another customer's records.
The platform can create public websites, landing pages and interactive calculators, then connect a domain and publish them. Compared with a conventional site builder, Base44 is most useful when the experience also needs application behavior: saved preferences, logged-in content, generated results, a searchable collection or an operational workflow behind a form.
For a primarily editorial site, compare Base44 with a content management system before committing. Confirm SEO controls, redirects, structured content workflows and who will maintain pages after launch. A prompt-generated site can launch quickly but still needs content governance and accessibility review.
Teams can create dashboards over Base44 entities or connected services, with filters, charts, roles and scheduled summaries. This is useful for a sales pipeline, project health view, customer-success overview or lightweight reporting portal.
Do not confuse a chart with trustworthy analytics. Define each metric in plain language, identify the source fields, handle time zones and missing data, and reconcile totals against the source system. Limit large queries, paginate lists and test performance with realistic record counts rather than a dozen demo rows.
Built-in AI actions and external AI integrations make it possible to create document processors, research assistants, content utilities or guided agents. Base44 can hold source data, invoke a model from backend logic and present structured results through a generated interface.
Add AI only where its uncertainty is acceptable. Store source references, separate generated suggestions from verified records and provide a human approval step for high-impact actions. Model output should not directly grant permissions, issue refunds or overwrite important records without deterministic validation.
Workflows can coordinate events across an app and connected tools: a new lead triggers an acknowledgment, waits, checks a state and alerts a team; a calendar event updates a booking; a scheduled job compiles a daily summary. The visual run history helps an operator see which step failed.
Production automation needs replay safety. If a workflow is retried, it should not send the same invoice twice or create duplicate records. Save external identifiers, make updates idempotent and decide who resolves a partial run. For high-value transactions, retain a manual reconciliation view.
Identify the target user, the problem, the one critical workflow and the information the app must store. Add explicit constraints: public or private, roles, sensitive fields, required integrations, expected volume and what is outside the first version. A useful first prompt describes behavior and acceptance criteria rather than asking for “a modern app.”
For example, specify that a request belongs to one customer organization, only that organization's members may see it, a manager can approve it and an audit timestamp must be saved. That is enough for the agent to make meaningful schema and permission choices.
Before applying changes, ask the chat to propose entities, relationships, roles and failure cases. Request a concise plan and ask which assumptions it made. Correct those assumptions in Discuss mode, where the app is not being modified.
This stage reduces rework and credit use. It is also where a nontechnical owner can ask for explanations: why a separate profile table is safer than extending a managed user object, why a webhook needs verification or why tenant IDs must be present on business records.
Ask Base44 to implement the smallest complete flow: create an account, submit one record, view that record under the correct role and perform one meaningful action. Avoid requesting every dashboard, integration and automation in the initial build.
Once generated, inspect the preview and dashboard. Confirm that the expected entity and fields exist, that validation is visible and that the flow survives refresh and a new session. Fix the model before adding breadth.
Open each important entity and inspect its permissions. Verify create, read, update and delete behavior separately. Move external credentials into secrets and ensure third-party calls run in a backend function or managed integration rather than client code.
Run the security scan and review every recommendation; the scan does not apply every fix automatically. For identity-dependent behavior, test dummy accounts with different roles. Attempt unauthorized reads and writes, not just approved actions.
Connect one service at a time. Confirm the account and scopes, execute a normal request, simulate an error and observe logs. For a workflow, define its trigger, each step, conditions, delays and the desired terminal state. Add a way to recognize a previously processed event.
If the source is a busy connector, filter early so irrelevant events do not spend credits. If an API can paginate, test more than one page. If an action changes money or customer state, provide a review queue or reconciliation report.
Populate records that include long names, empty optional fields, special characters and boundary values. Use the live preview and mobile views, then open the published candidate in a real browser session. Check navigation, focus, form errors, slow operations and role-specific states.
For mobile-store delivery, test the web app first. The wrapper reflects the published app, so a broken web flow remains broken in the store package. Review store permissions and privacy disclosures, and remember that native push and full offline behavior are not currently built in.
Export important data and code, save the reviewed version or branch and record the live plan and integrations. Run the current security scan, review logs and confirm the domain. Publish to a limited audience when possible, watch key events and keep an unpublish or rollback plan.
After release, test the app as a new user rather than relying on an existing admin session. Watch workflow runs, failed functions and credit consumption. Production feedback should become small, testable changes rather than another broad prompt.
Describe who can do what, under which condition and what must be recorded. “Add an approval page” is ambiguous; “Managers can approve pending requests in their own organization, and approval records actor and time” gives the agent a testable rule.
Separate functional and visual prompts. First make a workflow correct, then refine presentation. This makes regressions easier to identify and reduces the chance that a styling request changes data logic.
Bundle closely related edits, but do not combine authentication, schema, payment and redesign work in one prompt. A narrow change has a clear before/after state and can be reverted without discarding unrelated progress.
Keep a small change log outside the chat: requirement, prompt, affected files or entities, test result and release. Chat history is useful context, not a substitute for durable product documentation.
Base44 separates message credits from integration credits, and actions can consume different amounts. Use Discuss mode for planning, make acceptance criteria explicit and avoid asking the agent to repeatedly rediscover the same requirement. Check the live credit display because model selection and action complexity can change consumption.
For integrations, reduce unnecessary calls through filters, caching and batched work where the external contract allows it. A poorly scoped schedule can consume credits even when no useful business event occurred.
Document entities, exported data, functions, integrations, secrets, domains and authentication assumptions. Use GitHub or periodic ZIP export when the plan supports it. This does not produce a turnkey replacement for Base44's managed infrastructure, but it makes the application understandable and reduces dependency on a single editor history.
Before assuming an app is portable, perform a trial export and identify what would replace managed auth, the database, file storage, workflows and hosting. Portability is an architecture exercise, not a button label.
Focus review on code that accepts untrusted input, handles identity, calls external services, uses a service role, changes money or processes webhooks. Confirm validation and authorization occur server-side. Search for exposed credentials and hard-coded test values.
The built-in security scan checks several common classes of risk, but it is not a formal proof. High-risk or regulated applications need an independent security and compliance process appropriate to the data and jurisdiction.
Disconnect an integration, expire authorization, submit duplicate events, omit required data and force a workflow step to fail. Verify that the user sees an actionable message and that an operator can resume or reconcile the process.
For destructive actions, provide confirmation and an audit trail. For important data, export backups and test restoration. A successful demo proves only the happy path.
Base44's documentation is actively changing. Record the date and plan when making a buying decision. Treat “planned,” “rolling out,” “beta” and “working on” as different from generally available. Do not promise a customer native push, full offline behavior, custom white-labeled authentication or a specific model without confirming it in the live account.
Base44 is a strong fit for a founder who can define users, workflows and acceptance criteria but does not want to assemble a frontend, database, auth provider and deployment stack for an early test. The founder still needs to own product decisions and validation.
Teams that currently coordinate work through spreadsheets, forms and chat can use Base44 to create a more structured operational tool. The greatest value appears when the process is specific enough that generic software creates workarounds but bounded enough to model and test clearly.
Product teams can move beyond clickable mockups to prototypes with real records, roles and business logic. GitHub and code access can help developers evaluate what was generated, while branches and test users support structured review.
Developers may use the generated app as a starting point, edit code directly, connect GitHub or use Base44's SDK and backend service with an external frontend. This is useful when managed infrastructure is desirable. It is less suitable when the project requires complete control of runtime, database internals or deployment topology from day one.
An agency can use Base44 for portals, dashboards and workflow tools when ownership, plan costs, maintenance and handoff are agreed in advance. Put the client in the correct workspace, document integrations and clarify who controls domains, data and billing.
Base44 may be a poor fit for systems that require full offline operation, deeply native mobile behavior, self-hosted infrastructure, unusual database guarantees, a fully custom authentication experience or independently audited regulated controls. It can still serve as a prototype, but the production architecture should be decided before user and data migration becomes expensive.
The primary builder runs on the web. Published apps receive a hosted web address and can use custom domains on eligible plans. Users can open published apps in normal desktop or mobile browsers, and responsive behavior can be reviewed in the editor.
Base44 documents iOS and Android apps for creating, editing and managing projects. Mobile browser access is also supported. Some administrative tasks, including certain domain and security controls, still require desktop access, so mobile should be treated as a convenient build surface rather than a complete replacement for the desktop workflow.
A published app can be added to a device home screen. Eligible users can also run a store-readiness scan and generate IPA and AAB packages for submission through their own Apple and Google developer accounts. The package is a web-view wrapper around the published Base44 app; it does not currently add native push notifications or full offline mode.
The code view supports in-product inspection and editing. ZIP export and GitHub synchronization are documented for Builder and higher. Base44 also provides a CLI and JavaScript SDK for local development and backend access. Confirm plan and beta status for the exact developer feature before basing a delivery commitment on it.
The current official plan documentation lists Free, Starter, Builder, Pro and Elite tiers and presents a feature table for comparing them. Because entitlements can change independently of the plan names, use that current table to verify app limits, credits and every required production feature before purchase. This guide does not assign a durable feature bundle to any tier.
Plan details change, so this guide intentionally does not reproduce dollar prices. Check the live plan page for monthly versus annual billing, regional or app-store pricing and current entitlements before purchase.
Base44 uses separate allowances for AI messages and integration actions. A prompt's cost can depend on the work and selected model, while external actions and workflows can draw from integration credits. Unused credits and reset behavior are governed by the current plan rules.
Estimate cost from the app's real workflow, not only from the first build. Iteration, model choice, scheduled jobs and third-party calls can dominate long-term consumption. Monitor usage during a trial, record the actions that spend credits and include maintenance in the budget.
Plan-dependent capabilities may determine whether a tier is viable even when its credit allowance looks sufficient. Make a feature checklist and verify each item against the current official plan table. Also account for external costs such as domains, Apple and Google developer programs, API providers and payment processing.
Lovable is another prompt-driven application builder with a strong focus on generating web products and collaborating around code. Compare the generated stack, backend choices, Git workflow, design control and how easily the project can move to independently managed infrastructure.
Replit combines an AI coding agent, cloud development environment and deployment platform. It may suit builders who want a more code-visible general development workspace, while Base44 emphasizes an integrated application model and managed product controls.
Bolt offers browser-based AI software generation with direct project files and a familiar web-development flow. Evaluate how much backend assembly and deployment ownership you want versus Base44's integrated entities, auth and hosting.
Softr focuses on business applications, portals and internal tools with structured building blocks and data connections. It can be attractive when predictable business components matter more than open-ended AI generation.
Retool and Power Apps target internal and enterprise application development with mature connectors, governance and role-based administration. They can require more configuration but may align better with organizations already invested in their ecosystems or with stricter governance needs.
A conventional stack offers maximum runtime, database and deployment control at the cost of more engineering and operations work. It remains the safer choice for unusual performance requirements, deeply native apps, regulated systems or products whose core advantage depends on custom infrastructure.
The reviewed Product Hunt and G2 pages contain both positive and negative experiences, but their contributors are self-selected. The exact G2 profile showed four reviews and the exact Capterra listing showed three when accessed, so those two samples are especially too small to support a universal quality claim. Use the reported themes as questions for a representative trial, not as controlled benchmarks.
Build a representative feature before committing: use your real roles, data volume and hardest integration. Measure correction cycles and credit use. A successful to-do list says little about a multi-tenant operational system.
Base44 documents a security scanner and explicitly assigns the app owner responsibility for reviewing security settings. The scanner checks permission gaps, exposed credentials, login verification, vulnerable packages and browser security headers, but owners must review the findings and decide which recommendations to apply.
Base44's privacy documentation describes ownership and export controls, default US data storage, and EU or UK residency options that vary by plan and app creation date; it also distinguishes storage location from processing location. Evaluate data classification, residency, contractual requirements and subprocessors against the current official terms before storing sensitive or regulated information. Do not infer an encryption mode or security certification that the evidence ledger does not establish.
Code and collection data can be exported on eligible plans, but managed authentication, database infrastructure and hosting are not exported as self-hosted equivalents. Moving away can require rebuilding those layers and migrating identities, data, files, integrations and workflows.
Plan for this before launch. Keep entity definitions and integration contracts documented, use GitHub or ZIP export where available and test a data export. “Own the app” and “can reproduce the whole runtime elsewhere immediately” are different statements.
Base44's current store packages wrap the published web app. Native-only push notifications and full offline operation are not currently supported in that flow. App owners still manage developer accounts, store submissions, privacy disclosures and review feedback.
The documentation says built-in support for StoreKit and Google Play Billing for digital purchases is being worked on. That is roadmap language, not a current entitlement. Do not ship Stripe-based digital goods inside a store package without checking current Apple and Google rules and Base44's live guidance.
Base44 supports managed login, while its current login documentation says a fully custom authentication flow and complete white-label built-in authentication screens are not available. White labeling is described as planned. Confirm the exact identity-provider, SSO and branding requirements against current official documentation before choosing the platform for a customer-facing enterprise product.
The Workflows transition in July 2026, evolving backend documentation and gradual feature rollouts demonstrate that Base44 is a moving platform. Tutorials and reviews can become stale. Record the version, plan and date for every important technical or purchasing claim, and prefer current official documentation over screenshots from an earlier UI.
The reviewed Product Hunt and G2 samples contain positive ease-of-use or prototyping reports alongside complaints about credits, continuity, support or more complex projects. They do not establish a universal scale limit. Performance depends on data shape, queries, integrations, generated code and traffic patterns.
Run load and failure tests that match the intended app. Ask Base44 for current limits and support commitments when the project is business-critical. If a failure requires contractual response times or a specific deployment region, confirm those requirements in writing before launch.
Yes. Current official documentation covers generated interfaces, persistent entities, authentication, backend functions, integrations, workflows and hosted publishing. Whether a particular app is production-ready depends on its design, permissions, testing, integrations and operational requirements, not merely on generation completing.
No coding is required to create and iterate on a basic app through chat and visual editing. Technical knowledge becomes valuable when reviewing data models, security, complex integrations, generated functions and migration choices. Base44 also exposes code, GitHub, CLI and SDK workflows for developers.
Base44 currently documents a Free tier with limited apps and credits, plus Starter, Builder, Pro and Elite paid tiers. Important production features are plan-dependent. Check the live pricing page because allowances, prices and entitlements can change.
Message credits cover AI building or editing interactions, while integration credits cover actions that use integrations and automated work. The exact amount consumed varies by action and, for messages, can vary by model and complexity. Monitor the workspace's live usage rather than estimating from prompt count alone.
On eligible plans, current documentation supports ZIP export and GitHub integration, and entity data can be exported. The export does not reproduce Base44's managed authentication, database infrastructure and hosting as self-hosted services, so a complete migration still needs an architecture and data plan.
Base44 can scan an app for store readiness and generate submission packages on an eligible plan. You need your own Apple and Google developer accounts and remain responsible for listings and review. The package is a web-view wrapper and currently lacks native push notifications and full offline operation.
Require the correct visibility and login behavior, define entity permissions, store credentials as secrets, run the security scan and test with dummy accounts for every role. Re-run the scan after material schema, permission or integration changes. High-risk apps also need independent security and compliance review.
Yes, both are documented, but they are plan-dependent. Custom domains receive managed HTTPS once configured, and the GitHub workflow supports version control and local collaboration. Confirm the live entitlement and repository ownership requirements for the workspace.
They represent two generations of Base44 automation. Current documentation says apps created from July 6, 2026 use Workflows, while earlier apps may retain Automations; an app exposes one system, not both. Workflows add multi-step actions, conditions, delays and run visibility.
It can be, when the product fits the managed platform and the team verifies permissions, reliability, costs, portability and support. Run a representative pilot with real roles and integrations before committing. Choose a conventional or more controllable stack when full infrastructure ownership, deeply native mobile behavior, unusual scale guarantees or regulated deployment controls are non-negotiable.
