Przejdź do treści
dvnt.io

Koszty i współpraca z wykonawcą15 min czytania2848 słówRedakcja dvnt

Przejęcie projektu IT od poprzedniego wykonawcy — co przekazać, co sprawdzić w 2 tygodnie, naprawić czy przepisać

Przejmujesz projekt IT po innej firmie? Przekazanie kodu źródłowego, plan pierwszych 2 tygodni i decyzja: naprawić czy przepisać.

Przejęcie projektu IT od poprzedniego wykonawcy kończy się wtedy, gdy nowy zespół sam zbuduje, uruchomi i wdroży system z tego, co dostał — nie wtedy, gdy dostaniesz archiwum z plikami. Przekazanie kodu źródłowego to jeden z siedmiu elementów i każdy z nich ma swój dowód, że działa. Zbierz wszystko, sprawdź to w dwa tygodnie i dopiero wtedy decyduj, czy naprawiać, czy przepisywać. Decyzja podjęta na pierwszym spotkaniu, zanim ktokolwiek uruchomił system, jest zgadywaniem.

Tekst jest dla właściciela albo zarządu firmy, której aplikacja webowa, portal, system w modelu SaaS albo aplikacja mobilna utknęła u wykonawcy, z którym współpraca się kończy. Poprzednik jeszcze istnieje i odbiera telefon, a projekt jest młody albo niedokończony. Jeśli dostawcy już nie ma, a system ma kilkanaście lat, sytuację opisuje tekst o tym, co zrobić ze starym systemem, gdy dostawca zniknął. Jeśli projekt dopiero zaczyna się sypać i chcesz go ratować z obecnym wykonawcą, zacznij od tekstu o opóźnionym projekcie IT. Tekst należy do działu Aplikacje webowe.

Przekazanie kodu źródłowego to nie wszystko — co musi przekazać poprzedni wykonawca

Przekazanie projektu ma siedem części i tylko jedna z nich to kod. O reszcie firmy zwykle dowiadują się dopiero wtedy, gdy nowy zespół prosi o hasło do serwera albo pyta, dlaczego płatności działają tylko na jednym środowisku. Urząd Zamówień Publicznych ostrzega przed tym nawet urzędy: w rekomendacjach dotyczących zamówień na systemy informatyczne (Tom II, grudzień 2021, odczyt 4.11.2026) pisze, że zamawiający bez planu na wypadek zakończenia współpracy z wykonawcą „naraża się na faktyczne uzależnienie od niego”. Rekomendacja dotyczy zamówień publicznych, ale rozumowanie pasuje do każdej firmy, która zleca budowę systemu.

  1. Kod z pełną historią. Repozytorium kodu ze wszystkimi gałęziami i historią zmian, przeniesione na konto firmy — nie archiwum ZIP z ostatnią wersją. Historia pokazuje, kto, kiedy i dlaczego coś zmieniał; bez niej nowy zespół czyta kod źródłowy aplikacji jak tekst bez kontekstu.
  2. Środowiska i infrastruktura. Serwery albo konta chmurowe, domena, DNS, certyfikaty, środowisko testowe obok produkcyjnego — i dostęp administratora do każdego z nich, na konto firmy.
  3. Konta zewnętrzne. Bramka płatności, wysyłka poczty, mapy, analityka, klucze API usług, z których system korzysta, a w aplikacji mobilnej także konta deweloperskie w App Store i Google Play. Jeśli aplikacja jest opublikowana z konta wykonawcy, nie zaktualizujesz jej bez niego.
  4. Dane. Aktualny zrzut bazy i plików użytkowników — oraz próba odtworzenia go na osobnym serwerze. Kopia, której nikt nie odtworzył, jest obietnicą, nie kopią; jak to sprawdzać, opisuje tekst o kopiach zapasowych i awaryjnym odzyskiwaniu.
  5. Dokumentacja techniczna oprogramowania. Instrukcja uruchomienia (README), instrukcja wdrożenia, schemat bazy z historią migracji, opis integracji i zapis ważniejszych decyzji architektonicznych.
  6. Wiedza z systemu zgłoszeń. Backlog, lista znanych błędów, historia zgłoszeń od użytkowników, ustalenia z ostatnich miesięcy. UZP wymienia to wprost: przekazanie wiedzy może obejmować „przekazanie informacji znajdujących się w narzędziach przeznaczonych do obsługi zgłoszeń serwisowych (zlecenia, raporty itp.)”. To element najczęściej pomijany, bo nie wygląda jak produkt — a właśnie w nim leży odpowiedź na pytanie, co jest naprawdę skończone.
  7. Umowa i odbiory. Umowa z aneksami, protokoły odbioru etapów, licencje komponentów i usług, lista opłacanych abonamentów. Bez nich nie porównasz tego, co odebrano, z tym, co działa. Jak wyglądają etapy i odbiory w dobrze prowadzonym projekcie, pokazuje tekst o procesie tworzenia aplikacji krok po kroku.

