# Powerhouse Academy

> Powerhouse is an open-source toolkit for building decentralized applications with document models, real-time collaboration, and scalable network organizations. This documentation covers the full developer journey: getting started, building document models and editors, working with processors and data, deploying packages, and the underlying architecture.

## Get Started

- [Explore the demo package](https://powerhouse.academy/academy/GetStarted/ExploreDemoPackage): To give you a quick idea of how the Powerhouse Vetra builder platform operates on document models and packages, why don't you try installing a package
- [Create a new to-do list document](https://powerhouse.academy/academy/GetStarted/CreateNewPowerhouseProject): This tutorial step has a corresponding branch in the repository. You can:
- [Write the document specification](https://powerhouse.academy/academy/GetStarted/DefineToDoListDocumentModel): This tutorial step has a corresponding branch. After completing this step, your project will have a generated document model with:
- [Implement the document model reducers](https://powerhouse.academy/academy/GetStarted/ImplementOperationReducers): This step focuses on implementing the reducer logic for add, update, and delete operations.
- [Write document model tests](https://powerhouse.academy/academy/GetStarted/WriteDocumentModelTests): This step focuses on writing comprehensive tests for the reducers you implemented in the previous step.
- [Build a to-do list editor](https://powerhouse.academy/academy/GetStarted/BuildToDoListEditor): - Editor Scaffolding: step-5-generate-todo-list-document-editor - Complete Editor UI: step-6-add-basic-todo-editor-ui-components

## Mastery Track

- [Prerequisites](https://powerhouse.academy/academy/MasteryTrack/BuilderEnvironment/Prerequisites): Let's set up your machine to start building your first Document Model. Don't worry if this is your first time setting up a development environment - w
- [Vetra Studio](https://powerhouse.academy/academy/MasteryTrack/BuilderEnvironment/VetraStudio): Vetra Studio is the builder environment where you create, manage, and collaborate on Powerhouse packages. It consists of two main components:
- [Create a package with Vetra](https://powerhouse.academy/academy/MasteryTrack/BuilderEnvironment/CreateAPackageWithVetra): A Powerhouse Package is a distributable unit that bundles one or more document models, editors, and optional reactor modules into a single installable
- [Vetra Cloud](https://powerhouse.academy/academy/MasteryTrack/BuilderEnvironment/VetraCloud): Vetra Cloud is the hosted infrastructure layer for Powerhouse applications. It lets you spin up a personal cloud environment that runs Powerhouse Conn
- [Vetra builder tooling](https://powerhouse.academy/academy/MasteryTrack/BuilderEnvironment/BuilderTools): This page provides an overview of all the builder tooling offered in the Vetra ecosystem by Powerhouse. This list will be maintained and updated as ou
- [What is a document model?](https://powerhouse.academy/academy/MasteryTrack/DocumentModelCreation/WhatIsADocumentModel): This chapter on Document Model Creation will help you with an in-depth practical understanding while building an advanced to-do list document model.
- [Specify the state schema](https://powerhouse.academy/academy/MasteryTrack/DocumentModelCreation/SpecifyTheStateSchema): The state schema is the backbone of your document model. It defines the structure, data types, and relationships of the information your document will
- [Specify document operations](https://powerhouse.academy/academy/MasteryTrack/DocumentModelCreation/SpecifyDocumentOperations): In the previous section, we defined the state schema for our document model. Now, we turn our attention to a critical aspect of document model creatio
- [Use the Document Model Generator](https://powerhouse.academy/academy/MasteryTrack/DocumentModelCreation/UseTheDocumentModelGenerator): When building document models with Vetra Studio, code generation happens automatically. As you add and update specification documents in your Vetra St
- [Implement document reducers](https://powerhouse.academy/academy/MasteryTrack/DocumentModelCreation/ImplementDocumentReducers): In our journey through Powerhouse Document Model creation, we've defined the "what" – the structure of our data (State Schema) and the ways it can be 
- [Implement document model tests](https://powerhouse.academy/academy/MasteryTrack/DocumentModelCreation/ImplementDocumentModelTests): In the previous chapter, we implemented the core reducer logic for our document model. Now, we reach a critical stage that underpins the reliability a
- [Example: Todo-demo-package](https://powerhouse.academy/academy/MasteryTrack/DocumentModelCreation/ExampleToDoListRepository): The Todo-demo is maintained by the Powerhouse Team and serves as a reference for testing and introducing new features. It will be continuously updated
- [Document Model Versioning](https://powerhouse.academy/academy/MasteryTrack/DocumentModelCreation/DocumentModelVersioning): This chapter covers advanced document model versioning—a system for evolving document schemas and operations while maintaining backward compatibility 
- [Build document editors](https://powerhouse.academy/academy/MasteryTrack/BuildingUserExperiences/BuildingDocumentEditors): At Powerhouse, frontend development for document editors follows a simple and familiar flow, leveraging the power and flexibility of React.
- [Build a Drive-app](https://powerhouse.academy/academy/MasteryTrack/BuildingUserExperiences/BuildingADriveExplorer): Drive-apps enhance how contributors and organizations interact with document models. They create an 'app-like' experience by providing a custom interf
- [CSS Customization for Connect Integration](https://powerhouse.academy/academy/MasteryTrack/BuildingUserExperiences/CSSCustomization): When your editor runs inside Connect, it's rendered within a specific container hierarchy. Understanding this structure allows you to customize your e
- [Document Toolbar](https://powerhouse.academy/academy/MasteryTrack/BuildingUserExperiences/DocumentTools/DocumentToolbar): The DocumentToolbar renders a default set of document controls for common document actions: undo, redo, download, document name editing, revision hist
- [Operations history](https://powerhouse.academy/academy/MasteryTrack/BuildingUserExperiences/DocumentTools/OperationHistory): A document model in Powerhouse is the core unit for managing business data. Each document (such as an invoice, contributor agreement, or scope of work
- [Revision history timeline](https://powerhouse.academy/academy/MasteryTrack/BuildingUserExperiences/DocumentTools/RevisionHistoryTimeline): The history timeline feature enables users to view document history and navigate through different revisions of a document. This guide explains how to
- [Inspector Modal](https://powerhouse.academy/academy/MasteryTrack/BuildingUserExperiences/DocumentTools/InspectorModal): The Inspector Modal is a development and debugging tool in Connect that provides visibility into the internal state of your application. It allows you
- [Renown authentication flow](https://powerhouse.academy/academy/MasteryTrack/BuildingUserExperiences/Authorization/RenownAuthenticationFlow): The Renown login flow leverages decentralized identity (DID) creation and the Ceramic network for credential storage and verification, ensuring secure
- [Document Permission System](https://powerhouse.academy/academy/MasteryTrack/BuildingUserExperiences/Authorization/DocumentPermissions): This documentation is still being written and may be incomplete. The feature is not yet available on production.
- [Signing](https://powerhouse.academy/academy/MasteryTrack/BuildingUserExperiences/Authorization/Signing): Powerhouse uses two complementary signing mechanisms to establish trust across the document lifecycle:
- [Reactor API Authorization](https://powerhouse.academy/academy/MasteryTrack/BuildingUserExperiences/Authorization/Authorization): This documentation is still being written and may be incomplete.
- [Configure a drive](https://powerhouse.academy/academy/MasteryTrack/WorkWithData/ConfiguringDrives): A drive in Powerhouse is a container for documents and data. It's a place where you can organize and store your documents and share them with others. 
- [Using the API](https://powerhouse.academy/academy/MasteryTrack/WorkWithData/UsingTheAPI): Switchboard is the API interface that enables developers and data engineers to access data captured through document models in Connect and Fusion.
- [Using subgraphs](https://powerhouse.academy/academy/MasteryTrack/WorkWithData/UsingSubgraphs): This tutorial will demonstrate how to create and customize a subgraph using our to-do list project as an example. Let's start with the basics and grad
- [Building a processor](https://powerhouse.academy/academy/MasteryTrack/WorkWithData/BuildingAProcessor): Processors are components that receive document operations from the reactor and perform side effects. While specialized processor types like relationa
- [Processor best practices](https://powerhouse.academy/academy/MasteryTrack/WorkWithData/ProcessorBestPractices): This guide covers advanced patterns for processors that need to mutate documents or query indexed data. It builds on the concepts from Building a Proc
- [Relational database processor](https://powerhouse.academy/academy/MasteryTrack/WorkWithData/RelationalDbProcessor): In this chapter, we will implement a Todo-List relational database processor. This processor receives operations from the reactor and can use resultin
- [Publish your package](https://powerhouse.academy/academy/MasteryTrack/Launch/PublishYourProject): This guide assumes familiarity with building document models in Vetra Studio. Please start with the Get Started chapter or Document Model Creation sec
- [Setup your environment](https://powerhouse.academy/academy/MasteryTrack/Launch/SetupEnvironment): Powerhouse is a powerful platform that helps you manage and deploy your applications efficiently. This guide will walk you through the process of sett
- [Configure your environment](https://powerhouse.academy/academy/MasteryTrack/Launch/ConfigureEnvironment): After successfully setting up your server and installing the Powerhouse services using the ph service setup command as described in the Setup Environm
- [Docker deployment guide](https://powerhouse.academy/academy/MasteryTrack/Launch/DockerDeployment): Powerhouse provides official Docker images for deploying your applications in containerized environments. This guide covers the available Docker image

## Example Use Cases

- [Example use-cases](https://powerhouse.academy/academy/ExampleUsecases/Overview): Explore real-world examples of applications built with the Powerhouse ecosystem. Each use-case provides a complete walkthrough from project setup to a
- [Create a new chatroom project](https://powerhouse.academy/academy/ExampleUsecases/Chatroom/CreateNewPowerhouseProject): This tutorial has a complete reference implementation available. You can:
- [Write the document specification](https://powerhouse.academy/academy/ExampleUsecases/Chatroom/DefineChatroomDocumentModel): This tutorial step has a corresponding implementation in the repository. After completing this step, your project will have a document model specifica
- [Implement the document model reducers](https://powerhouse.academy/academy/ExampleUsecases/Chatroom/ImplementOperationReducers): This tutorial covers two key implementations:
- [Build the ChatRoom editor](https://powerhouse.academy/academy/ExampleUsecases/Chatroom/ImplementChatroomEditor): This tutorial covers building the ChatRoom editor:
- [Step 0 - get the starter code](https://powerhouse.academy/academy/ExampleUsecases/TodoList/GetTheStarterCode): Normally you would initialize a new powerhouse project by running ph init with your project name. But since this is a tutorial, we want to provide bra
- [Step 1 - Generate the `TodoList` document model](https://powerhouse.academy/academy/ExampleUsecases/TodoList/GenerateTodoListDocumentModel): This tutorial guides you through creating a simplified version of a 'Powerhouse project' for a To-do List. A Powerhouse project primarily consists of 
- [Step 2 — Implement the `TodoList` document model reducer operation handlers](https://powerhouse.academy/academy/ExampleUsecases/TodoList/ImplementTodoListDocumentModelReducerOperationHandlers): Your document model update's the state of a given document by applying a set of append-only actions. Once these have been applied to the document, we 
- [Step 3 — Adding our own tests for the document model actions](https://powerhouse.academy/academy/ExampleUsecases/TodoList/AddTestsForTodoListActions): Similarly to the operation handler logic, when you add a new module to your document model, we generate some boilerplate tests for your code.
- [Step 4 — Generating a document model editor for `TodoList` documents](https://powerhouse.academy/academy/ExampleUsecases/TodoList/GenerateTodoListDocumentEditor): Run the command below to generate the editor template for the TodoList document model. This command reads the TodoList document model definition from 
- [Step 5 — Implement `TodoList` document editor UI components](https://powerhouse.academy/academy/ExampleUsecases/TodoList/ImplementTodoListDocumentEditorUIComponents): Out of the box, we have a component for updating our TodoList documents' names, but we would like to create, read, update, and delete all of the data 
- [Step 6 - Generate the custom drive editor for managing our `TodoList` documents](https://powerhouse.academy/academy/ExampleUsecases/TodoList/GenerateTodoDriveExplorer): in Connect, a "drive" is just a document with the type "powerhouse/drive", which is specifically created for containing and managing other documents.
- [Step 7 - Add shared component for showing TodoList stats](https://powerhouse.academy/academy/ExampleUsecases/TodoList/AddSharedComponentForShowingTodoListStats): So far we've been creating components that live in the same directories as the editors that use them. But sometimes we want to use the same component 
- [VetraPackageLibrary](https://powerhouse.academy/academy/ExampleUsecases/VetraPackageLibrary/VetraPackageLibrary): Packages of documents are a core structuring mechanism in the Vetra framework, allowing developers to group and manage related document efficiently. T

## API References

- [Powerhouse CLI](https://powerhouse.academy/academy/APIReferences/PowerhouseCLI): The Powerhouse CLI tool is the only essential tool to install on this page. Install it with the command below.
- [React Hooks](https://powerhouse.academy/academy/APIReferences/ReactHooks): This page provides a reference for the hooks available in @powerhousedao/reactor-browser. These hooks are intended to be used by editors (including dr
- [IReactorClient](https://powerhouse.academy/academy/APIReferences/ReactorClient): The IReactorClient interface is the primary way to interact with a Powerhouse reactor programmatically. It wraps lower-level APIs to provide a simpler
- [Advanced reactor usage](https://powerhouse.academy/academy/APIReferences/AdvancedReactorUsage): This page covers the low-level IReactor interface and the internal components you can access through ReactorModule. Most developers should use IReacto
- [Relational Database](https://powerhouse.academy/academy/APIReferences/RelationalDatabase): This page covers the relational database tools available in Powerhouse applications, providing type-safe database operations with real-time updates th
- [PHDocument Migration Guide](https://powerhouse.academy/academy/APIReferences/PHDocumentMigrationGuide): This guide covers the breaking changes introduced in Powerhouse v4.0.0 related to PHDocument structure changes. If you're upgrading from v3.2.0 or ear
- [Vetra Remote Drive](https://powerhouse.academy/academy/APIReferences/VetraRemoteDrive): These commands enable collaborative development using Vetra remote drives. Instead of working with local drives only, you can connect your Powerhouse 
- [Subgraph Migration Guide (v6 Reactor)](https://powerhouse.academy/academy/APIReferences/SubgraphMigrationGuide): This guide covers the breaking changes to the GraphQL subgraph API introduced in the v6 Reactor. If you were querying the old /graphql/document-drive 
- [Processor Migration Guide (v6 Reactor)](https://powerhouse.academy/academy/APIReferences/ProcessorMigrationGuide): This guide covers the breaking changes to the processor interface introduced in the v6 Reactor. If you have existing processors built on the legacy st
- [Attachment service](https://powerhouse.academy/academy/APIReferences/AttachmentService): The @powerhousedao/reactor-attachments package decouples large binaries (images, files, avatars) from the action and operation pipeline. Instead of ca
- [Renown SDK](https://powerhouse.academy/academy/APIReferences/renown-sdk/Overview): A comprehensive SDK for integrating Renown authentication and user profile management into your React applications.
- [Authentication Guide](https://powerhouse.academy/academy/APIReferences/renown-sdk/Authentication): Comprehensive guide to implementing authentication with the Renown SDK.
- [API Reference](https://powerhouse.academy/academy/APIReferences/renown-sdk/APIReference): Complete API reference for the Renown SDK.
- [CLI Identity & Authentication](https://powerhouse.academy/academy/APIReferences/renown-sdk/CLIIdentity): This guide covers how to authenticate the Powerhouse CLI with your Ethereum identity and use that identity in the Switchboard for authenticated operat

## Component Library

- [Document-Engineering](https://powerhouse.academy/academy/ComponentLibrary/DocumentEngineering): The reusable components in the Document-Engineering system are a set of of front-end components based on graphQL scalars.
- [Step 1: Create Custom Scalars](https://powerhouse.academy/academy/ComponentLibrary/CreateCustomScalars): This tutorial provides step-by-step instructions for creating custom scalars & components, and to contributing to the document-engineering project.
- [Step 2: Integrate Your Scalar into a React Component](https://powerhouse.academy/academy/ComponentLibrary/IntegrateIntoAReactComponent): This guide explains how to use a custom scalar (created as described in the previous step) within a React component. You'll learn how to leverage the 

## Architecture

- [Powerhouse Architecture](https://powerhouse.academy/academy/Architecture/PowerhouseArchitecture): Vetra is part of the Powerhouse Ecosystem and acts as the builder platform for creating an independent, open-source and decentralized back-end for any
- [Working with the Reactor](https://powerhouse.academy/academy/Architecture/WorkingWithTheReactor): Document models are the common design pattern that is used for all documents and files. DocSync is a decentralized synchronization protocol that is st

## Book of Powerhouse

- [Overview](https://powerhouse.academy/bookofpowerhouse/Overview): Powerhouse is an initiative at the intersection of software development, legal innovation, and new business models for open-source projects. These ele
- [**Part 1: Powerhouse General Framework and Open-Source Capitalism**](https://powerhouse.academy/bookofpowerhouse/GeneralFrameworkAndPhilosophy): Powerhouse emerged in the wake of Ethereum’s DAO movement, which began gaining momentum after the collapse of _The DAO_ in 2016. This turning point sp
- [Part 2: Powerhouse Software Architecture](https://powerhouse.academy/bookofpowerhouse/PowerhouseSoftwareArchitecture): Powerhouse’s software architecture is designed to empower scalable, decentralized organizations with a modular, layered approach. It uses document mod
- [Part 3: Development Approaches](https://powerhouse.academy/bookofpowerhouse/DevelopmentApproaches): Powerhouse’s development approaches are designed to enable efficient, scalable, and innovative solutions for decentralized organizations. By drawing f
- [Part 4: Scalable Network Organizations (SNOs)](https://powerhouse.academy/bookofpowerhouse/SNOsandANewModelForOSSandPublicGoods): Decentralized Autonomous Organizations (DAOs) once promised to revolutionize global collaboration by enabling decentralized governance, transparent de
- [**Part 5: Powerhouse Platforms – Decentralized Operations and Builder**](https://powerhouse.academy/bookofpowerhouse/SNOsInActionAndPlatformEconomies): The Powerhouse architecture is not only organizational but also deeply technological. To enable scalable network organizations (SNOs) to operate effec

## Release Notes

- [Powerhouse v5.3.0 🚀](https://powerhouse.academy/academy/ReleaseNotes/v5.3.0): 1. Authentication & Permissions - CLI authentication and document-level permissions 2. Improved Code Generation - TS Morph and templates for faster, m

## Miscellaneous

- [Cookbook](https://powerhouse.academy/academy/Cookbook): This section covers recipes related to the ph-cmd, the command-line tool for Powerhouse project initialization, code generation, package management, a
- [Glossary](https://powerhouse.academy/academy/Glossary): - Powerhouse – A network organization that provides open-source software and services to support decentralized operations for other network organizati
- [LLM docs](https://powerhouse.academy/academy/LLMDocs): The Powerhouse Academy follows the llms.txt standard to provide machine-readable documentation for LLMs and AI coding tools.
- [Step 2 — Implement the `TodoList` document model reducer operation handlers](https://powerhouse.academy/academy/TodoListTutorial/ImplementTodoListDocumentModelReducerOperationHandlers): Your document model update's the state of a given document by applying a set of append-only actions. Once these have been applied to the document, we 
- [Step 3 — Adding our own tests for the document model actions](https://powerhouse.academy/academy/TodoListTutorial/AddTestsForTodoListActions): Similarly to the operation handler logic, when you add a new module to your document model, we generate some boilerplate tests for your code.
- [Step 5 — Implement `TodoList` document editor UI components](https://powerhouse.academy/academy/TodoListTutorial/ImplementTodoListDocumentEditorUIComponents): Out of the box, we have a component for updating our TodoList documents' names, but we would like to create, read, update, and delete all of the data 
- [Step 7 - Add shared component for showing TodoList stats](https://powerhouse.academy/academy/TodoListTutorial/AddSharedComponentForShowingTodoListStats): So far we've been creating components that live in the same directories as the editors that use them. But sometimes we want to use the same component 

## Optional

- [llms-full.txt](https://powerhouse.academy/llms-full.txt): Complete documentation concatenated into a single file for full-context LLM ingestion