Yarii is a fully self-hosted ERP system built for nonprofit and mission-driven organizations that respect data protection, privacy, self-hosting, and fund transparency. It provides governance workflows and modular management dashboards to help nonprofits streamline operations — without relying on third-party proprietary platforms.
Yarii provides a structured and modular frontend designed to support nonprofit organizations with transparency, accountability, and operational efficiency. Below is a detailed overview of the core features implemented in the system.
The dashboard serves as the central control panel for users.
- Aggregated financial summaries (total funds, expenses, balances)
- Overview of active projects and recent activity
- Quick-access panels for frequently used modules
- Real-time visual indicators for organizational performance
This allows decision-makers to quickly assess operational and financial status.
Yarii enables structured and transparent financial tracking.
- Recording and tracking of donations
- Expense entry and categorization
- Transaction history with filtering and search capabilities
- Structured data representation for financial auditing
The system ensures traceability of funds from receipt to allocation.
Projects are treated as first-class entities within the system.
- Creation and management of initiatives
- Budget allocation per project
- Linking transactions to specific projects
- Monitoring spending against allocated budgets
This ensures accountability and financial clarity across initiatives.
Yarii implements role-based access control to protect sensitive data and maintain governance standards.
- User creation and profile management
- Role assignment and permission control
- Access restrictions based on role hierarchy
- Module-level authorization enforcement
Typical roles include:
- Administrator (full system access)
- Manager (operational control)
- Accountant (financial oversight)
- Standard User (restricted access)
Permissions are enforced at the interface level to ensure that users only see and interact with authorized modules.
The system provides structured reporting capabilities to support transparency and compliance.
- Financial summaries by date range
- Project-level financial breakdowns
- Activity reports
- Exportable datasets (e.g., CSV or PDF, depending on backend integration)
Reports are designed to assist audits, internal reviews, and stakeholder communication.
The frontend is built using Angular with a modular architecture to ensure scalability and maintainability.
- Feature-based module separation
- Reusable shared components
- Structured routing with guarded access
- Environment-based configuration management
This design allows future expansion without major refactoring.
Yarii is designed for organizations that prioritize data ownership and privacy.
- Compatible with self-hosted deployments
- Secure authentication flow
- Controlled API communication
- Frontend enforcement of permission boundaries
The architecture supports secure nonprofit operations without reliance on external SaaS platforms.
This section outlines the core technologies, architectural decisions, and development structure of the Yarii frontend application.
- Framework: Angular
- Language: TypeScript
- Styling: Tailwind CSS
- Architecture Pattern: Modular, feature-based structure
- Routing: Angular Router with guarded routes
- State Handling: Component-driven state management (extendable to NgRx if required)
- Environment Configuration: Angular environment files for dev/prod separation
The project follows a scalable and maintainable folder structure: src/ ├── app/ │ ├── core/ # Core services, guards, interceptors │ ├── shared/ # Reusable components and utilities │ ├── features/ # Feature-based modules (dashboard, users, projects, etc.) │ ├── auth/ # Authentication module │ └── layout/ # Navigation and layout components ├── assets/ ├── environments/ └── styles/
- Route guards to protect restricted pages
- Role-based access enforcement at UI level
- Token-based authentication (backend integrated)
- Dynamic navigation rendering based on user role
- Structured HTTP services
- Centralized API configuration
- Error handling via interceptors
- Environment-based API base URL switching
- Optimized production builds using Angular CLI
- Compatible with Docker-based deployment (if backend containerized)
- Can be hosted on any static hosting server (Nginx, Apache, etc.)
We welcome contributions to improve Yarii. Whether you are fixing a bug, improving UI/UX, or adding new features, contributions are appreciated.