Team reviews code.
Corrdex reviews architecture.

Turn architectural decisions into enforceable rules. Corrdex helps teams detect drift, review structural changes, and keep systems healthy as codebases and organizations scale.

Start for free →Book a demoDemo
•No agent installs•Works with any TS/JS repo•CI/CD native•Free tier available
corrdex/acme-backend
Scanning
0files analyzed
0drift detected
0broken boundaries
Architecture map
CheckoutControllerPaymentServiceOrderRepositoryInvoiceWorker
Live findings
DRIFT
Wrong-layer import
CheckoutController imports OrderRepository directly.
VIOLATION
Boundary broken
InvoiceWorker writes to the HTTP response layer.
IMPACT
Blast radius: 38 files
A change in PaymentService now fans out across checkout.
Last scan: 2s ago · TypeScript2 merges blocked
The real cost of architectural debt

Your codebase grows.
Your architecture does not keep up.

Every team starts with good intentions. Over time, the wrong imports creep in, responsibilities blur, and the original structure becomes invisible. Reviews do not catch it. Documentation does not survive. And the engineer who understood it all just got promoted.

Corrdex exists so that does not happen to you.

"Why is our service layer calling the DB directly?"
Architecture drift accumulates invisibly across hundreds of PRs. Nobody sees the pattern until it's too late.
"I'm terrified to touch this module."
No visibility into change impact. You do not know what breaks until it already has.
"The only doc we have is the original engineer's memory."
Architectural knowledge evaporates with every team change. There is no institutional memory.
"We want to enforce architecture but can't scale reviews."
Manual architecture review does not scale past 3 engineers. Rules in docs do not run in CI.
10 features, one platform

Every layer of architectural governance — built in.

01
Architecture Drift Detection
Stop architecture rot before it requires a full rewrite.

Flags every file accumulating the wrong responsibilities — continuously, automatically, with zero false positives.

continuousautomated
Controller
Repository
02
Boundary Enforcement
Stop architectural violations before they reach production.

Controllers can't call repos. Services can't reach the HTTP layer. Rules enforced at every import, in real time.

real-timeCI/CD
Controller
Repository
03
Change Impact Analysis
Know every file a change can affect before the PR is merged.

Blast radius mapped and risk-scored at PR-time. Your reviewer sees structural risk before they even open the diff.

PR-timerisk-scored
PaymentSvc
38 files affected
04
Architecture Memory
Your architecture survives team turnover.

Every decision, every rule, every boundary — persisted across reorgs, departures, and new hires. Your architecture doesn't forget, even when your team changes.

persistentorg-wide
Team
A
Alexdeparted
S
Samdeparted
D
Danadeparted
Architecture Rules
rule('no-ctrl-repo', {
  from: 'controller',
  forbidden: ['repository'],
})
✓ Rules persisted — 3 engineers later
05
Team Architecture Governance
Your best engineers' judgment, enforced at scale.

Encode what your senior engineers know. Run it in CI. Block violations automatically — forever.

TypeScript rulesCI-blocking
rule('no-controller-repo',
  severity: 'error'
  blocking: true
)
✓ 3 violations blocked in CI today
06
PR Architecture Review
Merge blocked. Architecture violation caught at commit time.

Every PR gets a full structural health check. Violations surface before review. Merges blocked automatically — no manual oversight required.

merge-gatingGitHub · GitLab
PR #847 · feat/order-servicemerge blocked
✓
CI / Build
7 jobs passed
✓
Tests
47 / 47 passed
✗
Architecture
2 violations
↳ checkoutController → OrderRepository
↳ orderService → HTTP layer
08
System Topology Visualization
See your architecture the way it actually is.

An interactive live graph of every layer, dependency, and coupling score — updated continuously as your codebase evolves.

interactivelive
APIPaySvcOrderSvcPayRepoOrdRepoStripe
10
Codebase Radar
Understand any codebase in seconds. No README required.

Point it at any repo and get a complete architectural map — layers, owners, boundaries — instantly. Perfect for audits, due diligence, and day-one onboarding.

instantany repono setup
Scanning...
controllers/checkout.tscontroller
services/payment.tsservice
repos/order.tsrepository
workers/invoice.tsqueue-worker
config/stripe.tsconfig
✓ 247 files classified
checkoutauthpaymentorderRepopayRepoDB
07
Architecture Diff
See what actually changed architecturally — not just which lines.

Structural diff on every PR. Spot boundary shifts, layer regressions, and ownership changes — before they merge.

semantic diffPR-native
−import { OrderRepository }
+import { OrderService }
 
class CheckoutController {
+ // direct DB access removed
}
09
AI Architecture Reasoning
Ask your codebase anything. Get grounded answers in seconds.

Natural language. Architecturally grounded. Not hallucinations — answers backed by the actual structure of your codebase.

AI-poweredbeta
Who owns the payment flow?
Ownership traced across 4 layers:
paymentService.tsowner
checkoutController.tsdrift ⚠
stripeWebhook.tsclean
See it in action

The features that matter most

Architecture Drift Detection

Catch drift before it becomes
a crisis.

Most teams only discover architecture drift during a painful refactor sprint after years of accumulation. Corrdex monitors every file continuously and flags violations the moment a responsibility boundary gets crossed.

->Detects files accumulating the wrong responsibilities in real time
->Surfaces drift trend over time so you can see if architecture is improving or slipping
->Blocks PRs that introduce new drift while tracking legacy violations with zero false positives
Learn more ->
ControllerServiceRepository
Change Impact Analysis

