Over the past year, we have been spending more time building with Frappe. Some of that work has been client projects powered by CRM, HelpDesk, and ERPNext. Some of it has been internal tools designed to improve how our team learns, experiments, and builds solutions on top of the framework.

As often happens, one tool led to another. We built a collection of agent skills to capture our development patterns and implementation knowledge. We experimented with Frappe Playground to make exploring the framework easier. We started working on Frappe Local to simplify local development and onboarding.

Along the way, we also began building more apps, utilities, and prototypes of our own. A recurring problem kept showing up. Finding Frappe apps is relatively easy. Understanding them, validating them, determining compatibility, and consuming that information programmatically is much harder. We needed a reliable source of app metadata that our own tools could use. That requirement eventually became Frappe Brewery.

Why We Built It

We wanted a system that could:

• Discover and catalog Frappe apps
• Extract useful metadata automatically
• Expose data through JSON APIs
• Support curated collections of apps
• Run with minimal infrastructure
• Be easy for anyone to fork and host

We also wanted flexibility. In some situations, we may want a public registry containing community apps. In others, we may want a private registry containing only approved applications for a specific organization or use case.

Rather than building a traditional application with databases and servers, we chose a different approach.

Static by Design

Frappe Brewery is designed as a static registry. The frontend is built with Vue.js and frappe-ui. The generated registry data is published as static JSON that can be consumed by websites, tools, CLIs, or applications.

The entire registry can be hosted on Cloudflare Pages, while Cloudflare Functions provide lightweight API endpoints where needed. This keeps operational overhead low while making the registry highly portable. Anyone can fork it, customize it, and deploy their own version.

Extracting Metadata from Frappe Apps

One of the more interesting challenges was gathering meaningful metadata. Frappe applications store information across multiple files, conventions, and repository structures. Some information is explicit, while some must be inferred. To solve this, we built extraction scripts that analyze repositories and generate structured metadata including:

• Application name and title
• Description
• Logo and branding assets
• Repository information
• Installation branches
• Frappe version compatibility
• Dependencies and requirements
• Additional registry metadata

The resulting data is normalized into a consistent format that can be consumed by both humans and machines.

GitHub as the Control Center

The registry itself is managed through GitHub. New submissions start as GitHub issues containing basic repository information. From there, automated workflows take over.

Extraction scripts attempt to gather metadata from the repository. Validation checks are executed. Generated results are posted back to the issue automatically, allowing maintainers and contributors to review the findings.

Once an application is accepted, a pull request is generated containing the proposed registry entry along with a preview of how the listing will appear.

Additional validation runs during the pull request process before maintainers perform a final review. When the pull request is merged, the registry index is rebuilt and published automatically. The result is a workflow that remains transparent, auditable, and largely automated.

Open Source First

Frappe Brewery is completely open source. Our public registry is simply one implementation of the project. Organizations, consultants, product teams, and community groups can fork the registry and maintain their own curated collections.

A private implementation could contain only approved internal applications. Another could focus on industry-specific solutions. A third could act as a community-driven catalog. The underlying tooling remains the same.

Curated, Not Crowded

The goal is not to become the largest collection of Frappe apps. The goal is to become a useful one. We believe discoverability improves when there is thoughtful curation behind it.

For our public registry, we intend to prioritize applications that demonstrate good craftsmanship, useful functionality, thoughtful user experience, and adherence to Frappe best practices.

We are less interested in collecting every repository and more interested in showcasing quality work from across the ecosystem.

What Comes Next

Frappe Brewery is only one piece of a larger set of tools we are building around the Frappe ecosystem. Many of these projects started as solutions to problems we encountered ourselves. Some will remain internal. Others will be released as open-source tools that can benefit the wider community.

We already have a growing roadmap for Brewery, including improvements to metadata extraction, validation, compatibility checks, discovery features, and developer tooling. As always, the best tools tend to come from scratching your own itch.

Frappe Brewery is one of them. We are excited to see where it goes next.