A Developer Guide to the Base44 Core App Dashboard

While AI assistants generate up to 46% of production code in modern software projects [Uvik Software Development Survey], developers report that 66% of that generated output requires manual verification or direct debugging before it can be deployed safely. This trust gap makes visual control interfaces essential for applications built using natural language or vibe coding platforms. The Base44 Core App Dashboard is the admin interface used to configure production settings, manage environment variables, and review app telemetry.

Vibe coding platforms automate database table generation, routing logic, and client interfaces from simple prompts. However, scaling an application requires human oversight. Without a dedicated control plane, configuring secure connections or auditing user data becomes a complex task. The Base44 Core App Dashboard provides a single control interface for each application. It acts as a bridge between high-level prompt generation and low-level system configuration.

To deploy an app safely, developers must verify database models, secure sensitive credentials, and monitor performance. The dashboard serves as this administrative hub, ensuring that developers can audit generated code, adjust configurations, and maintain security boundaries. By providing a clear layout of the application's runtime state, the dashboard helps teams transition from a rapid prototype to a production environment. Developers can inspect auto-generated database schemas, verify endpoint permissions, and check database indexes. This step is critical because AI models can generate inefficient database structures or create wide-open access filters. Auditing these settings in a visual interface ensures that the application meets basic production standards.

To launch the control plane, developers run the CLI command:

base44 dashboard open

This command opens the dashboard in your default browser. In this interface, developers manage the four key sections of the Base44 app dashboard:

1. App Telemetry and Analytics: Displays user engagement, behavior tracking, and payment stats through custom widgets.
2. Secrets and Custom Domains (Dashboard Settings): Configures production variables, API keys, database credentials, and SSL routing.
3. Database Entities and Access Controls: Controls table definitions, data schemas, and role-based permissions (RBAC) such as owner, admin, authorized, or public filters.
4. Third-Party Connectors and Integrations: Manages OAuth flows, webhooks, and integrations like Stripe or Slack.

Navigating the dashboard is straightforward. The layout is designed to group similar management tasks, allowing developers to switch between settings and telemetry. Each application has exactly 1 main dashboard interface. This ensures that configuration changes, environment keys, and access controls are unified, reducing the risk of security gaps.

The dashboard works with the Base44 CLI. If you are developing locally, running the open command from your terminal is the fastest way to check variables or verify database schemas. This integration ensures that command-line actions and visual configurations stay in sync, making it easier to manage the app lifecycle. The CLI tool communicates with the Base44 backend by issuing an OAuth handshake. If a session is active, it redirects the terminal output to the visual interface. If no active session is found, it directs you to authenticate through the command line first.

The Base44 dashboard settings work with the CLI secrets manager. This allows developers to set, list, and delete environment variables from either the visual browser dashboard or their local terminal.

To manage environment keys from the CLI, you can use the following commands:

• base44 secrets set API_KEY=value sets a new variable in your active environment.
• base44 secrets list displays the names of all active variables.
• base44 secrets delete API_KEY removes the selected variable from the runtime environment.

When you update variables using the CLI, the changes sync to the dashboard settings. Conversely, keys edited in the browser dashboard are immediately updated in the terminal environment. This prevents variable mismatches, ensuring that your local code execution matches the production environment.

Storing keys securely is critical. Base44 encrypts credentials at rest and injects them into the runtime environment as standard variables. This ensures that database tokens, payment keys, and external API credentials are never hard-coded in the generated repository, maintaining standard security practices. Developers can manage development, staging, and production environments by choosing specific scope tags. The settings dashboard lists these environment profiles, allowing teams to test functions locally using staging keys before deploying the application to the production server. This synchronization reduces environment drift, which is a major cause of serverless function failure.

While Base44 manages code generation and deployment, applications need a secure, persistent storage layer for files, documents, and media assets. Traditional cloud storage options like AWS S3 or Google Drive are passive. They require developers to build custom database pipelines, split documents, and set up embedding databases to run semantic searches.

Fast.io offers shared workspaces where developers and AI agents collaborate on files, shares, and workflows. Enabling Intelligence Mode on a Fast.io workspace indexes files automatically for semantic search. This provides a Model Context Protocol (MCP) server that agents can query directly, bypassing manual database setup.

Fast.io key capabilities include:

• Shared workspaces: A collaborative space where team members and agents read, write, and manage project files.
• Per-file version history: Every file keeps full version history, allowing you to restore prior versions and audit concurrent edits.
• Granular permissions: Protect files with org, workspace, folder, or file-level controls.
• Metadata Views: A structured extraction layer that turns documents into a live, queryable database. Users describe fields in natural language, and Fast.io designs a typed schema supporting Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time. Link to Metadata Views to learn more.
• Ownership transfer: An agent can build an organization and hand it off to a human administrator.

To connect your Base44 backend, Fast.io exposes a Streamable HTTP endpoint and legacy SSE via Fast.io agent storage. Base44 serverless functions query this endpoint to read and write assets, ensuring that data changes trigger webhooks for automated workflows.

Connecting Base44 to your workspace is simple. Developers add the MCP configuration to the project directory. The following JSON block is an example configuration for connecting Base44 to the workspace endpoint:

{
  "mcpServers": {
    "fastio-workspace": {
      "command": "curl",
      "args": [
        "-s",
        "-H",
        "Authorization: Bearer YOUR_FASTIO_API_KEY",
        "https://fast.io/mcp"
      ]
    }
  }
}

Fast.io plans scale with your organization. Starter plans start at $29/month, Business plans at $99/month (up to 20 seats), and Growth plans at $299/month (up to 50 seats). Every organization starts with a 14-day free trial that requires a credit card. The agent flow is: an agent signs up, then hands off to a human who creates the organization and initiates the trial. This pricing model uses usage-based credits, where teams pay for storage, bandwidth, and AI operations rather than strict seat-based licensing.

Using Metadata Views, teams can extract critical information from unstructured files like PDFs, scanned sheets, or handwritten images. For example, a contract processing module in Base44 can read files in the workspace, extract payment deadlines or counterparty names, and populate a data sheet. Because Fast.io indexes files incrementally, updating a contract in the workspace instantly syncs the metadata grid. This allows Base44 functions to fetch structured parameters via MCP without running expensive text parsing routines.

Govern your vibe-coded app assets in a shared workspace

Bring persistence, security, and human collaboration to your Base44 deployments with shared workspaces and a structured data layer. Starts with a 14-day free trial.

Start 14-Day Trial

Base44 analytics tracks user growth, engagement, behavior, and payments through custom widgets in the dashboard telemetry panel. Telemetry data is updated in real time, giving developers a clear view of application health.

Integrating Base44 telemetry with Fast.io workflows provides a comprehensive log of both app events and file changes. Fast.io maintains an append-only audit log of all file reads, writes, and permissions changes. By setting up webhooks in Fast.io, you can stream workspace actions directly to your Base44 backend, showing the metrics alongside standard telemetry.

For example, if a Base44 application handles billing documents, a user upload triggers a Fast.io webhook. The webhook sends the event to Base44, which runs a function to parse the document using Metadata Views. The processing time, credits consumed, and billing output are then logged in the Base44 analytics dashboard. This ensures that application telemetry and workspace actions are monitored together, helping you scale your app efficiently.

Telemetry widgets are highly customizable. Developers can build widgets using simple database queries to track user login frequency, payment conversions, or file processing speed. By combining these application metrics with the append-only activity feed from Fast.io, teams gain complete visibility into their software ecosystem. This dashboard telemetry eliminates guesswork, showing exactly where system bottlenecks occur and how resources are spent.