Independent software assessment: what a good one covers and what you should get back

Qasim Ali · Senior Software Engineer (Java, AI), CS2 Technologies
Published · 7 min read

At some point most managers who own a piece of software need someone from outside to look at it. You might be about to buy a company, fund a rebuild or take over from a vendor who’s leaving. The people who built the system can tell you a lot, but they can’t be the ones to judge it.

An independent software assessment answers a narrow question: what’s really in this codebase and around it, and what will it take to get where you need to go? Done well, it ends with a written report you can put in front of a board, an investor or a new vendor.

This article explains what a good assessment covers, what you should get back, how to scope one so the answer arrives in time, and which findings should make you stop and ask more questions.

1. When an outside opinion pays for itself

The most common trigger is money changing hands. Before you buy or invest in a software company, the pitch deck says scalable and secure, and you need someone to open the repository and the cloud account and tell you what’s actually there before the price is set. Technical due diligence is the name for that.

Other moments call for it too. A big rebuild is about to be approved, and nobody has checked whether the old system could be modernized instead. A vendor has left, or a new one is coming in, and you want a baseline both sides agree on. A customer or an auditor has sent a security questionnaire, and the honest answers are vague. In each case, the cost of the review is small next to the cost of a wrong decision.

For managers: Commission an assessment before the decision that’s hard to undo, not after. Its value drops sharply once the contract is signed.

2. Architecture and code quality

A reviewer starts with the shape of the system. Does the structure match how the business actually works, or does every new feature have to touch five places? Are there clear boundaries between parts, or is it one tangle where a change in billing can break login? None of this calls for a particular style. Monoliths can be fine, and microservices can be a mess.

Then comes the code itself. Look for tests on the paths that matter, readable naming, consistent error handling and a build that works on a fresh machine. How changes reach production matters just as much: an automated pipeline with reviews says more about long-term health than any single file. A good reviewer will also say what’s solid, because the decision you face often turns on what you can keep.

For managers: Ask for a judgment on whether the architecture fits where the business is going, along with a list of what’s worth keeping.

3. Security and dependencies

Security review covers how users log in and what they’re allowed to see, how tokens and passwords are stored, and whether secrets such as API keys sit in the repository. The OWASP guidance gives a shared checklist for web applications, and tools like Burp Suite and OWASP ZAP can test whether the protections hold up against a running system.

Dependencies deserve their own pass. Most applications are built mostly out of open-source libraries, and some of those will be out of support or have known vulnerabilities. The same goes for the platform underneath: a framework or language version that no longer gets security fixes is a finding with a cost attached, even if nothing is broken today. Licences belong in this part too, especially before an acquisition.

For managers: Make sure the report names outdated frameworks and libraries with known vulnerabilities, and says what bringing them up to date involves.

4. Infrastructure, operations and cloud cost

Software doesn’t stop at the code. A reviewer should check who owns the cloud accounts, whether infrastructure is defined in code (Terraform, for example) or was clicked together in a console, and whether anyone has ever restored a backup to prove it works. Monitoring and alerting matter here: when something fails at night, does anybody find out before the customers do?

Cloud cost is part of the same picture. A system that costs far more to run than its usage justifies is a finding, and so is one whose bill nobody can explain service by service. Neither is necessarily a disaster, but both affect what the system is worth to you.

For managers: Check that the cloud accounts, domains and repositories are, or will be, in your company’s name. If they belong to a vendor, that’s the first thing to fix.

5. Data and documentation

Data usually outlives the code that wrote it. The assessment should look at the database design, how schema changes are managed, and the quality of what’s stored. If the system holds personal information, the reviewer should check where it lives and who can reach it, against the rules that apply to you, such as PIPEDA in Canada or the GDPR in the EU.

Documentation is the other half. A short, current description of how the system fits together, how to deploy it and what to do when it breaks is worth more than a thick binder from three years ago. Missing documentation isn’t a scandal, but it raises the cost of every handover.

For managers: Ask whether a new engineer could deploy the system using only what’s written down. The answer tells you a lot about handover risk.

6. The team and the bus factor

Many systems run on knowledge that lives in one or two heads. The commit history, the deploy process and short interviews with the people who build and run the system usually show where that knowledge sits. A deploy that depends on one person’s memory is a business risk, whatever the code looks like.

Interviews add context that code can’t give: why a decision was made, what the team already knows is fragile, what they’d change with more time. A good reviewer treats those conversations as evidence rather than as an audit of people.

For managers: Find out who could leave tomorrow and take something critical with them. That person’s knowledge should be written down before anything else happens.

7. What you should get back

The deliverable is a written report aimed at whoever makes the decision. Each finding should have a severity, a rough sense of what fixing it involves, and a place in a recommended order. A pile of raw scanner output isn’t a report. Neither is a slide deck full of adjectives. You want a document that says what to do first and why.

At CS2 the assessment is fixed scope, fixed price and ends in that report. It runs in four steps: an agreed scope, read-only access and interviews, analysis of architecture, code quality, security posture, infrastructure, delivery practice and team risk, then the written report and a briefing call to walk through it. The assessment ends with the report. If you then want us to do the work, that’s a separate decision and a separate proposal, and plenty of clients take the report to their own team or another vendor.

For managers: Insist on a written, prioritized report with severity for each finding and a briefing to go through it. Anything less is just an opinion.

8. Scoping it, and the red flags to watch for

Scoping starts with the question you need answered. “Is this worth the asking price?” leads to a different review than “Can our team maintain this?” or “What do we fix before the audit?” Agree on that question, on what access the reviewer gets and on the date you need the answer. How long it takes depends on the size of the codebase and how fast access arrives, which is why the scope and price should be fixed in writing before work starts.

Some warning signs show up before the review even begins. A seller or vendor who offers demos but won’t grant read-only access to the code and the cloud account is telling you something. On the reviewer’s side, be wary of anyone who won’t put findings in writing, who reviews only from slides, or who seems to be using the assessment to sell you a rewrite. A good assessment can recommend a rebuild, but it should show its reasoning so another team could check it.

For managers: Write down the one question the assessment must answer, and make read-only access a condition before you talk price with the other side.

The short version

An independent software assessment tells you what’s really in a system before a decision that’s hard to undo. A good one covers architecture, code, security, dependencies, infrastructure and cost, data, documentation and the people who hold the knowledge. It ends in a written, prioritized report. Scope it around one clear question, get read-only access, and keep the review separate from any decision about who does the work.

Qasim Ali

Senior Software Engineer (Java, AI), CS2 Technologies

Qasim has 18 years of backend experience, including ten years on the backend platform of Vodafone Kabel Deutschland, and works with the CS2 team on assessments, client builds and CS2’s own products. If you need an outside read on a system before a big decision, he’s happy to talk through what it should cover.