Switching development partners is stressful for a startup, mostly because your product keeps running while the people who built it step away. A clear Laravel project handover checklist turns that risk into a managed process. This guide walks through what to collect, what to verify and what to ask, so the new team can take over without surprises and the old team no longer holds the keys.

One note before we start: never send passwords or API keys by email or chat. Use a password manager with shared vaults, and rotate every secret after the transition. Nothing in this article contains real credentials, and your handover documents shouldn't either.

Why a Laravel project handover checklist matters

Laravel apps rarely consist of code alone. A typical production system includes a server, a database, a queue worker, a scheduler, a mail provider, a payment gateway, file storage and several third-party APIs. If any one of these lives under the outgoing agency's account, you may not discover it until something breaks.

Start by agreeing on a handover window, ideally two to four weeks of overlap. Put the end date, deliverables and responsibilities in writing. A short overlap is far cheaper than an emergency recovery later, as our guide to why software projects fail explains.

1. Source code ownership

Confirm first that your contract assigns intellectual property to you. Then confirm the practical side: where the code actually lives.

  • The repository should sit in a GitHub organization, GitLab or Bitbucket organization that you own, not the agency's account.
  • Request the full commit history, all branches and tags, not a zip of the latest version.
  • Check for private packages, custom forks or licensed components (for example, paid admin panels or themes) and confirm the licenses are in your name or transferable.
  • Ask for the list of Composer and npm dependencies and note anything abandoned or pinned to an old version.

2. Hosting and servers

Identify who pays for and administers the infrastructure. Many startups find their app runs on the agency's cloud account.

  • Which provider is used (AWS, DigitalOcean, Forge-managed servers, shared hosting)?
  • Is the account in your company's name? If not, plan a migration or an ownership transfer.
  • What are the server specs, PHP version, web server, and operating system?
  • How are deployments done: manual, CI/CD, Envoyer, or scripts? Get the pipeline configuration.
  • Are there staging and production environments, and do they match?

If the agency uses a server management tool, make sure you have an owner-level account there as well as on the cloud provider. Our Laravel performance guide covers server tuning once you own it.

3. Domains and DNS

Your domain is one of your most valuable assets, and one of the most commonly registered in the wrong name.

  • Verify the registrant details in a WHOIS lookup and confirm your company is listed.
  • Get registrar account access, or start a formal domain transfer.
  • Export a full copy of DNS records, including MX, SPF, DKIM and DMARC entries, before any change.
  • Check SSL certificate issuance and renewal: automatic via Let's Encrypt, or purchased?

4. Database and backups

Ask for a current database dump and restore it on a clean environment to prove it works. A backup you've never restored is only a hope.

  • What database engine and version is used?
  • How often are backups taken, where are they stored, and how long are they retained?
  • Are uploaded files (storage directory or S3 buckets) backed up as well?
  • Are migrations and seeders complete, so a new database can be built from scratch?
  • Does the database contain personal data that has compliance implications?

Keep at least one backup copy in an account you control, separate from the hosting provider.

5. Environment configuration

The .env file holds the settings that make your app work in each environment. It usually isn't in the repository, so it is easy to lose.

  • Request a documented list of every environment variable, with a description of its purpose. Use a template such as .env.example with placeholder values only.
  • Transfer actual values through a secure vault, not email.
  • Identify which values are tied to agency-owned accounts (mail, storage, monitoring) and need replacing.
  • Confirm how config is cached and how it differs between staging and production.

6. Queues and scheduled jobs

These are the quiet parts of a Laravel app, and the most often forgotten. If workers stop, emails don't send, invoices don't generate and imports stall, often with no visible error.

Queues

  • Which queue driver is used (database, Redis, SQS)?
  • How are workers kept running: Supervisor, Horizon or something else? Get the configuration.
  • What is the retry and failed-job policy, and is anyone monitoring the failed jobs table?

Scheduled jobs

  • Get the cron entry that triggers schedule:run and a list of everything defined in the task scheduler.
  • Document what each task does, how often, and what depends on it.
  • Check for any cron jobs or scripts on the server that live outside the codebase.

