Quotes and Documents in Minutes, Not Hours

The concept: a template, not a blank page

The real lever isn't letting AI write a quote from scratch. It's giving the AI a good template plus the key facts, so it fills in rather than invents. Think of it like training a new assistant: you don't hand over a blank page and ask for a quote, you hand over your best approved example along with the facts of the case. That way your style stays intact, the legal soundness of your proven wording stays intact, and the AI only takes over what actually eats up time today: typing, phrasing, and pulling details together. The better the template, the less rework afterward. A human checks and approves, that stays the rule, not the exception.

The 60 second version

• Give AI a good template plus bullet points, not an open-ended task. Filling in beats inventing.
• Start with your three most common document types, one approved example each as a template.
• Build the template once, cleanly, with variables in [square brackets], then reuse it every time.
• Flag anything to double-check with [CHECK], especially prices, dates, and quantities. Nothing gets overlooked.
• Nothing leaves the building unchecked. A human approves it until the trust is earned.
• Measure the time before and after for one week. Without a number, it's just a gut feeling.
• Highly individual or legally sensitive documents stay manual work. AI drafts, the human is accountable.

Which document type pays off first? The readiness test

Before you build anything, sort your documents into categories. Not every document is equally suited to this, and starting with the wrong one costs you trust. Three tiers help with the selection. Rule of thumb: the more standardized and frequent a document is, the bigger the lever. The more individual and rare it is, the more it stays manual work.

• Tier 1, ready right away: highly recurring documents with a fixed structure and little variation. Order confirmations, appointment confirmations, standard quotes from a catalog, receipt confirmations. Here the lever is biggest and the risk is smallest.
• Tier 2, suitable with care: quotes with individual components, project descriptions, scope-of-work descriptions. AI drafts the skeleton, a human fills in the special cases and checks closely.
• Tier 3, manual work for now: contracts, legally sensitive letters, highly individual concepts, anything with liability risk. Here AI can at most research or proofread; the draft stays with the subject-matter expert.
• Selection tip: start with the most annoying document in Tier 1, not the most important one in Tier 2. A quick proof point is worth more than one big swing.

Phase 1: Finding the right three documents

Goal: know within ten minutes which three document types to tackle first. Don't pick the most important ones, pick the most frequent ones with a clear structure.

• List the five to eight document types your team writes regularly.
• Estimate roughly: how many times per week, how many minutes each? That becomes your later benchmark.
• Mark the three with the highest frequency times effort. That's where the biggest lever sits.
• Check each candidate: is there a fixed structure? Is there a good approved example? Low liability risk? Three yeses means a good starting point.

I want AI to pre-draft recurring documents in my business.
Here are the document types we write regularly, with rough frequency and effort: [list, e.g. quotes about 20 per week at 30 min each; order confirmations about 40 per week at 10 min each; ...].
Rate each type against three criteria:
1) fixed, recurring structure?
2) little individual variation?
3) low legal risk?
Give a short assessment for each, sort each type into Tier 1 (ready right away), Tier 2 (suitable with care), or Tier 3 (manual work for now), and recommend the three best candidates to start with, with reasoning.

Phase 2: Turning your best example into a clean template

This is the most important step, and the one most people skip. Don't pick just any document, pick your best approved example, and turn it into a template with clear placeholders. That way the AI knows exactly what to insert where later, and the fixed wording stays untouched.

• Find one approved, well-written document per type. Quality over quantity.
• Replace all case-specific details with variables in [square brackets], for example [customer name], [service], [quantity], [unit price], [delivery date].
• Leave anything that always stays the same exactly as it is: greeting, legal clauses, payment terms, closing.
• Flag the spots that always need checking with [CHECK], for example after every price and every date.
• Save the finished template in a fixed location. From now on it's your standard, not a one-off text.

I'll give you a finished, approved [document type, e.g. quote]. Turn it into a reusable template.
Steps:
1) Replace all case-specific details with placeholders in square brackets (e.g. [customer name], [service], [quantity], [unit price], [delivery date]).
2) Leave any text that always stays the same exactly as written (greeting, payment terms, legal clauses, closing).
3) Add the marker [CHECK] after every spot a human should always verify (prices, dates, quantities).
4) At the end, list all the placeholders I need to fill in.
Here is the document: [insert document].

Phase 3: Writing the fill-in brief (so AI fills in reliably)

Now you connect the template and the key facts. The brief is your instruction to the AI: use this template, insert these facts, invent nothing, flag anything uncertain. The clearer the boundaries, the less rework. Clarify beforehand where the key facts come from (email, CRM, note) and where the draft should go (folder, inbox).

• Give the AI the finished template and the key facts for the specific case.
• Explicitly forbid inventing numbers, prices, and dates. Anything missing gets flagged, not guessed.
• Set the tone and format: formal, direct address, concise, no hype.
• Define the approval point: present a draft with [CHECK] markers, send nothing without your approval.

