Home/Guides/Web app maintenance checklist

// Guide

Web application maintenance checklist: monthly, quarterly and yearly tasks

A web application maintenance checklist is the recurring work that keeps a business app secure, backed up and usable. Monthly: security patches, dependency updates, error-log reviews and backup checks. Quarterly: a real restore test, an access review, a performance check and testing on the phones and browsers people use. Yearly: certificates, domains, licenses, documentation and platform end-of-support dates.

This list covers custom software maintenance tasks for the systems that operations teams run on: customer and dealer portals, internal tools, order and scheduling apps, production data systems. Unlike a marketing website, a business application has a database people write to all day, logins for employees and outside users, scheduled jobs and connections to other systems, and each needs its own checks.

It’s also the list to pick up when someone says, “Our developer is moving on, and someone needs to keep this running.” Walk through it with the outgoing developer and you’ll learn quickly what has been done and what hasn’t.

How to use this checklist

Turn each line into a recurring ticket with a named person as the owner (“IT” isn’t a person). Keep a short maintenance log: the date, what changed, who did it and anything odd. It’s the first thing the next engineer reads when something breaks.

What software maintenance covers, and what counts as new work

Maintenance is the planned work that keeps an application healthy while everything around it changes. Even if nobody touches the code, the operating system, database, framework and outside services underneath it keep shipping security fixes, new versions and end-of-support dates. Support is the other half: answering questions and fixing problems as people run into them. Many arrangements include both.

What does software maintenance include? Four kinds of work:

  • Corrective: fixing what’s broken, like a report that double-counts.
  • Adaptive: keeping the app working as its surroundings change, such as a new browser version or an outside service retiring an API version.
  • Preventive: patches, upgrades and clean-up that head off outages.
  • Small improvements: a new filter, an extra column, clearer wording on a form.

New work is anything that changes what the system does or who uses it: a new workflow, new screens, a new integration or a new group of users. It needs its own scoping and testing, and when it gets squeezed into “maintenance”, the routine tasks below are what gets skipped.

Request (hypothetical)
Usually
Why
Apply this month’s security patches
Maintenance
Keeps the existing system safe.
The nightly import broke after a supplier changed its file format
Maintenance
Adaptive fix: same job, new input.
Add a column to the weekly export
Maintenance
A small change to something that exists.
Move to a supported database version
Maintenance, often planned as its own project
Needed to stay supported, but big enough to schedule and test separately.
Give dealers their own login to check order status
New work
New users, screens and permissions.
Add an approval step for large purchases
New work
A new workflow.
Connect the app to the accounting system
New work
A new integration.

Agree on gray areas in writing before work starts. A simple rule: if the change keeps the system doing what it already does, it’s maintenance. If it changes what the system does or who uses it, scope it as a project.

Monthly web application maintenance checklist

Monthly tasks are short once they’re routine. Several can be automated, but someone still has to read the results.

  • Apply security patches to the operating system, web server, language runtime, framework and database. Do anything marked as a security fix first.
  • Update dependencies. Libraries pull in other libraries, and a vulnerability can turn up anywhere in that chain. Run your stack’s dependency scanner; for JavaScript projects, npm audit reports known vulnerabilities in your dependencies.
  • Test updates on a staging copy first: a separate copy of the app with test data. Run the main workflows there, then release to production.
  • Read the error logs for new errors, errors that repeat daily and errors people have learned to live with (“just refresh and try again”).
  • Check scheduled jobs and outgoing email. Imports, exports, nightly calculations and password-reset emails fail quietly. Confirm they ran and the output looks right.
  • Confirm backups ran. Both the database and uploaded files, stored outside the production server and account, at a normal size. A suddenly smaller backup is a warning sign.
  • Check disk space and database growth. Logs, uploads and history tables grow until something fills up.
  • Run the transactions the business depends on. Log in, submit the main form, create a test record and confirm the notification arrives.
  • Check that alerts reach a person. An uptime alert that goes to a former employee’s inbox is the same as no alert. Then note everything in the log.

Quarterly application maintenance checklist

Every three months, test the things that only matter on a bad day.

  • Restore a backup to a separate copy and use it. Steps below.
  • Review access to the app, server, database, code repository and outside services. Remove anyone who has left or changed roles (see the access section).
  • Check performance. Compare page and report times with last quarter and find the slowest queries. Tables that grow every day are the usual suspects.
  • Test on real phones and browsers. Run the main workflows on the devices your users have, where they work. When a manager says, “Our contractors need to do this from their phones,” this test shows whether they can. Our mobile-friendly test is a quick first check.
  • Read notices from outside services. Payment, email, mapping and shipping services retire API versions on announced dates, and the notice goes to whoever signed up.
  • Collect workarounds from daily users. A workaround is a bug report nobody filed.
  • Check certificate expiry dates and the renewal automation. Lifetimes are shrinking (see the yearly list).

