signals intelligence for people who hire developers
Your developer
sends invoices.
We read the code.
DevWatch analyzes your project’s git history and tells you — in plain English — how much real work is getting done, and whether it’s any good. Like having an engineering manager on your side, for the price of a lunch.
first report free · no card required
the tests are real, and the hard part —
refunds — didn’t get skipped.”
// case file 001 — the problem
You can’t read code.
You’re paying for it anyway.
Most freelance developers are honest. But you’re wiring money every month against progress updates you can’t verify, in a language you don’t speak. “It’s almost done” has no receipt. Screenshots prove nothing.
And the traditional fix — hiring another developer to audit the first one — costs $5,000 and up, feels like an accusation, and tells you nothing about next month. You don’t need a private investigator. You need a manager.
// standard operating procedure
Three steps.
No code knowledge required.
- 01
Connect your repository.
It’s your code — the repo should live in your account, with your developer as a collaborator. Not the case yet? We’ll show you how to fix that. DevWatch itself only ever gets read-only access, revocable anytime.
- 02
We read the history.
Every commit, weighted by difficulty — not by lines of code, which can be faked. Boilerplate, copy-paste bulk, and generated files don’t inflate anyone’s score.
- 03
You get a plain-English report.
Weekly effort and quality signals, red flags, and honest uncertainty — shareable with your co-founder, your investor, or the developer themselves.
// methodology
Stop counting
lines of code.
Lines are the easiest thing to fake and the first thing amateurs measure. Here’s what a DevWatch report weighs instead — alongside the classic inspection toolbox, included with every run.
// under the hood — measured first, judged second
// what we weigh
01 · difficulty-weighted
A gnarly 40-line concurrency fix outweighs 4,000 lines of boilerplate. Every commit is scored for how hard the work actually was.
02 · padding-proof
Vendored libraries, lockfiles, and generated files are detected and excluded from credit. Bulk is not work.
03 · quality-read
Tests that arrive with features, sound structure, hard parts done — not just evidence that “code happened.”
04 · cadence-aware
Steady weekly progress reads differently than a 2am dump the night before an invoice. The rhythm is part of the evidence.
05 · plain-english
Every score ships with a written narrative you can actually read, question, and forward — no dashboards to decode.
06 · knows its limits
Git can’t see meetings or debugging dead-ends — so we never pretend it can. Thin evidence gets said out loud, not papered over with fake precision.
// what we check
Security scan
Every library your project depends on, checked against the public databases of known vulnerabilities.
Leaked secrets
Passwords and API keys accidentally left in the code — caught before someone less friendly finds them.
License trouble
Open-source code with strings attached that could complicate selling, licensing, or fundraising later.
Aging dependencies
Libraries running years out of date, quietly stacking up risk and future rework costs — measured in years behind, with the worst offenders named.
The raw ledger
Commits, active days, lines added and removed — every week, straight from the history.
Code hygiene
The automated tidiness checks professional teams run on every change — flagging sloppy, error-prone code before it becomes bugs.
// active cases
You hired a freelancer to build your product, and every invoice is a small act of faith.
An agency built your MVP and you’d like to know what four people actually did for that retainer.
You’re buying a codebase — an app, a SaaS, a side project — and the seller says it’s solid.
Your developer left and you inherited a repo you can’t read. What did they leave you?
// request clearance
Know what you paid for.
Connect your repo, get your first report free — no card, no sales call. See what the history says before your next invoice arrives.
// frequently intercepted questions
Is this spying on my developer?
No. DevWatch reads the git history — the work product you’re paying for — never screenshots, keystrokes, or hours. It’s what a technical co-founder would do, if you had one.
The repo is in my developer’s account. Is that normal?
It should be the other way around. The professional norm is that you own the repository — it lives in your account, and your developer works in it as a collaborator. You’re paying for that code; it’s your asset. If your project currently lives in your developer’s personal account, transferring it is a routine ten-minute operation, and we include a template that makes the ask easy. If they refuse — that’s a red flag worth taking seriously.
My project is private. Where does the code go?
Credential patterns are stripped before analysis, third-party and vendored code is never sent anywhere, and we don’t train models on your code. Reports live in your account and nowhere else.
What does it cost?
Your first report is free — no card required. After that it’s a small subscription, a fraction of the $5,000+ a one-off human audit costs.
Isn’t that kind of expensive?
So is an engineering manager. DevWatch does the oversight slice of that job for roughly the price of one of their lunches. Under the hood, every report runs serious frontier-model compute, tuned to read code accurately instead of just plausibly — and we’re a small team with no venture money, so nobody is subsidizing your tokens to juice a growth chart. The price is the honest cost of doing the job properly. It also means we’ll still be here next year.