Role: You are an assistant at our company.
Task: Fill in the following template for a specific case. Don't write freely, only insert the key facts into the template.
Template: [insert template with placeholders]
Key facts: [customer, service, scope, quantities, unit prices, delivery date, special notes]
Rules: Don't invent prices, numbers, dates, or terms. Anything missing from the key facts should be left as [MISSING: ...] and listed at the end instead of guessed. Don't change the template's fixed wording.
Tone: formal, direct address, concise, no filler phrases, no dashes.
Approval: Mark all prices, dates, and quantities with [CHECK]. Present only a draft, send nothing.
Format: the finished document plus a short bullet list of what I need to check or add.

Phase 4: Trial period and measurement

Two weeks on real cases decide whether the template approach sticks. Measure it properly, otherwise it stays a gut feeling. What matters isn't just the time saved but also the correction rate: how often did you have to fix something? That shows where the template or the brief is still too vague.

• Run 20 to 30 real cases through it; a human checks and approves each one.
• Log the time before and after, and how often you had to make corrections.
• Sharpen the template wherever the AI kept getting it wrong, not the brief first.
• After two weeks, decide based on the numbers: expand, refine, or drop it.

Measurement log for documents (two weeks):
Date | document type | case no. | time before (min) | time after including review (min) | had to correct? (yes/no) | what was wrong?
At the end, evaluate: average before, average after, minutes saved per document, correction rate in percent, most common reason for correction.
Decision per document type: expand / refine template / drop.

A worked example: quotes at a trades business

An electrical contractor with 25 employees writes quotes daily for recurring services: distribution boards, smart home packages, EV chargers. Until now, an employee opens an old quote, copies it, pulls together current prices, adjusts the wording, and checks it. Here's what the same process looks like with a template and AI, with the filled-in building blocks below:

• One-time setup: three quote templates built with variables (standard installation, smart home, EV charger), each based on an approved best-example quote.
• Start: the employee gathers the key facts from the customer conversation (service, quantity, materials, desired date).
• Step 1: they pick the matching template and give AI the key facts.
• Step 2: the AI fills in the template, marks prices and dates with [CHECK], and lists any missing details.
• Step 3: the employee checks prices against the current list, fills in special cases, and approves it.
• Before: about 30 minutes per quote. After: about 8 minutes of review. Example figures, measure with your own numbers during the pilot.

Role: You are an assistant at an electrical contracting business.
Task: Fill in the following quote template for a specific case without writing freely.
Template: [quote template with placeholders, e.g. [customer], [service], [quantity], [materials], [unit price], [delivery date]]
Key facts: Customer: the Miller family. Service: EV charger installation, 11 kW including connection. Quantity: 1. Materials: per standard kit. Desired date: week [X].
Rules: Don't invent prices or dates. Mark missing details as [MISSING: ...] and list them at the end. Don't change the template's fixed wording.
Approval: mark prices, quantities, and dates with [CHECK]. Present only a draft.
Format: the finished quote plus bullet points of what I need to check and add.

How to set it up (two paths, no developers needed)

You don't need developers to get started. Choose based on your systems and how far along you are.

• Path A (no technical setup, about 30 minutes): In ChatGPT (Projects) or Claude (Projects), create a project for each document type, store the fill-in brief as a standing instruction, and upload the template as a file. Paste in the key facts, review the draft. Ideal for proving it's worth doing.
• Path B (connected to your systems): Using n8n or Make, build a flow that pulls the key facts from a form or your CRM, calls the AI with the brief and template, and places the finished draft for approval in a folder or inbox. More setup work, but it runs on its own afterward.
• Recommendation: use Path A first to prove the case on three document types, then invest in Path B. That way you're not paying for setup on something that hasn't proven itself yet.

For advanced teams: from template to system

Once the template approach is running for three document types, a few techniques separate a one-off helper from a system that scales with you. Anyone with technical staff or a partner to work with should start here. These are the exact building blocks we use in our own workflows.

• Connecting to inbox and CRM: instead of copying key facts by hand, pull them directly from the quote inbox or the CRM. A new request triggers the draft, and the finished data (customer, service, address) comes from the system. The common standard for these connections is MCP (Model Context Protocol), or alternatively the APIs of your own tools.
• A template library with variables: keep all templates in one place, each with a clear list of its placeholders. That way you build the wording once, cleanly, and update it in one spot instead of in dozens of old documents. You update a price change exactly once.
• Fan out (preparing several documents in parallel): when a lot comes in at once (for example, ten order confirmations after a trade show), have a draft created in parallel for each case and present them all together for approval. You then review them in a batch instead of one by one.
• Approval workflow as a dial: decide per document type how much trust applies. Tier 1 documents (appointment confirmation) can go out after a quick visual check, Tier 2 documents (individual quote) need the full review. That way you expand automation in a controlled way instead of approving everything at once.
• A lasting measurement log: after the pilot, keep a lightweight measurement running (minutes saved, correction rate per document type). That shows which template needs sharpening and where the next document type is worth tackling.
• Versioned templates: keep track of when you last changed a template and why. For legally relevant wording (payment terms, right of withdrawal), that history is worth its weight in gold if someone asks which version applied.

