A maintenance agreement decides what happens when your application breaks at 9 a.m. on a Monday, or when a security fix is published and nobody acts on it. This Laravel maintenance agreement checklist helps you read the document the way an operator would: what is covered, what is not, how fast someone responds, and who owns what. It is general business guidance, not legal advice, so have a qualified lawyer review the final contract.

Start with what the agreement is for

Maintenance keeps a working application working. It is not the same as building new features, although vendors often bundle the two. Before comparing proposals, write down what the application does for your business, who depends on it and what an hour of downtime costs you in practical terms.

That context makes every clause easier to judge. A internal reporting tool can tolerate a next-day fix. A checkout or booking system usually cannot. If you are still estimating what to set aside, the guide on budgeting for software maintenance is a useful companion, and our Laravel development cost page explains how ongoing work fits into total cost.

Laravel maintenance agreement checklist: included tasks

Vague wording such as "general maintenance" is the most common source of disputes. Ask for a named list of tasks and how often each happens.

Tasks that should usually be listed

  • Dependency updates: Composer packages and front-end packages, with testing before release.
  • Patch and minor framework updates within your current Laravel version, following the Laravel release and support policy.
  • PHP version compatibility checks against the supported PHP versions schedule.
  • Bug fixes for defects in existing, agreed behavior.
  • Queue, scheduler and log health checks.
  • Database housekeeping such as pruning and index review.
  • Monthly or quarterly reporting on what was done.

Ask how updates are tested and deployed. A staging environment, a rollback plan and a short regression check are signs of a mature process. Our software development process shows how we think about release discipline.

Major version upgrades

Moving between major Laravel versions is a project, not routine maintenance. Check whether the agreement treats it as separate, quoted work. The Laravel upgrade checklist for older applications shows why it deserves its own scope.

Exclusions you should expect and question

Every agreement has exclusions. The goal is to make sure they are explicit and reasonable.

  • New features and enhancements: normally excluded or billed separately. Ask how they are requested and estimated.
  • Third-party failures: payment gateways, email providers or APIs changing without notice. Ask whether adapting to those changes is covered. See the API integration checklist for what breaks most often.
  • Hosting and infrastructure costs: who pays the cloud bill, and who manages the server?
  • Issues caused by unapproved changes by your staff or another vendor.
  • Data fixes caused by user error.
  • Performance tuning beyond a baseline. Deeper work may sit outside the retainer; the Laravel performance guide shows how large that area can be.

Ask for a clear definition of a bug versus a change request. Many arguments start with the sentence "I thought that was broken, not missing."

Support hours and channels

State the hours in a specific time zone, including public holidays. "Business hours" means little when your vendor is several time zones away. That is not a problem in itself, and many teams work well offshore, but you should know the overlap. Our piece on making remote teams work covers this in more detail.

  • Which channels are official: email, ticketing system, chat, phone?
  • Is there an out-of-hours option for critical incidents, and is it priced separately?
  • How many hours of work are included per month, and what happens to unused or excess hours?

Response time versus resolution time

These are different promises, and agreements often only make the easier one.

  • Response time: how quickly someone acknowledges and starts looking at the issue.
  • Resolution time: how long until the problem is fixed or a workaround is live.

A one-hour response with no resolution target tells you very little. Many vendors will not commit to fixed resolution times for every case because causes vary, which is honest. Look instead for resolution targets by severity, regular status updates and an agreed workaround process.

Define severity levels

Ask for written definitions, for example:

  • Critical: the application is down or data is at risk.
  • High: a core workflow is broken with no workaround.
  • Medium: a feature is impaired but a workaround exists.
  • Low: cosmetic or minor issues.

Confirm who decides the severity. If only the vendor decides, you may find everything is "medium."

Security updates

