Skip to content
dvnt.io

Costs and working with a vendor19 min read3680 wordsRedakcja dvnt

Taking over a software project from the previous vendor — what to hand over, what to check in two weeks, fix or rewrite

A software handover checklist for taking over a project: what the previous vendor hands over, a two-week review, then fix or rewrite.

Taking over a software project from the previous vendor is finished when the new team can build, run and deploy the system on its own from what it was given — not when you receive an archive of files. Handing over the source code is one of seven elements on a software handover checklist, and each of them has its own proof that it works. Collect everything, check it over two weeks, and only then decide whether to fix or to rewrite. A decision made at the first meeting, before anyone has run the system, is a guess.

This article is for the owner or board of a company whose web application, portal, SaaS product or mobile app is stuck with a contractor the company is parting ways with. The previous vendor still exists and still answers the phone, and the project is young or unfinished. If the vendor has disappeared and the system is many years old, that is a different case, which we cover in a separate article on legacy software after the vendor is gone. If the project is only starting to slip and you want to rescue it together with the current contractor, the first step is different and this text does not cover it. The article belongs to our section on web and mobile apps.

Source code handover is not everything — what the previous vendor has to hand over

A project handover has seven parts, and only one of them is code. Companies usually learn about the rest when the new team asks for the server password, or asks why payments work in only one environment. Even public bodies are warned about this: the Public Procurement Office (Urząd Zamówień Publicznych, UZP), in its recommendations on public procurement of IT systems (Volume II, December 2021, read 4 November 2026), writes that a contracting authority with no plan for the end of cooperation with a contractor "exposes itself to actual dependence on it" (our translation). The recommendation concerns public contracts, but the reasoning fits any company that commissions a system.

  1. Code with its full history. The code repository with every branch and the whole change history, moved to the company's own account — not a ZIP archive of the latest version. The history shows who changed what, when and why; without it the new team reads your application's source code like a text with no context.
  2. Environments and infrastructure. Servers or cloud accounts, domain, DNS, certificates, a test environment next to production — and administrator access to every one of them, on the company's account.
  3. External accounts. The payment gateway, outgoing email, maps, analytics, the API keys of every service the system uses and, for a mobile app, the developer accounts in the App Store and Google Play. If the app is published from the contractor's account, you cannot update it without them.
  4. Data. A current dump of the database and of user files — and an attempt to restore it on a separate server. A backup that nobody has restored is a promise, not a backup; how to check this is described in our article on backups and disaster recovery.
  5. Technical documentation. Setup instructions (README), deployment instructions, the database schema with its migration history, a description of the integrations and a record of the important architectural decisions.
  6. Knowledge from the ticketing system. The backlog, the list of known bugs, the history of user reports, the decisions agreed in recent months. This is the element most often missed, because it does not look like a product — yet it is where the answer to "what is actually finished?" lives. UZP names it explicitly: the transfer of knowledge may include "passing on the information held in tools used to handle service requests (orders, reports, etc.)" (our translation).
  7. Contract and acceptance. The contract with its amendments, the acceptance records for each stage, the licences of components and services, and the list of paid subscriptions. Without them you cannot compare what was accepted with what works. How stages and acceptance look in a well-run project is shown in our article on the app development process step by step.

Seven handover groups · for each one you record proof, not “received”

GroupWhat you getProof that it works
1CodeRepository with full history and branches, on the company’s accountA new person cloned it and built the system
2Environments and infrastructureServers or cloud accounts, domain, DNS, certificates, test environmentAdministrator access on the company’s account; the new team deployed a test version
3External accountsPayments, email, API keys, App Store and Google Play developer accountsPassword changed, the predecessor has no access
4DataDump of the database and filesCopy restored on a separate server
5DocumentationREADME, deployment guide, database schema, decision recordsSomeone from outside the project started the system from the instructions alone
6Knowledge and ticketsBacklog, known bugs, ticket historyTicket list compared with what works
7Contract and acceptanceContract, amendments, acceptance records, licencesEvery accepted stage checked in the running system

CONCLUSIONCode is one of seven groups. The handover is finished when the new team builds, runs and deploys the system on its own.

What the previous vendor hands over — and how to check that it worksThe measure of a handover is whether the successor can work with what was handed over. Source: UZP, Recommendations on public procurement of IT systems, Volume II (2021), recommendation 15.4 and rationale of recommendation 14.2; dvnt, November 2026.

