Self-improving AI report generation for a roof inspection team.
This is a system I built for a multi-trades inspection company. After a roof inspection, someone had to turn the inspector's photos and notes into a formatted report and get it to the client. That step was slow, and it was manual.
The problem
Two things were costing the company time and money.
First, turnaround. After an inspection, the report was written by hand. Someone pulled the photos, described what they saw, wrote up the condition and the recommendations, and formatted the whole thing. A single report could take several days to get out the door, or a week or more when everyone was busy.
Second, the human time to edit and send. Even once a report was drafted, someone had to clean it up, format it, and get it to the client. That was hours of admin work that didn't scale.
Even on the old turnaround, the company was still winning most of the opportunities it pursued. The cost fell on time, labour, and expense: assembling each report by hand tied up hours of skilled time per job, and the lag got bad enough that another person was brought in to help keep reports moving.
So the report step was the bottleneck. It slowed delivery to the client, and it kept pulling in more time and labour the busier the team got.
The proposed solution
The goal: take the inspector's photos and produce a finished, editable report with almost no manual work.
A few constraints shaped the design.
The inspectors weren't going to change how they work. They already upload their photos to their field-management software (tools like Service Fusion, Jobber, or similar). Anything I built had to sit on top of that.
The output had to be an editable Word document. The inspectors and the admin team needed to open the report and make changes themselves, without learning a specialised tool. A locked PDF that nobody can edit is useless to them.
And it had to come out branded and consistent, so the report looked like something they would send to a client.
The plan: let the inspectors tag a job as needing a report, then have a system pick it up, analyse the photos, write the report, format it, and notify the right people.
How I built it
Tagging the job
The inspectors keep doing what they already do: upload their photos to the job record in their field-management software. When a job needs a report, they adjust a couple of custom fields on that job to flag it. That is the whole change to their workflow: a couple of fields.
The trigger
I built an n8n workflow that runs every ten minutes. It checks the field-management software for any jobs with those fields tagged. When it finds them, it pulls all the job information and every photo attached to the job.
Image analysis
Each photo gets sent to an image-analysis model. For every image, it returns a structured JSON breakdown: what the image is showing, the condition or type of damage, and other meta information the report needs. The system does that first pass automatically, across up to fifty photos a job.
Aggregation
Once every image has been analyzed, an aggregation step combines all of those individual JSON results into a single array. The system handles up to fifty images per job.
The report writer
That array goes to the report writer, which is an AI agent built on Claude Sonnet 4.6. It gets three things: the combined image analysis, the job details, and a system prompt that defines exactly how the report should be structured, formatted, and written. It produces the full report as structured JSON.
Generating the document
That JSON gets passed to a docx node, which builds the actual Word document from it. The result is a formatted, branded report. End to end, between the image analysis and the report writing, a full run takes up to about ten minutes.
Storing and notifying
The finished Word document gets uploaded to a NocoDB database as a record. Each record holds the job details and the attachments: the full inspection report and a condensed summary report (for example, an insurance summary). A link to the report is then emailed to whoever needs it: the maintenance manager, the admin team, or anyone else on the list. They get the link, confirm the report is done, download it, review it, and send it to the client.
The run summary
At the end of each run, the system compiles an HTML breakdown and emails it to everyone on the list. It shows how many reports were processed, which ones are done, a short summary of each, and links to open them. This is the monitoring layer. It lets the company see the system working and catch anything that didn't run the way it should.
The feedback loop
This is the part I'm most interested in long term. Every notification email includes a link to a feedback form tied to that specific report ID. Anyone can leave feedback on a report, and it gets stored on that report's record in NocoDB.
Once a day, a principles generator runs. It scans all the records and all the feedback and looks for patterns. When the same kind of feedback shows up repeatedly, it hands that off to another step that turns the feedback into a clear summary and updates a principles document held in the system's memory. The next time the report writer runs, it references that document.
So the system improves based on real feedback from the people using it, without me sitting in the middle of every change. As more people use it, it gets better at producing what they want.
The outcome
The automated run, image analysis through to a formatted, branded Word report, takes about ten minutes. Reports that used to take days now go out the same day, often within minutes to an hour once a person has given them a look.
The writing and formatting that used to eat hours of admin time is mostly gone. The report comes out already formatted in a branded template. People still review it and make changes where needed, and they are editing a finished document.
The bigger win is the time and labour that come back. The hours of manual assembly that used to go into every report are mostly recovered, the help that had to be pulled in to cover the backlog is freed up for other work, and the whole inspection-to-report process is far more relaxed than it was. Reports go out on time with light editing, and the team no longer reorganises around the report step.
I'll be straight about the limits. It's not fully hands-off. Someone still reviews each report before it goes to a client, and the ten-minute processing window makes this a steady pipeline, not an instant one. That's the right tradeoff for now. The review step keeps quality up while the feedback loop does its work.
As we have been tweaking the inspection reports, it has become very efficient for me to complete the final inspection report with limited editing allowing me to send the reports in a very timely manner. Absolutely worth every minute and every penny to do this and I know the best guy that can help you do this 🙂
Opportunities for improvement
Pricing and a services knowledge base
Right now the report makes recommendations, but someone still has to price the work. If I connect the system to a knowledge base of common services and pricing, it can match recommendations to services and build a pricing table directly in the report, in real time. That removes the manual quoting step for whoever is finishing the report.
An approval gate
Once the report is being written, formatted, and priced automatically, the next step is a single approval gate. The system produces the finished report, and the user hits approve. From there it goes to the client with very little human involvement. At that point the report step would keep pace with inspections on its own, with almost no hands-on time.
I'm not rushing to that last step. Removing the human entirely only makes sense once the feedback loop has run long enough that I trust the output. But the path is there.
The takeaway
The report step was the bottleneck, so that's where the system went.
The AI is one piece of this. What made it work was building around how the team already works, keeping the output editable, and giving them a way to feed corrections back in so the system improves over time.
If you're sitting on a slow, manual step that is eating time and labour, that's usually the place to start.