How to run a backup restore test

CISA tells organizations to “regularly test the availability and integrity of backups in a disaster recovery scenario” (#StopRansomware Guide), and the NIST Cybersecurity Framework 2.0 lists backups that are “created, protected, maintained, and tested” as an outcome (PR.DS-11). For a web application:

  1. Restore the latest database backup and uploaded files to a separate environment, never over production.
  2. Time it, from “we need the backup” to “people can log in”. That’s your real recovery time.
  3. Open the newest records and check that recent uploads and settings came back too.
  4. Note what was missing: configuration, keys, scheduled jobs, steps someone had to remember.
  5. Log the date, the time it took and the gaps, and close the gaps before the next test.

Example (hypothetical, not client data)

A property-management company’s maintenance-request app restores its database cleanly, but tenant photos live in separate file storage that was never backed up. The restore test finds the gap on a quiet Tuesday instead of the morning after a server failure.

Yearly checklist: renewals, documentation and platform lifecycle

Once a year, review everything with an expiry date and every decision that needs lead time.

  • Certificates. Make sure renewal is automated and monitored; a yearly check no longer works. A CA/Browser Forum ballot cuts the maximum lifetime of public TLS certificates from 398 days to 47 days in steps between March 2026 and March 2029. If you relied on Let’s Encrypt’s reminder emails, it announced it would stop sending them on June 4, 2025.
  • Domains and DNS. Confirm auto-renew, a current payment card and registration in the company’s name. For .com and other generic domains, ICANN’s Expired Registration Recovery Policy requires renewal reminders about a month and a week before expiration, sent to the registrant on file. If that’s a former employee, nobody reads them.
  • Licenses and subscriptions. Paid libraries, hosting plans, email and map services, app-store developer accounts: list each with its renewal date, cost approver and billing card.
  • Platform end-of-support dates. List the versions of the operating system, database, runtime and framework, and when each loses support. Microsoft’s extended support for SQL Server 2016 ended in July 2026. The Node.js release page is blunt: “Production applications should only use Active LTS or Maintenance LTS releases.” Plan upgrades while they’re still optional. On Classic ASP? Read our Classic ASP end-of-life guide.
  • Documentation. Update the runbook: how to build, release and restore the app, what runs on a schedule, which outside services it uses and where credentials are kept.
  • Rotate credentials: API keys and service and database passwords, starting with anything a departed person knew.
  • Walk through a disaster. If the server vanished, who rebuilds it, from what, and how long would the business wait?
  • Review the backlog with the business. Separate maintenance from new work, and ask whether the system still fits how the operation runs. If not, weigh rewrite vs refactor.

Developer moving on? Your first call is with an engineer.

We maintain and support the custom software operations teams depend on, including systems someone else built. Tell us what the app does and how it’s been looked after so far.

See maintenance and support

Access and accounts: the maintenance item everyone skips

Patches get attention because tools nag about them. Nothing nags you about the contractor who finished in March and can still log in, or the domain registered to a developer’s personal email.

Review two layers: the people who use the app and the people who can change it. NIST’s Cybersecurity Framework 2.0 lists access permissions that are “managed, enforced, and reviewed” under least privilege as a core outcome (PR.AA-05).

Where access lives
What to check
Who should hold it
App user accounts
Former employees, contractors and outside users still active; shared logins.
Named individuals, switched off on their last day.
Admin roles in the app
Who can change settings, see every record or export data.
As few people as the work needs.
Code repository
Departed developers or agencies still listed.
An organization the company owns.
Hosting and cloud console
Personal logins, shared passwords, a former employee’s card on the bill.
A company account with individual logins and two-factor authentication.
Database
One shared admin password.
Named logins; the app’s own login limited to what it needs.
Domain registrar and DNS
Registrant email, recovery phone, payment card.
The company, with a role address (such as it@) as contact.
Outside services and API keys
Keys a departed person had; keys pasted into code or spreadsheets.
Company accounts, keys stored in one place and rotated.

When someone leaves: six offboarding steps

  1. Switch off their app login and admin roles on their last day.
  2. Remove them from the repository, hosting, database and outside services.
  3. Change every shared password and API key they knew.
  4. Move two-factor recovery off their personal phone.
  5. Reassign scheduled jobs, reports and alert emails that run under their name.
  6. Record it in the maintenance log.

Contractors and outside developers need the same steps, and an HR exit process may not catch them. If the person leaving built the system, collect everything on our software handover checklist before their last day; it writes the request for you. If an employee built the tool on a personal account, see employee-built apps your team depends on. If the developer has stopped answering, start with what to do when your developer disappears.

Signs web application maintenance has been neglected

Look for these when you assess a system nobody has looked after for a while.

Sign
What it usually means
First step
Nobody knows when a backup was last restored
Recovery time is unknown; the backup may be incomplete.
Run a restore test this month.
“We can’t update that, it breaks something”
Updates were skipped until they piled up.
List versions and support end dates; plan upgrades in order.
Errors people work around
Staff absorb bugs instead of reporting them.
Read the error logs; collect the workarounds.
Only one person can release a change
The release steps live in someone’s head.
Write the runbook now.
Former employees or the old agency can still log in
Nobody owns access reviews.
Run the offboarding steps.
A certificate or domain has expired before
Renewals depend on memory.
Automate renewals; alert a role address.
Empty reports nobody noticed
Scheduled jobs fail silently.
Add alerts for failed jobs.

One or two of these is housekeeping. Several at once means the app needs a stabilization pass first: overdue security updates, then backups, access and documentation. If the code itself is the problem, see how to modernize an old web application.

Example (hypothetical, not client data)

The first quarterly pass on a parts distributor’s dealer portal, two years after its developer left: the backup job had stopped after a server move, three former employees and the original agency still had admin logins, certificate notices went to the old developer’s inbox, and the framework was two major versions behind. Dealers placing orders saw none of it.

In-house maintenance or a maintenance partner?

Either can work. What matters is whether someone actually does these tasks every month, and whether more than one person can fix the system.

Factor
In-house fits when
A partner fits when
Skills
Someone on staff knows the code, hosting and database.
Nobody on staff is comfortable changing the code or server.
Amount of work
There’s steady development work every week.
Work comes in bursts: monthly patches, occasional fixes, a yearly upgrade.
Coverage
Two people can each release a fix and restore a backup.
One person holds it all, and a vacation stops work.
Upgrades
Your team has upgraded this stack before.
Upgrades keep getting postponed because they feel risky.

A split often works: your team handles user accounts, reports and first-line questions; an outside engineering team handles patches, upgrades, backups and fixes.

Questions to ask any maintenance partner

  • Will we talk to the engineers who work on our system, or to an account manager?
  • What’s included, and how will you tell us when a request is new work?
  • Do you start with a review of the code, hosting and documentation?
  • How are updates tested before they reach production?
  • Can we see your maintenance log and runbook?

How we work: you talk directly to the engineers doing the work. We provide ongoing maintenance for Amusement Advantage’s contractor portal, which we’re modernizing page by page for its network of 60,000+ contractors, each page tested on a staging copy before production. We host and maintain a national retail chain’s careers website (a confidential client, so we don’t name it), and we designed, built and still run Just A Menu, our own platform. See maintenance and support for how an engagement starts, or browse our guides.

// FAQ

Web application maintenance FAQ

What’s the difference between software maintenance and support?

Maintenance keeps the software healthy on a schedule: updates, patches, backups, renewals and small fixes. Support answers questions and fixes problems as people run into them. Many arrangements include both.

How often should we test backups?

Test an actual restore regularly, at least quarterly for systems the business depends on. Restore to a separate copy, time it and check the newest records. A backup you haven’t restored is a hope, not a plan.

Does maintenance include new features?

Usually not. Small adjustments to existing screens and reports may be covered; new workflows, screens, integrations or groups of users are new work and should be scoped separately.

Does an app need maintenance if nobody is changing it?

Yes. The operating system, database, framework and outside services underneath it keep releasing security fixes and retiring old versions, and certificates, domains and licenses keep expiring. An app nobody looks after gets less safe every month.

What should we do when our developer is leaving?

Before their last day, move the code repository, hosting, domain, database and outside-service logins into company-owned accounts, and get the latest backup and the written release steps. Our free software handover checklist builds the request for you.

// Bring us in

Tell us about the software your business runs on.

A new build, a system that’s hard to use, a stuck project or a prototype that needs to go live. An engineer, not a salesperson, will get back to you.

202-88-MAGIC · or email info@effortlesspresence.com