If your business breaks ground—excavation and site work, landscaping and irrigation, fencing, pools, paving, foundations, utility and septic installs, drainage and trenching—you live with a rule that outranks every other rule on the job: no dig without a current locate. You call the one-call center, the ticket gets filed, the public utilities get marked, and for a fixed window your crew is legally clear to excavate. Then the window runs out. Maybe the job ran long because of rain. Maybe the crew moved to the neighbor's yard to finish a phase. Maybe the backhoe is on site and somebody says the ticket is probably still good, and the day turns on whether anyone can actually check. Most contractors manage this from a truck console of handwritten ticket numbers, a wall calendar, and memory—and memory is the one system on the job that never files anything on time.
Utility locate ticket tracking turns that truck-console ritual into a workflow that files, watches, and renews itself. Every project that will break ground carries a locate ticket on its job record: the ticket number, the confirmation code, the filing date, the expiration date, the scope of the dig, and the status of the marks. Expiration clocks run themselves, renewal reminders go out before the window closes, crews get a go/no-go answer on their phones before the first bucket goes in, and a weekly report shows you exactly which projects are clear to dig and which are not. Nothing depends on a ticket number written on a coffee cup.
This guide covers why locate tickets slip through manual management, what an automated tracking flow actually does, how to build one end to end with a no-code workflow platform, the rules that make the system trustworthy, the mistakes that make locate programs collapse in the field, how this workflow differs from the permits and checklists it often gets confused with, and the edge cases worth planning for before your first ticket runs out mid-job.
Why Manual Locate Management Fails
Before we get into the fix, it is worth being honest about why the manual approach breaks down. It is not that contractors are careless about locates—the opposite is true, because nobody wants to hit a gas line. It is that locate windows, moving dig dates, and dozens of concurrent jobs are a bookkeeping problem, and a truck console is not a bookkeeping system.
The locate window expires mid-job
A locate ticket carries an expiration window that varies by state—sometimes a couple of weeks, sometimes longer—while a landscape project runs on rain, supply delays, and neighbor approvals. The ticket is filed, the marks go down, and the job starts. Then the window closes while the job is half finished, and nobody notices because the expiration date lived on a piece of paper nobody has seen since the first day of work. The crew finishes the phase they were on and moves to the next one, and the dig that happens on day fifteen is happening on a stale ticket. A system that does not watch the clock is a system that lets this happen on schedule.
Ticket numbers live where nobody can reach them
The ticket number and confirmation code get handwritten on a job sheet, and the job sheet goes home in the truck. The office answering a question about the ticket has nothing but the customer's address and a guess. The crew in the field has the paper that was on the clipboard this morning, if it is on the clipboard this morning. And when the one-call center or the locator needs the ticket number to process an update, the person who can actually dig is the person who cannot find it. Evidence that cannot be retrieved in seconds is not compliance—it is an archive, and the question that matters is whether anyone can find it before the excavator rolls.
A dig date moves and nobody re-checks the ticket
Jobs slip. The pouring slab moves a week, the fence install waits for the grading crew, the trench gets rescheduled around the customer's vacation. Every one of those moves is an ordinary business event, and every one of them is a moment when the ticket on file should be re-checked against the new dig date. In manual operations, the reschedule happens in a text message and the ticket happens on a calendar, and the two systems never meet. The dig that was clear on the old date is a different dig on the new date, and the crew only finds out when they check—assuming they check.
Renewals and extensions are remembered by nobody
When the window is about to close and the job is not finished, the contractor needs to renew or update the ticket before digging again. That action requires knowing three things at the right moment: which jobs are still active, which tickets are about to expire, and whether the scope of the remaining work still matches the ticket. A contractor running twenty concurrent jobs cannot hold that in their head on the morning the windows close, so renewals go out late, or go out with the wrong scope, or never go out at all—and the crew digs on Thursday with a ticket that ended Tuesday.
One bad call takes the whole day off the clock
When a locator cannot find the site, or the marks are incomplete, or the ticket was filed with a description the locator could not match, the locate gets flagged and the dig is off. The flag goes back to the ticket filer—somewhere on paper—and the crew, who does not know, arrives with an excavator and an expectation. Manual operations surface that flag when the crew calls the office, which is after the truck has already burned the drive. The flag is generated the moment the locate fails; a manual process simply has no way to surface it in time.
Subcontractors dig without ever seeing the ticket
The fence installer you subcontract, the concrete crew pouring the apron, the landscaper finishing the neighbors' yards—they all break ground on jobs where your ticket is the only locate on file. Manual ticket management treats subcontractors as someone else's bookkeeping, so they show up, dig, and complete the job without anyone verifying that the ticket covered their work, their dates, and their scope. The responsibility does not transfer with the subcontract; only the paperwork does.
The pattern across all five failures
Every one of these failures has the same root: locate tickets are generated at the right moment—when the job is filed—and then travel through the slowest, most loss-prone part of the business—paper, memory, and text messages—before they can protect the dig. Automation keeps the ticket exactly where it was born: digital, dated, attached to the job, and watching its own clock.
What Utility Locate Ticket Tracking Actually Does
Every project files its ticket before it reaches the schedule
The workflow starts at intake: when a job that breaks ground is created—estimate converted to booking, phase added to a project, trench scheduled—the intake form asks one gate question: will this work dig? If yes, the job cannot reach the crew schedule without a locate ticket attached. The ticket number, the confirmation code, the filing date, and the state where it was filed all get captured at the same moment, on the same record.
Ticket details attach themselves to the right job
Because the ticket is filed from data already on the job—the address, the site description, the scope of work—the details flow in automatically: what is being dug, where, how deep, and on which dates. Nothing is retyped. The site description that went to the one-call center is stored on the job record, so when the description needs to be corrected or the scope needs an update, the office is working from the same words the locator received, not from memory of what was said.
Expiration clocks run themselves
The moment the ticket is filed, the workflow starts a clock: locate filed, marks requested, window ends on a date. That date is computed and stored, and the countdown is visible on the job record—days remaining, visible on a glance. When the window closes on a job that is still active, the job's status flips on its own: clear to dig becomes stale ticket, and the stale state is exactly the state the crew is not allowed to dig in.
Renewals go out on a schedule, before the window closes
Days before the window ends, the workflow notifies the office: this active job's locate expires soon. The renewal reminder carries everything needed to act—job, address, remaining scope, ticket number, expiration date—so the renewal or the scope update is a five-minute task instead of a scramble. Renewals that have been confirmed get logged the same way the original ticket was, and the clock resets with the new window.
A no-locate flag escalates instead of hiding
When a locate comes back flagged—locator could not match the site, marks incomplete, description ambiguous—the flag takes a deliberate path: the job's dig-ready status is suspended, the office gets the flag with the ticket details, and a task is created to correct and re-file. The crew's go/no-go answer flips to no-go automatically. A manual operation buries that flag in a pile; the automated one refuses to let the crew arrive before the flag is cleared.
Crews get a go/no-go answer on their phones
On the morning of any dig, the crew opens the job on a phone and sees a single deliberate answer: locate current, marks on file, dig date within the window—go. Or: ticket expired on a date, renewal pending—no-go, hold the dig. That answer is computed from the ticket on the record, not from what anyone remembers. The crew never has to call the office to verify a ticket number, and the office never has to trust a coffee-cup number to clear them.
Scope and date changes trigger a re-check automatically
When a job's dig date moves or its scope grows—a fence project adds the neighbors' yard, a trench extends past the originally filed area—the workflow re-checks the ticket against the new facts: is the dig date still inside the window, and does the ticket's scope still cover the work? When either answer is no, the renewal-and-update path starts on its own, and the job holds its dig-ready state until the ticket matches the dig again.
A weekly compliance picture lands on a schedule
Each week, the workflow compiles the numbers that matter: active jobs with current locates, jobs digging this week and their ticket status, renewals completed, locates flagged and their clearance time, and jobs that were scheduled to dig without a current ticket—the list that should be empty. That report is the difference between a compliance program and a compliance intention, because it shows you the rate at which tickets are expiring under jobs instead of expiring on paper.
Building the Workflow Step by Step
What you need before you start
Three things: a source of truth for jobs (your scheduling system, project board, or even a structured job list), a capture form for ticket details, and a notification channel for the office and the crews. No proprietary software, no mapping platform unless you already have one—the one-call centers you file with stay exactly where they are, and the workflow watches what they produce.
Step 1: Add the dig gate to job intake
Create a single-screen intake addition: does this job break ground? If yes, require the locate fields before the job can be marked scheduled: state, filing date, ticket number, confirmation code, expiration date, and the scope description as filed. Every additional field should be a field a locator can act on, because the description on the ticket is the description the workflow re-checks against later scope changes.
Step 2: File the locate from job data
When a qualifying job is created, stage the filing: the address, site description, dig scope, and target dates pre-fill from the job record, so filing the locate is a review-and-submit rather than a retyping session. Capture the ticket number and confirmation code the moment the center returns them, and let those flow back onto the job record automatically.
Step 3: Start the clock and attach the evidence
On filing confirmation, compute the expiration date and store the full ticket package—number, code, dates, scope, state—on the job. Upload or link the confirmation page where your center provides one. The countdown becomes visible on the job from day one, which is what turns expiration from a surprise into a scheduled event.
Step 4: Build the renewal ladder
Schedule the expiration-aware sequence: a first renewal reminder several days before the window closes to the office and the project owner; a second reminder closer in if the first has not been acted on; and on expiry, an automatic flip of the job to stale-ticket with an immediate notification. Each reminder carries the ticket package so acting on it requires no lookup.
Step 5: Wire the no-locate escalation
Build the flag path: when a locate fails or a mark is incomplete, suspend dig-ready automatically, create the corrective task, and notify the office with the details. Add the second escalation the manual process always forgets: if a corrective task sits unworked past a cutoff, notify the project owner, because a flag that sits on a desk is a crew about to roll.
Step 6: Give the crew its go/no-go answer
Create the crew-facing status on the job: a single field the workflow computes—dig-clear or hold—based on ticket currency, flag status, and dig date inside the window. Make it visible where the crew already works, on the job screen they open in the morning. When the answer is hold, the workflow includes why: expired on a date, flag pending, window closing before the scheduled dig.
Step 7: Trigger re-checks on change
Schedule the change listeners: when a dig date moves or the scope description grows, re-check the ticket automatically and route the job into the renewal path when the ticket no longer matches the dig. Log every re-check so the weekly report can show how often moving jobs turned stale tickets into current ones.
Step 8: Deliver the weekly report and close the loop
Compile weekly: dig-clear rate, renewals completed on time, flags and their clearance times, and scheduled digs that had no current ticket. Share it with operations. Rising flags on one locator's area is a description-quality conversation; rising expiry-without-renewal is an office-load conversation; a clean no-ticket list is the sign the program is working.
The Rules That Make the System Trustworthy
A locate workflow is only as good as the facts on its tickets, and a few deliberate rules keep it honest.
The ticket on the record is the only ticket that counts
One ticket number per job, on the record, always current-state. When a ticket is superseded by a renewal, the old number is marked superseded on the same record rather than erased, so any question about what was filed and when has a complete history to answer from. A system that keeps one live number per job and a history underneath never confuses the crew with two answers.
Descriptions are written for the locator, not for the office
The site description stored on the job is the description the locator acts on, so it is written the way locators need it: what is being dug, where on the property, how deep, and near what. A description that says the back yard is not a description; a description that says the trench runs along the rear lot line from the alley to the patio is. The workflow makes that description a first-class field that travels with the job and re-checks against scope changes.
Expiry is a state, not a date
The job does not carry a date that someone must compare to today; it carries a computed state—current, expiring soon, stale, flagged, superseded. States flip on their own and drive their own notifications, which is what makes the system self-enforcing instead of self-reminding.
Common Mistakes to Avoid
Treating the locate as an office fact instead of a crew fact
Locates managed by the office but invisible to the crew recreate the truck console with extra steps. The crew-facing go/no-go status is the core deliverable, not a garnish; if the dig-clear answer is not on the screen the crew opens in the morning, the workflow has not shipped.
Filing the ticket after the schedule instead of before it
If locates are filed the week of the dig, the locator's backlog becomes the project's backlog, and crews dig on requests rather than on marks. The dig gate at intake exists precisely so that filing happens at job creation, when the buffer between request and dig is at its widest.
Letting scope changes skip the re-check
The most dangerous tickets are not the expired ones—those are loud—but the current ones that no longer match the work. A current ticket filed for a patio pour does not cover the fence line the customer added in a phone call. Every scope change must flow through the re-check, or the program quietly protects the digs it was filed for and none of the digs it actually runs.
Ignoring the private-utility half
Public locates are only half the picture: sprinkler lines, septic fields, private power to a shop, gas lines past the meter, invisible pools of prior work. A tracking program that treats a public-locate ticket as dig-clearance for the whole site teaches crews to trust marks that were never coming. Make the private-locate checklist a deliberate part of the job record where the site carries private lines.
Keeping the renewal ladder too gentle
A renewal reminder that arrives on time but sits unread is an expired ticket with a paper trail. The ladder must escalate—first the office, then the project owner, then a hold on the dig—and the hold must be real. Programs fail in month three when reminders become wallpaper; the escalation ladder is what keeps them from failing politely.
Forgetting subcontracted digs
Subcontractors break ground on your jobs and your responsibility. Give every subcontracted dig the same gate as your own crews: no current ticket on the job, no go. The cleanest way is to make the crew-facing status the answer the subcontractor checks before rolling, the same answer your own crews check.
How This Differs from Related Automations
Locate ticket tracking gets confused with several neighboring workflows. They are related but distinct.
- Permit Tracking Automation watches municipal approvals—permit applications, review follow-ups, inspections, close-out archives. Locate tracking watches one-call utility tickets and their windows. A job often carries both, and they share a platform but answer different regulators: the city says whether you may build; the locate says whether you may dig.
- Recurring Job Checklist Automation runs the same playbook on every visit—service steps, safety checks, departure tasks. A locate is not a recurring task; it is a per-job document with a clock, and it needs a document-tracker, not a routine-runner.
- Technician ETA Notifications solve the customer-facing arrival question before the crew shows up. Locate tracking solves the regulator-and-safety question before the excavator rolls. They bookend a dig: the ETA tells the customer when, the locate status tells the crew whether.
- Job Status Update Automation pushes progress messages to customers. It is communication; locate tracking is clearance and evidence. A status update says the trench is started; the locate record says the dig was authorized and within its window when it started.
- Daily Route Planning Automation decides the order crews work the day's jobs. Route planning is upstream of the dig; locate tracking is the gate the planned dig passes through on the way to the ground.
- Safety Incident Reporting Automation documents what happened when a job went wrong. Locate tracking is the discipline that keeps the worst incident in the business from happening in the first place; the two share a platform because both turn safety from memory into record.
In a mature excavation operation, intake, route planning, and locate tracking run as one stack, and locate tracking is the gate. It defends the business directly—every stale ticket it catches before the dig is a hit, a fine, an outage, or a lawsuit that never happened.
Edge Cases Worth Planning For
- Multi-phase projects that outlive their windows. A landscape project with five phases can span several locate windows. File the ticket to cover the whole scope when possible, and where the project genuinely outlasts the window, let the renewal ladder carry the phases rather than relying on a ticket that expired under phase two.
- Emergency and off-schedule digs. Storm damage, water breaks, and urgent repairs cannot always wait on standard windows. Build an emergency path into the workflow: the same ticket fields, the same clock, and a flag that makes the emergency visible to the weekly report so urgency never becomes the excuse for the missing record.
- Sites on state lines and multi-state work. Neighboring states run their own one-call centers with their own ticket formats and windows. Capture the state at filing and let the workflow store the package per state, because a contractor working three states is running three locate systems whether they meant to or not.
- White-lining and site prep. Marking the dig area in white paint before the locator arrives is ordinary practice, and it is exactly the kind of step that lives outside paperwork. Attach it as a step on the job: site prepped, dig area marked, ticket filed—the record shows the discipline, not just the ticket.
- Weather that moves the dig. Rain moves dig dates more reliably than any customer does. The date-change listener exists for this: when the schedule moves, the ticket re-checks, and the renewal path starts before the crew's next scheduled morning rather than after.
- Locator no-access and re-mark requests. Locked gates, dogs, and no-parking zones fail locates the way they fail crews. Give the job record a place for site access notes that travel with the filing, so the second locate does not fail for the same reason the first did.
Frequently Asked Questions
Does this replace calling the one-call center? No, and it does not need to. The one-call centers stay exactly where they are—the workflow files through them, watches what they produce, and tracks the ticket from request to expiry. What it replaces is the truck console of ticket numbers, the wall calendar of windows, and the memory that forgets the renewal.
How is this different from permit tracking? Permits are municipal approvals with review cycles and inspections; locates are utility tickets with windows and marks. A job usually needs both, and a mature operation tracks both on the same job record—but the locate carries the clock the crew actually digs on, which is why it gets its own workflow.
What happens when a locate is flagged and the crew is already scheduled? The workflow suspends the job's dig-clear status the moment the flag lands, notifies the office, and creates the corrective task. The crew's morning status shows hold with the reason, so nobody rolls on a flagged ticket by accident. The flag is also visible in the weekly report with its clearance time, so slow flags become a process conversation instead of a surprise.
Will crews actually check the status? Yes, when it is one deliberate answer on the screen they already open—dig-clear or hold—and the answer is computed rather than remembered. Frame it the way it works: the status protects the crew the same way it protects the business, because nobody wants to be the one holding the excavator when the ticket turns out to be stale.
Do I need special software or mapping tools? No. A structured job list, a capture form for the ticket fields, and the notification channels the office and crews already use are the whole requirement. The workflow tracks the tickets the centers produce; it does not need to draw the marks.
What about jobs where the customer wants to dig themselves? Give the same record the same discipline: the ticket fields, the clock, and the scope as filed. The customer's dig is still a dig on a site you know, and a tracked record is the difference between advising and hoping.
How long does it take to build this? With a no-code platform and your existing job list, most contractors have the core flow running within a day: the dig gate at intake, the ticket fields, the expiration clock, and the renewal reminders. The crew-facing status, the flag escalation, and the weekly report add a bit more. The gate and the clock alone prevent most of the damage on their own.
Is this worth it for a small operation? Small excavation businesses feel locate failures more, not less—one hit to a utility line can end the business, and a small team has no clerk to manage windows by hand anyway. A three-crew operation gets the same ticket discipline as a large one, and the setup cost is low because the workflow watches the tickets you were filing anyway.
The Bottom Line
The quiet genius of locate ticket tracking is that it changes nothing about how your crews dig. Same jobs, same excavators, same ground. It just adds one deliberate status at intake and one computed answer in the morning—a ticket attached to every dig, a clock watching every window—and in exchange, every job your business breaks ground on becomes a record instead of a memory.
You can build the core flow in a day with a no-code platform like Automate Anything—add the dig gate to intake, capture the ticket package, turn on the renewal ladder, and let the clocks watch themselves. Start with the jobs digging this week, catch your first expiring window before it expires, and expand from there.
Build your first automation at https://automateanythingsoftware.com