The 7 code dimensions that decide your hireability score
DevProfile scores every analysis across seven dimensions of your actual code. What each one measures, why reviewers care, and how to raise it.
Key takeaways
- The score reads your repositories, not your claims — it moves when the code moves
- Consistency and naming are the cheapest dimensions to improve this week
- Tests and documentation are where junior profiles lose the most points
- Track the score across runs: the trend matters more than any single number
Why dimensions instead of one number
A single score tells you where you stand; it doesn't tell you what to do. DevProfile computes the 0–100 hireability score from seven measurable dimensions of your repositories — consistency, architecture, patterns, naming, documentation, tests, and complexity — because that's roughly the checklist a senior engineer runs when they open a candidate's repo.
Each dimension is scored from the code itself. That's the point of the product: no self-assessment, no keyword matching — the same evidence a technical reviewer would use, read the same way.
Consistency and naming: the first impressions
Consistency measures whether your codebase behaves like one author with standards or several authors with none: formatting, file organization, commit cadence, and whether conventions hold across the repo. It's the first thing a reviewer notices and the cheapest thing to fix — a formatter, a linter, and one honest cleanup pass move it immediately.
Naming is judged because it's a proxy for thinking. Variables called data2, functions that lie about what they do, and abbreviations only you understand all read as unclear reasoning. Renaming toward honesty — handleSubmit that actually submits, userRepository that actually stores users — is free and visible.
Architecture and patterns: the structural signals
Architecture scores how your projects are organized: separation of concerns, sensible boundaries between layers, dependencies pointing the right direction. A backend with controllers, services, and repositories in the right relationship outscores a single 900-line file regardless of what the file does.
Patterns measures whether you reach for established solutions — and whether you over-reach. Idiomatic use of your framework scores well; a hand-rolled ORM inside a CRUD app scores as inexperience. The signal reviewers want is judgment: standard problems solved the standard way, novelty spent only where the problem is actually novel.
Documentation, tests, and complexity: where juniors bleed points
Documentation and tests are the two dimensions where early-career profiles consistently score lowest — which makes them the highest-leverage fixes. A README that explains setup and decisions, docstrings on the non-obvious functions, and a test suite that covers the core paths can move a profile more than any new project would.
Complexity measures whether your functions and modules stay small enough to reason about: nesting depth, function length, and how tangled the call graph gets. High complexity isn't ambition — it's usually a refactor that never happened. Extracting functions and flattening conditionals is unglamorous work that shows up directly in the score.
Use the trend, not the snapshot
The first analysis is a baseline, not a verdict. Every subsequent run re-scores the same seven dimensions, and the trend line tells you whether your work is compounding. The roadmap orders the fixes by impact; the statistics page shows whether they landed.
Run your first analysis free, get the seven numbers, and know exactly which week of work raises which one.
Related roadmap
Backend Developer Roadmap
From your first language to production APIs — databases, auth, testing, and deployment in one staged path.
View the roadmap