Frappe Framework: a metadata-driven low-code stack for Python and JavaScript

The problem Frappe Framework solves: metadata instead of hand-written CRUD

Most web frameworks give you routing, templating and an ORM, then leave the repetitive parts to you. Every new entity needs a model, a migration, a form, a list view, validation, permission checks and a set of API endpoints. Frappe Framework takes the position that those artifacts should be derived from a description of the entity rather than written one by one. The README states the philosophy plainly: "The best code is the one that is not written".

The framework was started in 2005 and inspired by the Semantic Web, according to the README. The idea it took from that work is that a system should describe not only how information is displayed but what it means, so that name, address and similar concepts carry their semantics into the application. The README argues that applications built on semantics end up more consistent and extensible than applications designed purely around user interaction.

The target user is not a beginner. The README says so directly: "Framework is not for the light hearted - it is not the first thing you might want to learn if you are beginning to learn web programming, but if you are ready to do real work, then Framework is the right tool for the job." The first application built on it was ERPNext, described in the README as having more than 700 object types. That scale explains the design: a system with hundreds of entities cannot afford hand-written scaffolding for each one.

How DocType metadata becomes a form, a table and a REST API

The mechanism is the metadata layer. An entity is described once, and the framework generates the storage, the admin interface and the HTTP surface from that description. The README lists the outputs: a built-in admin interface with list and form views, role-based permissions, and a REST API that is "automatically generated for all models".

The stack underneath is split. The README describes the framework as full-stack, using Python and MariaDB on the server side with a tightly integrated client-side library. The pyproject.toml dependencies confirm the Python side is substantial: PyMySQL pinned exactly at 1.1.2, mysqlclient at 2.2.8, and a forked PyPika from a git URL. The comment above PyMySQL is worth reading before you touch that file: "We depend on internal attributes, do NOT add loose requirements on PyMySQL versions." That is a maintenance constraint, not a suggestion.

The client side is a separate build. The package.json scripts run esbuild directly (build, production, watch), and the dependency list is long and specific, including jQuery 3.7.1, Bootstrap 4.6.2, Vue-related packages such as @headlessui/vue and @vueuse/core, and Frappe's own charting and datatable libraries. Node is required at version 24 or higher per the engines field. The repository also carries a realtime/ directory and a socketio.js file at the top level, and socket-io is listed among the repository topics, which points to a realtime channel as part of the architecture.

The practical consequence is that a form you create in the admin interface is not a mockup. It is backed by a table and reachable over HTTP without additional code, which is the whole point of the design.

Installing Frappe Framework with Docker Compose

The README gives two production paths. Managed hosting through Frappe Cloud is the first, described as taking care of installation, setup, upgrades, monitoring and maintenance. Self hosting through Docker is the second and is the shortest path to a running instance.

The README lists the prerequisites as docker, docker-compose and git, then gives these commands. The frappe_docker repository is a separate repository from the framework itself, so you are cloning the deployment tooling, not the framework source.

git clone https://github.com/frappe/frappe_docker
cd frappe_docker
docker compose -f pwd.yml up -d

After a couple of minutes, the README states the site should be reachable on localhost port 8080. The default credentials given are Administrator with the password admin. Change them before the instance is exposed to anything. The README also points to the Frappe Docker README for ARM-based setup, so on Apple silicon or an ARM server you should follow that section rather than the commands above.

For a development install, the README's path is different. It says to set up bench by following the installation steps in the documentation, then start the server with bench start. The bench install script installs all dependencies including MariaDB, and the README notes that new passwords are created for the Frappe Administrator user, the MariaDB root user and the frappe user, displayed by the script and saved to ~/frappe_passwords.txt.

bench start

With the server running, a second terminal creates a site. The README then says to open http://frappe.localhost:8000/app in a browser.

# Create a new site
bench new-site frappe.localhost

That URL is the first real use: the admin interface at /app is where entities are described and where the generated list and form views appear.

Where Frappe Framework is the wrong tool