Siedem grup przekazania · przy każdej zapisujesz dowód, nie „otrzymano”

GrupaCo dostajeszDowód, że działa
1KodRepozytorium z pełną historią i gałęziami, na koncie firmyNowa osoba sklonowała je i zbudowała system
2Środowiska i infrastrukturaSerwery lub konta chmurowe, domena, DNS, certyfikaty, środowisko testoweDostęp administratora na konto firmy; nowy zespół wdrożył wersję testową
3Konta zewnętrznePłatności, poczta, klucze API, konta deweloperskie App Store i Google PlayHasło zmienione, poprzednik nie ma dostępu
4DaneZrzut bazy i plikówKopia odtworzona na osobnym serwerze
5DokumentacjaREADME, instrukcja wdrożenia, schemat bazy, zapis decyzjiKtoś spoza projektu uruchomił system z samej instrukcji
6Wiedza i zgłoszeniaBacklog, znane błędy, historia zgłoszeńLista zgłoszeń porównana z tym, co działa
7Umowa i odbioryUmowa, aneksy, protokoły odbioru, licencjeKażdy odebrany etap sprawdzony w działającym systemie

WNIOSEKKod to jedna z siedmiu grup. Przekazanie kończy się, gdy nowy zespół sam zbuduje, uruchomi i wdroży system.

Co przekazuje poprzedni wykonawca — i jak sprawdzić, że działaMiarą przekazania jest to, czy następca może z tego pracować. Źródło: UZP, Rekomendacje dotyczące zamówień publicznych na systemy informatyczne, Tom II (2021), rek. 15.4 i uzasadnienie rek. 14.2; opracowanie dvnt, listopad 2026.

Transfer wiedzy mierzy się tym, czy następca może pracować, a nie tym, ile stron dostał. UZP w uzasadnieniu do rekomendacji o kodach źródłowych (s. 39) pisze, że jeśli celem jest utrzymanie lub rozwój systemu „samodzielnie lub w ramach usług podmiotu trzeciego”, opis kodów albo dokumentacja „powinna zapewniać niezbędny transfer wiedzy i być wystarczająca dla realizacji tych celów”. Dlatego przy każdej pozycji listy zapisujesz nie „otrzymano”, tylko dowód: nowa osoba sklonowała repozytorium i zbudowała system, kopia bazy działa na osobnym serwerze, hasło do panelu płatności jest zmienione, a poprzednik już się nie loguje. Przekazanie dokumentacji bez takiej próby niczego nie dowodzi.

Ten sam dokument przypomina o drugiej rzeczy: majątkowe prawo autorskie do programu to „czym innym” niż faktyczny dostęp do kodów źródłowych. Umowa może przenosić prawa, a kod i tak leży na serwerze wykonawcy. Co powinna mówić umowa o prawach i wydaniu kodu, opisuje tekst o tym, jak wybrać software house. Jeśli współpraca jeszcze trwa i chcesz najpierw sprawdzić, jak trudne będzie odejście, zacznij od dwunastu pytań z tekstu o vendor lock-in.

