Dev.to AI 🤖 Ai 👁 0 📖 5 min read

5 AI Prompts Every Solo Freelancer Needs for Client Proposals and Onboarding

Most freelancers don't lose clients because the work is bad. They lose them in the two weeks around the work: the proposal that arrives three days late, the onboarding email that misses the one detail that mattered, the

Most freelancers don't lose clients because the work is bad. They lose them in the two weeks around the work: the proposal that arrives three days late, the onboarding email that misses the one detail that mattered, the scope that quietly doubles because nobody wrote down what "revisions" meant.

When you're a one-person business, that admin layer is your second job. It's also the part where AI actually earns its keep, because these are repetitive, high-stakes, text-heavy tasks with a known shape.

Below are five prompts I use as the template layer of a solo practice. They're written to be pasted into any capable model (ChatGPT, Claude, Gemini). Replace the bracketed parts with your own context, and keep the output in a file you own rather than in the chat window.

1. The discovery call compressor

You finish a call with a good feeling and no notes. Two days later you're reconstructing what they said from memory, and the proposal reflects your optimism rather than their words.

You are a business analyst helping a solo consultant turn a sales call
into a shared record of what was agreed.

Here are my raw notes from the call:
[PASTE NOTES OR TRANSCRIPT]

Produce:
1. A two-paragraph summary of the client's situation, in plain language.
2. "What they said they need" — 3-5 bullet points, using their vocabulary,
   not mine.
3. "What I think is actually blocking them" — 2-3 bullets, clearly marked
   as my interpretation, with the evidence from the notes.
4. Open questions that must be answered before I can quote a price.
5. Red flags: scope ambiguity, budget signals, decision-maker uncertainty.

Do not invent details. If a section has nothing to support it, write
"not enough information" instead of filling the gap.

That last instruction matters more than the rest. A model that invents a budget figure because the section looks empty is worse than no summary at all.

2. The proposal skeleton (with the price logic made explicit)

A proposal isn't a price list. It's a document that lets a non-expert decide whether you understand their problem.

Draft a project proposal for the client described below.

Client context: [DISCOVERY SUMMARY]
My service: [WHAT YOU DO, IN ONE SENTENCE]
My rate logic: [HOURLY / FIXED / RETAINER + WHY]
Comparable projects: [1-2 PAST PROJECTS AND WHAT THEY COST]

Structure:
1. Their situation in 3 sentences (their words, not mine).
2. What success looks like, stated as outcomes a client could check.
3. Scope: included, explicitly excluded, and what counts as a revision.
4. Two options — a core scope and a larger scope. Never more than two.
5. Timeline with client dependencies named ("waiting on brand assets"
   is a line item, not an excuse).
6. Price, payment schedule, and what happens if scope changes.
7. A single, concrete next step.

Tone: direct, no adjectives about my own excellence. Do not use the words
"passionate", "seamless", "cutting-edge", or "holistic".

The two-option structure is the useful part. Three options push the decision back onto the client. One option invites a yes/no on your price. Two options turn the conversation into "which one", which is a different and much easier question.

3. The onboarding packet generator

Onboarding is where trust is either confirmed or quietly lost. The freelancer who sends a single, complete email the day the contract is signed looks like an organisation. The one who sends four emails over a week asking for the same asset twice does not.

Build a client onboarding packet for a project starting on [DATE].

From the signed scope: [PASTE SCOPE]
Client's main contact: [NAME, ROLE]
How we'll work: [TOOLS, MEETING CADENCE, TIME ZONE]

Produce:
1. A welcome email (150 words max) that confirms the start date, names the
   one thing I need from them first, and sets the next checkpoint.
2. A checklist of everything I need from the client before kickoff,
   grouped by when it blocks me.
3. A short "how we work" page: response times, revision process, how
   changes get priced, where files live.
4. Three status-update templates (on track / waiting on you / at risk)
   that are honest without being alarming.

For each item, say whether it belongs in the first email or the shared doc,
and why.

Point 4 is the one most freelancers skip. Status updates that only get sent when something is wrong teach clients that hearing from you is bad news.

4. The scope-creep reply

The request arrives as a favour: "quick tweak", "one more version", "while you're in there". Answering it badly costs you either the margin or the relationship.

A client has asked for work outside the agreed scope:

Their message: [PASTE MESSAGE]
Signed scope, verbatim: [PASTE RELEVANT CLAUSE]
Our history: [ANY PREVIOUS FAVOURS / FLEXIBILITY]

Write three replies:
A. It's genuinely small — absorb it, and mention what it substitutes for.
B. It's small but recurring — absorb this one, set the boundary for next time.
C. It's real work — quote it as a change order with a price and a timeline impact.

Each reply: under 120 words, no apology padding, no passive-aggressive
tone, and it must leave the client feeling informed rather than corrected.
Then tell me which one you'd send and what in my history made you choose it.

5. The project close-out and referral ask

The best time to ask for the next piece of work is the week the last one landed well. Most of us are already three projects ahead and forget.

I'm closing out a project. Here's what happened: [OUTCOME, DELIVERABLES]

Write:
1. A close-out summary the client could forward to their boss without
   editing it.
2. A request for a testimonial that tells them exactly what to comment on
   (specific beats "great to work with").
3. One referral ask that is easy to say yes to — not "let me know if you
   know anyone", but a named type of person and a one-line intro.
4. A three-line note I can send in six weeks that reopens the conversation
   without pretending the project is still running.

A note on using these well

Three habits make the difference between these being useful and being generic output you still have to rewrite:

  • Feed it your own words. A prompt with an empty client context section produces a proposal for nobody.
  • Keep a library, not a chat history. Every output you improve should be saved back as a template. That's how a repeatable process forms.
  • Read it as your client would. If a sentence only makes sense to someone who already knows the project, it's not finished.

If you want these five in a single file with the client-facing templates that go with them — plus 47 more prompts I use for quotes, invoices, follow-ups, and project admin — they're collected here:

No subscription, no community to join. Just the files.

📰 Read the original article on Dev.to AI

Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.