Size up a legacy codebase to plan & estimate¶

Before you can modernize, port, or bid on an inherited codebase, you need to know what you're taking on: how big it is, where the hard parts are, and how tangled it is. Understand turns "we have no idea" into concrete numbers you can put in a plan, a staffing decision, or a customer quote — usually in an afternoon, without building the code.

This page is the scoping workflow; each step links to its full how-to.

1. Get the size and shape¶

Analyze the code and read the top-level numbers first: lines, files, classes, and functions on the Home dashboard, and the distributions in the metrics overview. This alone answers "how big is this, really?" more honestly than a line count of the repo, because it counts what actually compiles.

2. Find the hotspots that drive effort¶

Effort concentrates in the complex, risky parts — not evenly across files. Surface them:

Where is my risky / complex code? — the Metrics Treemap and Heatmap make the big, complex units stand out, so you can size the hard 20% separately from the routine 80%.
Measure & track technical debt — a debt/complexity baseline you can quote and later measure progress against.

3. Assess the entanglement¶

The cost of change is driven as much by coupling as by size — tightly wired code is expensive to touch. Gauge it with dependencies and coupling & cohesion metrics, and sketch the intended structure with an architecture so you can talk about subsystems, not files.

4. Turn it into an estimate¶

Export the numbers to build the estimate and set a baseline you'll track through the project:

Export & track metrics over time for the spreadsheet behind your scope.
Push metrics to leadership dashboards to keep stakeholders aligned as the effort proceeds.
Compare two versions of a project — keep the original analysis as a baseline database, so each milestone can be measured against where you started.

Where to next¶

Once you've scoped it and the work begins:

Onboarding to an unfamiliar codebase — get the team productive.
Refactoring at scale and Finding & reducing complexity — the execution playbooks.