Dla porównania tak wygląda przekazanie na koniec projektu u nas: kod w repozytorium klienta, instrukcja uruchomienia lokalnego środowiska i zasady pracy dla programistów, zapis decyzji architektonicznych, instrukcja wdrożeń (jak wdrażać, jak wycofać zmianę, jak diagnozować produkcję), dokumentacja schematu bazy z historią migracji i sesja przekazania z zespołem następcy. Tego samego możesz wymagać od poprzednika. To nie jest standard luksusowy, tylko minimum, przy którym ktoś inny może przejąć pracę.

Dzień pierwszy: hasła, konta i dane osobowe

Pierwszego dnia zmieniasz każde hasło i każdy klucz, który znał poprzedni wykonawca — zanim ktokolwiek zacznie czytać kod. Nie chodzi o brak zaufania: hasło zapisane kiedyś w kodzie albo w pliku konfiguracji zostaje w historii repozytorium i w kopiach u każdego, kto je sklonował. Dokumentacja GitHuba (odczyt 4.11.2026) mówi to jednoznacznie: jeśli wrażliwe dane to sekret — hasło, token, klucz — pierwszym krokiem jest jego unieważnienie lub zmiana, bo dopiero wtedy przestaje dawać dostęp. Przepisanie historii repozytorium nie usuwa kopii, które zostają „w klonach lub forkach” (tłumaczenie własne).

Kolejność na pierwszy dzień:

  • spis wszystkich kont i kluczy (punkty 2 i 3 listy przekazania) i nowe hasła dla każdego, łącznie z kluczami API;
  • usunięcie kont poprzednika z repozytorium, serwerów, paneli chmurowych, bramki płatności i sklepów z aplikacjami — a jeśli jeszcze pomaga przy przekazaniu, zawężenie jego dostępu do tego, czego potrzebuje, z datą wygaśnięcia;
  • dostęp administratora na konto firmy, nie na prywatny adres pracownika ani wykonawcy.

Pytanie kontrolne pochodzi z zasad The Twelve-Factor App: konfiguracja jest poprawnie oddzielona od kodu, jeśli kod można by w każdej chwili upublicznić „bez narażenia jakichkolwiek danych dostępowych” (tłumaczenie własne). Zapytaj więc nowy zespół: czy moglibyśmy pokazać ten kod obcej firmie bez zmiany żadnego hasła? Jeśli odpowiedź brzmi „nie”, uporządkowanie konfiguracji trafia na listę ryzyk.

Dane osobowe Twoich klientów to osobna decyzja — i podejmujesz ją Ty, nie wykonawca. Poprzedni wykonawca, który miał dostęp do produkcyjnej bazy, często ma też jej kopie: na serwerze testowym, w zrzutach, na komputerze programisty. RODO w art. 28 ust. 3 lit. g stanowi, że podmiot przetwarzający po zakończeniu świadczenia usług „zależnie od decyzji administratora usuwa lub zwraca mu wszelkie dane osobowe oraz usuwa wszelkie ich istniejące kopie”, chyba że prawo nakazuje ich przechowywanie. Wybierz więc: usunąć czy zwrócić, i poproś o potwierdzenie na piśmie, łącznie z kopiami. Nowy wykonawca, który dostaje dostęp do bazy z danymi osobowymi, potrzebuje własnej umowy powierzenia — ten sam art. 28 ust. 3 wymaga, żeby przetwarzanie przez podmiot przetwarzający odbywało się na podstawie umowy (lub innego instrumentu prawnego). Szerzej o obowiązkach firmy piszemy w tekście o RODO i prywatności.

Pierwsze 2 tygodnie z nowym wykonawcą — plan i rezultat każdego etapu

Przez pierwsze dwa tygodnie nowy wykonawca nie rozwija systemu, tylko udowadnia, że go rozumie — i kończy ten czas raportem, na którym oprzesz decyzję. Tak planujemy przegląd, gdy przejmujemy cudzy system. Przy dużym systemie albo przy braku dokumentacji trwa dłużej, przy małym i dobrze opisanym — krócej. Ważniejsze od liczby dni jest to, że każdy etap kończy się rezultatem, który możesz zobaczyć.

Dni 1–2: dostęp i sekrety. Wszystko z poprzedniej sekcji. Rezultat: spis kont z właścicielem i datą zmiany hasła; poprzednik nie ma dostępu, chyba że świadomie zostawiłeś mu go na czas przekazania.