The framework's own README is the best source of its limits. It states it is not the first thing to learn if you are beginning web programming. That is not modesty; it reflects how much of the stack is opinionated and how much of the documentation assumes you already understand the metadata model.

The database coupling is the second constraint. The README describes the server side as Python and MariaDB, while pyproject.toml also carries psycopg2-binary and the repository topics include postgres. Those two facts do not say which databases are supported for production or what the compatibility guarantees are. If your organisation requires PostgreSQL, the README does not settle the question, and you should treat the presence of a driver as the start of an investigation rather than an answer.

The dependency surface is the third. The Python dependency list is long and includes two git-sourced packages (PyPika and a forked gunicorn) plus an exactly pinned PyMySQL. The Python version range is narrow: requires-python is >=3.14,<3.15, and package.json requires Node 24 or higher. A build that must run on an older interpreter, or on a host that only offers an older Node, will not work without changes you would have to maintain.

Finally, the "no code" promise has a boundary. The Report Builder is described as letting users create custom reports without writing code, and the admin interface covers data management. Anything outside those shapes, such as a custom interactive front end, means writing JavaScript against the client library, which is a full build pipeline with esbuild rather than a script tag.

Frappe Framework compared with Django plus Django Admin

Django is the closest comparison because it also pairs a Python web framework with a generated admin interface. The difference is where the metadata lives and how much is generated from it.

With Django you write models in Python, run migrations, register them with the admin, and then extend the generated admin with custom forms, actions and permissions. The REST layer is a separate decision: you add Django REST Framework or build views yourself. The generated admin is a management tool that most teams keep behind a login for staff rather than treating as the product.

Frappe Framework inverts the emphasis. The metadata is the application definition, and the README presents the admin interface, role-based permissions and the REST API as first-class features of the framework rather than an internal tool plus an add-on. Custom forms and views are described as customizable through server-side scripting and client-side JavaScript, which means customization happens inside the generated structure instead of alongside it.

The trade-off is legibility. A Django project can be read top to bottom as Python. A Frappe application is partly metadata stored in the database, so understanding what a running system does may require reading records rather than files. That is the price of the consistency the README claims for semantic applications, and it is a real one for teams whose review process is built around pull requests.

Maintenance, releases and what the MIT licence leaves to you

The repository is not archived, and the last push was on 2026-09-21. Releases are frequent and maintained on two lines: v16.34.0 and v15.121.0 were both published on 2026-09-15, with v16.33.1 a week earlier. Running two release lines in parallel means a v15 installation is not abandoned, but it also means upgrade notes matter more than usual, because a fix you need may land only on the newer line.

The licence is MIT, stated in the README badge and in the package.json license field. MIT is permissive: it allows commercial use and modification with minimal conditions. This is a description of the licence identifier, not legal advice. The practical implication for a self-hosted deployment is that the framework code is not the thing you pay for; the operational work is. The README's self-hosting section covers installation only. It does not document rollback, backup scheduling or upgrade procedures, so those are yours to design.

The dependency pins are the recurring cost. PyMySQL is pinned exactly and the comment in pyproject.toml warns against loosening it, PyPika and gunicorn come from git URLs at specific commits, and the front end needs Node 24 or higher with an esbuild build step. Each of those is a place where an upgrade can require attention. Frappe Cloud exists precisely to absorb that work, and the README describes it as handling installation, setup, upgrades, monitoring, maintenance and support.

Editorial conclusion

Adopt Frappe Framework if your application is form-and-workflow heavy and you want the admin interface, role permissions and REST API generated from metadata instead of written by hand. Do not adopt it if you are starting to learn web programming, if you need a stack that runs on a single language, or if you cannot accept MariaDB as the database underneath. Before committing, verify what the README does not state: which database your deployment will actually use, how you will run backups and restores, and whether the Python version your host provides satisfies the requires-python range in pyproject.toml.

Frequently asked questions

Official sources

1. frappe/frappe on GitHub
2. License: MIT
3. Project website
4. README
5. Releases