Operately

Operately is an opinionated open source platform built to give startups and growing companies the operational structure they need to execute without a dedicated COO. Rather than offering another blank-canvas project tool, it ships with proven workflows already embedded: structured goal check-ins, project review cadences, milestone tracking, and a team activity feed that creates shared situational awareness.

The platform connects company-wide OKRs directly to the daily work happening inside team Spaces. Goals cascade from the company level down to individual contributors, and every check-in surfaces progress in a unified feed rather than buried in Slack threads or spreadsheet rows. Project milestones link to goal targets so leadership can see execution health at a glance without chasing status updates.

Operately is self-hostable with a single-command Docker install and ships an Apache 2.0-licensed Community Edition alongside a closed Enterprise Edition for more complex deployments. An integrated CLI, REST API, and published AI agent skills for Claude Code and Codex allow automated goal updates and project check-ins, making it a first-class target for AI-assisted operations workflows.

Built with Elixir and Phoenix on the backend and React with TypeScript on the frontend, Operately is designed for teams of five to one hundred people who want the discipline of a structured operating model without enterprise complexity or per-seat pricing.

What You Get

• Goal and OKR management — Set company-wide, space-level, and individual goals with numeric targets, track progress through structured check-ins, and cascade objectives so daily work connects visibly to strategic priorities.
• Project management with milestones — Organize work into projects with task boards (list and Kanban views), milestone tracking, and a configured champion/reviewer accountability model that defines who owns delivery and who signs off.
• Team Spaces — Give each department or team a named home with its own goals, projects, task board, documents folder, and message board, with granular access-level controls (full access, standard, view-only, guest).
• Execution cadence engine — Built-in check-in schedules create a consistent review rhythm; automated daily assignment digests surface overdue items; the Work Map gives a real-time overview of all active goals and projects across the company.
• Resource Hub and Documents — Centralized document and file storage inside each Space, with rich-text editor powered by Tiptap, file uploads to S3-compatible storage, and link sharing.
• CLI, REST API, and AI agent skills — Full programmatic access to goals, projects, and check-ins via a typed TypeScript CLI, a structured REST API with token-based auth, and published skill files for Claude Code and Codex so AI agents can post updates autonomously.
• Notification and subscription system — Granular per-resource subscriptions, email digests via configurable SMTP (with Amazon SES support), and in-app notification center with read/unread tracking.
• Self-hosted with Docker — Single-command installation with a provided install.sh script and Docker Compose stack; upgrades are documented and managed through migration scripts.

Common Use Cases

• Startup operational cadence — A seed-stage team adopts Operately instead of a COO to run weekly goal reviews, track project milestones, and keep the whole company aligned on quarterly OKRs without daily standups.
• Engineering team coordination — An engineering manager uses Projects with milestone boards and task Kanban to coordinate a product release, with automated check-in reminders so contributors update status on schedule.
• Cross-functional goal alignment — A nonprofit sets annual targets at the organizational level, breaks them into space-level goals for each program team, and uses the Work Map to show board members real-time execution health.
• AI-assisted operations — A DevOps team uses the Operately CLI and published Claude Code skills to let AI agents post project check-ins from CI pipeline results, reducing manual reporting overhead.
• Remote team transparency — A distributed consulting firm replaces scattered email threads with Operately message boards inside each client Space, stores deliverables in the Resource Hub, and tracks SLA milestones on a shared project board.
• Compliance-focused goal tracking — A regulated company uses Operately’s full audit trail of activities and structured goal check-ins to demonstrate operational discipline during audits or investor due diligence.

Under The Hood

Architecture Operately is structured as a layered Phoenix/Elixir monolith with clear internal boundaries between concerns. All data mutations flow through an explicit Operations layer — each operation is an isolated module with a single run/2 function that executes inside an Ecto.Multi transaction, writes an activity record, and dispatches notifications before committing. This design means no business logic leaks into controllers or resolvers; every state change is auditable by construction. The frontend communicates with the backend through a custom typed binary API protocol (TurboConnect) rather than REST or traditional GraphQL, enabling end-to-end type safety between the Elixir server and TypeScript client without code generation from schemas. Background jobs are handled by Oban with PostgreSQL as the queue store, keeping infrastructure requirements minimal.

Tech Stack The backend is Elixir 1.18 on the Phoenix 1.7 framework, using Ecto 3.13 with PostgreSQL for persistence. Email notifications are sent via Swoosh with configurable adapters including SMTP and Amazon SES. File storage targets S3-compatible object stores via ex_aws. AI features use LangChain for Elixir to integrate with Anthropic’s Claude and OpenAI models. The frontend is React with TypeScript, Apollo Client for some data paths, Tiptap for rich-text editing, Radix UI primitives for accessible components, Pragmatic Drag and Drop for Kanban reordering, and Tailwind CSS for styling. The component library (turboui) is a standalone package within the monorepo. The CLI is a TypeScript Node.js tool. CI runs on Semaphore CI with Wallaby for end-to-end browser tests.

Code Quality Operately has extensive test coverage spanning unit tests for Elixir domain modules (over 650 test files), browser-driven end-to-end feature tests using Wallaby, and TypeScript unit tests for frontend utilities with Jest. The feature test suite uses a step-based page object pattern that keeps test intent readable without coupling tests to implementation details. Dialyzer static analysis is configured in CI to catch type errors at the Elixir layer. Warnings are treated as errors in the CI compile step. The codebase enforces an icon import linter to prevent direct third-party library leakage, and an AGENTS.md provides detailed guidance for AI coding agents contributing to the repo — reflecting active investment in code quality tooling.

What Makes It Unique Operately’s most distinctive technical decision is encoding organizational execution cadences as first-class product concepts rather than configurable workflows. The check-in system, activity audit trail, and accountability model (champion/reviewer roles) are not optional plug-ins — they are built into the data schema and cannot be removed. The Operations pattern guarantees that every mutation produces an activity record, which is unusual in Phoenix applications that typically write directly through contexts. The TurboConnect typed API protocol between Elixir and TypeScript eliminates a category of integration bugs without requiring GraphQL. The native LangChain integration and published AI agent skills for Claude Code treat AI automation as a distribution channel, allowing organizations to hook autonomous agents into their operational processes through documented, versioned APIs rather than fragile scraping.

Self-Hosting

Operately’s core is licensed under Apache 2.0, which permits commercial use, modification, distribution, and private use without restriction or copyleft obligation. Self-hosters can run it, modify it, and embed it in commercial products without sharing changes back. The ee/ directory contains the Enterprise Edition, governed by a separate proprietary license that requires either a paid Operately cloud subscription or a separately negotiated enterprise license; development and testing use of the EE code is permitted without a license, but production deployment requires one.

Running Operately yourself requires a Docker host with sufficient resources for an Elixir/Phoenix application and a PostgreSQL database. The install.sh script and provided Docker Compose file handle initial setup, including SMTP configuration, S3-compatible object storage for file uploads, and an optional AI provider API key. You are responsible for database backups, SSL/TLS termination, log retention, and applying upgrades by re-running migration scripts. The upgrade path is documented and tested but requires manual intervention for each release; there is no automated update mechanism in the community edition.

Compared to Operately’s hosted SaaS offering, a self-hosted Community Edition instance gives up managed database backups, automatic version upgrades, uptime SLAs, and the proprietary Enterprise Edition features (which include enhanced admin tooling and SaaS-specific instrumentation). The flat-rate pricing model the hosted version uses means the cost gap between SaaS and self-hosted narrows for teams with more than a handful of members, since there are no per-seat fees on either path — the primary trade-off is operational burden and infrastructure cost versus convenience and vendor-managed reliability.