Knowledge transfer is measured by whether the successor can work, not by how many pages they received. In its rationale for the recommendation on source code (p. 39), UZP writes that if the aim is to maintain or develop the system "on one's own or through the services of a third party", the description of the code or the documentation "should ensure the necessary transfer of knowledge and be sufficient to achieve those aims" (our translation). That is why, for each item on the list, you write down not "received" but the proof: a new person cloned the repository and built the system, the database copy runs on a separate server, the password to the payment panel is changed and the predecessor can no longer log in. Handing over documentation without such a trial proves nothing.

The same document recalls a second thing: the economic copyright in a program is "something different" from actual access to the source code (our translation). A contract can transfer the rights while the code still sits on the contractor's server. What the contract should say about rights and about releasing the code is described in our article on how to choose a software development company. If the cooperation is still running and you want to see first how hard leaving would be, start by checking how locked in you are to this vendor: who holds the code, the accounts and the data.

For comparison, this is what a handover at the end of a project looks like with us: the code in the client's repository, instructions for running the local environment and working rules for developers, a record of architectural decisions, deployment instructions (how to deploy, how to roll back a change, how to diagnose production), documentation of the database schema with its migration history, and a handover session with the successor's team. You can ask the same of your predecessor. It is not a luxury standard; it is the minimum at which someone else can take over the work.

Day one: passwords, accounts and personal data

On the first day you change every password and every key that the previous vendor knew — before anyone starts reading code. This is not about distrust. A password once written into the code or into a configuration file stays in the repository history and in the copy of everyone who cloned it. The GitHub documentation (read 4 November 2026) is clear: if the sensitive data is a secret — a password, token or credential — the first step is to "revoke and/or rotate that secret", because only then can it no longer be used for access. Rewriting the repository history does not remove every copy: the data may still be accessible "in any clones or forks of your repository".

The order for the first day:

  • an inventory of all accounts and keys (items 2 and 3 on the handover list) and new passwords for each, including API keys;
  • removal of the predecessor's accounts from the repository, servers, cloud panels, the payment gateway and the app stores — or, if they are still helping with the handover, narrowing their access to what they need, with an expiry date;
  • administrator access on the company's account, not on the private address of an employee or of the contractor.

The control question comes from The Twelve-Factor App: configuration is correctly separated from code if the codebase "could be made open source at any moment, without compromising any credentials". So ask the new team: could we show this code to an outside company without changing a single password? If the answer is no, cleaning up the configuration goes onto the list of risks.

The personal data of your customers is a separate decision — and you make it, not the contractor. A vendor who had access to the production database often has copies of it as well: on a test server, in dumps, on a developer's laptop. Under the GDPR (in Poland known as RODO), Article 28(3)(g), the processor, "at the choice of the controller, deletes or returns all the personal data to the controller after the end of the provision of services relating to processing, and deletes existing copies unless Union or Member State law requires storage of the personal data". So choose: delete or return — and ask for written confirmation that includes the copies. A new vendor who gets access to a database with personal data needs a contract of their own: the same Article 28(3) requires that processing by a processor is governed by "a contract or other legal act under Union or Member State law". We write more about a company's obligations in our article on GDPR and privacy.

The first two weeks with the new vendor — the plan and the result of each stage

For the first two weeks the new vendor does not develop the system; it proves that it understands it — and ends that time with a report on which you base your decision. This is how we plan a review when we take over someone else's system. For a large system or one with no documentation it takes longer, for a small and well-described one less. What matters more than the number of days is that every stage ends with a result you can see.

Days 1–2: access and secrets. Everything from the previous section. Result: a list of accounts with the owner and the date the password was changed; the predecessor has no access, unless you deliberately left it for the duration of the handover.

Days 3–5: build and deploy without the predecessor. A person from the new team takes the repository, reads the README, starts the system on a clean machine and then deploys it to a test environment — without a phone call to the previous vendor. Joel Spolsky, in the Joel Test of 2000, asked how many steps it takes to make a shipping build from the latest source snapshot, and answered: "If the process takes any more than one step, it is prone to errors." Result: the system runs in an environment the new team controls, and every gap in the instructions is written down.

Days 6–9: review. Tests, dependencies and their versions, configuration, the data model, the record of decisions. This is where the internal quality becomes visible — through the eight checks described in the next section. Result: a list of findings with an assessment of what to do about each.