Security is where vague promises cost the most. Ask how the vendor learns about vulnerabilities, how quickly they assess them and how they apply fixes. Sources like the OWASP Top Ten and the Laravel security documentation give a shared vocabulary for the conversation.

  • Are security patches included in the base fee, or billed per hour?
  • Is there a target window for critical patches after they are released?
  • Do they run dependency audits, for example with Composer’s audit command?
  • Will they tell you when a patch cannot be applied without larger work?

Be wary of anything that promises your application will be "fully secure." No one can honestly promise that. A good agreement describes a process instead. For mobile clients, the mobile app security checklist covers the other side of the stack.

Backups and recovery

A backup you have never restored is a hope, not a plan. The agreement should say what is backed up (database, uploaded files, environment configuration), how often, where copies are stored and how long they are kept.

  • Restore testing: how often is a restore actually tried?
  • Recovery point and recovery time: how much data could you lose, and how long to be back online? The NIST contingency planning guide explains these ideas.
  • Storage location: separate from the main server, and under whose account?
  • Encryption and access: who can read the backups?

Monitoring and alerting

Monitoring should tell you about problems before customers do. Ask what is watched: uptime, error rates, queue backlogs, failed jobs, disk space, SSL certificate expiry and scheduled task completion.

Also ask who receives alerts, whether you get access to the dashboards and whether error tracking and logs belong to you. Laravel’s own logging documentation is a good baseline for what should be captured.

Incident escalation

When something goes wrong, you want a path, not a scramble. The agreement or an attached runbook should name the first contact, the escalation contact and the point at which a senior engineer is pulled in.

  1. Detection and acknowledgment.
  2. Severity assignment.
  3. Containment, such as maintenance mode or rollback.
  4. Regular updates at an agreed interval.
  5. Resolution and confirmation with you.
  6. A written post-incident summary with preventive steps.

Ask for the post-incident report as a standard deliverable for serious issues. It is one of the clearest signs of an accountable vendor.

Ownership and exit

Ownership is easy to ignore until you want to switch vendors. Confirm in writing who owns the source code, the repository, the hosting accounts, domain, third-party service accounts, credentials and documentation. Ask whether the code lives in a repository under your organization.

Check the notice period, handover assistance and whether handover is billed. A vendor confident in its work will not make leaving difficult. See the Laravel project handover checklist and the onboarding checklist for an existing application for what a clean transition involves.

Contract-review checklist

  • Named list of recurring tasks and their frequency.
  • Clear definition of bug, change request and new feature.
  • Written exclusions, including third-party and hosting issues.
  • Support hours, time zone, holidays and channels.
  • Response targets and resolution targets by severity.
  • Who assigns severity.
  • Security patch process and timing.
  • Backup scope, frequency, location and restore tests.
  • Monitoring scope and alert recipients.
  • Escalation contacts and post-incident reporting.
  • Ownership of code, accounts, data and documentation.
  • Hour limits, rollover and overage rates.
  • Term, renewal, notice and handover terms.
  • Liability and confidentiality terms, reviewed by your lawyer.

Questions to ask a vendor

  1. Who will actually work on my application, and is there a backup person?
  2. How do you test updates before they reach production?
  3. What happened in your last serious incident, and what did you change afterward?
  4. How do you handle a security patch that breaks a feature?
  5. Can I see a sample monthly report?
  6. Do I get direct access to the repository, hosting and monitoring?
  7. What would you recommend we do differently if you inherited this codebase?

If the application is inherited and you are unsure of its condition, a technical review before signing can prevent surprises in the scope.

Choosing the right engagement model

Some businesses need a fixed monthly retainer. Others do better with a small block of hours or a dedicated developer who also builds features. The comparison of dedicated teams, freelancers and in-house developers and our page on how to hire Laravel developers can help you decide.

Conclusion

A good maintenance agreement is specific, measurable and fair to both sides. Use this Laravel maintenance agreement checklist to turn vague promises into written commitments, then ask your lawyer to review the final text. If you would like a second opinion on a proposal, or want to discuss support for an existing application, explore our Laravel and PHP development services and get in touch with RuhaniSoft.