Dni 3–5: zbudowanie i wdrożenie bez pomocy poprzednika. Osoba z nowego zespołu bierze repozytorium, czyta README, uruchamia system na czystym komputerze, a potem wdraża go na środowisko testowe — bez telefonu do poprzedniego wykonawcy. Joel Spolsky w Joel Test z 2000 roku pytał, ilu kroków potrzeba, żeby z najnowszej wersji kodu zbudować wersję do wydania, i odpowiadał: jeśli proces ma więcej niż jeden krok, „jest podatny na błędy” (tłumaczenie własne). Rezultat: system działa na środowisku, które kontroluje nowy zespół, a każda luka w instrukcji jest zapisana.

Dni 6–9: przegląd. Testy, zależności i ich wersje, konfiguracja, model danych, zapis decyzji. Na tym etapie widać jakość wewnętrzną — przez osiem sprawdzeń opisanych w następnej sekcji. Rezultat: lista ustaleń z oceną, co zrobić z każdym z nich.

Dni 10–11: zgłoszenia i backlog wobec odbiorów. Nowy zespół porównuje to, co odebrano w protokołach, z tym, co faktycznie działa, i z tym, co wisi w systemie zgłoszeń. Tu wychodzi, ile projektu jest naprawdę skończone. Rezultat: lista w trzech kolumnach — odebrane i działa, odebrane i nie działa, nieodebrane.

Dni 12–14: raport ryzyk i decyzja. Ryzyka uszeregowane według priorytetu i rekomendacja, co dalej — omówione z Tobą na spotkaniu, nie wysłane mailem. Rezultat: decyzja (rozwijać, naprawiać etapami, przepisać fragment albo przepisać) i plan pierwszych prac.

Czternaście dni w pięciu etapach · każdy kończy się rezultatem, który widzisz

EtapRezultat
Dostęp i sekretyDni 1–2Spis kont z nowymi hasłami, poprzednik bez dostępu
Zbudowanie i wdrożenie bez poprzednikaDni 3–5System działa na środowisku nowego zespołu, luki w instrukcji zapisane
PrzeglądDni 6–9Testy, zależności, konfiguracja, model danych, zapis decyzji — lista ustaleń
Zgłoszenia i backlog wobec odbiorówDni 10–11Lista: odebrane i działa, odebrane i nie działa, nieodebrane
Raport ryzyk i decyzjaDni 12–14Ryzyka z priorytetami, jeden z czterech wyników i plan pierwszych prac

WNIOSEKDecyzja na końcu, nie na początku. Czas zależy od wielkości systemu i stanu dokumentacji.

Pierwsze 2 tygodnie po przejęciu — etapy i rezultatyZbudowanie i wdrożenie bez poprzednika to test przekazania, nie formalność. Źródło: opracowanie dvnt, listopad 2026; zbudowanie jednym krokiem — Joel Spolsky, The Joel Test (2000).

Termin pierwszych prac nie powinien być wzięty z powietrza. UZP przypomina zamawiającym, że opis zamówienia „powinien uwzględniać realistyczny termin na przeprowadzenie migracji”. U Ciebie znaczy to tyle: nie umawiaj daty pierwszej nowej funkcji, zanim nie skończy się przegląd. Przegląd jest osobnym, płatnym zleceniem z własnym rezultatem. U nas jego koszt zaliczamy na poczet projektu, jeśli po przeglądzie prowadzimy go dalej razem. Tak samo działa analiza przed budową nowego systemu, którą opisujemy w tekście o analizie przedwdrożeniowej. Czym różni się taki przegląd od pełnego przeglądu kodu przez specjalistów, wyjaśnia tekst o audycie aplikacji.

Zły kod widać bez czytania kodu — osiem sprawdzeń na start

