Self-hosted · Apache-2.0

Run it on your own metal.

The TruePPM core is open source and self-hostable. Bring your own Postgres, point it at your own identity provider, and keep every schedule, estimate and forecast inside your perimeter. One command to deploy.

Deploy guide Try the read-only demo →API reference →

# one command, full stack — batteries includedgit clone https://gitlab.com/trueppm/trueppmcd trueppm && docker compose up -d# → migrations & admin bootstrap run themselvesweb Running # React UI · :5173api Running # REST + WebSocket · :8000celery·beat Running # scheduling & forecast jobsdb·valkey Running # Postgres 16 · cache/queue

Open core

What's open, and what's not.

The engine that matters — scheduling, forecasting, the agile↔waterfall bridge, the API — is Apache-2.0, and so is everything one team needs to run a program. Organization-wide governance is the only paid layer, and it sits on top of the core rather than inside it. If it isn't in the API, it doesn't exist.

Apache-2.0 core

Critical-path scheduling (CPM) engine
Monte Carlo (probabilistic) forecaster
Board, timeline (Gantt), work breakdown, calendar, sprints
Program rollup, REST API & webhooks
Basic single sign-on (OIDC/OAuth) & offline-first sync

Enterprise

Cross-program resource leveling & approval workflows
Org identity governance — SAML, SCIM & directory sync
Portfolio governance & earned-value (EVM) rollups
Immutable audit trail & cross-region disaster recovery
SLAs & dedicated support

The engine, standalone

Just need the scheduler? Pip-install it.

The critical-path (CPM) and Monte Carlo engine that powers TruePPM ships as a separate Apache-2.0 Python package. Drop it into your own tooling — no platform required.

Critical path, slack (float) & all four dependency types
Calendar-aware lag and cycle detection
Monte Carlo finish-date forecasting (P50 / P80 / P95)
Validated in CI against a Rust/WASM conformance twin

View on PyPI Source on GitLab →

Beta · Apache-2.0 · trueppm-scheduler

# install the standalone enginepip install trueppm-scheduler# build the schedule, read the critical pathfrom trueppm_scheduler import schedule, Project, Task result = schedule(project)for t in result.tasks:print(t.name, t.early_finish, t.is_critical)

Deploy

Up and running in three steps.

Docker Compose for a laptop or a single VM, a production Helm 3 chart for Kubernetes — whatever your stack, there's a paved path.

01 · START

One command, batteries included

Compose brings its own Postgres 16 and Valkey; migrations and admin bootstrap run themselves. Prefer your own Postgres? Point DATABASE_URL at it.

docker compose up -d

02 · EXPLORE

Seed the demo

One command loads the Atlas sample program with six persona logins — sign in as the program manager, the product owner, or the executive and see your role's view first.

manage.py load_sample_project --with-personas

03 · CONNECT

Wire up sign-on

Add your own OIDC/OAuth identity provider from the admin UI — Keycloak, Authentik, Google, GitHub, GitLab and more — and invite your team. No redeploy.

Workspace → Settings → Single sign-on

Postgres version, bundled

services in the stack

command to deploy

data leaves your perimeter

The read-only demo

What try.trueppm.com shows you — and what it doesn't.

Sign in with one click as a shared, read-only account and open real, populated projects — drag a task and watch the critical path recompute live. Nothing is a screenshot, and nothing you do is saved: every write is refused server-side, not just hidden in the UI. Honestly, it's a tour of the engine and the screens, not the day-to-day job — grooming a backlog, leveling a resource conflict, completing work and watching burndown react all need a change that sticks, and that only exists once you run it yourself.

~50%

you can see almost the whole app read-only — but only a schedule reschedule is interactive; every other workflow needs a write

In the demo

One-click sign-in as a shared account — no signup, no form to fill
Every screen, populated — schedule, board, sprints, resources, risk register, forecast
Drag a task and watch the critical path recompute live — the real engine, not a mock-up

Only in your own instance

Any change that actually saves — grooming, resourcing, completing work, comments
Multiple programs, your own team, workspace & admin settings, your own identity provider
Writes over the API and webhooks for automation — reads work in the demo, writes don't

Run it yourself Try the read-only demo →

API-first

The UI is just one client.

Everything the app can do, the API can do — schedules, dependencies, forecasts, webhooks. A typed OpenAPI schema (so you can generate a client in any language), predictable resources, and a webhook for every state change so you can wire TruePPM into CI, status pages and incident tooling.

REST API with a typed OpenAPI schema
Forecast any project on demand
Real-time webhooks on every change

Read the full API reference →

# forecast a projectPOST /api/v1/projects/{id}/monte-carlo/# → distribution + sensitivity{"p50": "2026-08-14","p80": "2026-08-21","p95": "2026-09-02","cpm_finish": "2026-08-07","sensitivity": [{ "task_id": "pour", "index": 0.92 }]}

Trust

Your data, your rules.

In your perimeter

Self-host and no schedule data ever leaves your network. Encrypt at rest with your own keys.

Single sign-on

Basic OIDC/OAuth sign-in through your own identity provider is in the open core. SAML, SCIM provisioning, and directory-driven deprovisioning come with Enterprise.

Activity & audit

An operational activity log ships in the core — who moved what, when, and why the date shifted. A tamper-evident, immutable audit trail comes with Enterprise.