Manage

Manage is an open-source project management platform built for teams that want full ownership of their data and infrastructure. Developed with Next.js, tRPC, and PostgreSQL, it delivers a cohesive suite of tools — task lists, calendar events, rich-text posts, file storage, and activity tracking — all under one self-hosted roof. Authentication is handled via email OTP through better-auth, and multi-tenancy is built in from the ground up via organization-scoped routing.

The platform is designed for teams who have outgrown ad-hoc tools but don’t want to hand their data to a SaaS vendor. Manage can be deployed with a single click on Railway or manually on any Node.js/Bun-compatible host. It requires a PostgreSQL database, optional S3-compatible storage for file uploads, and an SMTP server for email notifications.

Under the hood, Manage uses tRPC 11 with TanStack Query for end-to-end type-safe API calls, Drizzle ORM for schema management, Biome as its linter and formatter, and Turbowire for real-time push notifications. The BlockNote editor provides a rich collaborative writing experience for posts and task descriptions, with built-in user mention extraction and notification delivery.

What You Get

• Task lists with drag-and-drop ordering — Organize work into task lists per project, with draggable tasks using dnd-kit, assignees, due dates, status tracking, and position persistence in the database.
• Project calendar with iCal import/export — A full calendar view with recurring event support via rrule, all-day events, per-timezone rendering, and the ability to import .ics files from external calendar services.
• Rich-text posts and documentation — A BlockNote-powered editor embedded in each project for writing docs, announcements, and updates, with file attachment support via S3-compatible storage and user @mentions.
• Real-time notifications via Turbowire — Push notifications delivered to users when they are mentioned in tasks, posts, or events, using Turbowire serverless WebSocket broadcasting.
• Organization-level multi-tenancy — Create organizations, invite team members via email link, assign roles (owner/admin/member), and route all project data through org-scoped URL segments.
• One-click Railway deployment — A ready-to-deploy Railway template covering the Next.js app, PostgreSQL, and all required environment variables, enabling self-hosting without manual infrastructure setup.
• Email OTP authentication — Passwordless sign-in via six-digit one-time codes delivered to users’ email addresses, with configurable signup disablement for closed self-hosted installs.
• Activity feed per project — An audit trail logging every task creation, status change, assignment update, post publish, and event modification, scoped to the project and visible to all members.

Common Use Cases

• Privacy-first startup project tracking — A small startup deploys Manage on Railway to track their product roadmap and engineering tasks internally, keeping sprint data and customer-facing timelines off third-party servers.
• Agency client project management — A web agency creates one organization per client, inviting client stakeholders as read-only members to follow progress on deliverables via the activity feed and published posts.
• Research team coordination — A university lab uses Manage to coordinate experiments across multiple researchers, scheduling lab calendar events, assigning tasks with due dates, and sharing protocol docs via the rich-text post feature.
• Open-source community project board — A distributed open-source team uses Manage as their issue tracker and communications hub, with public-facing project posts and private internal task lists, all hosted on their own infrastructure.
• Internal operations tracking — An operations team at a mid-size company deploys Manage to coordinate recurring calendar events, track process improvement tasks, and document runbooks using the post editor without relying on external SaaS tools.

Under The Hood

Architecture Manage is structured as a multi-tenant Next.js 16 App Router application, with organization context threaded through a dynamic [tenant] URL segment at the top of the route hierarchy. Server-side session resolution and tenant lookup happen at request time via getOwner() and getTimezone() utility functions, keeping context injection clean and uniform across all server components and tRPC procedures. The tRPC layer uses protectedProcedure middleware that verifies the session, resolves the active organization, and injects userId, orgId, and isOrgAdmin into the request context, eliminating repetitive auth checks in individual routers. Real-time capability is layered on top via Turbowire — a serverless WebSocket hub — that broadcasts notifications to user-scoped channels when mentions are detected in BlockNote content using an HTML-parsing mention extraction pass.

Tech Stack Manage is built on Next.js 16 with React 19 and fully embraces React Server Components for data-heavy pages while using TanStack Query with tRPC’s @trpc/tanstack-react-query adapter for client-side mutations and cache invalidation. Drizzle ORM with Drizzle Kit manages a PostgreSQL schema covering users, organizations, projects, task lists, tasks, calendar events, posts, blobs, notifications, and activity entries. Authentication is handled by better-auth with the emailOTP and organization plugins, providing passwordless sign-in and org-scoped sessions out of the box. File storage follows an AWS S3 presigned-URL upload pattern using the AWS SDK v3, with blob metadata tracked in PostgreSQL and orphaned blobs cleaned up on content edits. Biome serves as the unified linter and formatter. The BlockNote rich-text editor is embedded for posts and task descriptions, with React Email and Nodemailer handling transactional email delivery.

Code Quality The codebase maintains strong TypeScript discipline throughout — tRPC procedures are fully typed end-to-end with Zod input schemas, Drizzle relations provide typed query results, and the neverthrow library appears in error-handling paths to force explicit result handling in critical operations. Biome is configured with strict linting rules and auto import organization. However, no test files of any kind exist in the repository, leaving all functional correctness unverified by automated checks. Error handling is inconsistent: some paths use typed results while others bubble raw exceptions or log warnings with console.warn. There is also no CI configuration visible in the repository, meaning no automated quality gate runs on contributions.

What Makes It Unique The most distinctive technical choice in Manage is its use of tRPC 11 with React Server Components and TanStack Query simultaneously — server components fetch initial data directly, while client components use the same tRPC procedures through the React Query adapter for mutations and real-time invalidation, eliminating a separate REST API surface entirely. The multi-tenant architecture is driven by URL slug resolution at request time rather than subdomain routing, making it simpler to self-host on a single domain. Calendar events support full rrule-based recurrence with per-timezone rendering via date-fns-tz, and iCal file import via node-ical allows teams to seed events from existing calendar systems. The Turbowire integration for real-time @mention notifications is a lightweight serverless alternative to a full WebSocket server, requiring no persistent process beyond the Next.js deployment.

Self-Hosting

Manage is licensed under the GNU Affero General Public License version 3 (AGPL-3.0). This is a strong copyleft license that grants full freedom to use, modify, and redistribute the software, but imposes an important condition: if you modify Manage and make it available over a network, you must release your modifications under the same AGPL-3.0 terms. For most organizations self-hosting internally for their own team’s use, this condition does not trigger — internal deployments are not considered ‘making available over a network’ to the public. However, if your business intends to offer Manage as a service to third parties, you must open-source your modifications.

Operationally, running Manage yourself means taking full responsibility for PostgreSQL maintenance, backup schedules, application updates, and uptime. The app is stateless beyond its database connection, which simplifies horizontal scaling — you can run multiple Next.js instances behind a load balancer as long as they share the same PostgreSQL instance and S3 bucket. Drizzle Kit handles schema migrations via drizzle-kit push, though there is no migration rollback strategy documented. Email delivery depends on an external SMTP provider of your choice. The Railway one-click deploy template is a practical starting point, but production self-hosters will need to plan for SSL termination, environment variable management, and monitoring independently.

There is no documented paid cloud tier or managed offering for Manage at this time. The project appears to be maintained by a small team as a fully open-source effort, which means support is limited to GitHub issues and community contribution. Self-hosters receive no SLA, no managed upgrades, and no dedicated support channel. What you gain in return is complete control over your data and infrastructure, the ability to customize the codebase freely (subject to AGPL terms for network distribution), and no per-seat pricing regardless of team size.