Days 10–11: tickets and backlog against acceptance. The new team compares what was signed off in the acceptance records with what actually works and with what sits in the ticketing system. This is where you see how much of the project is really finished. Result: a list in three columns — accepted and working, accepted and not working, not accepted.

Days 12–14: risk report and decision. Risks ranked by priority and a recommendation for what to do next — discussed with you in a meeting, not sent by email. Result: a decision (develop, repair in stages, rewrite a part, or rewrite) and a plan for the first work.

Fourteen days in five stages · each one ends with a result you can see

StageResult
Access and secretsDays 1–2List of accounts with new passwords, predecessor without access
Build and deploy without the predecessorDays 3–5The system runs in the new team’s environment, gaps in the instructions written down
ReviewDays 6–9Tests, dependencies, configuration, data model, decision records — a list of findings
Tickets and backlog against acceptanceDays 10–11List: accepted and working, accepted and not working, not accepted
Risk report and decisionDays 12–14Risks with priorities, one of four outcomes and a plan for the first work

CONCLUSIONThe decision comes at the end, not at the start. The duration depends on the size of the system and the state of the documentation.

The first two weeks after a takeover — stages and resultsBuilding and deploying without the predecessor is the test of the handover, not a formality. Source: dvnt, November 2026; build in one step — Joel Spolsky, The Joel Test (2000).

The date of the first work should not be picked from thin air. UZP reminds contracting authorities that the description of the subject of the contract "should allow for a realistic time for carrying out the migration" (our translation). For you it means: do not agree a date for the first new feature before the review is over. The review is a separate, paid engagement with its own result. With us, its cost is credited towards the project if, after the review, we carry the project on together. The same applies to the analysis before building a new system, which we describe in a separate article on pre-implementation analysis. How such a review differs from a full code review by specialists is explained in our separate article on the application audit.

Bad code can be seen without reading the code — eight checks to start with

You will not see the quality of code on the screen, but you will see its effects — if you ask the new team to show you eight things. Martin Fowler, in his article on the cost of quality from 2019, observes that "a user can't see the internal modular structure of the software, let alone judge that it's better". An application can look almost finished and be built in such a way that every change takes a week. These checks do not require reading code: you ask someone to show you something and watch whether it works.

  1. A new person starts the system locally from the README. Without help, from the instructions alone. If this takes many days or needs a call to the previous vendor, the documentation does not transfer knowledge.
  2. Deployment without the predecessor. The new team releases a version to the test environment on its own. This is the Joel Test question about building in one step, applied to a takeover.
  3. Tests with one command, and a result. Whether automated tests exist, whether they can be run all at once and how many of them pass. Fowler describes self-testing code as code where, should the tests pass, you can be confident that it is free of "any substantial defects".
  4. A list of dependencies with versions. Every library and component the system uses, including the dependencies of those dependencies. OWASP Top 10:2025, category A03, says you are likely vulnerable if you do not track the versions of all components or if "the software is vulnerable, unsupported, or out of date", and recommends keeping a Software Bill of Materials (SBOM), an inventory of every component. You ask one thing: is anything on the list no longer supported by its maker?
  5. No passwords in the code. The test from the previous section: could the code be shown to an outside company without changing a single password?
  6. History in the repository. Whether the history is many small, described changes spread across the life of the project, or one "dump" of the whole code at the end. This is our assessment, not a rule from a source: a single dump does not mean the code is bad, but it does mean you cannot learn from it why the code is the way it is.
  7. A record of decisions. Michael Nygard, in his article on documenting architecture decisions from 2011, describes a new person joining a project who, without understanding the rationale, has two choices: "Blindly accept the decision" or "Blindly change it". According to Nygard, a project that accumulates too many decisions accepted without understanding ends up with a team "afraid to change anything", and "the project collapses under its own weight". A record of decisions (an ADR) is a set of short text files in the repository — or the absence of them.
  8. A bug database. Whether the known bugs are written down somewhere, with priority and a description. This is another Joel Test question: "Do you have a bug database?".

You ask someone to show you something and watch whether it works · no scoring