Jakości kodu nie zobaczysz na ekranie, ale zobaczysz jej skutki — jeśli poprosisz nowy zespół o pokazanie ośmiu rzeczy. Martin Fowler w tekście o koszcie jakości z 2019 roku zauważa, że użytkownik „nie widzi wewnętrznej, modułowej struktury oprogramowania, a co dopiero mógłby ocenić, że jest lepsza” (tłumaczenie własne). Aplikacja może wyglądać na prawie skończoną i być zbudowana tak, że każda zmiana zajmuje tydzień. Te sprawdzenia nie wymagają czytania kodu: prosisz, żeby ktoś coś pokazał, i patrzysz, czy się udało.

  1. Nowa osoba uruchamia system lokalnie z README. Bez pomocy, z samej instrukcji. Jeśli to trwa wiele dni albo wymaga telefonu do poprzednika, dokumentacja nie przekazuje wiedzy.
  2. Wdrożenie bez poprzednika. Nowy zespół sam wypuszcza wersję na środowisko testowe. To przekład pytania z Joel Test o budowanie wersji jednym krokiem.
  3. Testy jednym poleceniem, z wynikiem. Czy istnieją testy automatyczne, czy da się je uruchomić naraz i ile z nich przechodzi. Fowler opisuje kod, który sam się testuje, jako taki, przy którym po przejściu testów możesz być pewien, że kod jest wolny od „istotnych błędów” (tłumaczenie własne).
  4. Lista zależności z wersjami. Wszystkie biblioteki i komponenty, z których system korzysta, łącznie z zależnościami tych zależności. OWASP Top 10:2025 w kategorii A03 pisze, że prawdopodobnie jesteś podatny na atak, jeśli nie śledzisz wersji wszystkich komponentów albo oprogramowanie jest „podatne, bez wsparcia lub nieaktualne” (tłumaczenie własne), i zaleca prowadzenie SBOM, czyli wykazu wszystkich składników oprogramowania. Ty pytasz o jedno: czy na liście jest coś bez wsparcia producenta.
  5. Brak haseł w kodzie. Test z poprzedniej sekcji: czy kod można pokazać obcej firmie bez zmiany żadnego hasła.
  6. Historia zmian w repozytorium. Czy historia to wiele małych, opisanych zmian rozłożonych na czas projektu, czy jeden „zrzut” całego kodu na koniec. To nasza ocena, nie reguła ze źródła: jeden zrzut nie znaczy, że kod jest zły, ale znaczy, że nie dowiesz się z niego, dlaczego jest taki, jaki jest.
  7. Zapis decyzji. Michael Nygard w tekście o dokumentowaniu decyzji architektonicznych z 2011 roku opisuje nową osobę w projekcie, która bez znajomości uzasadnienia ma dwa wyjścia: „ślepo zaakceptować decyzję” albo „ślepo ją zmienić” (tłumaczenie własne). Projekt, w którym narasta zbyt wiele decyzji przyjętych bez zrozumienia, według Nygarda zapada się pod własnym ciężarem, bo zespół boi się cokolwiek zmienić. Zapis decyzji (ADR) to krótkie pliki tekstowe w repozytorium — albo ich brak.
  8. Baza błędów. Czy znane błędy są gdzieś spisane, z priorytetem i opisem. To kolejne pytanie z Joel Test: „Do you have a bug database?”.

Prosisz, żeby ktoś coś pokazał, i patrzysz, czy się udało · bez punktacji

PytanieCo pokazujeŹródło
1Czy nowa osoba uruchomiła system lokalnie z samego README?Czy dokumentacja przekazuje wiedzęJoel Test
2Czy nowy zespół wdrożył wersję testową bez poprzednika?Czy wdrożenie nie zależy od jednej osobyJoel Test
3Czy testy uruchamiają się jednym poleceniem i ile przechodzi?Czy kod da się zmieniać z kontroląFowler
4Czy jest lista zależności z wersjami i nic nie jest bez wsparcia?Ryzyko łańcucha dostawOWASP Top 10:2025 A03
5Czy kod można pokazać obcej firmie bez zmiany hasła?Oddzielenie konfiguracji od koduTwelve-Factor
6Czy historia repozytorium to wiele opisanych zmian, a nie jeden zrzut?Czy da się odtworzyć powody zmianocena dvnt
7Czy są zapisane decyzje architektoniczne?Czy nowy zespół nie musi ślepo akceptować ani ślepo zmieniaćNygard
8Czy jest baza błędów z priorytetami?Co wiadomo o znanych usterkachJoel Test

