Web-based code and document review, honestly assessed. Built before GitHub Pull Requests existed — still running in shops where GitHub doesn’t.

TL;DR

What it is: Open-source (MIT) web-based code and document review platform, built in 2006 and still actively maintained. Predates GitHub Pull Requests, GitLab merge requests, and every modern PR workflow by years [README].
Who it’s for: Engineering teams running legacy version control (Perforce, ClearCase, SVN, CVS) where GitHub-native review doesn’t apply. Also: teams that need to review non-code artifacts — PDFs, Office documents, images, schematics — alongside source code [website].
Cost savings: RBCommons (their hosted SaaS) pricing not publicly listed. Self-hosted runs on any Linux VPS with Apache or nginx — the software itself is free under MIT. Power Pack (commercial extension) required for PDF/Office review and report generation — pricing on request [README][website].
Key strength: Uniquely broad artifact support. No other code review tool lets you diff an Office document, a PDF schematic, and a commit side-by-side in the same review request [website]. The diff viewer is still technically impressive — moved code detection, indentation-aware diffs, interdiffs, commented lines outside the diff [website].
Key weakness: 1,695 GitHub stars in 2026 tells the adoption story. For teams already on GitHub, GitLab, or Bitbucket, the PR/MR workflow built into those platforms is the default choice. Review Board adds operational overhead in exchange for features most teams don’t use [merged profile][2].

What is Review Board

Review Board is a self-hosted, web-based review platform that started in 2006 when code review meant emailing diff files. The team wanted something better and built what became, by their own description, one of the tools that invented modern code review practices: multi-line commenting, moved code detection, interdiffs, and review request tracking [website].

The concept is different from the GitHub PR model. Instead of a pull request that lives inside your Git host, Review Board introduces a review request — a standalone artifact that collects diffs, screenshots, documents, mockups, and any file you want reviewed, runs discussions and threaded comments against them, tracks open issues and to-dos, and shows CI build status, all in one place [website]. This model works regardless of whether you’re using Git, Subversion, Mercurial, Perforce, ClearCase, CVS, Plastic, or Azure DevOps [README].

The project is backed by Beanbag, Inc., the company founded by its original developers. It’s available as community-supported open source under MIT, as a self-hosted commercial edition with the Power Pack extension, and as a hosted service at RBCommons [README][website].

As of this review it has 1,695 GitHub stars — a number that is both low by modern open-source standards and not the right metric. Review Board has been in active production at thousands of organizations since before GitHub launched. Its users aren’t the kind of team that stars repos on GitHub.

Why people choose it

The honest answer is: most teams don’t choose Review Board in 2026 — they’re already running it, or they’re in a shop where the GitHub-native workflow doesn’t exist.

The Perforce shop. A meaningful portion of game studios, financial firms, and embedded hardware teams run Perforce or ClearCase, not Git. GitHub, GitLab, and Bitbucket are built around Git. Review Board supports Perforce, ClearCase, CVS, and Plastic natively, which puts it on a short list of serious options for these organizations [README][website]. Digital.ai TeamForge — a platform used by defense contractors and large enterprises — ships Review Board as a first-class integration, which is a signal about where it lives [3][4].

The document review angle. This is Review Board’s most defensible differentiator. Game developers, UI/UX teams, and technical writers deal with image assets, SVG mockups, and screenshots that need review alongside code. Teams in regulated industries review contracts, schematics, and technical documentation. Review Board can diff a PDF against a previous version, highlight changed regions, let reviewers comment on specific text selections, and surface a side-by-side comparison with changes highlighted [website]. No other open-source code review tool does this. The feature requires the commercial Power Pack extension, but if PDF/Office review is your use case, that’s the price of admission.

The “pre-commit review” workflow. GitHub PRs work on branches that are already pushed. Review Board supports posting a diff before committing — you work locally, generate a diff with rbt post, and the review request goes up for approval before the commit ever lands in the repo [website]. Teams with stricter change control processes sometimes prefer this over the post-push PR model.

The legacy install base. The Digital.ai docs [3][4] show Review Board 4.0.6 integrated into TeamForge 24.0 and 24.1. These aren’t startups experimenting with new tools — they’re established enterprise ALM environments that have been running Review Board for years and aren’t migrating.

Features

Core review engine:

Review requests as the primary unit (not PRs) — collect diffs, images, documents, and all discussion in one place [website]
Diff viewer with syntax highlighting, moved code detection, indentation change indicators, commented lines outside the diff boundaries [website]
Interdiffs — track exactly what changed between diff revisions, so reviewers see only what’s new since their last review [website]
Threaded, contextual comments on code, image regions, and document text [website]
Issue tracking inside reviews — comments can open an “issue” that must be resolved before the request is approved [website]
Dashboard with filtering by groups and projects, bulk operations, customizable columns [website]

Version control support:

Git, Subversion, Mercurial, Perforce, ClearCase, CVS, Plastic, Azure DevOps [README][website]
Hosted repositories: Assembla, Beanstalk, Bitbucket, Codebase, GitHub, GitLab, Gitorious, Kiln, Unfuddle [README]

Image and document review (Power Pack required for documents):

Contextual commenting on image regions, side-by-side image diffs, color-based diffs, adjustable transparency diffs [website]
PDF and Office document review with text selection commenting, table of contents navigation, side-by-side revision comparisons [website]

Automation and integrations:

Review Bot: automated code review via CI — Jenkins, CircleCI, Travis CI supported out of the box; extensible in Python [website]
RBTools CLI: post changes for review, land reviewed changes, patch from someone else’s diff, check status [website]
REST API for custom integrations, IDE plugins, and automation [features/canonical]
LDAP/Active Directory support [features/canonical]
Extension framework for custom features without forking [README]

Hosted option:

RBCommons: managed hosting by the same team, pricing not publicly disclosed [README]
Demo instance at demo.reviewboard.org [README]

Pricing: SaaS vs self-hosted math

Pricing transparency here is limited. The Review Board website does not publish RBCommons pricing tiers publicly — you contact them for rates. Power Pack (the commercial extension for PDF/Office review, reports, Azure DevOps Enterprise, and GitHub Enterprise integration) has a trial download but listed pricing is also contact-sales [website].

What is clear:

Self-hosted community edition:

Software: $0 (MIT license) [README]
VPS to run it on: $5–20/month depending on team size
Power Pack: commercial license, pricing not public [website]

Features gated behind Power Pack:

PDF and Office document review [website]
Report generation [website]
Better multi-server scalability [website]
Microsoft Azure DevOps integration [website]
GitHub Enterprise integration [website]
LDAP/Active Directory user sync (listed as “coming soon” in README) [README]

RBCommons (their managed SaaS):

Pricing: contact sales. No free tier listed publicly [website].

For a comparison: if you’re evaluating Review Board against GitHub’s code review (which costs $0 if you’re already on GitHub Free, or is bundled in GitHub Team at $4/user/month), the calculation isn’t about Review Board’s license cost — it’s about whether you need anything Review Board does that GitHub PR doesn’t. For a Perforce shop or a team reviewing PDFs: Review Board wins on features. For a standard Git shop: GitHub PR is already paid for.

Deployment reality check

Installation involves more steps than a modern Docker Compose tool. The recommended path is the Review Board Installer for Linux, which handles distribution-specific package management [5]. The manual path requires:

Python 3.8+ (Review Board 7.0) [5]
MySQL 8+ or PostgreSQL 10+ [5]
Apache + mod_wsgi, gunicorn, nginx, or uwsgi [5]
A Review Board site directory (e.g. /var/www/reviews.example.com) [5]
Python Virtual Environment recommended for Review Board 5.0.5+ [5]

The Digital.ai TeamForge integration docs [3][4] show that enterprise installs often deploy Review Board alongside a dedicated database server — the full distributed setup involves configuring services tokens across multiple machines and provisioning via TeamForge’s toolchain. This is not a 20-minute Docker setup.

The Python virtual environment warning matters. Ubuntu 23.04+, Fedora 38+, and distributions released after 2022 enforce PEP 668 — they prohibit system-level pip installs. If you’re on a modern Linux and you follow an older Review Board guide, it will fail with an “externally managed environments” error. The official docs call this out and recommend the Virtual Environment path [5].

What can go sideways:

The installer simplifies things, but the manual path has enough moving parts (web server config, DB setup, site provisioning commands) that non-technical admins will struggle.
Docker is available as an alternative to bare metal, but the docs route you through manual installation by default [5].
Power Pack requires a license file installed on the server — not a credential in a config, an actual license file — which adds friction to containerized deployments.

Realistic time estimate: a technical user comfortable with Linux server administration can stand up a working instance in 1–3 hours. A non-technical founder should not attempt this without help or without using RBCommons.

Pros and cons

Pros

Genuinely MIT-licensed. Unlike some “open core” tools that put the useful features behind commercial tiers, Review Board’s community edition is real software with a real MIT license [README][2]. You can run it for free indefinitely.
Supports VCS that GitHub never will. Perforce, ClearCase, CVS, Plastic — Review Board treats these as first-class citizens. For teams locked into legacy SCM, this is the entire value proposition [README][website].
Document and image review is unique. PDF diff with contextual commenting, Office document review, image diffs with region commenting — nothing else in the open-source space does all of this [website].
Pre-commit review workflow. Post diffs before they’re committed. Useful for teams with strict change control who don’t want unreviewed code touching the main branch [website].
Mature, production-hardened. Running in production since 2006 at thousands of organizations. Not a new project that might disappear next year [README].
REST API and extension framework. Deep programmatic access for automation, custom tooling, and IDE integrations [README][features].
RBTools CLI is solid — post, land, patch, status check without leaving the terminal [website].

Cons