QuestionWhat it showsSource
1Did a new person start the system locally from the README alone?Does the documentation transfer knowledgeJoel Test
2Did the new team deploy a test version without the predecessor?Deployment does not depend on one personJoel Test
3Do tests run with one command, and how many pass?Can the code be changed under controlFowler
4Is there a list of dependencies with versions, and is nothing unsupported?Supply chain riskOWASP Top 10:2025 A03
5Can the code be shown to an outside company without changing a password?Configuration separated from codeTwelve-Factor
6Is the repository history many described changes, not one dump?Can the reasons for changes be reconstructeddvnt assessment
7Are architecture decisions recorded?The new team does not have to accept or change them blindlyNygard
8Is there a bug database with priorities?What is known about existing defectsJoel Test

CONCLUSIONEvery “no” is an item in the risk report. The answers are not added up: a “no” on tests weighs differently.

Eight quality checks without reading codeYou cannot see the quality of code on the screen — you can see its effects. Source: J. Spolsky, The Joel Test (2000); M. Fowler, Self Testing Code (2014); OWASP Top 10:2025 A03; The Twelve-Factor App, III. Config; M. Nygard, Documenting Architecture Decisions (2011); item 6 — dvnt, November 2026.

The results do not add up to a score. Spolsky summed the answers to his twelve questions, but we do not sum these eight, because a "no" on tests weighs differently from a "no" on a bug database. Every "no" becomes an item in the risk report of day fourteen. These checks are a starting point for a new team that does not know the history of the system. If one supplier has known the system for years and you want to track its condition over time, the five numbers described in our article on technical debt work better.

Fix or rewrite the inherited code

The "fix or rewrite" decision is made at the end of the review, and before you make it you separate three engagements that proposals after a takeover often blur into one. To finish is to add the features that are missing. To fix is to remove bugs, that is, to change what the system does wrong. To refactor, by Martin Fowler's definition of 2004, is a change to the internal structure of software "to make it easier to understand and cheaper to modify without changing its observable behavior". Refactoring neither adds features nor removes bugs — it prepares the code for both. Each of the three has a different result and is priced differently, so in a proposal they should be separate lines. When refactoring is enough and when you have to rebuild, including a first version of a product that has to scale, is covered in a separate article on refactoring versus rewriting.

Without tests, changing the structure of code is risky. Fowler, writing about self-testing code, describes old codebases as "often terrifying places, where developers fear to change working code" and notes that "even fixing a bug can be dangerous, because you can create more bugs than you fix" — and then the team is afraid to refactor as well. That is why the first step after taking over code with no tests is not tidying up, but a safety net of tests around whatever has to keep working as it does today.

The outcome depends on three questions:

  1. Is the data model good? This is about the structure of the database: which objects the system stores and how they relate. A bad data model spreads into every feature. A good model with messy code around it can be tidied in stages.
  2. Is the technology supported, and is there a second team on the market? If the framework and libraries are in versions supported by their makers and other developers know them, there is something to build on. If the system stands on something unsupported or on a niche tool, every further change costs more than the last.
  3. Is there a safety net of tests? If so, you can change code under control. If not, tests are the first item in the plan, whatever the outcome.

In our scheme these answers lead to one of four outcomes. Develop — when the data model is good, the technology is supported and tests exist. Repair in stages — when the model and the technology hold up, but tests are missing or the quality of the code is poor. Rewrite a part — when one module has a bad model or outdated dependencies and the rest is healthy. Rewrite — when the data model is bad throughout and the technology has no future. Sometimes the honest answer is: this is not worth saving. That too is an outcome of the review, not a failure.

A decision diagram with no figures.
Fix or rewrite — three questions, four outcomesA decision diagram with no figures. On the left, three questions: is the data model good, is the technology supported with a second team on the market, is there a safety net of tests. On the right, four outcomes: develop — good model, supported technology, tests in place; repair in stages — model and technology hold up, tests or quality missing; rewrite a part — one module with a bad model or outdated dependencies, the rest healthy; rewrite — a bad model throughout and technology with no future. Notes under the diagram: without tests the first step is a safety net of tests; refactoring changes structure, not what the system does; "not worth saving" is also a possible outcome.Source: M. Fowler, Definition Of Refactoring (2004) and Self Testing Code (2014); dvnt, November 2026.

Rewriting everything is the most expensive and the riskiest outcome. The arguments against it, and a way to replace a system in stages, are laid out in our articles on technical debt and on legacy software after the vendor is gone. A project taken over after a year or two is not a legacy system, though: it usually stands on current technology, and the problem lies in the quality of execution, not in age. So it more often ends in staged repair than in a rewrite — unless the review shows a bad data model.

