A lot of freelance work in Thailand starts with a single line in a chat: "This one's ฿15,000." The client replies "sounds good, go ahead," and work begins the same afternoon. Nothing feels wrong about it — both sides agreed on a number. The trouble shows up on delivery day, when the real questions surface: how many revision rounds does that price include, what was the deposit supposed to be, and if the client walks away halfway through, does anything get refunded? None of that was ever written down, so there's nothing to point back to.
A freelance quotation isn't paperwork for its own sake. It's the document that locks in terms before the work starts — the one reference point both sides can reopen when their memory of the conversation starts to drift apart.
What a Quotation Actually Is, Versus a Price in Chat
A quotation is the document a freelancer sends before work begins, listing the deliverables, the price, the payment terms, and how long that price stays valid. What separates it from a number typed into a chat is structure: it has a document number, an issue date, an expiry date, and once the client confirms or signs it, it becomes something both sides can point to later as the actual agreement.
That difference matters most when something goes sideways. Chat history can vanish with a phone upgrade or a deleted thread. A quotation sent as a file or a link, sitting in a "confirmed" state, is far harder to argue with — and it doubles as a record freelancers can use when reasoning about their own cash flow, since it shows exactly what's pending and from whom.
What Belongs in a Quotation That Actually Holds Up
A working quotation doesn't need to be elaborate, but it needs these pieces:
- Line items, not one lump sum. Separate "logo concept plus two revision rounds" from "final files (AI, PNG, PDF)" so both sides agree on exactly what the price covers, item by item.
- Payment terms. Deposit percentage, the channel it's paid through (PromptPay, bank transfer), and when the remaining balance is due — before or after final files ship.
- An issue date and an expiry date. A quotation with no expiry is a quiet liability. A price set three months ago may no longer cover today's costs, but the client can still dig up the old email and confirm it as if nothing changed.
- A short scope summary. It doesn't need the full detail of a standalone scope-of-work document, but it needs enough to show what's included and what counts as an add-on billed separately.
- The number of revision rounds included in the price. This is one of the most common points of friction in Thai freelance work — the clearer the number on the quotation, the less room there is for an open-ended argument about "just one more round."
Why the Document Number Matters More Than It Seems
Solo freelancers tend to skip proper numbering, figuring a filename with a date is good enough. That works fine until there are a dozen active clients and a project that's been re-quoted three times — and now finding "the actual latest quotation for this client" eats up time it shouldn't.
The simplest system is year plus sequence: QT-2026-014. Every time the price changes, a revised quotation gets a suffix — QT-2026-014-R2 — so it's immediately clear this is the second revision, not the original. That numbering also pays off later, when freelancers need to trace back through what was quoted for income records, or when a client asks "wait, which price did we actually settle on?" — a question that comes up more often than expected once negotiation goes more than one round.
From Quotation to Invoice to Receipt
A quotation isn't the end of the document chain — it's the start of one. The client confirms the quotation, the freelancer issues an invoice built from the same line items, the client pays, and a receipt closes out the job.
The common failure point is retyping the invoice from scratch. Line items drift from the original quotation without anyone intending it — an add-on discussed verbally gets left off, or a price gets mistyped because someone was working from memory instead of the source document. The safer approach is a system where a confirmed quotation converts directly into an invoice, carrying over the line items, pricing, and terms as one unit. That removes the retyping step entirely, which matters most with corporate clients whose accounting departments cross-check every invoice against the original quote before approving payment.
Writing Quotations That Hold Up Under Negotiation
A few habits make quotations easier to negotiate and harder to dispute later:
- Always itemize prices. That lets a client negotiate by dropping specific line items rather than asking for a flat discount off the total, which eats into every part of the job equally whether it makes sense there or not.
- Pre-define out-of-scope work. State an hourly rate or a per-revision rate for anything beyond what's agreed, so there's no ad-hoc price negotiation mid-project with nothing to anchor it to.
- Cap validity at 15–30 days, especially for work with variable material or third-party costs. That keeps a slow-deciding client from locking in a price the freelancer can no longer actually deliver at.
- Always get written confirmation — a click-to-confirm in a system, a signature, or at minimum a saved message — before starting. That holds even for long-time repeat clients; verbal agreements are the ones that get misremembered first.
Choosing a Tool: Match It to the Size of the Work
Most freelancers start with a Word or Canva template, which genuinely works fine with a handful of clients. It's free and fully customizable. The tradeoff is that everything is manual — numbering, converting to an invoice, tracking whether a client has actually confirmed — all tracked by hand across separate files, which holds up until the client list grows and old quotations become hard to find.
Thai accounting platforms like FlowAccount or PEAK go further on the tax and bookkeeping side. They include built-in quotation tools that connect directly to tax invoicing, which is genuinely hard to replicate manually. Their tradeoff is that they're built for businesses that need full accounting functionality — which means a lot of solo freelancers end up paying for and navigating around features they never touch day to day.
A tool built specifically for freelancers, like MANA, focuses on the three-document workflow — quotation, invoice, receipt — as one connected chain, tied to the same project and client records already in the system. Compared to a free template, nothing gets retyped between documents. Compared to full accounting software, there's no unused accounting layer to learn. Confirmation status sits on the same screen as the project itself, so tracking one job doesn't mean switching between several apps.
None of these are strictly better in every case. A free template fits the early stage with few clients. Accounting software fits anyone who needs full tax coverage. A freelancer-specific system fits anyone trying to cut retyping and keep every project in one place. The right pick depends on which problem is actually costing time right now.
The Most Common Mistakes
- No expiry date, which means honoring an old price that no longer covers real costs once a client finally confirms.
- Quotation and invoice amounts don't match, from typing each one separately in a different file without cross-checking.
- No clear deposit terms, leaving no working capital to cover materials or subcontractors once the job is underway.
- Everything bundled into one total, which makes negotiation harder and leaves the client unsure what they're actually paying for — and neither side feels the outcome was fair.
The Bottom Line
A freelance quotation isn't a formality tacked on to look professional. It's the starting point of a document chain that prevents money disputes and scope disputes before work even begins. Proper numbering, an expiry date, and a direct path into an invoice mean freelancers stop having to remember what price they quoted to which client months ago. And when quotation, invoice, and receipt all live in one connected system — the way they do in MANA — nothing gets retyped and no old file needs tracking down.