Best Practice: Quotes, Tickets & Projects — Knowing the Difference
There's a well-known failure mode in MSP circles sometimes called a "projicket" — a genuine project crammed into a single service ticket because nobody paused to recognise it had outgrown one. The symptoms are familiar: an engineer quietly overloaded by work with no visible plan, a client with no sense of phases or milestones, and a PSA that shows one ticket sitting open for weeks with no structure explaining why. The reverse failure exists too, just less talked about — wrapping routine, well-understood work in full project ceremony it doesn't need, adding overhead that serves no one.
Getting this right matters because a ticket and a project aren't just different sizes of the same thing — they come with genuinely different tools: a ticket has an SLA clock and a single assignable owner; a project has phases, milestones, and staged billing. Using the wrong structure doesn't just feel awkward, it means the work is missing the scaffolding it actually needs.
This guide covers the general distinction first, since it's a judgement call every service organisation has to make for itself, then how MSP Pulse structures quotes, tickets, and projects to support that decision rather than make it for you.
1. What actually distinguishes a project from a ticket
The Project Management Institute defines a project as a temporary initiative in a unique context, undertaken to create value — the two words that matter are temporary (it has a defined end) and unique (it isn't the same repeatable work you've handled a hundred times before). A ticket, whether an incident or a service request, is by contrast something your process already knows how to handle — routine, bounded, and usually resolvable by one person without a formal plan.
| Ticket / service request | Project | |
|---|---|---|
| Nature of the work | Routine, well-understood, repeatable | Unique, requires planning before execution starts |
| Typical duration | Hours to a few days | Commonly weeks; rarely less than a day's work, rarely open-ended |
| Resources involved | Usually one engineer | Often multiple roles, sometimes multiple teams or departments |
| Structure | Status workflow (new → in progress → resolved) | Phases, milestones, a defined scope and end date |
| Governance | Handled within normal service desk process | Often needs sign-off, a budget, or change-management review |
| Billing | Usually a single, continuous model (T&M, included in a recurring agreement) | Often staged — a deposit, milestone-triggered charges, a fixed total |
| Risk if mishandled | Low — the process already absorbs the occasional miss | High — a project with no plan behind it is where cost and scope quietly run away |
None of these is individually decisive — a two-hour job touching three departments might still be a ticket; a single-engineer job stretching six weeks might still need project structure purely because of its duration. It's the combination that signals the shift, which is exactly why Section 2 recommends writing your own threshold down rather than relying on any one column in isolation.
2. Write the threshold down once — don't rely on instinct per request
Organisations that do this well tend to convert the fuzzy factors from Section 1's table into a small set of concrete numbers: a duration threshold (commonly "more than a day, but rarely more than a couple of weeks of work" for an MSP), a cost or hours threshold, and a resources threshold (more than one role or team involved). None of the specific numbers matter as much as having them written down and applied consistently — the same discipline recommended for priority matrices in the service desk guide.
Without a written threshold, the decision drifts to whoever happens to triage the request that day, and different people draw the line in different places — one engineer is comfortable absorbing a four-day job into a ticket, another would have flagged it as a project on day one. That inconsistency is invisible until a project-sized job that lived as a ticket runs into exactly the kind of scope creep or missed cost that formal project structure exists to prevent.
Beware of defaulting everything non-trivial into a project out of caution. Over-formalising routine work wastes real time on planning overhead a four-hour job doesn't need, and it trains the team to see project structure as bureaucracy rather than a tool that earns its keep on the work that actually needs it.
Revisit the threshold periodically, not just set it once and forget it. As your team or client base grows, what used to comfortably fit in a ticket may start routinely overflowing it — that's a signal the threshold itself needs revisiting, not that everyone's suddenly worse at triage.
3. How MSP Pulse structures the two
MSP Pulse gives projects real internal structure that a ticket deliberately doesn't have. A project breaks down into phases, phases contain tickets, and tickets contain tasks. Project work isn't a different kind of ticket: it's ordinary tickets given a parent structure, so the usual ticket tooling (status workflow, time logging, activity history) still applies without a parallel set of project-specific equivalents. Each project gets its own number (PRJ-0001, PRJ-0002 and so on), the same way tickets and quotes are numbered.
Every milestone belongs to a phase. On a project's Workflow tab, each phase is a single tile listing its tickets and its milestones together, with the phase's dates and a way to mark it complete. Phases are numbered by their position and can be reordered, and a phase can't be deleted while it still holds tickets or milestones, so you don't lose work by accident.
A milestone fires on a defined trigger. It can be marked reached by hand, or automatically when a ticket closes, when a phase completes, or when a linked quote is won. A milestone is either Open or Reached. Reaching one is what releases any billing event linked to it, which means a charge can be tied to a meaningful point in the work rather than an arbitrary date.
A project can also hold tasks that aren't tickets, such as a checklist item or a fixed-price piece of work, and its Planning tab holds the up-front plan: goals, scope, team, assumptions and risks.
Projects end by status, the same discipline applied to tickets elsewhere. A project is closed or cancelled, never deleted, and the list defaults to the active projects so a finished one doesn't clutter the view without losing its record.
4. When a quote becomes a project in MSP Pulse
A quote can stand alone, be attached to a ticket, or be attached to a project, and several quotes can attach to the same project. Winning a quote then seeds the work into whichever one it is attached to: labour tasks and products onto a ticket, or tasks and recurring items onto a project.
The ticket-or-project decision is made by a person when the quote is created, not worked out from its contents. MSP Pulse doesn't inspect a quote's size or complexity and choose for you, so your written threshold from Section 2 has to be applied at that moment by whoever is building quotes.
There are two ways in. From a ticket's Quote tab, a new quote is attached to that ticket. From a project's Quotes card (on its Finance tab), a new quote is attached to the project as it's created, and you can also link a quote that already exists. In both cases creating a quote opens a short dialog that collects the client, contact, title, validity, payment terms and billing agreement, and saving takes you to the quote itself. So the project needs to exist first; if the work turns out to be a project after the quote has gone out, create the project and link the quote to it.
A ticket that has outgrown itself can be moved under a project. On a project's Workflow tab you can create a new ticket inside a phase or link an existing one, which is how you rescue a projicket without starting again.
5. Billing and governance genuinely differ structurally, not just by convention
This isn't only a labelling difference. Project work gets billing and governance machinery a ticket doesn't, which is itself a reason to put genuinely project-sized work into a project rather than stretch a ticket to cover it.
Staged billing is tied to milestones. A quote's billing schedule can bill in pieces: a deposit up front, charges released when a milestone is reached, and a balance on completion. A deposit is credited back automatically on the final itemised invoice, so the client pays net. Deposits work on an ordinary ticket quote too, but milestone-triggered charges need a project to have milestones to trigger them.
A project is invoiced on its own. In Invoicing → Load pending a project appears as its own row and becomes its own invoice, instead of being folded into the client's combined invoice. Fixed-price project tasks bill on completion, hourly project work bills from the time logged, and anything a milestone has already billed is not billed twice.
The PO number follows the same order for both: ticket, then project, then agreement, most specific first, so a project's charges resolve to whichever PO actually governs them.
The practical takeaway: if you find yourself wanting staged payments, a sign-off point, or genuine phased delivery for a piece of work, that's a strong signal it belongs in a project, not a sign you need to bolt project-like billing onto a ticket by hand.
6. Keep the boundary honest over time
Watch for a ticket quietly becoming a projicket. A ticket that's accumulated many tasks, stretched across far more days than your threshold allows, or pulled in more than one role is showing the exact symptoms Section 1's table describes — the fix is recognising it and moving the work into proper project structure, not adding more tasks to the same ticket because it's already underway.
Watch for the opposite drift too — small requests dressed up as projects out of habit. If project overhead is being applied reflexively to work that would resolve fine as a ticket, that's worth noticing as its own kind of inefficiency, not a safer default.
Review the threshold itself periodically, the same discipline recommended throughout this guide series for agreements, catalogue items, and account codes — a line that made sense for a five-person team may not make sense at twenty, and the only way to know is to actually look rather than assume last year's rule still fits.
Pre-flight checklist for ticket vs project
- [ ] A written threshold exists (duration, cost, resources involved) — not left to individual instinct per request
- [ ] The threshold is applied when the quote is created, since MSP Pulse doesn't infer ticket vs project from a quote's contents
- [ ] Whoever builds quotes knows and applies the threshold consistently
- [ ] A ticket showing projicket symptoms (many tasks, stretching well past the duration threshold, multiple roles) gets moved under a project rather than absorbed further
- [ ] Routine work isn't being wrapped in project overhead out of habit
- [ ] Staged billing (deposit, milestones, balance) used where the work genuinely has phases, not forced onto a ticket that doesn't need it
- [ ] Each milestone sits in the right phase, with a trigger that matches how you actually sign the work off
- [ ] The threshold itself reviewed periodically as the team or client base grows