7. Third-party integrations

List every external service the app touches. For each, record who owns the account and how to move it to you. Our API integration project checklist goes deeper.

  • Payments (Stripe, PayPal and similar), including webhook endpoints and keys
  • Email and SMS providers
  • Cloud storage and CDN
  • Analytics, error tracking and logging tools
  • Maps, CRM, accounting or ERP APIs
  • Social login and OAuth apps

Where accounts are in the agency's name, ask them to add you as owner or transfer the account. Where that isn't possible, create new accounts and plan a cutover, including webhook updates.

8. Documentation

Good documentation shortens onboarding for the new team considerably, as our Laravel developer onboarding checklist shows. At minimum, ask for:

  • A README with setup, run and test instructions
  • An architecture overview and a diagram of main components
  • Database schema notes and key business rules
  • Deployment and rollback procedures
  • A list of known bugs, technical debt and unfinished work
  • API documentation, if the app exposes one

Also request a recorded walkthrough call with the outgoing developers. An hour of screen sharing often reveals more than a long document.

9. Access revocation

Once the new team has confirmed everything works, remove the old team's access. Do this deliberately, with a list, and after you have verified that nothing depends on their credentials.

  • Remove agency members from the repository, cloud account, server panel, registrar and every integration.
  • Rotate all secrets: database passwords, application key planning, API keys, webhook secrets and SSH keys.
  • Remove old SSH keys and deploy keys from servers.
  • Review admin users inside the application itself, using a clear roles and permissions plan.
  • Check shared inboxes, forwarding rules and project management tools.

Be careful with the Laravel application key: changing it invalidates encrypted data and sessions, so plan that change with your new developers instead of doing it blindly.

Copyable handover checklist

Copy this into your project tracker and mark each item with an owner and a date.

  • [ ] Contract confirms IP assignment to our company
  • [ ] Repository transferred to our organization with full history
  • [ ] Private packages and licenses documented and transferred
  • [ ] Hosting and cloud accounts in our name, owner access confirmed
  • [ ] Deployment pipeline and scripts delivered
  • [ ] Domain registrar access and WHOIS verified
  • [ ] DNS records exported
  • [ ] SSL renewal process documented
  • [ ] Database dump delivered and test-restored
  • [ ] Backup schedule, location and retention confirmed
  • [ ] Uploaded files backed up
  • [ ] Environment variables documented, values shared via vault
  • [ ] Queue driver, workers and monitoring documented
  • [ ] Scheduler entries and server cron jobs listed
  • [ ] Third-party accounts listed and transferred
  • [ ] Webhooks reviewed and updated
  • [ ] README, architecture and deployment docs delivered
  • [ ] Walkthrough session completed
  • [ ] New team deployed to staging successfully
  • [ ] Old team access removed
  • [ ] All secrets rotated

Questions to ask the outgoing agency

  1. Is any part of the system hosted or licensed under your accounts?
  2. Which services bill to you and get passed on to us?
  3. What is the last time a backup was restored successfully?
  4. What breaks if queue workers or the scheduler stop?
  5. Are there manual steps in deployment that aren't written down?
  6. Which parts of the code are fragile, untested or poorly understood?
  7. Are there customizations to vendor packages or the framework?
  8. What features were started but not finished?
  9. Which Laravel and PHP versions are we on, and what upgrades are overdue?
  10. Who can we contact for questions after the handover ends?

After the handover: stabilize and plan

Once access is clean, have the new team run a code audit, update dependencies safely and add monitoring and tests around critical flows. Budget for it using our notes on software maintenance costs. If you need an experienced team to take over, our Laravel development services cover audits, maintenance and new features. If you prefer to extend your own team, our dedicated developers can work as an embedded part of your startup.

Conclusion

A handover succeeds when ownership, access and knowledge all move to you, and when you have tested each of them. Use this Laravel project handover checklist as a working document, and don't close the old engagement until every box is checked. If you'd like help auditing your current setup or taking over a Laravel project, talk to RuhaniSoft and we'll walk you through a safe transition.