If you need to take over an unfinished Laravel project, the first week matters more than any later sprint. The previous team may have left, a freelancer may have disappeared, or an agency relationship may have ended badly. Whatever the reason, you are inheriting code, data and promises you have not yet verified. This guide walks a new team through a structured assessment so you can decide, with evidence, whether to continue, repair or rebuild.

It is written for founders and business owners who will be commissioning this work, so each step explains what to ask for and what the answer tells you.

Why assessment comes before any quote

Many owners ask for a fixed price on day one. It is a reasonable request, but a reliable quote on inherited code is not possible without looking inside. Two Laravel projects that appear 70% finished on screen can differ enormously underneath: one has clean structure and a working test suite, the other has copied code, outdated packages and a database nobody can rebuild.

An assessment turns unknowns into a written list of facts. Estimates built on that list are far more dependable. It is the same logic described in our guide to estimating a software project, and it is why any honest partner will propose a short discovery phase first. For background on typical cost drivers, see our notes on Laravel development cost.

Step 1: Secure repository access

Nothing else can start until you control the code. Ask for the full repository, not a zip file, so you can see history.

  • Ownership: confirm the repository sits in an account your company controls, such as a GitHub organization, and not a developer's personal account. The GitHub documentation explains transferring repositories and managing organization access.
  • Branches: identify which branch matches production. Unfinished work is often spread across several branches.
  • History: read recent commit messages. Long gaps, huge commits or messages like "fix" repeated dozens of times tell you about discipline.
  • Secrets: check that credentials are not committed. If they are, plan to rotate them.

If you cannot obtain the repository at all, treat that as a serious risk before you spend anything else.

Step 2: Get it running locally

A project that cannot be installed on a clean machine is a project with hidden dependencies. Have a developer who has never seen it try the setup from the README and note every point where they get stuck.

  1. Check the PHP version required in composer.json against the supported PHP versions.
  2. Run composer install and record any errors.
  3. Copy the example environment file and list every variable the app expects.
  4. Build front-end assets and note the Node version needed; the Node.js release schedule shows which versions are still maintained.
  5. Boot the app and click through the main screens.

The time and effort this takes is itself a measure of handover quality. Our developer onboarding checklist covers this stage in more depth.

Step 3: Examine the database and migrations

The database is usually the most valuable asset in an unfinished product. Check it carefully.

  • Fresh migration: run all migrations on an empty database. If they fail, the schema has probably been edited by hand.
  • Schema drift: compare the migrated schema with a copy of the production or staging database.
  • Seeders and factories: can you generate realistic test data?
  • Data quality: look for missing indexes, duplicate records and unclear relationships.

Refer to the Laravel migrations documentation for the expected workflow. Always work on a copy of real data, never the live database, and mask personal information.

Step 4: Check dependency health

Dependencies reveal how well the project has been maintained. Review the Laravel version, PHP version and every package in composer.lock.

  • Is the Laravel version still receiving fixes? The Laravel release notes list support windows.
  • Run composer outdated and composer audit to spot abandoned or vulnerable packages.
  • Look for packages pulled from forks or private sources that you may not have access to.
  • Note any paid licenses tied to the previous developer's account.

An old framework version is not automatically a reason to walk away, but it adds upgrade work. See our Laravel upgrade checklist and the OWASP Top Ten for the security risks that outdated components create.

Step 5: Build a feature inventory

Compare what was promised with what exists. Take the original scope, contract or requirements document and mark each feature with a status.

  • Complete: works end to end and has been verified.
  • Partial: screens exist, but logic or edge cases are missing.
  • Stubbed: placeholder code or hard-coded values.
  • Missing: not started.

Include integrations, user roles, emails, background jobs and admin tools, which are often forgotten. If requirements were never written down, write a requirements document now. For permissions in particular, see our roles and permissions guide.

Step 6: Review tests and quality signals

Run the test suite, if one exists. Passing tests are useful, but their coverage matters more than their count. The Laravel testing documentation describes the feature and unit tests you would expect to find.