WNIOSEKKażde „nie” to pozycja w raporcie ryzyk. Odpowiedzi się nie sumuje: „nie” przy testach waży inaczej.

Osiem sprawdzeń jakości bez czytania koduJakości kodu nie widać na ekranie — widać jej skutki. Źródło: 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); pkt 6 — opracowanie dvnt, listopad 2026.

Wyniki nie składają się w punktację. Spolsky sumował odpowiedzi na swoje dwanaście pytań, ale tych ośmiu nie sumujemy, bo „nie” przy testach waży inaczej niż „nie” przy bazie błędów. Każde „nie” to pozycja w raporcie ryzyk z dnia czternastego. Te sprawdzenia są punktem startu dla nowego zespołu, który nie zna historii systemu. Jeśli system zna jeden dostawca od lat i chcesz śledzić jego stan w czasie, lepiej sprawdzają się pięć liczb opisanych w tekście o długu technologicznym.

Naprawić czy przepisać przejęty kod

Decyzja „naprawić czy przepisać” zapada na końcu przeglądu, a zanim ją podejmiesz, rozdziel trzy zlecenia, które w ofertach po przejęciu często zlewają się w jedno. Dokończyć to dopisać funkcje, których brakuje. Naprawić to usunąć błędy, czyli zmienić to, co system robi źle. Refaktoryzować to według definicji Martina Fowlera z 2004 roku zmienić wewnętrzną strukturę oprogramowania tak, żeby było łatwiejsze do zrozumienia i tańsze w modyfikacji, „bez zmiany jego obserwowalnego zachowania” (tłumaczenie własne). Refaktoryzacja nie dodaje funkcji i nie usuwa błędów — przygotowuje kod na jedno i drugie. Każde z trzech zleceń ma inny rezultat i inaczej się je wycenia, więc w ofercie powinny być osobnymi pozycjami. O tym, kiedy wystarczy refaktoryzacja, a kiedy trzeba przebudować, także pierwszą wersję produktu pod większą skalę, piszemy w tekście refaktoryzacja czy przepisanie.

Bez testów zmiana struktury kodu jest ryzykowna. Fowler w tekście o kodzie, który sam się testuje, opisuje stare bazy kodu jako miejsca, w których programiści boją się zmieniać działający kod, a nawet poprawka błędu bywa niebezpieczna, bo można wprowadzić więcej błędów, niż się usuwa — i wtedy zespół boi się też refaktoryzować. Dlatego pierwszym krokiem po przejęciu kodu bez testów nie jest porządkowanie, tylko siatka testów wokół tego, co ma działać tak jak dziś.

O wyniku przesądzają trzy pytania:

  1. Czy model danych jest dobry? Chodzi o strukturę bazy: jakie obiekty system przechowuje i jak są ze sobą powiązane. Zły model danych przenosi się na każdą funkcję. Dobry model z niechlujnym kodem wokół da się porządkować etapami.
  2. Czy technologia ma wsparcie i drugi zespół na rynku? Jeśli framework i biblioteki są w wersjach wspieranych przez producentów i znają je inni programiści, jest co rozwijać. Jeśli system stoi na czymś bez wsparcia albo na niszowym narzędziu, każda kolejna zmiana jest droższa od poprzedniej.
  3. Czy jest siatka testów? Jeśli tak — możesz zmieniać kod z kontrolą. Jeśli nie — testy są pierwszą pozycją planu, niezależnie od wyniku.

W naszym schemacie z tych odpowiedzi wynika jeden z czterech wyników. Rozwijać — gdy model danych jest dobry, technologia wspierana, a testy istnieją. Naprawiać etapami — gdy model i technologia się bronią, ale brakuje testów albo jakość kodu jest słaba. Przepisać fragment — gdy jeden moduł ma zły model albo przestarzałe zależności, a reszta jest zdrowa. Przepisać — gdy model danych jest zły w całym systemie, a technologia nie ma przyszłości. Bywa też, że uczciwą odpowiedzią jest: tego nie warto ratować. To również jest wynik przeglądu, nie porażka.

