@powerhousedao/academy 4.1.0-dev.12 → 4.1.0-dev.120

package/README.md

@@ -1,8 +1,8 @@
 # Website
 
 This documentation website is built using [Docusaurus](https://docusaurus.io/), a modern static website generator.
-To contribute to the documentation please work on a feature branch in case of big refactors, and build & serve before pushing to the development branch. 
-Pushing from the dev branch to the main branch will trigger an auto deployment in Heroku for the staging deployment. 
+To contribute to the documentation please work on a feature branch in case of big refactors, and build & serve before pushing to the development branch.
+Pushing from the dev branch to the main branch will trigger an auto deployment in Heroku for the staging deployment.
 
 ### Installation
 
@@ -16,7 +16,7 @@ $ npm install
 $ npm run dev
 ```
 
-This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server. The server will break upon broken links or big navigation/relinking. 
+This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server. The server will break upon broken links or big navigation/relinking.
 
 ### Build
 

package/babel.config.js

@@ -1,3 +1,3 @@
 module.exports = {
-  presets: [require.resolve('@docusaurus/core/lib/babel/preset')],
+  presets: [require.resolve("@docusaurus/core/lib/babel/preset")],
 };

package/blog/BeyondCommunication-ABlueprintForDevelopment.md

@@ -3,7 +3,7 @@ title: Beyond Communication - A Blueprint for Development
 description: GraphQL Schema’s as a common language for software design
 slug: Graphql-schema-as-a-common-language
 authors:
-  - name: Call me T. 
+  - name: Call me T.
     title: Product Manager at Powerhouse
     image_url: https://avatars.githubusercontent.com/u/148560082?v=4
     socials:
@@ -12,6 +12,7 @@ tags: [Design thinking, Tooling, Product, GraphQL, Schema's]
 image: https://i.imgur.com/mErPwqL.png
 hide_table_of_contents: false
 ---
+
 GraphQL Schema’s as a common language for software design, bridging the gaps between all stakeholders with the help of a single source of truth document model.
 
 <!-- truncate -->
@@ -26,7 +27,7 @@ GraphQL Schema’s as a common language for software design, bridging the gaps b
 
 #### For non-technical contributors, schemas offer a clear, readable map of how data flows through a system. Business analysts, product managers, and designers can quickly grasp the relationships between data types and operations without needing to dive into code. “**For developers, schemas serve as a contract, reducing ambiguity during implementation**”. Queries and mutations clearly define how data can be fetched or modified, leaving little room for misinterpretation.
 
-#### 
+####
 
 #### By bringing clarity to these conversations, GraphQL fosters collaboration within cross-functional teams and accelerates onboarding for new contributors.
 
@@ -34,12 +35,12 @@ GraphQL Schema’s as a common language for software design, bridging the gaps b
 
 The utility of GraphQL schemas extends far beyond communication. They act as a blueprint that shapes every phase of the development lifecycle:
 
-* **Planning and Design**:  
-  * During the design phase, schemas enable teams to validate assumptions early. Data requirements and workflows can be reviewed collaboratively, ensuring alignment before development begins.  
-* **Implementation**:  
-  * Developers use schemas as a definitive source of truth, minimizing the need for rework caused by unclear specifications.  
-* **Testing and Maintenance**:  
-  * When the schema evolves, it highlights changes or inconsistencies, making it easier to adapt systems without breaking existing functionality.
+- **Planning and Design**:
+  - During the design phase, schemas enable teams to validate assumptions early. Data requirements and workflows can be reviewed collaboratively, ensuring alignment before development begins.
+- **Implementation**:
+  - Developers use schemas as a definitive source of truth, minimizing the need for rework caused by unclear specifications.
+- **Testing and Maintenance**:
+  - When the schema evolves, it highlights changes or inconsistencies, making it easier to adapt systems without breaking existing functionality.
 
 The result is a smoother development process, where every stakeholder operates with a shared understanding of the system’s architecture.
 
@@ -49,9 +50,9 @@ GraphQL's design pairs naturally with the Command Query Responsibility Segregati
 
 In a CQRS-driven architecture:
 
-* **Queries** retrieve data efficiently.  
-* **Mutations** handle data modifications.  
-* **Subscriptions** enable real-time updates.
+- **Queries** retrieve data efficiently.
+- **Mutations** handle data modifications.
+- **Subscriptions** enable real-time updates.
 
 GraphQL’s separation of these operations ensures clarity and scalability, especially in distributed systems. Developers can optimize read and write models independently, leading to improved performance and maintainability. This structured approach also simplifies troubleshooting and ensures a smoother evolution of complex systems.
 
@@ -59,12 +60,12 @@ GraphQL’s separation of these operations ensures clarity and scalability, espe
 
 GraphQL’s strong typing makes it a natural ally for TypeScript, a language known for its type safety and developer-friendly features. Together, they form a powerful combination that enhances developer experience and system reliability.
 
-* **Type Safety Across the Stack**:  
-  * Developers can auto-generate TypeScript types from GraphQL schemas, ensuring consistency between client and server. This reduces boilerplate code and eliminates many common runtime errors.  
-* **Improved Developer Productivity**:  
-  * With type safety built into both the API and the client code, developers can catch potential issues during development, saving time and reducing bugs.  
-* **Seamless Front-End Integrations**:  
-  * For front-end teams, GraphQL and TypeScript streamline the process of building data-driven applications, ensuring that APIs and components stay in sync.
+- **Type Safety Across the Stack**:
+  - Developers can auto-generate TypeScript types from GraphQL schemas, ensuring consistency between client and server. This reduces boilerplate code and eliminates many common runtime errors.
+- **Improved Developer Productivity**:
+  - With type safety built into both the API and the client code, developers can catch potential issues during development, saving time and reducing bugs.
+- **Seamless Front-End Integrations**:
+  - For front-end teams, GraphQL and TypeScript streamline the process of building data-driven applications, ensuring that APIs and components stay in sync.
 
 This synergy results in cleaner, more reliable code and a significantly improved development experience.
 
@@ -72,12 +73,12 @@ This synergy results in cleaner, more reliable code and a significantly improved
 
 Beyond fostering better communication and aligning stakeholders, GraphQL drives efficiency in several key ways:
 
-* **Streamlined API Development**:  
-  * With its declarative queries, GraphQL eliminates over-fetching and under-fetching of data, allowing front-end teams to request only what they need.  
-* **Empowered Non-Technical Contributors**:  
-  * The interactive nature of GraphQL schemas makes them accessible to non-technical stakeholders, enabling them to explore APIs independently and contribute more effectively to design discussions. The ‘lingua franca’ characteristic now truly starts to live up to its promises as designer or business analysts now can interact with the base schema and steer and discuss potential solutions together with the development team.   
-* **Real-Time Introspection**:  
-  * Tools like GraphQL Playground allow teams to inspect and test APIs dynamically, making development and debugging faster and more collaborative.
+- **Streamlined API Development**:
+  - With its declarative queries, GraphQL eliminates over-fetching and under-fetching of data, allowing front-end teams to request only what they need.
+- **Empowered Non-Technical Contributors**:
+  - The interactive nature of GraphQL schemas makes them accessible to non-technical stakeholders, enabling them to explore APIs independently and contribute more effectively to design discussions. The ‘lingua franca’ characteristic now truly starts to live up to its promises as designer or business analysts now can interact with the base schema and steer and discuss potential solutions together with the development team.
+- **Real-Time Introspection**:
+  - Tools like GraphQL Playground allow teams to inspect and test APIs dynamically, making development and debugging faster and more collaborative.
 
 These features combine to create a more agile, responsive development environment, where teams can adapt quickly to changing requirements.
 
@@ -85,4 +86,4 @@ These features combine to create a more agile, responsive development environmen
 
 The success of any software project hinges on clear communication and shared understanding. GraphQL schemas provide the common language that teams need to align around a unified vision. From clarifying data relationships to supporting scalable architectures, GraphQL empowers organizations to overcome the "lost in translation" problem and focus on what truly matters: building great products.
 
-For teams seeking to improve collaboration, efficiency, and scalability, GraphQL is more than a tool—it’s a framework for shared success,
+For teams seeking to improve collaboration, efficiency, and scalability, GraphQL is more than a tool—it’s a framework for shared success,

package/blog/TheChallengeOfChange.md

@@ -1,9 +1,9 @@
 ---
 title: The Challenge of Change
-description: Rapid Application Development with document models. 
+description: Rapid Application Development with document models.
 slug: Rapid-Application-Development-with-document-models.
 authors:
-  - name: Call me T. 
+  - name: Call me T.
     title: Product Manager at Powerhouse
     image_url: https://avatars.githubusercontent.com/u/148560082?v=4
     socials:
@@ -12,6 +12,7 @@ tags: [Dao, Tooling]
 image: https://i.imgur.com/mErPwqL.png
 hide_table_of_contents: false
 ---
+
 ### **The Challenge of Change**
 
 The pace of innovation is relentless. Organizations today find themselves in a race to adapt to new technologies, shifting consumer demands, and evolving or opaque regulations. Yet, the traditional methods of building and maintaining software systems often lag behind the speed of change, creating bottlenecks that stifle growth and innovation.
@@ -20,10 +21,10 @@ The pace of innovation often outstrips an organization’s ability to adapt, kee
 
 <!-- truncate -->
 
-Across many industries, this comes down to a familiar struggle of common trade-offs in product and solution development. 
+Across many industries, this comes down to a familiar struggle of common trade-offs in product and solution development.
 
 **\- Speed vs. Accuracy:** The balance between haste or precision  
-**\- Customizability vs. Scalability:** Meeting specific needs or relentless standardisation 
+**\- Customizability vs. Scalability:** Meeting specific needs or relentless standardisation
 
 As businesses push to innovate, they face a crucial question: how can they accelerate development without sacrificing quality or flexibility?
 
@@ -37,19 +38,18 @@ The answer lies in embracing methodologies that prioritize agility and adaptabil
 
 Key benefits of RAD include:
 
-* **Rapid Prototyping**: Organizations can quickly test ideas without committing to large-scale development, allowing for faster feedback and iteration.  
-* **Iterative Development**: Instead of delivering a finished product all at once, RAD emphasizes incremental improvements, reducing the risk of misaligned expectations.  
-* **Adaptability to Change**: By designing with flexibility in mind, RAD allows organizations to pivot and respond to new demands or challenges with ease.
-
-These principles have been widely embraced in industries ranging from DAO’s, incubators, tech startups to multinational corporations (in the case of the latter often with the help of a high ticket consultant). Other methodologies from adjacent domains of RAD, that you might be more familiar with include: 
+- **Rapid Prototyping**: Organizations can quickly test ideas without committing to large-scale development, allowing for faster feedback and iteration.
+- **Iterative Development**: Instead of delivering a finished product all at once, RAD emphasizes incremental improvements, reducing the risk of misaligned expectations.
+- **Adaptability to Change**: By designing with flexibility in mind, RAD allows organizations to pivot and respond to new demands or challenges with ease.
 
-* **Lean Start-up Methodology**: Focussing on finding product market fit early with a minimum viable product through a build, measure, learn cycle.   
-* **Pre-totyping:** A method by Google's first engineering director focused on validating that you are building the ‘right it’ before you ‘build it’ right with the help of smoke tests or mock-ups.   
-* **Design-thinking:** Where designers & developers go through non-linear, iterative processes of discovery, definition, development & delivery of their ideas with the help of prototyping together with end-users.
+These principles have been widely embraced in industries ranging from DAO’s, incubators, tech startups to multinational corporations (in the case of the latter often with the help of a high ticket consultant). Other methodologies from adjacent domains of RAD, that you might be more familiar with include:
 
+- **Lean Start-up Methodology**: Focussing on finding product market fit early with a minimum viable product through a build, measure, learn cycle.
+- **Pre-totyping:** A method by Google's first engineering director focused on validating that you are building the ‘right it’ before you ‘build it’ right with the help of smoke tests or mock-ups.
+- **Design-thinking:** Where designers & developers go through non-linear, iterative processes of discovery, definition, development & delivery of their ideas with the help of prototyping together with end-users.
 
 ![Iteration](./images/Iteration.png)
-*Figure 1: Notice how  Design thinking, Lean Startup Methodology and Rapid Application Development all rely on tooling that put rapid iteration at the center of the methodology? It remains crucial to select the right tool with the correct prototype fidelity at any of the stages these methodologies prescribe*
+_Figure 1: Notice how Design thinking, Lean Startup Methodology and Rapid Application Development all rely on tooling that put rapid iteration at the center of the methodology? It remains crucial to select the right tool with the correct prototype fidelity at any of the stages these methodologies prescribe_
 
 ---
 
@@ -57,9 +57,9 @@ These principles have been widely embraced in industries ranging from DAO’s, i
 
 Despite their success in simpler times, traditional development methodologies are currently often falling short in today’s dynamic environments.
 
-* **Long Lead Times**: Developing complex systems from scratch can take months or even years, by which time business requirements may have shifted.  
-* **Limited Customization**: Off-the-shelf solutions may be fast to deploy but rarely align perfectly with an organization’s unique workflows.  
-* **High Costs of Change**: Adjusting systems mid-development often incurs significant costs and delays, making organizations hesitant to pivot.
+- **Long Lead Times**: Developing complex systems from scratch can take months or even years, by which time business requirements may have shifted.
+- **Limited Customization**: Off-the-shelf solutions may be fast to deploy but rarely align perfectly with an organization’s unique workflows.
+- **High Costs of Change**: Adjusting systems mid-development often incurs significant costs and delays, making organizations hesitant to pivot.
 
 To overcome these challenges, businesses need a new approach—one that combines speed, flexibility, and precision.
 
@@ -71,16 +71,16 @@ Powerhouse is proposing a framework built to address these very challenges, offe
 
 At the core of Powerhouse’s approach is its **document model-driven architecture**, a GraphQL schema based foundation that reimagines how data, workflows, and processes are structured. This architecture enables organizations to:
 
-* **Capture Data Effectively**: Modular document models allow organizations to define and adapt workflows with higher accuracy.   
-* **Automate Workflows**: With tools to streamline even the most complex processes, so organizations can focus on innovation instead of repetitive tasks.  
-* **Iterate and Evolve Rapidly**: Modular, reusable components reduce development times, enabling organizations to adapt to their most pressing challenges and changes. 
+- **Capture Data Effectively**: Modular document models allow organizations to define and adapt workflows with higher accuracy.
+- **Automate Workflows**: With tools to streamline even the most complex processes, so organizations can focus on innovation instead of repetitive tasks.
+- **Iterate and Evolve Rapidly**: Modular, reusable components reduce development times, enabling organizations to adapt to their most pressing challenges and changes.
 
 ---
 
 ### **From a front-end developers perspective**
 
->“The coolest part is being able to plug into any document model and start building UI components for it without the hassle of managing a 'backend' or 'state management' for the components. All front-end devs use and love redux, the event driven architecture these document models are using. But the fact that as a front end dev, you don't have to set up any of it, and can just plug into the underlying framework saves time. It allows me to focus on my actual tasks \- building awesome UI components and experiences. I could start thinking of the same document model but with a 1000 different UI’s depending on the user's specific needs and preferences. Like swapping skins in my favorite video game”
+> “The coolest part is being able to plug into any document model and start building UI components for it without the hassle of managing a 'backend' or 'state management' for the components. All front-end devs use and love redux, the event driven architecture these document models are using. But the fact that as a front end dev, you don't have to set up any of it, and can just plug into the underlying framework saves time. It allows me to focus on my actual tasks \- building awesome UI components and experiences. I could start thinking of the same document model but with a 1000 different UI’s depending on the user's specific needs and preferences. Like swapping skins in my favorite video game”
 
-The rapid application development process we’re setting up, allows us to move quicker from initial problem definition to potential prototype opens up time for designers and developers to actually test and iterate on their imagined solution. 
+The rapid application development process we’re setting up, allows us to move quicker from initial problem definition to potential prototype opens up time for designers and developers to actually test and iterate on their imagined solution.
 
 By prioritizing rapid, iterative development, Powerhouse aims to empower organizations to innovate faster, adapt more seamlessly, and achieve sustainable growth in even the most challenging environments.

package/docs/academy/00-EthereumArgentinaHackathon.md

@@ -0,0 +1,208 @@
+---
+id: EthereumArgentinaHackathon
+title: Ethereum Argentina Hackathon
+---
+
+# Ethereum Argentina Hackathon
+
+**November 19-20, 2024**
+
+Welcome to the Vetra hacker page for the Ethereum Argentina Hackathon! We're excited to support developers building with Powerhouse during this event.
+
+## Overview
+
+Join us for two days of intensive development support as you build decentralized applications using the Vetra framework. Our team will be available online and at the mentor's table to help you navigate the builder platform, answer questions, and guide you through best practices.
+
+## 📅 Event Details
+
+- **Dates**: November 19-20, 2024
+- **Format**: Online & IRL Developer Support
+- **Time Zone**: Argentina Time (ART)
+- **Support Hours at Mentor Table @ la Rural**: Please get in touch on Discord to schedule! https://discord.gg/pwQJwgaQKd
+- **Hackathon informations**: [Taiki Hackathon](https://taikai.network/ethargentina/hackathons/tierra-de-buidlers-2025/overview)
+
+## 🚀 Getting Started
+
+<details>
+<summary> Vetra Introduction & Follow Along Demo </summary>
+
+Please Rewatch our Hackathon introduction & follow along tutorial. 
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/R5MAaGaopJg" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
+
+Find a complete overview of how to use the Vetra Studio for you project [Here](docs/academy/GetStarted/VetraStudio.md)
+
+**Quick Start Summary**
+
+- Step 1: Install the powerhouse-CLI: `pnpm install -g ph-cmd`
+- Step 2: Initialize a project & directory `ph init my-project-name`
+- Step 3: CD into you project directory
+- Step 4: Launch Vetra Studio with the `ph vetra`command
+- Step 5: Add the necessary document models & editors for your intended solution in Vetra Studio
+- Step 6: If you're well versed in schema creation or graphql. Just talk with an agent about your imagined solution.
+- Step 7: Start your preferred agent to help you with the initial scaffolding of your schema, operations and reducers. 
+- Step 8: Test your implementation in the "Vetra Preview Drive" with the `ph vetra --watch`command. 
+- Step 9: Run pnpm build and push your project to a remote repository.Follow the package publishing [Tutorial](academy/MasteryTrack/Launch/PublishYourProject.md)
+
+**Basic tips** 
+- 1️⃣ Write a detailed description of your intented functionality inside the document model specification manifest
+- 2️⃣ Ask your agent to ask for clarifying questions before starting any ideation process. 
+- 3️⃣ For each document model you'll want to create an accompanying editor in vetra studio. 
+- 4️⃣ An 'App' specifcation is an drive that can act as an app because of the specific interface you create for it. 
+
+### Before the Hackathon
+
+1. **Set Up Your Environment**
+   - Install the Powerhouse CLI
+   - Set up your development environment
+   - Review the [Get Started Guide](./01-GetStarted/home.mdx)
+
+2. **Explore the Platform**
+   - Check out the [Demo Package](./01-GetStarted/00-ExploreDemoPackage.mdx)
+   - Familiarize yourself with [Document Models](./02-MasteryTrack/02-DocumentModelCreation/01-WhatIsADocumentModel.md)
+
+3. **Join Our Community**
+   - Discord: [Join our server](#)
+
+
+</details>
+
+:::Tip Use your preferred AI agent
+Vetra studio is compatible with Cursor, Claude and Gemini. j
+Use the dedicated markdown files to guide your agent with the correct instruction.
+::: 
+
+
+## **Hackathon Project Ideas**
+
+Powerhouse is perfect for building:
+
+- **Real World Use-cases**: Every document can act as a mini ledger/blockchain. 
+- **Decentralized Applications**: Create apps with built-in version control and collaboration.
+- **Document-Based Systems**: Build structured data applications.
+- **Collaborative Tools**: Enable real-time multi-user editing.
+- **Data Management Platforms**: Create systems with queryable, structured data.
+
+### Coordination & DAO Design
+
+- 🧩 **What if** DAOs weren't chaotic? What documents would you need to make them coordinate like space X and ship like stripe?
+- 🎯 **What if** making decisions as a group felt like playing a co-op strategy game. With a clearly aligned vision, instant dashboards and a way to capture hard won knowledge in expertise into custom software for the Dao?
+
+:::tip IDEA
+The ultimate DAO Template toolkit where vision & mission documents influence guidelines & onboarding for contributors.
+:::
+
+---
+
+### GovTech & Public Infrastructure
+
+- 🗳 **What if** local governments had to reach consensus with residents before making a decision? How would that look like?
+- 🚧 **What if** you could submit pothole fixes or transit complaints into a civic DAO, and track the response like GitHub issues?
+- 🧾 **What if** municipal budgets were editable public documents with community feedback loops?
+
+:::tip IDEA
+An Open Source Enterprise Resource Planning-suite for municipalities & governments
+:::
+
+---
+
+### Education & Group Work
+
+- 📝 **What if** your group project auto-divided work, tracked contributions, and paid out in real-time?
+- 👾 **What if** "homework" was a multiplayer quest, and grades came from the DAO?
+- 🏫 **What if** we DAO-ified a classroom and let the students vote on rules, roles, and rewards?
+
+:::tip IDEA
+The remote classroom SAAS back-end that fosters connection, gives purpose to bullies and empowers younger generation to dream big again.
+:::
+
+---
+
+### 💸 Grants, Crypto, and Incentive Design
+
+- 💰 **What if** grant tooling felt like bounty hunting across a galaxy of projects?
+- 📊 **What if** every grant had a live budget dashboard, contributor feed, and impact score?
+- 🎮 **What if** you could stake on coordination itself, betting that people will work together well?
+
+:::tip IDEA
+The future of grant platforms that dares to imagine grants in new ways. With follow up, tracking and impact visualisations of teams, time, risk & resources invested.
+:::
+
+---
+
+### 💸 Lawmaking, Legislation & Legal
+
+- 🧑‍⚖️ **What if** any government or DAO could fork a legal template, customize it, and track changes in a public, composable way?
+- 🎨 **What if** legislation could be transparently co-created by citizens, NGOs, and governments all with aligned incentives?
+- 💻 **What if** legislation, contracts & templates could exist on an open-source market place like software?
+- 🤖 **What if** a network agent could create a legal vehicle by simply inputing  set of requirements and risk preferences (in non legalese)?
+- 🤝 **What if** 2 agents in a network could negotiate terms of an agreement according to predefined functions and risk parameters, without lawyers?
+
+:::tip IDEA
+Build a Decentralized Lawmaking Engine using Reactive Document Models
+:::
+
+
+## 🛠️ Resources
+
+### Documentation
+
+- [Quick Start Guide](./01-GetStarted/home.mdx)
+- [Create a New Project](./01-GetStarted/01-CreateNewPowerhouseProject.md)
+- [Define Document Models](./01-GetStarted/02-DefineToDoListDocumentModel.md)
+- [Build Editors](./01-GetStarted/04-BuildToDoListEditor.md)
+- [API References](./04-APIReferences/00-PowerhouseCLI.md)
+
+### Tutorials
+
+- [To-Do List Example](./01-GetStarted/02-DefineToDoListDocumentModel.md)
+- [Chatroom Use Case](./03-ExampleUsecases/Chatroom/02-CreateNewPowerhouseProject.md)
+
+## 🏆 Judging Criteria
+
+Projects will be evaluated based on:
+
+- **Usefulness & Impact**: How well does it solve a certain job or problem?
+- **Composability/Structure**: How are the different document models and / or drive apps collaborating?
+- **Clarity of the developer or user experience**: Did you unlock the secret sauce of UX & reactive documents?
+- **Alignment with Vetra/Powerhouse principles**: Local-first, auditable, usefull for common good. 
+
+## 📋 Submission Guidelines
+
+### What to Submit
+
+- GitHub repository with your code
+- (Video) presentation (2-3 minutes)
+- README with:
+  - Project description
+  - Setup instructions
+  - Screenshots/demos
+  - Technologies used
+
+The Powerhouse team will add you as a builder on the Vetra platform and host your application and drive. 
+
+
+## Tips for Success
+
+### Development Tips
+
+1. **Start Simple**: Begin with a basic implementation and iterate
+2. **Use Templates**: Leverage existing examples and templates
+3. **Ask Questions**: Don't hesitate to reach out for help
+4. **Test Early**: Test your application frequently during development
+5. **Document**: Keep notes on your decisions and implementations
+
+### Presentation Tips
+
+1. **Show, Don't Tell**: Live demos are more impactful than slides
+2. **Tell a Story**: Explain the problem you're solving
+3. **Highlight Innovation**: Show what makes your solution unique
+4. **Be Concise**: Respect the time limits for presentations
+5. **Prepare Backup**: Have screenshots/video in case of technical issues
+
+---
+
+**Good luck, and happy hacking! 🚀**
+
+*Last updated: November 17, 2025*
+

package/docs/academy/01-GetStarted/00-ExploreDemoPackage.mdx

@@ -2,8 +2,8 @@
 
 ## Let's get started
 
-To give you a quick idea of how the Powerhouse ecosystem operates on document models and packages, why don't you try installing a package? 
-We will show you how to install the Powerhouse command-line tool `ph-cmd` and then use it to install a pre-built demo package with a document models, an editor and a drive-app.
+To give you a quick idea of how the Powerhouse ecosystem operates on document models and packages, why don't you try installing a package?
+We will show you how to install the Powerhouse command-line tool `ph-cmd` and then use it to install a pre-built demo package containing a document model, an editor, and a drive app.
 
 ## Step 1: Install the Powerhouse CLI
 
@@ -18,7 +18,7 @@ Verify the installation:
 
 ```bash
 ph-cmd --version
-```                                                   
+```
 
 ## Step 2: Install the to-do list demo package
 
@@ -73,27 +73,34 @@ This command downloads and sets up the `@powerhousedao/todo-demo-package`, makin
 
 </details>
 
-
-You have now successfully installed `ph-cmd` and added your first package! 
+You have now successfully installed `ph-cmd` and added your first package!
 
 ## Step 3: Run the connect app in studio mode
+
 To run the package locally in Connect Studio (our collaboration and contributor app), run:
 
 ```bash
 ph connect
 ```
-Click the returned localhost URL and you should see Connect Studio appear in your browser. 
+
+Click the returned localhost URL and you should see Connect Studio appear in your browser.
+
 <figure className="image-container">
   <img src={require("./images/Connect.png").default} alt="Connect Home" />
   <figcaption>The Powerhouse Connect Studio interface.</figcaption>
 </figure>
 
-When you move to the settingswheel in the bottom right corner you'll get access to the **Package Manager**. 
-Here, you'll see that you've installed the `@powerhousedao/todo-demo-package`, which contains not only a **Document Model** and its accompanying editor but also a **Drive App** specific to the to-do document model. 
+When you click the settings wheel in the bottom right corner, you'll get access to the **Package Manager**.
+Here, you'll see that you've installed the `@powerhousedao/todo-demo-package`, which contains not only a **Document Model** and its accompanying editor but also a **Drive App** specific to the to-do document model.
 
 <figure className="image-container">
-  <img src={require("./images/Packagemanager.png").default} alt="Package Manager" />
-  <figcaption>The Package Manager showing the installed todo-demo-package.</figcaption>
+  <img
+    src={require("./images/Packagemanager.png").default}
+    alt="Package Manager"
+  />
+  <figcaption>
+    The Package Manager showing the installed todo-demo-package.
+  </figcaption>
 </figure>
 
 ## Step 4: Create a todo list document
@@ -123,27 +130,43 @@ Now move into the drive you've just created:
 - You'll see a statistics widget that counts the open to-dos
 - After closing the document, look at the To-do Drive App interface—you'll see that it tracks your tasks and displays a progress bar
 
+This is an example of the **usefulness and impact of Drive Apps**.   
+They offer a customized interface that works well with the different documents inside your drive.    
+Read more about drive apps in the Mastery Track: [Drive Apps and Drive Explorers](/academy/MasteryTrack/BuildingUserExperiences/BuildingADriveExplorer).
+
 <figure className="image-container">
-  <img src={require("./images/TodoDriveApp.png").default} alt="Todo Drive App" />
-  <figcaption>A list of todo's in the custom todo drive app. </figcaption>
+  <img
+    src={require("./images/TodoDriveApp.png").default}
+    alt="Todo Drive App"
+  />
+  <figcaption>A list of todos in the custom todo drive app.</figcaption>
 </figure>
 
-A key feature you get with Connect is the **Operations History**. Every change to a document is stored as an individual operation, creating an immutable and replayable history. This provides complete auditability and transparency, as you can inspect each revision, its details, and any associated signatures. For example, you can see a chronological list of all modifications, along with who made them and when.
+A key feature of Connect is the **Operations History**. Every change to a document is stored as an individual operation, creating an immutable and replayable history. This provides complete auditability and transparency, as you can inspect each revision, its details, and any associated signatures. For example, you can see a chronological list of all modifications, along with who made them and when.
 
 <figure className="image-container">
-  <img src={require("./images/OperationsHistoryButton.png").default} alt="Operations History Button" />
-  <figcaption> You can find the button to visit the operations history in the document model toolbar </figcaption>
+  <img
+    src={require("./images/OperationsHistoryButton.png").default}
+    alt="Operations History Button"
+  />
+  <figcaption>
+You can find the button to visit the operations history in the document model toolbar
+  </figcaption>
 </figure>
 
 <figure className="image-container">
-  <img src={require("./images/OperationsHistory.png").default} alt="Operations History" />
-  <figcaption>Example of the operations history for a document, showing all modifications made to it in a list. </figcaption>
+  <img
+    src={require("./images/OperationsHistory.png").default}
+    alt="Operations History"
+  />
+  <figcaption>
+    Example of the operations history for a document, showing all modifications
+    made to it in a list.{" "}
+  </figcaption>
 </figure>
 
 Learn more about the [Operations History](../MasteryTrack/BuildingUserExperiences/DocumentTools/OperationHistory) and other document tools you get for free.
 
-This is the power of Drive Apps. They offer a customized interface that works well with the different documents inside your drive. Read more about drive apps in the Mastery Track: [Drive Apps and Drive Explorers](/academy/MasteryTrack/BuildingUserExperiences/BuildingADriveExplorer).
-
 ## Step 5: Enable operation signing and verification through Renown
 
 Renown is Powerhouse's **decentralized identity and reputation system** designed to address the challenge of trust within open organizations, where contributors often operate under pseudonyms. In traditional organizations, personal identity and reputation are key to establishing trust and accountability. Renown replicates this dynamic in the digital space, allowing contributors to earn experience and build reputation without revealing their real-world identities.
@@ -152,13 +175,15 @@ Renown is Powerhouse's **decentralized identity and reputation system** designed
 When signing in with Renown, use an Ethereum or blockchain address that can function as your 'identity', as this address will accrue more experience and history over time.
 :::
 
-### 5.1 Click the renown icon and connect your eth identity
+### 5.1 Click the renown icon and connect your Ethereum identity
 
 "**Log in with Renown**" is a decentralized authentication flow that enables you to log into applications by signing a credential with your Ethereum wallet. Upon signing in, a Decentralized Identifier (DID) is created based on your Ethereum key.
 
 <figure className="image-container">
   <img src={require("./images/RenownLogin.png").default} alt="Renown Login" />
-  <figcaption>The Renown login screen, prompting for a signature from a wallet.</figcaption>
+  <figcaption>
+    The Renown login screen, prompting for a signature from a wallet.
+  </figcaption>
 </figure>
 
 ### 5.2 Authorize Connect to sign document edits on your behalf
@@ -166,12 +191,20 @@ When signing in with Renown, use an Ethereum or blockchain address that can func
 This DID is then associated with a credential that authorizes a specific Connect instance to act on your behalf. That credential is stored securely on Ceramic, a decentralized data network. When you perform actions through the Powerhouse Connect interface, those operations are signed with the DID and transmitted to Switchboard, which serves as the verifier.
 
 <figure className="image-container">
-  <img src={require("./images/ConnectAddress.png").default} alt="Connect Address for DID" />
-  <figcaption>A newly generated DID and address shown within the Connect interface.</figcaption>
+  <img
+    src={require("./images/ConnectAddress.png").default}
+    alt="Connect Address for DID"
+  />
+  <figcaption>
+    A newly generated DID and address shown within the Connect interface.
+  </figcaption>
 </figure>
 
 <figure className="image-container">
-  <img src={require("./images/LoginComplete.png").default} alt="Renown Login Complete" />
+  <img
+    src={require("./images/LoginComplete.png").default}
+    alt="Renown Login Complete"
+  />
   <figcaption>Confirmation of a successful login with Renown.</figcaption>
 </figure>
 
@@ -182,16 +215,20 @@ By leveraging this system, every operation or modification made to a document is
 Now, return to your to-do list and make some additional changes. You'll notice that these operations are now signed with your Renown identity, making every action traceable and verifiable in the operations history.
 
 <figure className="image-container">
-  <img src={require("./images/OperationsHistorySignature.png").default} alt="Operation History Signature" />
-  <figcaption>Your DID is now signing the operations that are being added to the history.</figcaption>
+  <img
+    src={require("./images/OperationsHistorySignature.png").default}
+    alt="Operation History Signature"
+  />
+  <figcaption>
+    Your DID is now signing the operations that are being added to the history.
+  </figcaption>
 </figure>
 
 ## Step 6: Export a document
 
-Export the document as a `.phd` (Powerhouse Document) file using the export button in the document toolbar at the top. In this toolbar, you will find all available functionality for your documents. The `.phd` file can be sent through any of your preferred channels to other users on your network. 
+Export the document as a `.phd` (Powerhouse Document) file using the export button in the document toolbar at the top. In this toolbar, you will find all available functionality for your documents. The `.phd` file can be sent through any of your preferred channels to other users on your network.
 
-### Up next 
+### Up next
 
-Now that you have explored a Powerhouse package and discovered its basic functionalities, it is time to start building your own. 
+Now that you have explored a Powerhouse package and discovered its basic functionalities, it is time to start building your own.
 Our next tutorial focuses on creating a simple to-do list document and will introduce you to the world of **Document Models**.
-