The punch list app fields that actually close an item.
A punch list app has one job near the end of a project: turn a walkthrough full of loose ends into a list where every item has an owner, a photo, and a real sign-off. Owner, photo, sign-off: strip the category of field service apps down to what a jobsite actually holds it to, and those three are what remain.
This page is about the plumbing underneath any punch list app: what a punch item needs to capture, how the AIA's own substantial completion process actually works, and who has to sign off before an item is really closed.
See what a punch item needs to capture10
fields a punch item needs to close cleanly
6
steps from the first walkthrough to final payment
3
parties typically in the sign-off chain
2
photos required on every item: before and after
The short version
A photo, a trade, and someone with authority to sign off.
A punch list app needs an item ID, a location, the trade responsible, a description, priority, a before photo, an assignee, a due date, an after photo, and a sign-off with who and when. Under AIA A201-2017, the contractor drafts the list at substantial completion, the architect verifies and amends it, and it's attached to a Certificate of Substantial Completion, AIA Document G704. An item only actually closes once someone with authority to verify it, not just the trade that fixed it, checks it off. The rest of this page walks through both.
The fields
What a punch item needs to capture.
Every trade adds its own fields on top, but the base record every punch list shares looks the same:
- A unique item number that never gets reused
- The building, floor, room, or unit it applies to
- The trade responsible for it
- A description of the defect or omission
- Priority, life-safety items separated from cosmetic ones
- A photo of the issue at the time it's logged
- Who it's assigned to for the fix
- A target date for closing it
- A photo of the fix, attached before it can close
- A sign-off: who verified it, and when
The before-and-after photo pair is the field that ends most punch list disputes before they start: a photo of the defect when it's logged, and a photo of the fix before anyone marks it done. Getting reliable photo capture right, working offline, tied to the correct item, saved at full resolution, is its own piece of work, and it's covered separately in adding photo upload to your app.
Try it
Does your current punch list capture this?
Check off what your punch list already records, on paper, in a spreadsheet, or in whatever app your crew uses now.
0 of 10 · Start here — none of this is captured consistently yet.
The priority field
Not every item is this urgent.
A punch list mixes a cracked outlet cover with a missing fire-rated door in the same walkthrough. Sorting life-safety items from cosmetic ones up front, rather than working the list top to bottom, is what keeps the fixes that actually matter from sitting behind paint touch-ups.
Try it
How urgent is this punch item?
Answer what applies to a specific item. This is a starting point, not a code determination, an inspector or your architect has the final word on anything safety-related.
Suggested priority
Answer the questions above to see a suggested priority.
Substantial completion
How punch lists actually work at substantial completion.
The American Institute of Architects' A201-2017 General Conditions, the standard contract terms behind most architect-led commercial projects, defines Substantial Completion as the stage when the work is sufficiently complete that the owner can occupy or use it for its intended purpose. The punch list is how that stage gets proven out:
| Step | Who's responsible | What happens |
|---|---|---|
| Contractor submits the first list | Contractor | Once the contractor considers the work substantially complete, it prepares and submits a comprehensive list of items to be completed or corrected. |
| Walkthrough, list gets amended | Architect, owner, contractor | The three parties inspect the project together. The architect adds or removes items so the list reflects what's actually outstanding. |
| Certificate of Substantial Completion issued | Architect | If the architect agrees the project has reached substantial completion, it issues AIA Document G704 with the punch list attached and a deadline for closing what's left. |
| Items get fixed | Contractor and trades | Each trade corrects its own items, typically documenting the fix with a photo before marking it done. |
| Items get verified | Architect | The architect checks completed items against the contract documents before they count as closed, not just against the contractor's word. |
| Final payment released | Owner | Once every item is verified closed, the owner accepts the work and releases final payment, including retainage. |
Process from the AIA's own guidance on substantial completion and summary of the G704 certificate. Most residential and design-build projects borrow the same shape without using the AIA forms by name.
The detail worth building into an app rather than assuming: the certificate itself has to state the time allowed for completing or correcting the remaining items, and who's responsible for security, utilities, and insurance on the space in the meantime. An app that only tracks the items and skips that agreed deadline is missing half of what the certificate actually establishes.
Sign-off
Who actually closes an item?
On paper, the architect verifies the work and signs the certificate, with the owner accepting it. In the field, that one signature usually sits on top of a longer chain: the trade that did the fix marks it done, the general contractor or superintendent checks it, and only then does it reach the person with actual authority to verify it against the contract documents. An item that skips straight from "the sub says it's fixed" to "closed" hasn't really been verified at all.
Try it
Can this item actually close?
Check off what's true for a specific item on your list right now.
Status
Open
Nothing has happened on this item yet.
Terminology
Punch list, work order, or daily report?
All three show up on a construction jobsite, and they get confused because the same phone captures the photos for all of them. What's actually different is what triggers the record and whether it ever really "closes".
| Term | Triggered by | What it tracks | When it closes |
|---|---|---|---|
| Punch list | A walkthrough near substantial completion | A finite list of defects or omissions tied to one project | When every item is verified and the certificate is accepted |
| Work order | An individual reported problem or approved request | One job: assignment, parts, labor, a status history | When that job is signed off, then a new one opens for the next problem |
| Daily report | Every working day on an active site | Crew, weather, work performed, deliveries, delays | Never closes on its own, it's a running record for the life of the project |
If your team is tracking recurring repairs on a building that's already occupied rather than finish-out items on a project that's wrapping up, what you actually need is a work order app, not a punch list. And if what you're after is a daily record of crew, weather, and progress rather than a defect list, that's an app for construction daily report.
Old way, new way
A clipboard, or a punch list app?
Most of the fields on this page can technically be captured with a pen and a phone camera. What a clipboard can't do is stop someone from marking an item done without actually checking it.
Clipboard, spreadsheet, group chat
- Zero setup, everyone already knows how to use it
- No enforced sign-off, anyone can mark anything done
- Photos live wherever they were taken, not attached to the item
- Three trades, three copies of the list, no single source of truth
A punch list app
- Every item carries its own photo pair and location
- Sign-off is a role, not whoever happens to have the pen
- One list, live for the GC, the architect, and every trade
- Works offline on site, syncs once back on signal
Picking an approach
A construction punch list app, rated feature by feature.
"App vs. clipboard" is the headline version. In practice there are five real options teams reach for, and each one trades off differently on the fields that actually matter.
| Approach | Photo tied to each item | Works offline on site | Sign-off chain enforced | Who maintains it |
|---|---|---|---|---|
| Paper punch list / clipboard | yes, if you tape it in | yes, by default | No | you, by hand |
| Spreadsheet + phone photos | loosely, links break | No | No | you, and it drifts |
| Generic punch list app | Yes | depends | limited | the vendor |
| Field service / project management platform | Yes | Yes | Yes | the vendor, locked to their schema |
| Custom-built punch list app | Yes | Yes | whatever your process needs | you |
Android, and free vs. paid
Does it need to run on Android, and is it free?
An Android punch list app isn't a niche request, it's often the majority of the crew. If subs and trades are logging their own fixes, the app has to work as well on whatever phone they actually carry as it does on the superintendent's. Offline photo capture, a location tied to the item, and sync once back on signal all need to work on both platforms, not just the one the office happens to use to demo it.
As for a free punch list app: several construction and field service platforms offer one, usually capped by project count, users, or photo storage. That's fine for a single contractor closing out a small remodel. Once a project has several trades checking off dozens of items with before-and-after photos, most teams outgrow the cap fast and end up pricing out a paid plan, or building their own. Even a build-it-yourself platform like Newly starts at $25 a month, and dedicated construction management platforms typically run well past that per seat.
When to build your own
Building a punch list app that fits your sign-off chain.
The honest reason to build your own punch list app instead of buying one off the shelf usually isn't cost, it's fit. A vendor's app assumes a particular sign-off chain, a particular set of trades, a particular photo workflow. When yours doesn't match, you end up bending the process to the software instead of the other way around. That gap is what Newly is for: describe the punch list you actually run, the fields, the trades, who signs off on what, and it builds a real native app around your process instead of a vendor's schema.
The fields and the sign-off chain are worth nailing down on paper first, since they're cheap to change before anything is built. Wiring them to a real database, offline sync, and role-based sign-off is a separate decision, and it is worth getting right before you start describing screens.
Sources
Where the process came from.
The substantial completion and punch list process on this page comes from the AIA's own documentation, not general industry consensus:
FAQ
Punch list apps, answered.
A punch list (sometimes a punch-out list) is the list of items still to be completed or corrected before a construction project is considered finished. Under the AIA's A201-2017 General Conditions, it's compiled once the contractor believes the project has reached substantial completion, the stage where the owner can occupy or use the work for its intended purpose, and it stays open until every listed item is closed and final payment is released.
Start with the sign-off chain, not the form.
A punch list app lives or dies on the boring stuff: a photo pair on every item, and a close that only someone with real authority can trigger. Get those right, then build the app around them in Newly.