Schemat decyzyjny bez liczb.
Naprawić czy przepisać — trzy pytania, cztery wynikiSchemat decyzyjny bez liczb. Z lewej trzy pytania: czy model danych jest dobry, czy technologia ma wsparcie i drugi zespół na rynku, czy jest siatka testów. Z prawej cztery wyniki: rozwijać — model dobry, technologia wspierana, testy są; naprawiać etapami — model i technologia się bronią, brakuje testów albo jakości; przepisać fragment — jeden moduł ze złym modelem albo przestarzałymi zależnościami, reszta zdrowa; przepisać — zły model w całym systemie i technologia bez przyszłości. Pod schematem dopiski: bez testów pierwszym krokiem jest siatka testów; refaktoryzacja zmienia strukturę, nie to, co system robi; bywa też wynik „tego nie warto ratować”.Źródło: M. Fowler, Definition Of Refactoring (2004) i Self Testing Code (2014); opracowanie dvnt, listopad 2026.

Przepisanie całości jest najdroższym i najbardziej ryzykownym z wyników. Argumenty przeciw niemu i sposób wymiany systemu etapami opisują teksty o długu technologicznym i o starym systemie bez dostawcy. Przejęty projekt sprzed roku czy dwóch to jednak nie system legacy: zwykle stoi na aktualnej technologii, a problem leży w jakości wykonania, nie w wieku. Częściej kończy się więc naprawą etapami niż przepisaniem — o ile przegląd nie pokaże złego modelu danych.

Jak rozmawiać z nowym wykonawcą — pytania przed startem

Dobrego nowego wykonawcę poznasz po tym, że zanim poda cenę i termin, chce zobaczyć system. Zadaj mu pięć pytań:

  1. Czy zaczniecie od przeglądu z raportem, który wykorzystam niezależnie od dalszej współpracy? Raport powinien zostać Twój także wtedy, gdy wybierzesz inną firmę. Tak opisujemy audyt architektoniczny w ofercie doradztwa technologicznego.
  2. Jak udowodnicie, że system się buduje i wdraża? Dobra odpowiedź to konkretny rezultat w konkretnym etapie, nie „zapoznamy się z kodem”.
  3. Co zrobicie z kodem w pierwszym sprincie? Rozsądna odpowiedź: nic strukturalnego, zanim wokół zmienianych miejsc nie powstaną testy.
  4. Kto ocenia, a kto będzie przepisywał? Jeśli ta sama firma ocenia system i zarabia na jego przepisaniu, ma interes w wyniku. Nie dyskwalifikuje to oceny, ale powinieneś o tym wiedzieć; jak rozdzielić te role, opisujemy w tekście o długu technologicznym.
  5. Jak wycenicie osobno dokończenie, naprawę i refaktoryzację? Trzy różne rezultaty to trzy pozycje w ofercie. Jeśli po przejęciu podpisujesz też umowę utrzymania, co powinna obejmować, pokazuje tekst o SLA.

Czerwone flagi to „przepiszemy wszystko” przed zobaczeniem kodu, cena ryczałtowa za „przejęcie i dokończenie” przed przeglądem i brak pytań o dostęp, dokumentację i dane. Ogólne zasady sprawdzania firmy i umowy zebraliśmy w tekście o tym, jak wybrać software house.

Uczciwie o nas: cudze systemy przejmujemy zawsze po przeglądzie kodu, infrastruktury, dokumentacji, kopii zapasowych i dostępów i nie obiecujemy przejęcia przed nim — piszemy o tym na stronie o tym, jak budujemy oprogramowanie. Nie bierzemy pojedynczych poprawek w aplikacji zbudowanej przez inną firmę, bo pracujemy projektowo, ani systemów na starym stosie: mainframe, JEE legacy, ERP mających piętnaście i więcej lat.

Od czego zacząć: trzy kroki na ten tydzień

Zanim wybierzesz nowego wykonawcę, zrób trzy rzeczy, które nie zależą od nikogo poza Tobą.

  1. Zabezpiecz dostęp. Spis kont, nowe hasła, konta na firmę, a do poprzednika pismo z decyzją: dane osobowe usunąć czy zwrócić, z potwierdzeniem, łącznie z kopiami.
  2. Zbierz listę przekazania. Siedem grup z tego tekstu, przy każdej miejsce na dowód, że działa — nie na „otrzymano”. Wyślij ją poprzednikowi z terminem.
  3. Zamów przegląd. Dwa tygodnie, raport ryzyk z priorytetami, decyzja dopiero po nim.

