Dropbase

Dropbase is an AI-powered web app builder that lets developers create internal tools — admin panels, billing dashboards, CRM editors, and back-office utilities — using Python instead of wrestling with frontend frameworks. Rather than dragging and dropping components into a proprietary canvas, developers write or accept AI-generated Python code that wires together pre-built UI blocks (tables, buttons, charts) with data sources and external APIs.

The platform runs entirely inside Docker on your own machine or server. Each Dropbase app lives as a plain Python folder — main.py, functions.py, state.py, and store.py — that can be version-controlled, shared, and edited in any IDE. AI code generation produces readable, auditable Python rather than locked binary configurations, and because every file is yours, there is no vendor lock-in.

Integrating with external services is a matter of adding API keys to worker.toml. Dropbase AI can then infer which credentials to use when generating code that touches Stripe, Mailgun, HubSpot, Salesforce, or Slack. Database connections (PostgreSQL, SQLite) follow the same pattern. The worker that executes user code runs inside its own sandboxed Docker container per request, keeping credentials and side effects isolated from the platform.

What You Get

• AI Code Generation - Describe what you want in plain language and Dropbase generates the Python handler functions, UI layout, and data-fetching logic as readable, editable source files.
• App-as-Folder Architecture - Every app is a regular Python directory with main.py, functions.py, state.py, and store.py that you own, edit in any IDE, and version-control like normal code.
• Built-in UI Components - Compose tables, buttons, forms, and charts in Python using a declarative component model — no React, Vue, or frontend build step required.
• Typed State System - All page state flows through Pydantic BaseModel classes, giving you type safety, IDE autocomplete, and clear contracts between UI events and handler functions.
• Docker-Sandboxed Worker - User code runs in an isolated Docker container per request, keeping credentials, imports, and side effects separate from the platform itself.
• TOML-Driven Integrations - Add database connections (PostgreSQL, SQLite) and external API credentials (Stripe, Mailgun, HubSpot, Salesforce, Slack) to worker.toml; the AI uses these when generating code.
• Portable App Bundles - App folders are self-contained; zip and share them with other Dropbase instances or commit them to a monorepo alongside the rest of your codebase.
• Full PyPI Access - Import any Python package from PyPI inside your app functions — data manipulation with pandas, plotting with Plotly, or any custom library your team already uses.

Common Use Cases

• Internal order management dashboard - An e-commerce engineer builds a table UI backed by a PostgreSQL orders database, adds a button that triggers a Slack notification, and generates the entire handler in one AI prompt.
• HubSpot contacts editor - A growth team creates a spreadsheet-style interface to view and edit HubSpot contacts via the API, with changes saved back in real time without writing frontend code.
• Stripe billing admin panel - A SaaS startup builds a filterable view of subscriptions pulled from Stripe, with action buttons to send Mailgun emails or trigger plan changes.
• Salesforce leads manager - A sales ops team generates a web app to browse, filter, and update Salesforce leads using AI-written API integration code and a Pydantic-typed state model.
• Data quality review tool - A data engineer creates a table that queries a SQLite audit database, highlights anomalies with conditional formatting using pandas, and exports results as CSV.
• Inventory tracker - An operations team assembles a multi-page app with charts (Plotly), a data table, and form inputs that write inventory adjustments back to a shared PostgreSQL instance.

Under The Hood

Architecture Dropbase’s open-source repository is a bootstrapping harness for a four-service Docker Compose stack: a React frontend client, a Python API server, a Language Server Protocol (LSP) service for code intelligence, and a user-code worker. The server and LSP are distributed as closed pre-built images; the open-source layer comprises workspace scaffolding, the worker container definition, and configuration templates. Communication between the server and worker flows through Redis as a job queue, with the worker running each user Python function in an isolated Docker container. This produces clean service boundaries — the server never directly imports user code, and user code never reaches platform internals.

Tech Stack Python 3.11 is the runtime for both the worker environment and all user-authored app code. Docker and Docker Compose orchestrate the four services. Redis queues execution requests from the server to the sandboxed worker. The dropbase PyPI package (0.6.x) ships the user-facing component model: Pydantic 2.x defines Page, Table, Button, and State types that provide type safety and IDE autocomplete in app code. SQLAlchemy 1.x handles database connections, pandas enables data manipulation, and Plotly supports charting. The LLM layer is configurable via server.toml for either OpenAI (gpt-4o) or Anthropic (Claude Sonnet). Ruff and Black enforce code style at target-version Python 3.11. Ansible playbooks are included for deploying the full stack to remote VMs.

Code Quality No automated tests exist in the open-source portion of the repository. The platform core is distributed as binary Docker images and is not inspectable. What is visible — the demo workspace and worker entry point — shows clean patterns: typed Pydantic state models, handler functions with explicit signatures, and clear separation of data-fetching logic from UI declarations. Ruff is configured with a focused rule set (E4, E7, E9, F) and Black formatting targets Python 3.11. Documentation lives externally at docs.dropbase.io and the project’s README covers setup thoroughly with a demo SQLite database included.

What Makes It Unique The most distinctive design choice is the app-as-folder paradigm: each Dropbase app is a standard Python directory that developers read, edit, and version-control like any other source file. AI generation produces ordinary Python rather than proprietary binary configurations, making every generated line auditable and overridable. The Pydantic-typed component model — declaring Page and Block layouts directly in Python code rather than JSON or YAML — enables IDE type checking and autocomplete on what would otherwise be drag-and-drop configuration. Finally, per-request Docker sandboxing of user code provides meaningful execution isolation without requiring traditional container-per-tenant infrastructure.

Self-Hosting

Dropbase is released under the Dropbase Software License (DSL), a proprietary license authored by Castodia Inc. The license grants a non-exclusive right to download, use, modify, and deploy the source code exclusively for configuring a self-hosted service that integrates with Dropbase’s own platform services. Critically, the license explicitly forbids using any portion of the code to build competing products, SaaS/PaaS/IaaS services, or derivative commercial offerings. This means Dropbase is source-available rather than open-source in the OSI sense — you can read, run, and customise it for internal use, but you cannot fork it into a new product or white-label it.

Running Dropbase yourself requires Docker Desktop (especially on Apple Silicon) and basic Docker Compose familiarity. The start script builds the worker image locally and pulls the server, LSP, and client images from Docker Hub. There is no single-binary distribution. You are responsible for provisioning a host (the included Ansible playbook targets a single Linux VM), managing Redis, handling container restarts, and keeping Docker images updated when new versions are released. There is no auto-upgrade path; updating means pulling new tagged images and restarting Compose. LLM credentials (OpenAI or Anthropic API keys) must be kept in server.toml, and database credentials live in workspace/worker.toml — securing these files is your responsibility.

Dropbase offers a managed cloud product at dropbase.io that removes the infrastructure burden: hosted server and LSP, managed upgrades, and direct support access. The self-hosted path trades that operational simplicity for full data locality — no code or credentials leave your network. If your organisation requires air-gapped or on-premises deployment for compliance reasons, self-hosting is the only option. The tradeoff is that enterprise features, SLAs, and support contracts are not available for the self-hosted variant; those require engaging Dropbase’s commercial offering.