How to talk to the new vendor — questions before the start

A good new vendor wants to see the system before quoting a price and a date. Ask five questions:

  1. Will you start with a review and a report that I can use independently of any further cooperation? The report should stay yours even if you choose another company. This is how we describe the architecture audit in our technology consulting offer.
  2. How will you prove that the system builds and deploys? A good answer is a concrete result at a concrete stage, not "we will get familiar with the code".
  3. What will you do with the code in the first sprint? A sensible answer: nothing structural until tests exist around the places being changed.
  4. Who assesses, and who will rewrite? If the same company assesses the system and earns money on rewriting it, it has an interest in the result. That does not disqualify the assessment, but you should know about it; how to separate these roles is described in our article on technical debt.
  5. How will you price finishing, fixing and refactoring separately? Three different results are three lines in a proposal. If you are also signing a maintenance agreement after the takeover, what it should cover is shown in our article on the SLA.

The red flags are "we will rewrite everything" before seeing the code, a fixed price for "takeover and completion" before a review, and no questions about access, documentation and data. The general rules for checking a company and a contract are collected in our article on how to choose a software development company.

To be upfront about us: we always take over someone else's system after a review of the code, infrastructure, documentation, backups and access, and we do not promise a takeover before it — we write about this on the page about how we build software. We do not take on one-off fixes in an application built by another company, because we work project by project, nor systems on an old stack: mainframes, legacy JEE, ERP systems fifteen years old or more.

Where to start: three steps for this week

Before you pick a new vendor, do three things that depend on no one but you.

  1. Secure access. An inventory of accounts, new passwords, accounts in the company's name, and a letter to the predecessor with your decision: delete or return the personal data, with confirmation, including copies.
  2. Collect the handover checklist. The seven groups from this article, with a place next to each for proof that it works — not for "received". Send it to the predecessor with a deadline.
  3. Order a review. Two weeks, a risk report with priorities, and the decision only after it.

If, after the review, the system stays and you are looking for a team to develop it, see how we build web applications. If you would rather start with a conversation about what you received from the predecessor, book one below.

Frequently asked questions about taking over an IT project

What should the previous vendor hand over when you switch vendors?

Seven groups: the code repository with full history, environments and infrastructure (servers, domain, DNS, certificates), external accounts (payments, email, API keys, developer accounts in the app stores), the data with a test restore of the backup, technical documentation, knowledge from the ticketing system and backlog, and the contract with acceptance records. The Public Procurement Office (UZP) in its 2021 recommendations explicitly lists passing on information from service-request tools and documentation that is to ensure the necessary transfer of knowledge. For each item what counts is proof that it works, not just "received".

How long does it take a new team to take over a project?

We plan the review that precedes the decision at about two weeks: access and passwords, build and deployment without the predecessor, a quality review, a comparison of tickets with acceptance, and a risk report. For a large system or one with no documentation it takes longer, for a small and well-described one less. The date of the first new features is set only after the review.

Can a new vendor change the code written by the previous one?

That depends on the contract with the previous vendor and on which rights in the code passed to you. Rights in the program and actual access to the source code are two different things — you need both. In disputed cases start with a lawyer.

Is refactoring the same as fixing?

No. By Martin Fowler's definition, refactoring changes the internal structure of software to make it easier to understand and cheaper to modify, without changing what the system does. Fixing removes bugs, that is, it changes the system's behaviour, and finishing adds missing features. These are three different engagements and in a proposal after a takeover they should be priced separately.

Is it better to rewrite the application from scratch?

Usually not, and certainly not before a review. Rewriting everything is the most expensive and riskiest outcome; a young taken-over project more often ends in staged repair or a rewrite of a single module. Three answers decide: is the data model good, is the technology supported with a second team on the market, do tests exist. Sometimes the honest outcome of a review is: this is not worth saving.

What should you do with customer data held by the previous vendor?

Decide and write the decision down. Under Article 28(3)(g) GDPR, at the controller's choice, the processor deletes or returns all personal data after the end of the services and deletes existing copies, unless Union or Member State law requires storage. Ask the predecessor for written confirmation, including copies on test servers and in dumps, and sign a data processing agreement of your own with the new vendor. Settle the details of your situation with a lawyer or your data protection officer.

Related articles