The Problem

Operately organizes company operations—goals, projects, teams, documents—but the repository itself lacks automated quality gates. Four self-contained projects share space without a CI pipeline, so every push merges without validation. Across the estate of 499 repositories, this pattern means changes land untested, and 125 repositories here have deployment artifacts that have never been built automatically.

What This Does

Operately is a portfolio of four projects rather than a single codebase. The app project (3783 files, 757 code files) is a Ruby on Rails application with a React/TSX frontend; it uses Tailwind for styling and ships with a Docker production build via Dockerfile.prod. The turboui project (579 files, 569 code files) appears to be a UI component library in React/TSX, containing 447+ components including BorderedRow, Callouts, Badges/AccessLevelBadges, and formatted time displays. The cli project (79 files, 68 code files) provides command-line access to Operately’s API and agent skills. The smallest scripts project (22 files, 5 code files) likely contains automation tasks. Shared infrastructure includes a Gemfile/Gemfile.lock for Ruby dependencies and app/package.json/app/package-lock.json for Node dependencies; Tailwind configuration lives in app/assets/tailwind.config.js. Entry points such as app/assets/js/app.tsx and app/assets/js/api/index.tsx suggest the frontend bootstraps API calls and socket connections from the Rails backend.

How It Is Wired

Execution starts at the Rails entry point (typically app/assets/js/app.tsx), which mounts the React application and connects to the backend via API calls defined in app/assets/js/api/index.tsx. The API module (app/assets/js/api/) handles socket connections (socket.tsx) and stale client detection (staleClient.ts/staleClient.test.ts), suggesting real-time state synchronization. Components such as BorderedRow and Callouts in app/assets/js/components/ render UI segments, while FormattedTime subcomponents (LongDate, RelativeTime, ShortDate, etc.) format temporal data for display. The app/ directory also contains Elixir code (2772 files), including app/lib/operately/system_settings/email_secrets.ex and encrypted_email_secrets.ex, which the code-health audit flags as secret-shaped paths—these may contain credentials committed to the repository. The deployable artifact references app/rel/single-host/templates/docker-compose.yml.eex, indicating a single-host Docker deployment model. No internal call graph has been mapped beyond these observed paths; the wiring between the Rails backend, the React frontend, and the CLI remains undocumented.

How To Use It

Setup: The README provides a single-host installation path:

wget -q https://github.com/operately/operately/releases/latest/download/operately-single-host.tar.gz
tar -xf operately-single-host.tar.gz
cd operately
./install.sh
docker compose up --wait --detach

The Dockerfile.prod and app/rel/single-host/templates/docker-compose.yml.eex confirm the container build pipeline. For development, the Makefile and app/package.json imply build and test commands, but those targets are not documented in the available snippets.

Configuration: No environment variable file is committed; the app/.gitignore and root .gitignore would typically exclude sensitive configs. The Gemfile and app/package.json define runtime dependencies; no .env or config/settings.yml is present in the file listing, so required keys likely need to be supplied at runtime or via the Docker compose file.

Running it: The installed binary (./install.sh) and docker compose up are the confirmed entry points. No local development server command is evidenced beyond the package.json scripts, which are unreported in the directory breakdown.

Real-World Use

A technology startup adopts Operately to replace scattered spreadsheets and email threads for OKR tracking. The team enables the Goals/OKRs module, creates company-wide targets, and links daily tasks via Project Management boards. The CLI is used by AI agents to create goals and post check-ins, while the Message Boards replace daily standup emails. Documents and files are stored in the centralized Documents & Files section, with team spaces isolating nonprofit versus consulting firm data. The flat-rate SaaS pricing model avoids per-seat costs as the team scales to 30 users.

Code Health & Issues

  • [HIGH] Add a workflow that builds and tests this repository — evidence: 1403 source files, no CI configuration. Every change merges with nobody having run the build once, which across this estate is 499 repositories.
  • [HIGH] Add a build gate for the deployable artifacts here — docker-compose.yml — evidence: deployment artifacts with no workflow. Something in the repo is meant to reach a server and no automated step has ever validated it, which is the state of 125 repositories here.
  • [MEDIUM] Enable Dependabot or Renovate — evidence: 5 manifest(s), no update bot configured. Without a bot a published advisory sits unpatched until someone audits by hand, which across 1,322 repositories means never.
  • [MEDIUM] Move large binaries to Git LFS or out of the repository — app/priv/plts/project.plt — evidence: 2 blobs over 5MB: project.plt 9.2MB, dialyzer.plt 7.9MB. One repository here carries twenty blobs over 5MB including a 10.9MB spreadsheet, so every clone and every CI checkout pays for data nobody diffs.
  • [LOW] Add the repository convention files this project lacks — evidence: missing .editorconfig, .gitattributes, a formatter config. Without them one contributor's editor writes tabs into a Python file, a shell script commits with CRLF and fails in the container, and a notebook diff is unreviewable.

These findings are deterministic outputs of static analysis, not opinion.

The Bottom Line

Operately delivers a functional, opinionated company operating system with genuine Rails/React integration, real-time API access, and a capable CLI—useful for teams that need structured goal tracking without per-seat pricing. The absence of CI/CD, unvalidated Docker builds, and committed secrets are production risks that should be addressed before any deployment beyond a single-developer sandbox. Teams comfortable self-hosting and managing their own ops pipeline will find value here; organizations requiring out-of-the-box reliability will need to invest in the missing automation and hygiene fixes.