The data room does not reveal the risk. This article lays out a twelve-day technical review: access and inventory, code and architecture, dependencies and licences, security and data, hosting and recovery, team and contracts, then a report that leads to a decision rather than a score.
When you buy a software company or a software product, the data room is tidy: revenue, contracts, a product demo, and a slide about the roadmap. The risk is rarely in those documents. It sits in the repository nobody has read, the cloud account still owned by a former contractor, the one service with no tests, and the two engineers who know how deployment works. Technical due diligence exists to turn those unknowns into a decision you can price and defend.
Twelve days is a structure, not a promise. It is enough to read the parts that carry the business, test the claims that matter, and write a report a board can act on, provided access arrives on day one and the seller answers in writing. If access is delayed, the schedule slips. The answer is not to compress the review; it is to delay the decision or narrow the scope.
What the twelve days cover, and what they do not
The review covers the product and code, architecture, dependencies and licences, security posture, data and privacy, hosting and recovery, the team and knowledge concentration, contracts and intellectual property, scalability, and the roadmap. That is the space in which a buyer decides whether they can operate what they are buying, at what cost, and with which risks.
What it does not cover is equally clear: the financial audit, tax, legal opinion, and commercial valuation. We raise issues to the accountant and the lawyer; we do not replace their work. Technical due diligence answers a different question: can this system be operated, changed and secured, or are you buying a pleasant interface on top of a large technical debt?
Access needed before the start: read access to the repository with full history, the build and deployment pipeline, read-only access to the cloud account, the issue tracker, the incident log, architecture documents, the vendor list, a sample of customer contracts, and interviews with the people who actually operate the system. If the seller cannot grant repository access, that is a finding in itself, not an administrative obstacle.
The twelve-day structure
The table below is the schedule we work to. The days are not sealed boxes. Security may move earlier if an early signal appears, and a line may slip because access did not arrive. The order keeps the decision from drowning in detail before it has seen the whole picture.
| Phase | Days | What we do | What you get |
|---|---|---|---|
| Access and inventory | 1–2 | Clone the repositories, list services, trace accounts and owners, collect documents | A system list you can defend |
| Code and architecture | 3–4 | Read the revenue paths, review boundaries and the data model, inspect tests and error handling | Where change is cheap and where it is dangerous |
| Dependencies and build | 5–6 | Reproduce the build, audit packages and licences, check security updates | Maintenance cost and licence exposure |
| Security and data | 7–8 | Review authentication, authorization, tenant isolation, secrets, logs and backups | Deal-breakers and remediation scope |
| Hosting, recovery and scale | 9–10 | Verify infrastructure ownership, regions, the recovery plan, restore evidence and bottlenecks | Operational risk and cost to carry |
| Team, contracts and roadmap | 11 | Interview key people, review IP, service agreements, subprocessors and promises | Continuity and obligations |
| Report and readout | 12 | Rank findings by severity with evidence, impact, fix effort and conditions | A decision, not a score |
Days 1–2: access and inventory
Real access means you can clone the repository, build the system, run the tests, and read the logs. A screenshot is not access, and a demo is not access. If you cannot rebuild from a clean copy, you do not know what runs in production or how to restore it when it fails.
The inventory covers services, repositories, environments, cloud accounts, domains, certificates, vendor accounts, data stores, queues, scheduled jobs, and internal tools. Ask about ownership: who owns the account, who pays its bill, who can delete it, and who has left while their key still works. A system list without owners is a list of risks.
This stage also surfaces the undocumented obligations: a script running on an employee's laptop, a database copy on a desktop drive, a scheduled job nobody remembers, and a domain about to expire. These are not small details. They are the difference between a system that can be handed over and one that has to be rediscovered after closing.
Days 3–4: code and architecture
Do not read every file. Read the paths that carry revenue: signup, login, payment, order, entitlement, and reporting. These are the paths that stop the business when they break. They also hold the old decisions that govern the system today: how price is calculated, who holds permission, and when an order is considered complete.
In the architecture, look for boundaries and coupling: a service that knows too much about another, logic duplicated in two places, configuration written into code, migrations that cannot be reversed, and background jobs with no monitoring. Ask about the tenant model: is isolation enforced in the database or in the application layer, and has anyone tested it with users from two different customers?
Tests are not judged by a number but by their ability to catch a dangerous change. Exercise a payment path with a different amount, a duplicate order, users from two different tenants, and a large file upload. If those cases have no test, every future change is a gamble, however clean the code looks.
Days 5–6: dependencies and the build
Rebuild from a clean copy on your own machine. If it only works on one laptop, or needs a manual step only one engineer knows, that is a finding. Then read the lockfiles: are versions pinned, are frameworks current, are there abandoned packages, and are there transitive dependencies carrying licences that do not fit what you intend to sell?
Licensing is a deal issue, not a code style issue. A dependency that imposes conditions on distribution inside a product you ship can change what you may sell, what you must disclose, or what you must share. Review the open-source policy, the contribution record, and whether the code includes copied projects without attribution.
Inspect the build and deployment pipeline too: what runs on every change, what is skipped, who can merge to the main branch, and whether secrets exist in repository history. One secret in history means immediate rotation of everything it touched, not deletion from the latest commit.
Days 7–8: security and data
From reading to shipping
Want this built, not just explained?
Bring us the problem behind the article. We will tell you what it takes, what it costs, and whether we are the right team.
Start from the threat model, not the tool list. Who would attack this system, what do they gain, where is sensitive data, and who can reach it. Then review authentication, authorization, tenant isolation, input handling, file uploads, outbound requests, secrets management, data and key encryption, and access logs.
A vulnerability scan is not a penetration test. The first finds known bad versions; the second attempts to exploit a full path. If the product handles customer data, ask for evidence that isolation was actually tested, that one user's permission cannot open another user's data, and that logs do not retain what they should not.
At the data level, ask about categories, regions, subprocessors, retention, deletion, and cross-border transfer. The Personal Data Protection Law has been enforceable since September 2024, and the draft amendments published on 6 October 2026 propose localisation with limited exceptions and breach notification within 72 hours. If personal data is spread across logs, analytics and support tools, that is a report line, not a footnote.
Days 9–10: hosting, recovery, and scale
Ask whose name is on the cloud account. If it is the seller's personal account, or a contractor who no longer works there, that is a problem ahead of any conversation about price. Then look at infrastructure as code: can the environment be reproduced from a repository, or are the steps documented in a chat thread? Is the region pinned, or one click away from changing?
Ask for restore evidence, not a restore plan. When was a restore last tested, who ran it, how long did it take, and was the data complete? Ask about the target recovery time and the permitted data loss, and about copies in a second region. A plan that has never been executed is a document, not a capability.
For scale, do not order a full load test when the claim does not matter. Identify the bottleneck first: the database, the queue, an external interface, or file storage. Then test the claim that matters to the deal, such as behaviour when peak orders double or when an external provider fails. The report should say where the system breaks, not that it is scalable.
Day 11: team, contracts, and roadmap
The best code in the world becomes a liability if the only person who can deploy it leaves after closing. Ask who knows the system, who can deploy on a holiday, who wrote the critical parts, and whether their contracts assign intellectual property to the company or to the individual. Check external contractors, the code they wrote, and the confidentiality and assignment terms they signed.
Review customer contracts before vendor contracts: service levels, penalties, data processing, subprocessors, termination, and transition assistance. Then vendor contracts: minimum commitments, automatic renewal, and exit cost. Ask about promises made to customers that never reached the contract, because they live in conversations rather than files.
The roadmap is a technical line as much as a commercial one. Which features are promised, which are committed, and which are aspirational? Can the current architecture carry them, or does every new feature require a rebuild? The difference between “we plan to” and “we promised a customer” is the difference between one report and a very different one.
Day 12: the report
The report opens with a one-page decision: proceed, proceed with conditions, renegotiate, or walk away. Then findings ranked by severity, each with evidence that can be opened: a file and line, a configuration, a log, or a test you reran. Then impact: what happens if it is not fixed, who is affected, and whether it blocks closing. Then fix effort in weeks, not money, because a money estimate needs a scope that has not been agreed yet.
Do not deliver a score out of ten. A score hides the one finding that matters. Deliver a list, and mark which item stops the deal, which is priced, and which is handled after closing under a contractual condition. Conditions can be a price adjustment, a holdback, a warranty, remediation before closing, or key people staying for a defined period.
The red flags that stop us most often: a payment path with no test, a single region with no copy, secrets in repository history, an untested recovery plan, one person who knows deployment, unresolved intellectual property, a licence that constrains the product, a framework with no security updates, unproven tenant isolation, logs with no audit trail, customer data in analytics tools, personal cloud accounts, undocumented scheduled jobs, and an empty incident log. Any one of them is not an automatic walk-away, but it is a price or a condition.
The checklist before you sign
This is the minimum we ask for before the clock starts. If it is not assembled, the problem is the deal sequence, not the review.
Contract access before day one: repository history, build pipeline, read-only cloud account, issue tracker, and incident log.
Build from a clean copy on a machine outside the seller's environment, recording every manual step.
Read the revenue paths, not every file: payments, orders, permissions, and reporting first.
Test the critical paths with failure, duplicate, and cross-tenant cases.
Audit licences and transitive dependencies, not only the direct ones.
Prove tenant isolation and authorization with a test you rerun yourself, not a seller's report.
Evidence of an executed restore, a readable recovery plan, and a documented second region.
The names of everyone who can deploy, their contracts, and the ownership of the code they wrote.
Frequently asked questions
Can twelve days really cover a software business? It covers the technical decision when access is ready and scope is fixed. It does not replace the financial or legal audit, and it does not produce a commercial valuation. If the system is large or the data is incomplete, we extend the scope rather than compress it.
Do you need source code access? Yes, read access to the repository with full history. A demo and screenshots do not reveal technical debt, secrets in history, or abandoned dependencies.
What if the seller refuses access? Refusal is a finding, not an obstacle. You can price the risk or make access a condition before closing. What we do not recommend is buying first and discovering later that the system cannot be operated.
Do you deliver a score or a rating? No. We deliver a decision and findings ranked by severity, each with evidence, impact, fix effort and conditions. A single score hides the item that decides the deal.
Can you review a SaaS product without buying the company? Yes. The same method works for a vendor before contracting or a platform before acquisition, with more weight on contracts, data and continuity.
Sources
- Rasad: technical consulting — how we set scope and read architecture and risk.
- Rasad: penetration test versus vulnerability scan — the difference that changes a review result.
- W3C: Web Content Accessibility Guidelines — the reference we use when there is a public interface.
- web.dev: Web Vitals — the performance thresholds we measure when relevant.
- Rasad's published price bands — how technical consulting is priced.
Cover image: Wikimedia Finland, CC BY-SA 2.0, via Wikimedia Commons.