1,695 GitHub stars. This is a rough proxy for ecosystem health, and it’s low. Compare to GitHub’s native review (built-in), GitLab’s MR (built-in), or Gerrit (4,000+ stars). Low star count means fewer community tutorials, fewer third-party integrations, and a smaller pool of engineers who’ve used it before [merged profile].
Power Pack required for key features. PDF/Office review, reports, Azure DevOps Enterprise, and GitHub Enterprise integration all require a commercial license. The pricing is opaque (contact sales). If these features are your reason for choosing Review Board, you’re in closed-source SaaS territory for that part of it [website].
Limited independent reviews available. Finding real user experiences outside official documentation is harder than for actively growing tools. The third-party sources gathered for this review are primarily technical install docs and an aggregator listing — not analyst reviews or user testimonials. This opacity makes it difficult to verify real-world pain points [2][3][4].
Not optimized for the GitHub-native team. If your team’s code lives on GitHub, GitLab, or Bitbucket and you work with Git branches and PRs, Review Board adds operational overhead for marginal gain. The built-in review tools in those platforms have caught up on most daily-use features.
Installation is heavier than modern alternatives. Apache or nginx, Python venv, PostgreSQL or MySQL, site provisioning — more moving parts than a single docker-compose up [5].
RBCommons pricing opacity. The hosted option has no public pricing, making evaluation harder.
No obvious AI integration story. Unlike newer tools, there’s no mention of LLM-powered review suggestions, semantic diff analysis, or AI-assisted review workflows in the current product [website][README].

Who should use this / who shouldn’t

Use Review Board if:

Your team uses Perforce, ClearCase, Subversion, CVS, or Plastic, and you need a review tool that understands those VCS natively.
You need to review PDFs, Office documents, technical schematics, and images alongside code — all in one tool with proper diff and annotation support (Power Pack required).
You’re already running Review Board and it works. Migration away from working infrastructure carries real cost; there’s no urgent reason to switch.
You’re in an enterprise environment integrated with Digital.ai TeamForge, where Review Board is a supported component [3][4].
You want pre-commit review workflows where changes are reviewed before they ever touch the repository.

Skip it (use GitHub/GitLab PRs) if:

Your code lives on GitHub, GitLab, or Bitbucket. The review tooling is already there, it’s good enough for most teams, and it costs nothing incremental.
You have fewer than 10 engineers and no need for document review. The operational overhead of standing up and maintaining a separate review server isn’t worth it.
You’re a non-technical founder. Review Board is an engineering tool, not a product designed for non-technical users. The target audience for unsubbed.co’s typical content won’t find much value here.

Skip it (use Gerrit) if:

You need a review tool designed specifically for strict, gate-based code review where nothing merges without explicit approval — Gerrit’s permission model is built for this.

Skip it (use Phabricator/Phorge) if:

You want a broader development platform — tasks, wiki, audit logs, and code review in one place — that leans more toward the engineering workflow side.

Alternatives worth considering

GitHub Pull Requests — the default for Git teams. Built in, zero overhead, good enough for most code review needs. Not comparable on document review or legacy VCS.
GitLab Merge Requests — same category as GitHub PRs. GitLab’s self-hosted option is genuinely good. Also zero-cost if you’re already using GitLab.
Gerrit — open-source, designed for strict gate-based review (Android, Chrome, and most Google projects use it). More complex to operate, but extremely powerful for teams that need hard review gates before merge.
Phorge / Phabricator — open-source fork of Facebook’s Phabricator. Full development platform: code review (Differential), task tracking, wiki, audit logs. Good for teams that want everything in one self-hosted system.
Crucible (Atlassian) — commercial, Jira-integrated, also handles multiple VCS including Perforce. If you’re already paying for Atlassian, this is the natural comparison. No longer receiving major feature development.
Upsource (JetBrains) — commercial code review tool with deep IDE integration. Discontinued as of 2023 — don’t pick this.
LinearB / Graphite / CodeRabbit — newer AI-assisted review platforms if your primary interest is LLM-powered review suggestions. These assume a Git/GitHub workflow.

For the Perforce-or-ClearCase-and-document-review use case, the realistic shortlist is Review Board vs Crucible. Review Board wins on license cost (MIT vs Atlassian commercial). Crucible wins on Jira integration and vendor support.

Bottom line

Review Board is a tool that time treated strangely. In 2006, it was ahead of everything. Today, most of the features it invented are table stakes in GitHub and GitLab. For the majority of software teams in 2026, the right answer is to use the review tooling already built into your Git host and not add another server to operate.

The legitimate cases where Review Board still earns its place: legacy VCS shops (Perforce, ClearCase) where the major platforms simply don’t work, and teams with real document review needs — PDFs, Office files, schematics — where no other open-source tool competes. In those niches, it’s genuinely the right pick, MIT-licensed, mature, and battle-tested at enterprise scale.

If neither of those describes your situation, you don’t need it.