Tools and costs (rough figures, as of 2026, check current pricing)

The process and the template come first, the tool comes second. Pick whatever connects to the documents and systems you already have. You can switch providers later more easily than you can fix a badly built template.

• ChatGPT Team: roughly 25 to 30 euros per user per month. Good for getting started via Projects with uploaded templates.
• Claude (Team): roughly 25 to 30 euros per user per month. Strong when the AI needs to work with longer templates and several files at once.
• Microsoft 365 Copilot: roughly 30 euros per user per month, closer to your Word and Outlook documents if you already use Microsoft 365.
• n8n or Make for Path B: fixed flows connecting to inbox, CRM, and storage. n8n self-hosted is free, cloud starts around 20 euros a month; Make starts around 9 euros a month.
• One tool is enough to start. Process first, then the tool.

A worked cost example

Example figures, replace with your own numbers during the pilot.

• 20 quotes per week.
• Before: 30 minutes. After: 8 minutes of review. That's 22 minutes saved per quote.
• 20 times 22 minutes is 440 minutes, roughly 7.3 hours per week, or a good 30 hours per month.
• Tool costs roughly 30 euros a month.
• Compare the hours saved against your internal hourly rate, and you'll see the lever in euros. A rough guide, not a promise. Measure one week with and without it.

The most common mistakes

• Starting without a template. Then the AI invents details and you end up correcting more than you save. Build the template first, then the draft.
• Sending drafts out unchecked. Prices, dates, and quantities especially always need review. AI drafts, the human is accountable.
• Trying too many document types at once. Three is enough to start. Expand after you've proven it works.
• Not measuring the benefit. Without a before-and-after number, any assessment stays a gut feeling.
• Using a weak template just because it was easy to grab. Use your best example, not the next-best one.

Frequently asked questions

• Do I need developers? Usually not to get started (Path A, templates inside an AI project). For connecting to your inbox and CRM (Path B), technical support helps.
• What does this actually cost? Tools start at roughly 25 to 30 euros per user per month, plus your setup time. The bigger cost is the care you put into building the templates, not the license.
• What if the AI inserts the wrong price? That's exactly what the [CHECK] marker and the ban on inventing numbers are for. Missing details get flagged as [MISSING: ...] rather than guessed. Nothing goes out unchecked.
• Will this hurt my style? The opposite: because the AI fills in your approved template, your style stays intact. You even standardize it, instead of every employee phrasing things differently.
• Is my data safe? With EU-hosted tools, a data processing agreement, and no training on your data: yes, with the usual diligence.

GDPR and the EU AI Act in one paragraph

Before you start, check whether the documents contain personal data (customer names, addresses, contract details). If so, you need EU-hosted tools, a data processing agreement, and assurance that your data isn't used for training. Don't paste sensitive data into free personal accounts. Further EU AI Act obligations kick in from December 2027; pre-drafting standard documents with human approval is, as a rule, only lightly affected by that, but document the purpose and the process anyway. When in doubt, loop in your data protection officer briefly. In the DACH region, thinking about this from the start rather than bolting it on later is an advantage.

When to skip this

Contracts, legally sensitive letters, highly individual concepts, and anything with real liability risk don't belong in this workflow first. Very rare documents also don't justify the effort of building a template. Here, the subject-matter expert stays faster and safer. The template approach pays off where volume and a fixed structure come together, in other words the many similar documents that eat up time today without requiring much thought.

Your 30 day start

• Week 1: choose three document types (readiness test), find one best example for each, and turn it into a template with variables.
• Week 2: set up Path A (a ChatGPT or Claude project per type), store the fill-in brief, test it on 5 real cases each, and sharpen the template.
• Week 3: trial period with the measurement log on 20 to 30 cases; a human approves each one.
• Week 4: evaluate the numbers (minutes saved, correction rate), decide per type (expand or drop), and if it worked, plan Path B for the strongest type.

Where this comes from

This playbook isn't based on theory, it's based on systems we run ourselves. We use this exact template approach, a good format plus the key facts instead of free-form writing, to prepare our own content and documents, including in the content hub that produces this report. Templates with variables, human approval, and an ongoing measurement log are part of our daily work. What's written here is something we built, measured, and sharpened on our own workflows. We don't just talk about AI, we put it to work ourselves.