Building and Operating with Open Source: Lessons from AFFiNE with Yifeng - AFFiNE x Supabase
Based on AFFiNE's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.
AFFiNE’s product merges knowledge-base editing with whiteboard-style work, automatically shifting content into a whiteboard view.
Briefing
AFFiNE built an offline-first, open-source knowledge base and editor by treating early prototypes as learning tools, then tightening engineering discipline until the project could ship stable, production-ready releases—while keeping community momentum and data ownership at the center. The product experience blends document editing with whiteboard-style work: users start in familiar “note” editing, then switch into a whiteboard view where content is automatically reorganized. Under the hood, collaborative content is enabled by default, but users retain ownership of their data, and the system is designed so networking is optional rather than mandatory.
The origin story traces a sharp pivot from an unstable early prototype to a staged rewrite. The first AFFiNE prototype began as a web page with multiple modes (including “paper mode” and address-node style views) and delivered features that were novel enough to gain traction quickly—reportedly reaching 10K GitHub stars within 40 days and topping GitHub trending without paid promotion. Yet the early architecture couldn’t converge into a stable state: fixing one bug tended to introduce others, making long-term reliability difficult. That instability became the reason for a rewrite, and the team brought in new full-time focus to rebuild toward production readiness.
The rewrite followed a step-by-step release strategy aimed at shipping usable subsets at every milestone. Early major releases focused on a “pure markdown editor” with minimal UI widgets—enough to function reliably—while the team enforced “dogfooding,” using the product internally to surface real-world issues. Only after the core editor stabilized did the project expand into richer interfaces, including draggable UI widgets and progressively more complex content types. Later stages added structured capabilities such as table views that can behave like multi-dimensional spreadsheets, along with a more polished whiteboard experience. The overall goal was to reach “progressive richness” without sacrificing stability.
As the product matured, engineering management shifted toward modular ownership: each team member took responsibility for core subsystems and actively worked to reduce quality issues. Scaling the work required more than feature delivery; it demanded stronger system design in the editor and collaboration layers. That’s where open source became both a recruiting and a quality engine. Community contributors volunteered because they liked the ideas, and the project built sponsored relationships with core contributors. Traction also helped attract additional talent.
Operationally, AFFiNE centralized development on GitHub as a “single source of truth,” using public issue workflows such as “help wanted” to invite outsiders—especially beginners—into meaningful tasks. The team also tracked backlog health using ratios of opened versus closed issues, aiming to lower backlog entropy and improve maintenance.
On the business side, AFFiNE frames open source as a mutual benefit for commercialization: GitHub exposure lowers trial barriers via a try-demo web option and a Docker image for local deployment. The company also positions its ecosystem strategy as more open than closed competitors, with plans for plugins and integrations. Finally, AFFiNE open-sourced general-purpose collaboration infrastructure—Block Suite for editor and front-end collaboration, and an additional backend structure (AutoBase)—with the intent to reduce reinvention for future collaborative applications, even if those infrastructure projects weren’t yet ready for broad public reuse while AFFiNE itself remained the priority.
Cornell Notes
AFFiNE’s path to a production-ready, offline-first editor started with a fast, novel prototype that gained major GitHub traction but couldn’t stabilize. The team responded with a staged rewrite: ship a reliable markdown core first, dogfood it internally, then progressively add richer UI widgets, structured content like spreadsheet-like tables, and a polished whiteboard. Community involvement became a practical growth lever—contributors join via public GitHub workflows, and traction helps attract stronger engineering talent. Commercialization is designed to ride on open source exposure, using a web try-demo and Docker-based deployment to lower trial friction while keeping data ownership central. The broader strategy extends beyond AFFiNE itself by open-sourcing general-purpose collaboration infrastructure (Block Suite and AutoBase) to make future collaborative apps easier to build.
What made AFFiNE’s early prototype insufficient for long-term use, and what changed afterward?
How did AFFiNE’s “step-by-step” release strategy reduce risk during the rewrite?
Why did dogfooding matter in AFFiNE’s development process?
How does AFFiNE use open-source community participation beyond marketing?
What does “data ownership” and “network optional” mean in AFFiNE’s product framing?
How does AFFiNE connect open source to commercialization in practical terms?
Review Questions
- What specific engineering instability in the early AFFiNE prototype led to a rewrite, and how did the staged release plan address that risk?
- How do GitHub issue workflows and backlog metrics (opened vs. closed ratios) support both community contribution and product maintenance?
- Why does AFFiNE open-source collaboration infrastructure like Block Suite and AutoBase, and how does that relate to reducing reinvention for future collaborative apps?
Key Points
- 1
AFFiNE’s product merges knowledge-base editing with whiteboard-style work, automatically shifting content into a whiteboard view.
- 2
The project’s rewrite was driven by instability in the early prototype, where bug fixes often introduced new bugs and prevented stable convergence.
- 3
A staged release strategy reduced risk: start with a reliable markdown editor, then progressively add UI widgets and complex content types like spreadsheet-like tables.
- 4
Dogfooding was used as a quality lever early in the rewrite, creating a feedback loop before expanding into richer collaboration and interfaces.
- 5
Open-source community participation is operationalized through GitHub as a single source of truth, using “help wanted” tasks and modular ownership by team members.
- 6
AFFiNE ties commercialization to open-source exposure by offering a web try-demo and Docker-based deployment to lower trial friction.
- 7
General-purpose collaboration infrastructure (Block Suite and AutoBase) is open-sourced to make building collaborative applications less costly in the future.