Project management for a small or mid-size contractor is the discipline of controlling four things — scope, schedule, cost, and the paper trail that proves what happened — with a fraction of the staff a large general contractor has. The processes are the same ones a billion-dollar GC runs: you prequalify subs, send RFIs and submittals, log the day's work, manage change, and bill for what you've earned. The difference is that you do all of it without a document-control department, a contracts team, and a project-controls analyst. That constraint is the whole problem this guide is about.
This is the hub for our project-management coverage. Each section maps a phase of the job, explains where small contractors most often lose money or time, and links down to a focused article. Start here for the map, then go deep where you need to.
The shape of the problem
A construction project moves through the same arc every time: you win the work, buy it out to subcontractors, build it while answering questions and absorbing changes, bill for progress, and close it out. Each stage has its own paperwork, and each piece of paper exists because somewhere, sometime, a contractor lost an argument they would have won if they'd had the record.
The enterprise platforms — Procore and the like — solve this with depth, configuration, and headcount. For a contractor running a handful of jobs with a small office, that depth is overhead. What you actually need is the discipline of the documents, run lightly: the right form at the right moment, a record you can defend, and no busywork. The sections below walk the job in order.
Preconstruction: buy out the job to subs you trust
Most of a general contractor's risk lives in its subcontractors. They do the bulk of the physical work, and a single under-capitalized, under-insured, or unsafe sub can sink a job's schedule, budget, and safety record. The defense is subcontractor prequalification — vetting a sub's capacity, financial stability, insurance, and safety record before you hand them a contract, not after they've defaulted.
The industry frames prequalification around three things, sometimes called the "three Cs": Capacity (do they have the people, equipment, and experience for this scope?), Capital (are they financially stable enough to carry the work and pay their own people?), and Character (what's their reputation and past performance?). On top of that sits a documentation gate — current certificates of insurance, a workers' compensation experience modification rate (EMR), an OSHA 300A summary, references, and a written safety program.
> Read next: Subcontractor Prequalification: How GCs Vet Subs Before Awarding Work walks the process and the checklist, and explains how to score a sub objectively instead of going on gut feel.
The same preconstruction phase is where you assemble bid packages and award scopes. The discipline there is the same: define the scope tightly, invite qualified subs, and compare apples to apples.
Building it: the documents that keep everyone honest
Once the job is under way, three document streams carry most of the day-to-day project management: requests for information, submittals, and daily logs.
RFIs — resolving the gaps in the drawings
No set of construction documents is perfect. When the drawings are unclear, contradictory, or silent on something you need to build, you raise a Request for Information (RFI) — a formal, tracked question to the architect or owner that turns a verbal "just do it this way" into a documented decision. The RFI is both a tool for getting an answer and a record that protects you if that answer later causes a cost or schedule impact.
> Read next: RFIs for Small Contractors: How to Write Them, Log Them, and Avoid Delays covers the RFI process end to end — when to raise one, what to put in it, how long the architect has to respond, and how to keep an RFI log that holds up.
Submittals — proving what you're about to install
Before a sub fabricates or installs major materials and equipment, the design team reviews submittals — shop drawings, product data, and physical samples — to confirm what's being installed matches the design intent and the specification. The general contractor builds and maintains the submittal log: what's been submitted, who's reviewing it, where it sits in the approval cycle, and when it's due back. A blown submittal can stall procurement and push the schedule, so the log is a schedule-protection tool as much as a quality one.
Both RFIs and submittals share a hidden failure mode for small contractors: the question goes out, and then nobody can tell whose desk it's sitting on or how long it's been there. Tracking ball-in-court — who owes the next move, and how overdue they are — is the difference between a clean job and a stack of stalled paper.
Daily logs — the record that wins disputes
The daily log is the most undervalued document on the job and the one most likely to win you a dispute. It records, day by day, who was on site, what they did, the weather, deliveries, equipment, and — critically — any delays or interferences. Months later, when there's an argument about who caused a delay or whether a condition was as represented, the contemporaneous daily log is the evidence. A log written after the fact, or not at all, is worth far less.
> Read next: The Construction Daily Log: What a Dispute-Grade Record Actually Needs covers what to capture, why contemporaneous matters, and how to log delays so the record holds up.
Managing change: change orders
No project finishes the way it was drawn. The owner adds scope, a condition turns out differently than expected, an RFI answer changes the work. Each of those is a change order — a formal, signed modification to the contract that adjusts the price, the schedule, or both. The single most common way small contractors lose money is doing changed or extra work on a handshake and never converting it into a signed change order. A change is generally not enforceable until it's documented and signed by the parties; do the work first and paper it later, and you're hoping the owner remembers the conversation the way you do.
> Read next: Construction Change Order Management: How Small Contractors Document Extra Work and Get Paid covers what a change order must contain, how to price it, and how to keep changes from quietly eroding your margin.
Getting paid: pay applications and the schedule of values
On most commercial jobs, you don't invoice — you submit an application for payment, usually on the AIA G702 and G703 forms, billing for the percentage of each line of work completed during the period. The G703 breaks your contract into a schedule of values; the G702 summarizes it and calculates what's due after retainage (the 5–10% the owner holds back until completion). The math is exacting, and the forms are routinely rejected for a single penny of mismatch between the two sheets.
> Read next: AIA G702 and G703 Pay Applications: How to Fill Them Out (and Avoid Rejection) walks both forms line by line, explains retainage, and lists the errors that get a pay app bounced.
Behind the billing sits job costing — tracking actual labor, material, and sub costs against the budget for each job, by cost code — and, on longer jobs, a work-in-progress (WIP) schedule that tells you whether you're over- or under-billed relative to the work you've actually put in place. Those are the numbers that tell you whether a job is making money before it's finished, not after.
Closing it out
The last stretch of a job is the punch list — the running list of incomplete, defective, or non-conforming items the owner and architect identify in their final walkthroughs, which the responsible subs must correct before final payment and handover. A well-run punch process is organized by trade and location, tracks who owns each item and when it's due, and ties closeout to final billing and retainage release. After punch comes the closeout package: as-builts, warranties, O&M manuals, and the final pay application that releases retainage.
How the pieces fit together
| Phase | The document | Why it matters | Where small contractors slip |
|---|---|---|---|
| Preconstruction | Subcontractor prequalification | Screens out subs that can't carry the work | Awarding on price alone, skipping insurance + safety review |
| Building | RFI | Documents design clarifications | No tracking of who owes the answer |
| Building | Submittal log | Confirms what's installed; protects schedule | Lost track of approval status; procurement stalls |
| Building | Daily log | Contemporaneous record that wins disputes | Logs written late, or not at all |
| Change | Change order | Makes changed/extra work enforceable | Doing the work on a handshake |
| Billing | Pay application (G702/G703) | Bills earned work; tracks retainage | Penny mismatches; sloppy schedule of values |
| Billing | Job costing / WIP | Tells you if the job is profitable now | Finding out at closeout, too late to react |
| Closeout | Punch list | Drives final completion + retainage release | Disorganized; no owner per item |
The honest summary: small-contractor project management isn't about having more software than a big GC. It's about running the same handful of documents with discipline — the right form at the right moment, a record you can defend, and a way to see who owes the next move — without drowning your small office in busywork.
Doing all of this on email, spreadsheets, and a shared drive is where it breaks down — the RFI nobody tracked, the change order that never got signed, the pay app that bounced. Jobsite runs the whole project-management core — daily logs, RFIs, submittals, schedule, punch, and AIA-style pay applications — with ball-in-court tracking and the field in mind, so the paper trail keeps itself. See how it works →
Browse every article in this pillar on the project management topic page.
Articles in this guide
See how Jobsite handles this in practice: Project management on the platform →