Know the blast radius
before you merge.

"It's just a small change" until it takes down checkout because it touched a shared utility four layers deep. Corrdex maps the full downstream impact of every PR before you approve it.

->Blast radius scored by architectural coupling depth and dependency criticality
->Posted directly to your PR as a comment with no dashboard required
->Distinguishes high-risk structural changes from low-risk text changes
Learn more ->
StripeServiceAuthServiceCartServiceNotifyWorkerEmailServiceRefundServiceBillingServiceOrderServiceCheckoutAPIInvoiceWorkerPaymentService
Team Architecture Governance

Encode your best engineers.
Make rules that actually run.

Architecture rules should not live in docs nobody reads. They should run in CI and block merges. Corrdex lets you encode the things your senior engineers know and enforce them across every PR, forever.

->Write rules in TypeScript with no custom DSL to learn
->Rules run at PR time and block merges automatically
->Architecture Memory ensures judgment survives team churn
Learn more ->
RulesPoliciesDecisionsPatternsReviewsGuardrailsCorrdex
Built for every role

Everyone wins when architecture is healthy

For Developers

Stop second-guessing. Know exactly where to put your code, what's safe to change, and how your PR affects the rest of the system before you hit merge.

Instant structural understanding of any file or module
Blast radius of your PR shown before review
Architecture Diff tells you what structurally changed, not just what lines changed
Ask the codebase questions in plain English
Codebase Radar helps you understand any repo on day one
See developer features
For Team Leads

Your knowledge should not be a bottleneck. Corrdex encodes your architectural standards and enforces them at PR time so you review outcomes, not style.

PR-time architecture review blocks violations automatically
Governance rules encode your standards without manual review
Architecture Memory preserves decisions across team changes
Drift Detection catches scope creep before it spreads
Topology visualization shows the full system at a glance
See team lead features
For Engineering Orgs

Scale architectural governance across 10 teams or 100. Enforce org-wide standards, reduce onboarding time, and stop architectural debt before it compounds.

Org-wide architecture governance with team-specific overrides
Architecture Memory survives reorganizations and departures
Compliance-ready audit trail of every architectural decision
Reduce onboarding time with Codebase Radar
Track architectural health trends across the whole org
See enterprise features
AI-assisted architecture reasoning

Ask your codebase
anything.

Natural language questions. Architecturally grounded answers. Not AI hallucinations, answers backed by the actual structure of your codebase.

•"What owns the payment flow?" traces ownership across 3 layers
•"Where is our auth logic scattered?" finds fragmented responsibility
•"Which files are most risky to change?" surfaces high-coupling nodes
•"How does data flow from API to DB in the order module?" returns a full trace
In betaJoin the waitlist →
Corrdex
Corrdex AI
Reasoning over your architecture · beta
Where is our payment logic scattered across the codebase?
Payment logic is spread across 6 files in 4 different layers. Here is the map:

paymentService.ts — core logic
checkoutController.ts — inline charge logic
orderRepository.ts — writes payment status
stripeWebhook.ts — handles refunds
invoiceQueue.ts — re-charges failed payments
userService.ts — subscription logic

The faded files are where drift is accumulating.
Which of these is riskiest to change right now?
checkoutController.ts is highest risk. It is imported by 9 downstream files and has only 34% test coverage.
0.0×
Faster architectural issue resolution
0%
Reduction in architecture-related production incidents
0%
Faster onboarding for new engineers
0%
Of governance rules enforced automatically — no manual review
Integrations

Works with your existing stack

Plugs into your PR workflow, CI pipeline, and notification tools. No new UI to learn.

GitHub
GitLab
GitHub Actions
Pricing

Plans for every stage of your architecture

Whether you are exploring a legacy codebase alone or enforcing governance across hundreds of repositories.

Free

For individual developers exploring their architecture.

$0
Free forever
Top features
  • 1 Project
  • 1 Repository
  • Architecture Map
  • Codebase Radar
  • Semantic Classification
  • 10 AI Queries / mo
  • MCP Access
  • Community Support
Get started

Pro

For serious developers and consultants.

$24
per user / month
Everything in Free, plus
  • 10 Projects
  • Unlimited Repositories
  • Custom Rules & Violations
  • Architecture Drift Detection
  • Boundary Enforcement
  • Change Impact Analysis
  • 250 AI Queries / mo
  • Email Support
Upgrade to Pro

Team

Popular

For engineering teams that want architectural governance.

$99
per team / month
Everything in Pro, plus
  • Unlimited Projects
  • Organizations & Members
  • Shared Rule Libraries
  • Team Dashboards & Health
  • Architecture Memory
  • GitHub & GitLab Integration
  • PR / Commit-time Reviews
  • 2,000 AI Queries / mo
  • Priority Support
Start 14-day trial

Enterprise

For orgs managing architecture at scale.

Custom
Contact us for pricing
Everything in Team, plus
  • Unlimited AI Queries
  • SSO / SAML & RBAC
  • Private Rule Packs
  • Org-wide Policy Enforcement
  • Advanced Compliance Reporting
  • Audit Logs
  • Dedicated Slack Channel
  • Optional Private Deployment
Contact sales
See full feature comparison
Ready to keep your architecture honest?

Stop letting architecture drift.
Start enforcing it.

Your first repo is free. No install, no config, no excuses.

Analyze your repo free →Book a demo