On this page
- Start with the report's job, not its length
- Check that the report separates work types
- Read the ticket table for closure evidence
- Compare reported hours with the agreement
- Look for deferred and refused work
- Test a sample of entries against the live site
- Ask what the next month's report should change
- Keep the review to one page
- Related reading
Start with the report's job, not its length
A monthly maintenance report has one job: let someone who did not do the work decide whether the site is in better shape than it was last month. Length is a poor proxy for that. A ten-page ticket export can hide the two items that mattered, while a short note can show what changed, what broke, and what is still open. Read the report against that single purpose before you judge any individual row.
Ask who the report is written for. If it is addressed to a developer, the business owner cannot use it, and the review will drift into technical questions that do not affect the decision. A useful report names the site, the period covered, the person accountable, and the one or two events that deserve attention. Everything else is supporting detail that should be available but not forced to the front.
Check that the report separates work types
Maintenance work usually falls into a few distinct lanes: planned updates, unplanned incidents, small content requests, and work that turned out to be a new feature. A report that mixes them into one list makes it impossible to see where the retainer went. Ask for a summary line for each lane with a count and the time spent. If the vendor cannot separate them, the review should start with that gap rather than with the invoice.
Separation also exposes scope creep early. A request that began as a copy edit and became a template change belongs in a different lane, and the report should say so. When the lanes stay mixed, the client ends up paying feature rates for fixes and the vendor absorbs fixes at feature prices. Neither side can see the pattern until the annual review, which is a costly place to discover it.
Read the ticket table for closure evidence
Each row should name the request, the date it was received, the date it closed, and the person who verified the result. The verification field matters more than the closure date, because a ticket can be marked done without anyone checking the live page. Look for a short note on what was tested and where. A row that says only "completed" gives the reviewer nothing to confirm.
Sample the rows that touch money or trust: checkout, forms, booking, login, and any page that carries legal text. Those are the places where a small change can cause a large problem. Check that the report names the environment used for testing and whether the change was seen on a phone as well as a desktop. A vendor who tests only in a staging browser may never see the phone layout that users get.
Compare reported hours with the agreement
The report should show hours by lane against the hours included in the agreement. A single total at the bottom forces the client to reconstruct the split from memory. Ask for the opening balance, the hours used this month, any carryover rule, and the closing balance. If the agreement has a rollover cap, the report should apply it explicitly rather than leaving the arithmetic to the invoice.
Watch for hours that appear without a matching ticket, and for tickets that appear without hours. Both happen when the vendor tracks time in one tool and work in another. A monthly reconciliation does not need to be forensic, but it should explain every line that does not tie. Ask the vendor to add a short note beside each adjustment instead of sending a second spreadsheet.
Look for deferred and refused work
Useful reports say what the team chose not to do. A deferred plugin update, a declined redesign request, and a bug that could not be reproduced all belong in the record with a reason. Without that section, unfinished work disappears and the same request returns next month as if it were new. Ask for the reason in plain language and the condition that would reopen the item.
Refused work deserves the same treatment. If a request falls outside the retainer, the report should say which clause applies and what the client can do instead. That protects both sides from a disagreement later, when memory of the conversation has faded and the invoice is the only shared record. A short refusal note with the clause and an alternative is more useful than a silent omission.
Test a sample of entries against the live site
Pick five closed tickets and open the pages they name. Confirm that the change is visible, that the surrounding layout still works, and that no unrelated element moved. Check the same pages on a phone width, because a fix that works on a wide screen can break a narrow one. This sample takes ten minutes and catches the most common reporting error, which is a ticket closed before the change reached production.
Keep a note of what you checked and what you found. If a sampled item fails, ask for the evidence rather than a new promise, and record the response beside the original ticket. The pattern across a few months tells you whether the report is reliable. One failed sample is a mistake, while three in a row is a process problem that belongs in the next service review.
Ask what the next month's report should change
End the review with one or two concrete changes to the report itself. Maybe the ticket table needs a verification column, or the hours summary needs the carryover rule stated. Write the change, agree a start month, and check it in the following report. A review that produces only comments will repeat the same conversation next quarter.
Keep the request small enough to adopt. Vendors can change a column faster than they can rebuild a reporting system, and a small change that sticks is worth more than a redesign that never ships. If the report is generated from a help desk, ask whether the field already exists and is simply hidden. Many useful fields are collected but never exported, so the fix may cost nothing.
Keep the review to one page
The finished review should fit on one page: the hours position, the work by lane, the incidents, the deferred items, the sample result, and the one change requested. Store it with the contract so the next reviewer can see the trend without rereading twelve months of tickets. A page a month is enough to make renewal decisions from evidence. Write it before the service call so the discussion starts from the same facts.
Review the page at each service meeting and update it when the agreement changes. If a month is skipped, note the reason instead of leaving a blank. Consistency matters more than detail here, because the value comes from comparing one month with the next. A modest record kept every month beats a thorough audit done once.
Related reading
- NIST guide to enterprise patch management planning describes how update work should be planned, tracked, and verified rather than merely scheduled.
- W3C guidance on evaluating web accessibility explains how a review can check specific criteria instead of a general impression.
- How to reconcile an outsourced website maintenance invoice against the ticket log covers the money side in more detail.
- How to set a maintenance retainer boundary between fixes and new features helps when a monthly report shows work that should have been quoted separately.
Turn the guidance into a reviewable handoff
Record the owner, input, acceptance condition, evidence, and escalation point before production begins. That small contract makes the work easier to inspect and approve.
Plan a website production handoff