Ask: do tests cover payments, authentication and core workflows? Are they skipped or commented out? Is there static analysis or code formatting? No tests at all is common in unfinished projects. It does not end the conversation, but it raises the cost of every change, because nothing protects existing behavior.

Step 7: Confirm deployment and infrastructure access

Code you cannot deploy is not really yours. Build an access list covering:

  • Hosting or cloud account, and who is the billing owner
  • Domain registrar and DNS
  • Deployment method: CI pipeline, scripts or manual uploads
  • Queues, scheduler, cache and file storage
  • Third-party services such as email, payments, maps and analytics
  • Backups, and whether a restore has ever been tested
  • Error monitoring and logs

Missing access to any of these should be raised with the previous provider immediately. Our handover checklist for switching agencies lists what a departing team should hand over.

Step 8: Catalogue unresolved bugs

Gather known issues from the tracker, emails, chat messages and user feedback. Then add what your own review finds. Classify each item by impact:

  • Blocking: prevents launch or loses data or money.
  • Serious: breaks a key workflow with no workaround.
  • Minor: cosmetic or rare.

Pay particular attention to security issues and slow pages. Our Laravel performance guide and signs of a needed technical review help with triage.

Discovery checklist

  • Repository owned by your company, with full history
  • Clean local install by someone new to the project
  • Migrations run from scratch; schema matches staging or production
  • Dependencies listed, outdated and vulnerable ones flagged
  • Feature inventory with status for every item
  • Test suite run and coverage reviewed
  • Hosting, DNS, third-party and backup access confirmed
  • Bug list classified by impact
  • Licenses, API keys and credentials documented

Go/no-go criteria

After discovery, decide using explicit criteria rather than instinct.

Signs to continue

  • You own the code and can run it locally without heroic effort.
  • Migrations work and the data model broadly matches the business.
  • Dependencies are supported or upgradeable in reasonable steps.
  • Most core features are complete or partial rather than missing.

Signs to repair first

  • Weak or missing tests around important workflows
  • Outdated framework version or abandoned packages
  • Unclear deployment, but code quality is acceptable

Signs to consider a rebuild

  • The schema cannot be reproduced and the data is unreliable.
  • Business logic is scattered or duplicated so changes break unrelated areas.
  • Security problems are widespread and structural.
  • The original architecture no longer fits the product you want.

A rebuild is a last resort, not a default. Often a hybrid works: keep the database and proven modules, replace the weakest parts.

Hypothetical recovery plan

This is an illustrative example only, not a real client case, and it contains no timelines or prices.

Imagine a founder whose freelancer stopped responding. The app is a customer portal with invoicing and an API connection to an accounting tool. Discovery shows the repository is in the freelancer's personal account, the Laravel version is behind, there are almost no tests, and invoicing is half built.

  1. Stabilize: transfer the repository, rotate credentials, move hosting billing to the company, and confirm backups restore.
  2. Make it reproducible: document setup, fix failing migrations and create a staging environment.
  3. Protect: add tests around login, invoicing and the API integration before touching them.
  4. Upgrade: update dependencies in small, verified steps.
  5. Finish: complete the invoicing feature in priority order, with agreed acceptance criteria.
  6. Maintain: set up monitoring and a support routine, using a maintenance agreement checklist.

Only after steps one and two could a reliable estimate for the rest be produced.

Choosing who takes over

The right partner will insist on discovery, show you findings in plain language and avoid promising a price before seeing the code. Review our checklist for choosing a development company, and compare options such as hiring Laravel developers or a dedicated software team. Our development process shows how we structure this kind of work, and our Laravel services cover audits, upgrades and completion work.

Conclusion

To take over an unfinished Laravel project safely, secure access, prove the code runs, verify the database, judge dependency health, inventory features, test, confirm deployment and list the bugs. Then make a go/no-go decision from evidence. If you would like a second pair of eyes on a project you have inherited, talk to RuhaniSoft and we will start with an assessment.