Jeśli po przeglądzie system zostaje do rozwijania i szukasz zespołu, który to zrobi, zobacz, jak budujemy aplikacje webowe. Jeśli wolisz zacząć od rozmowy o tym, co dostałeś od poprzednika, umów ją poniżej.

Najczęstsze pytania o przejęcie projektu IT

Co powinien przekazać poprzedni wykonawca przy zmianie firmy?

Siedem grup: repozytorium kodu z pełną historią, środowiska i infrastrukturę (serwery, domenę, DNS, certyfikaty), konta zewnętrzne (płatności, poczta, klucze API, konta deweloperskie w sklepach z aplikacjami), dane z próbą odtworzenia kopii, dokumentację techniczną, wiedzę z systemu zgłoszeń i backlogu oraz umowę z protokołami odbioru. Urząd Zamówień Publicznych w rekomendacjach z 2021 roku wymienia wprost przekazanie informacji z narzędzi do obsługi zgłoszeń i dokumentację, która ma zapewniać niezbędny transfer wiedzy. Przy każdej pozycji liczy się dowód, że działa, a nie samo „otrzymano”.

Ile trwa przejęcie projektu przez nowy zespół?

Przegląd, który poprzedza decyzję, planujemy na około dwa tygodnie: dostęp i hasła, zbudowanie i wdrożenie bez poprzednika, przegląd jakości, porównanie zgłoszeń z odbiorami i raport ryzyk. Przy dużym systemie albo braku dokumentacji trwa dłużej, przy małym i dobrze opisanym krócej. Termin pierwszych nowych funkcji ustala się dopiero po przeglądzie.

Czy nowy wykonawca może zmieniać kod po poprzednim?

To zależy od umowy z poprzednim wykonawcą i od tego, jakie prawa do kodu na Ciebie przeszły. Prawa do programu i faktyczny dostęp do kodu źródłowego to dwie różne rzeczy — potrzebujesz obu. Co wolno zmieniać w kodzie bez zgody autora, opisujemy w tekście o starym systemie, którego dostawca zniknął; w sprawach spornych zacznij od prawnika.

Czy refaktoryzacja to to samo co naprawa?

Nie. Według definicji Martina Fowlera refaktoryzacja zmienia wewnętrzną strukturę oprogramowania, żeby było łatwiejsze do zrozumienia i tańsze w modyfikacji, bez zmiany tego, co system robi. Naprawa usuwa błędy, czyli zmienia zachowanie systemu, a dokończenie dopisuje brakujące funkcje. To trzy różne zlecenia i w ofercie po przejęciu powinny być wycenione osobno.

Czy lepiej przepisać aplikację od nowa?

Zwykle nie, i na pewno nie przed przeglądem. Przepisanie całości jest najdroższym i najbardziej ryzykownym wynikiem; przejęty młody projekt częściej kończy się naprawą etapami albo przepisaniem jednego modułu. O przepisaniu decydują trzy odpowiedzi: czy model danych jest dobry, czy technologia ma wsparcie i drugi zespół na rynku, czy istnieją testy. Bywa też, że uczciwy wynik przeglądu brzmi: tego nie warto ratować.

Co zrobić z danymi klientów u poprzedniego wykonawcy?

Zdecydować i zapisać decyzję. Według art. 28 ust. 3 lit. g RODO podmiot przetwarzający po zakończeniu usług, zależnie od decyzji administratora, usuwa lub zwraca dane osobowe oraz usuwa ich istniejące kopie, chyba że prawo nakazuje przechowywanie. Poproś poprzednika o potwierdzenie na piśmie, łącznie z kopiami na serwerach testowych i w zrzutach, a z nowym wykonawcą podpisz własną umowę powierzenia. Szczegóły swojej sytuacji ustal z prawnikiem albo inspektorem ochrony danych.

Powiązane artykuły