ProposalCraft

Analyze a client brief BEFORE drafting. Extracts budget signals, timeline urgency, red flags, scope creep risks, and suggests clarifying questions to ask the client. Use this first when a brief is vague or the budget is unclear.

Write an end-of-year (or end-of-engagement-period) review email to a long-term client — what was delivered, the standout result, a reflection on the working relationship, and a forward-looking suggestion for the next period. Positions you as a strategic partner rather than a transactional vendor. Naturally opens the conversation for renewal or expansion without hard-selling. Does not count against your monthly draft limit.

Write a warm, non-desperate email to past clients announcing you have capacity opening up. Past clients are the highest-converting leads — this email re-activates relationships without cold-pitching. Under 120 words, one soft ask. Does not count against your monthly draft limit.

Write a short, warm email to past clients or contacts announcing that you have upcoming availability for new project work. One of the highest-ROI freelancer marketing moves: a brief, personal note to people who already know your work often surfaces a project within days. Gets the tone right: confident, not desperate — you're sharing news, not asking for a favour. Required: availability_window (e.g. 'from July 1', 'starting mid-August', 'a couple of slots opening next month'). Optional: recipient_name (personalises the opening), services_offered (what you're available for — defaults to your usual work), project_type (narrow the ask: 'short-term projects', 'ongoing retainers', 'one-off design work'), max_projects (e.g. '1 or 2 projects' — signals scarcity without pressure), cta (what you want them to do: 'reply if you have something in mind', 'forward this to someone who might need help' — defaults to reply), your_name. Does not count against your monthly draft limit.

Write the professional follow-up email to send after you didn't win a competitive bid or pitch. Keeps the relationship warm without sounding bitter, desperate, or entitled — the goal is one clear thing: staying on their radar for future work. Under 100 words body. Gracious, brief, no post-mortem. Distinct from cold_pitch_follow_up (no response to a cold pitch — this is when they actively told you they went with someone else), client_followup (chasing a proposal that hasn't been decided yet), and no_response_closure_email (closing a ghost). Does not count against your monthly draft limit. Required: client_name, project_description (e.g. 'the website redesign project', 'your Q3 social media campaign'). Optional: reason_if_known (what they told you — e.g. 'went with a larger agency', 'found someone with more industry experience'; used to tailor tone), future_work_angle (a specific type of work you'd like to be considered for — e.g. 'smaller copy projects', 'ongoing social content'), project_name, your_name.

Write a short email confirming your written understanding of a project brief before work begins. Sends a concise scope summary — what you'll deliver, what's excluded, timeline, price, and what you need from the client to start — and asks them to confirm or correct before you begin. Prevents scope disputes by creating written alignment upfront. Required: client_name, deliverables (comma-separated list of what you're delivering), total (your price or rate, e.g. '$2,400 fixed' or '$120/hr, ~20hrs'). Optional: project_name, out_of_scope (up to 3 items explicitly excluded — omit if nothing needs spelling out), timeline (overall project duration or deadline, e.g. '3 weeks' or 'delivered by July 15'), start_date, what_you_need (assets, access, or information you need from the client to start — e.g. 'brand guidelines and CMS login'), your_name. Workflow: receive brief → discovery_call_follow_up_email (recap) → brief_confirmation_email (written scope sign-off) → project_kickoff_email (start). Does not count against your monthly draft limit.

Write a professional email responding when a client's budget falls short of your quoted price. Three strategic routes: 'scope_reduction' (offer a trimmed version of the project at your full rate), 'hold_rate' (explain why the rate stands and decline to move on price), or 'middle_ground' (propose an adjusted arrangement — phased delivery, reduced scope with option to expand, or flexible payment terms). Keeps the relationship warm regardless of outcome. Distinct from discount_request_response (flat refusal), competitor_response_email (price comparison objection), and change_order_email (agreed additions). Does not count against your monthly draft limit. Required: client_name, your_quoted_price, client_budget, response_route. Optional: project_name, what_can_be_cut, middle_ground_offer, your_name.

When a client says your quote is too high, write a revised proposal offering a reduced scope at a lower price — not a rate cut. Helps freelancers hold their rate while giving the client a path forward. Counts against your monthly draft limit.

Write the email informing a client that the project will cost more than originally estimated — due to unforeseen technical complexity, third-party cost increases, or scope that proved harder than anticipated. This is distinct from scope_change_email (client requested extra work) and budget_proposal (client said your quote was too high): this is the honest update when your own estimate turns out to be off, and you need to raise the number before proceeding. Structure: clear statement of original vs. updated figure, a brief honest reason (one sentence — not an essay), and a question asking how they'd like to proceed before you go further. Tone: direct and professional, not grovelling or defensive. Most freelancers either absorb the cost silently or surprise clients with a higher invoice — this is the professional middle path that respects the client's budget and your rate. Does not count against your monthly draft limit.

Write a professional email to a prospect when you're fully booked but don't want to lose them. Parks them warmly — acknowledges their enquiry, explains you're at capacity, gives an availability window (if known), and offers first priority when your schedule opens. Most freelancers either decline (and lose the prospect for good) or go silent (worse). This is the professional middle path that creates a warm pipeline for your next available slot. Required: client_name. Optional: project_description (what they came to you about — makes the email feel specific rather than templated), available_from (when you'll next have capacity, e.g. 'mid-July', 'early Q4', 'end of August' — omit if uncertain), offer_priority_slot (default true — offers to confirm intent now so you can hold the slot when it opens), your_name. Distinct from client_decline_email (permanent no for fit/budget reasons) and reactivation_email (following up on a cold prospect). Does not count against your monthly draft limit.

Turn a completed project into a structured portfolio case study. Most freelancers know they should document their work but never do — this generates a complete outline (challenge, approach, results, learnings) ready to paste into your website, LinkedIn, or proposal as a credibility sample. Does not count against your monthly draft limit.

Write a professional change order document when a client requests work outside the original project scope. Clearly defines what was agreed, what is being added, the additional cost and timeline impact, and requires client sign-off before work begins. Protects you from scope creep. Does not count against your monthly draft limit.

Write a professional change order email that formally confirms additional work a client has requested — scope, cost, and timeline impact — and asks for written approval before you begin. Keeps the engagement clean: no ambiguity, no verbal agreements that get disputed later. Distinct from scope_creep_email (which pushes back on unwanted additions) — this is for AGREED extra work. Does not count against your monthly draft limit. Required: client_name, project_name, change_description, additional_cost. Optional: additional_timeline, impact_on_existing_work, approval_method, your_name.

Write the email requesting access to client systems, tools, platforms, or repositories needed to start or continue work. For when you need logins, permissions, API keys, or repository invitations from the client side. Three routes: initial_request (default — first-time ask for specific access required to kick off or progress the project; tone is clear and practical, lists exactly what's needed and why), follow_up (chasing outstanding access that was promised or discussed but hasn't arrived yet — tone is patient but firm, reiterates the blocker clearly), partial_workaround (you've found a temporary workaround but still need full access eventually — explains what you've done, what you still need, and the impact of the delay). Distinct from client_material_chase_email (chasing files or content, not system access) and project_restart_email (restarting stalled work after a break). Does not count against your monthly draft limit. Required: client_name, access_needed (what you need — e.g. 'admin access to the WordPress dashboard', 'an invitation to the GitHub repo', 'read access to Google Analytics'). Optional: project_name, access_reason (why you need it — e.g. 'to set up the staging environment', 'to start the content migration'), workaround_description (for partial_workaround route — what you've done in the interim), deadline (when you need access by — e.g. 'by end of week', 'before Thursday's call'), route ('initial_request' | 'follow_up' | 'partial_workaround' — default initial_request), your_name.

Write a short, warm email marking the anniversary of working with a long-term client — 1 year, 2 years, or any meaningful milestone. Different from annual_review_email (which summarises deliverables and results in a structured retrospective) — this is the relationship-first touchpoint that makes a client feel like a long-term partner, not a transaction. No deliverables list, no pitch, no ask. Just a genuine acknowledgment of the working relationship and a light forward-looking line. Under 100 words. The goal is to be memorable and human, not to upsell — though it naturally positions you top-of-mind when their next need arises. Required: client_name, milestone (e.g. '1 year', '2 years', '18 months'). Optional: project_or_relationship (what you've worked on together — a named project or 'our work together' — makes the milestone feel specific), standout_moment (one specific thing from the relationship worth acknowledging — a result, a challenge you solved, a moment that stood out), forward_line (a single sentence looking ahead — what you're looking forward to, or an open door for what comes next), your_name. Does not count against your monthly draft limit.

Generate a structured client brief questionnaire to send to a new or prospective client before starting work. Prevents scope creep and 'bad brief' problems by collecting project goals, timeline, budget, stakeholders, and success criteria upfront. Use this at the very start of an engagement — before drafting a proposal or setting a price. Does not count against your monthly draft limit. Optional: project_type (e.g. 'website redesign', 'brand identity', 'copywriting project'), client_name, your_name, include_budget_question (defaults true), format ('email' to embed in a covering email, 'doc' for a standalone questionnaire to paste into a shared doc).

Write a short proactive check-in email during a long project — the 'just wanted you to know things are on track' message that prevents client anxiety and the 'where are we with this?' interruption. Under 100 words. Different from project_status_update (which is a full structured weekly report): this is a light, warm pulse sent mid-phase to maintain trust during silent execution periods. Does not count against your monthly draft limit.

Write a professional email responding to a client complaint or serious dissatisfaction — distinct from creative feedback on deliverables. This is for relationship-level issues: missed expectations, process frustrations, quality concerns, or a client who is genuinely upset. The hardest email to write under pressure — most freelancers either over-apologise (which signals guilt and invites further demands) or get defensive (which escalates). Three routes: acknowledge (own what's warranted, propose a concrete fix — the default for most complaints), dispute (professionally push back on a complaint you don't agree is fair, without burning the relationship), resolve (follow-up once the issue has been addressed, closing the loop and resetting the tone). Required: client_name, complaint_summary. Optional: project_name, what_went_wrong (for acknowledge), proposed_fix, your_response (for dispute — your position in 1-2 sentences), resolution_summary (for resolve), route, your_name. Does not count against your monthly draft limit.

Write a professional email declining a client project inquiry — when you can't or shouldn't take the work. Covers four common situations: capacity (you're fully booked), not_fit (the project isn't the right match for your skills or style), timing (wrong timing — project start doesn't align), or budget (their budget doesn't meet your rates). Warm and respectful throughout: preserves the relationship, never burns a bridge. Optionally offers to refer them to someone better suited — turning a decline into goodwill. Most freelancers either ghost prospects or write awkward excuses; this is the professional middle path that keeps the door open for future work. Does not count against your monthly draft limit.

Write the professional reply to critical or negative mid-project feedback from a client. Three response modes: 'accept' (default — feedback is valid, you acknowledge it and state your action plan), 'clarify' (there's a misunderstanding that needs resolving before you can act — asks one focused clarifying question without being defensive), 'discuss' (feedback is complex or directional enough that a call is needed to align properly). Distinct from revision_response_email (specific change requests like 'change the font' or 'rewrite section 2') — this is for qualitative, directional, or emotional feedback ('this doesn't feel right', 'I'm disappointed with the direction', 'this isn't what I was expecting'). Most freelancers either get defensive, over-apologise, or go silent — this is the professional middle path: acknowledges the concern, shows you heard them, and keeps the project moving forward. Does not count against your monthly draft limit.

Write a follow-up message for a proposal that hasn't received a response. Generates a short, non-pushy follow-up that reopens the conversation without sounding desperate. Provide the original proposal summary and how long it's been since you sent it.

Write a professional email chasing a client for overdue materials, content, or approvals needed to continue the project. Used when the client hasn't delivered what they committed to — content, feedback, access, sign-off — and the delay is blocking your work. Calibrates tone based on how overdue they are: friendly (1–5 days), firm (6–14 days), or escalation (15+ days). Makes the impact clear without blame. Distinct from project_delay_warning (when YOU are delayed), payment_reminder_email (financial), and third_party_delay_email (external vendor delay). Does not count against your monthly draft limit.

Write a structured end-of-engagement email that doubles as a practical handover checklist. Sent at project close or retainer end — covers what was completed, assets being transferred, outstanding actions for both sides, and any system access being revoked. Protects both parties by ensuring nothing falls through the cracks. Distinct from client_offboarding_email (which ends a relationship you chose to leave) and project_closure_email (a natural project wrap-up email) — this is the operational handover document with explicit action items and a checklist format. Does not count against your monthly draft limit.

Write a gracious, professional email ending an ongoing client relationship — a retainer, a long-term engagement, or a repeat working arrangement. Distinct from project_closure_email (a project that completed naturally) — this is for when you are choosing to end the relationship. The hardest email a freelancer has to write. Gets the tone right: clear and firm without blame, warm without being dishonest, and structured to preserve the relationship for future referrals. Does not count against your monthly draft limit.

Generate a tailored list of everything you need from a client before work can start — access, assets, decisions, approvals. Adapt by project type so the client knows exactly what to send and in what order. Send this after the kickoff email, before starting work. Does not count against your monthly draft limit.

Ask a trusted past client to be a named reference for a specific prospect — someone the prospect can email or call directly. Different from testimonial_request (written quote for your website), recommendation_request_email (LinkedIn), and referral_request (active warm intro). A reference is a person on your reference list who speaks directly to a prospect doing due diligence. This email makes the ask easy: it gives context on the prospect, sets expectations on time commitment, and makes it simple to say yes or no. Does not count against your monthly draft limit.

Write the professional email to send after completing a project — asks the client for feedback and, optionally, a short testimonial. Warm, brief, and non-pushy: makes it easy for a happy client to say yes, and easy for a less-satisfied client to share honest feedback without awkwardness. Distinct from bid_lost_follow_up (you didn't win the work), referral_thank_you (thanking someone who sent a referral), and cold_pitch_follow_up (no response to a pitch) — this is specifically the post-delivery check-in with a client you just delivered work to. Does not count against your monthly draft limit. Required: client_name, project_name. Optional: survey_link (URL to a feedback form — omit to ask directly in the reply), testimonial_ask (if true, adds a short sentence asking for a one or two line testimonial they're happy for you to quote), outcome_note (one sentence on the outcome you delivered, e.g. 'the site went live on schedule' — personalises the email), your_name.

Write a professional email to a client who hasn't delivered what they promised — assets, feedback, sign-off, content — and the project is blocked waiting on them. Keeps the tone factual and non-accusatory: the goal is to get what you need, not to assign blame. Does not count against your monthly draft limit.

Write a cold outbound pitch email to a potential client you've identified but who hasn't contacted you. Different from inbound proposal work — this is proactive business development. Short, specific, and ends with a single easy ask. Does not count against your monthly draft limit.

Write a short, professional follow-up when a cold pitch has gone unanswered. Shorter than the original pitch — brevity signals confidence. Doesn't repeat everything; just resurfaces the key hook, gives an easy out, and asks for one yes/no. Distinct from client_followup (which is for post-proposal follow-up after a prospect showed interest) and win_back_email (re-engaging a lapsed client). This is for genuine cold silence — they never replied at all. Does not count against your monthly draft limit.

Write a professional reply when a client tells you another provider quoted lower — or asks you to match a competitor's price. Three response modes: hold_rate (default — acknowledge the comparison, clarify what differentiates your work, hold your price without apologising or justifying at length; best when your rate reflects genuine experience and scope), adjust_scope (offer a reduced scope or phased approach that delivers real value at a lower price — not a discount, a trade; best when there's genuine flexibility in what's needed), or match_with_context (match or approach the price but anchor it clearly to a specific reason — limited capacity window, long-term relationship, or strategic fit; do not use just to close a deal). None of these modes cave, get defensive, or lecture the client about what they're 'really getting'. All three respect that the client is comparing options. Required: client_name. Optional: competitor_name (who they're comparing to — omit to keep vague), competitor_price (the competing quote), your_price (your quoted price), project_name, response_mode ('hold_rate', 'adjust_scope', 'match_with_context' — default hold_rate), differentiator (the one concrete thing that separates your work — e.g. 'previous work on similar-scale projects', 'full ownership of the project without handoffs', 'I already know your brand well'; omit for a clean close without specifics), your_name. Does not count against your monthly draft limit.

Write the email responding when a client says 'yes, but...' — they want to proceed with your proposal but are asking for a change: a lower price, a trimmed scope, a later start, phased payments, or a shorter contract. This is a distinct, high-stakes moment in the sales cycle — the client has chosen you, so the relationship risk is low, but the commercial terms are still live. Three routes: accept (agree to their condition and confirm the modified deal — use when the adjustment is workable and the project is worth taking), counter (propose your own modified terms as a middle ground — use when their ask is too steep but a partial adjustment is acceptable), hold (explain you can't move on this and offer the original terms or a graceful exit — use when the condition would make the project unprofitable or set a bad precedent). Distinct from discount_request_response (where the client hasn't committed), budget_negotiation_email (where budget was the blocker before agreement), and price_objection_response_email (where the client is objecting to the price without accepting). Does not count against your monthly draft limit. Required: client_name, condition_requested (what they've asked to change — e.g. 'reduce the fee by 15%', 'delay the start by six weeks', 'remove the discovery phase and go straight to design'). Optional: project_name, counter_offer (for counter route — your proposed middle ground, e.g. '10% reduction if they pay in full upfront', 'start in three weeks rather than six'), route ('accept' | 'counter' | 'hold' — default accept), your_name.

Write a speaker submission for a conference, meetup, or podcast — a talk abstract, key takeaways, and speaker bio formatted for a CFP (Call for Proposals). Public speaking is the highest-authority marketing move a freelancer can make. Most people don't do it because the CFP process feels opaque. This generates a submission-ready pitch. Does not count against your monthly draft limit.

Write a professional email proposing to renew a contract, retainer, or ongoing engagement with a client. Warm but businesslike — references the work done together, proposes renewal terms, and invites a conversation. Does not count against your monthly draft limit.

Write the short covering email sent when sharing a contract or agreement for a client to sign. Tells the client what they're signing, where to find it, when you need it back, and what happens next. Distinct from contract_template (the contract document itself) — this is the email that wraps around it. Does not count against your monthly draft limit.

Generate a plain-English Freelance Services Agreement — the full working contract covering services, payment, IP, revisions, termination, and liability. More comprehensive than an NDA (which covers only confidentiality) and more legally framed than a SOW (which covers deliverables). Suitable for most standard freelance and consulting engagements. Does not count against your monthly draft limit.

Write a short, professional follow-up when a client has agreed to move forward but hasn't returned the signed contract yet. The hardest follow-up to write because it feels pushy — but staying silent stalls the project, leaves income at risk, and signals that unsigned contracts are fine. Distinct from cold_pitch_follow_up (they never replied at all), client_followup (following up on a proposal they haven't approved yet), and no_response_closure_email (closing out a ghost). This is after the handshake: they said yes, you sent the contract, now it's sitting unsigned. Under 100 words. Matter-of-fact, no guilt, gives them an easy out if something has changed. Does not count against your monthly draft limit.

Write the short covering email to send alongside an NDA (Non-Disclosure Agreement) to a client or subcontractor. Explains why you're sending the document, what it covers, and what to do with it — without being heavy or legalistic. Distinct from nda_template (which generates the NDA itself) and subcontractor_brief (which briefs a subcontractor on the work). Does not count against your monthly draft limit. Required: recipient_name. Optional: project_description (brief note on the project the NDA covers), relationship ('client' or 'subcontractor' — defaults to 'client'), signing_method (how they should return the signed copy, e.g. 'DocuSign', 'reply with a signed PDF', 'HelloSign'), your_name.

Remove a saved proposal from your reference library

Write the email asking a client to formally sign off on completed deliverables before you close the project or send the final invoice. The email most freelancers skip — and then spend weeks chasing verbal approvals that were never properly captured. Confirms exactly what was delivered, sets a clear review window, and requests explicit written approval. Keeps the tone collaborative, not administrative. Distinct from milestone_delivered_email (mid-project delivery update), project_closure_email (final wrap-up after sign-off is received), and project_completion_email (marks the end of work). This is the bridge between 'I'm done' and 'it's officially accepted'. Does not count against your monthly draft limit. Required: client_name, project_name, what_was_delivered. Optional: review_deadline (e.g. 'by Friday 20 June', 'within 3 business days' — defaults to a 5-business-day window), next_step (what happens after sign-off, e.g. 'I'll send the final invoice', 'I'll hand over the source files', 'the project is complete' — defaults to final invoice), approval_method (e.g. 'reply to this email', 'click Approve in the shared doc', 'sign the attached form' — defaults to replying to the email), your_name.

Write the email requesting a project deposit before work begins. Deposits are standard professional practice — this email is confident and clear, not apologetic. Fills the gap between signing the contract/SOW and starting work. Works for any deposit amount or percentage. Does not count against your monthly draft limit.

Write a response when a client asks for a lower price. Caving too easily devalues your work; being defensive loses the deal. This generates a firm, warm reply in one of three modes: hold the rate (with reasoning), offer scope reduction instead, or offer payment terms instead. Protects your rate without burning the relationship. Does not count against your monthly draft limit.

Write the short follow-up email sent within 24 hours of a discovery call with a new prospect. Fills the critical workflow gap: meeting_request_email → [call happens] → discovery_call_follow_up_email → draft_proposal. Distinct from project_kickoff_email (sent after signing, not after an intro call) and meeting_request_email (schedules the call — this follows it). Structure: warm one-line open, brief summary of the 2–3 key things discussed (confirms you were listening and reduces 'what did we actually agree?' friction), confirmed next step with a date if available, and a low-pressure 'let me know if I've missed anything' close. Under 150 words. The email most freelancers skip — which is why sending it immediately differentiates you. Does not count against your monthly draft limit.

Write the email to a prospect who booked a discovery call and didn't show up. One of the most common and awkward freelancer situations — you cleared the time, they ghosted, and now you have to decide how to handle it. Gets the tone right: not passive-aggressive, not a pushover, not grovelling. First no-show: assumes good faith (tech issues, genuine emergency) and offers a single, low-friction reschedule. Second no-show: politely closes the door while leaving it ajar if they ever do want to proceed. Distinct from meeting_cancellation_email (you cancel), meeting_postponement_email (you postpone), and cold_pitch_follow_up (prospecting). Does not count against your monthly draft limit. Required: client_name. Optional: call_time (e.g. 'today at 2pm', 'Monday at 10am') — adds specificity, no_show_count (1 or 2 — defaults to 1 for first no-show, 2 gives the close-out version), reschedule_link (e.g. 'my Calendly link', 'cal.com/yourname' — defaults to replying to the email), your_name.

Prepare for a discovery call with a potential client. Given a brief, generates sharp questions to ask (budget, timeline, decision-maker, success criteria, pain points), a short call agenda, and the 2-3 things you must confirm before committing to a proposal. Use between analyze_brief and draft_proposal. Does not count against your monthly draft limit.

Generate a complete, ready-to-send professional invoice document in Markdown format. Produces the actual invoice (not a cover email or reminder) with a professional header, itemised line items, subtotal, optional tax line, and total due. Ideal for converting an accepted proposal into a billable document. Distinct from invoice_cover_email (the email you send alongside the invoice), invoice_reminder (chasing a late payment), and payment_plan_proposal (offering instalments). The output is Markdown — paste into your invoicing tool, convert to PDF, or send as a formatted email. Required: client_name, your_name, line_items (array of work items). Optional: invoice_number, invoice_date, due_date, tax_rate, payment_instructions, currency, your_business_name, client_company.

Draft a new client proposal based on a brief. Uses your saved winning proposals as style/voice references. Returns a ready-to-send proposal. Free plan: 5 drafts/month. Upgrade for unlimited.

Write the email when your work is ready ahead of the agreed deadline — the email most freelancers mishandle by either sitting on finished work until the deadline (wasted goodwill) or sending with no context (client doesn't know what to do with it). This generates a confident, warm note that announces early delivery, frames it positively, and gives the client a clear next step. Two routes: full_delivery (default — everything is done and ready; confident announcement with handover details and a brief note on what you'd like from them next), early_preview (a first draft or near-complete version is ready before expected — inviting early feedback so you can finalise faster; useful for iterative projects). Distinct from project_completion_email (delivery at the expected time), project_handover_email (operational asset handover with checklist), and milestone_approval_request_email (mid-project sign-off gate). Does not count against your monthly draft limit. Required: client_name, deliverables (what you're sending — e.g. 'the homepage design', 'the three proposal templates', 'the full copy deck'). Optional: project_name, original_deadline (the date they were expecting it — makes the earliness concrete, e.g. 'Friday 27 June', 'end of next week'), feedback_window (how long you can accommodate revisions on your current schedule, e.g. 'the next few days', 'this week' — omit to keep it open), route ('full_delivery' | 'early_preview' — default full_delivery), your_name.

Write a professional email to end an existing client relationship or retainer. Three modes: natural_end (the engagement has run its course — use when the project is done and you're not renewing; warm, leave the door open for future work), capacity (you genuinely don't have room to continue — honest, no blame, brief), fit_mismatch (the working relationship isn't working — handled carefully; professional and final without being cold or over-explaining). Most freelancers write these too apologetically (which reads as uncertain) or too abruptly (which burns the bridge). This tool finds the professional middle: clear, direct, warm where appropriate. Required: client_name. Optional: engagement_description (what you've been doing together — e.g. 'the monthly retainer', 'the content work', 'the design contract'), end_date (when the engagement ends — e.g. 'end of this month', 'June 30', 'after the current milestone'), reason (natural_end | capacity | fit_mismatch — defaults to natural_end), handover_note (optional: what you're doing to wrap up or help them transition — e.g. 'I'll deliver the final files by Friday', 'happy to brief a replacement'), your_name. Does not count against your monthly draft limit.

Write a professional, considered response when a client proposes paying you in equity, exposure, revenue share, or deferred payment instead of (or alongside) a cash fee. The hardest part of this email is saying no without burning the relationship — or saying yes with the right conditions. Three modes: decline (default — polite, firm, no-door-slamming; explains your policy without moralising), counter (you're open to it under specific conditions — e.g. partial cash + equity, milestone-based deferred, or a minimum cash floor), and open_to_discuss (you'd like to hear more before committing either way — useful when the offer might be genuinely interesting but you need more information). Distinct from discount_request_response (which handles cash price negotiation). Does not count against your monthly draft limit. Required: client_name, proposal_type (e.g. 'equity stake', 'revenue share', 'deferred payment after launch', 'exposure and portfolio work'). Optional: response_mode (decline | counter | open_to_discuss), project_description, your_conditions (only used in counter mode — what would make you say yes, e.g. '50% cash upfront and 5% equity'), your_name.

Write the email you send when you discover mid-project that the work is going to cost more or take longer than your original estimate — through no fault of the client (you under-estimated, the work turned out to be more complex, or hidden dependencies emerged). Distinct from change_order_email (which covers client-requested additions), scope_creep_email (which calls out the client adding work), and project_delay_notification_email (which covers timeline slippage without a cost impact). Three routes: revised_estimate (default — disclose the gap, explain why, present the new number, ask for a go-ahead before continuing; best when the overage is significant and you need client approval to proceed), propose_split (offer to complete the current agreed scope at the original price and quote the additional complexity as a separate phase 2; best when the new work is genuinely separable and you can deliver something useful at the original budget), absorb (you'll eat the extra cost this time — be transparent that you're doing so and why, and set expectations for future estimates; best for small overages on long-term client relationships). Required: client_name, original_estimate (what you originally quoted — e.g. '$3,000', '2 weeks', '$3,000 / 2 weeks'), overrun_reason (what you discovered that changed the picture — be specific). Optional: revised_estimate (the new number or timeline — e.g. '$4,500', '3.5 weeks'), project_name, route ('revised_estimate' | 'propose_split' | 'absorb' — default revised_estimate), your_name. Does not count against your monthly draft limit.

Write the professional email requesting reimbursement from a client for project expenses you have incurred on their behalf — stock images, fonts, software licences, hosting, printing, materials, travel. Required: client_name, expense_description (what you bought and why it was needed), amount. Optional: project_name, receipt_note (e.g. 'I have attached the receipt'), add_to_next_invoice (default false — if true, frames this as a heads-up addition to the next invoice rather than a standalone request), payment_instructions (e.g. 'via your usual payment portal', 'by bank transfer to the details on my invoice'), your_name. Distinct from budget_update_email (cost overrun from increased project scope or time) and invoice_cover_email (billing for your own labour). Does not count against your monthly draft limit.

Write a short, genuine email asking a client for private feedback after a project — not a public testimonial, just honest input to help you improve. Clients who are asked for feedback feel valued; you get patterns you'd never discover otherwise. Distinct from testimonial_request (which asks for a public review for marketing purposes). Does not count against your monthly draft limit.

Read the full content of a saved proposal by filename. Use list_proposals first to see available filenames.

Write a cold pitch email to a blog, newsletter, or publication asking to contribute a guest article. Guest posts build SEO authority, earn backlinks, and put your name in front of an established audience — but most pitches are rejected because they lead with the writer's ego, not the editor's interests. This generates a reader-first pitch that opens with a concrete article angle tailored to the publication's audience, briefly establishes your credibility, and ends with a frictionless ask. Distinct from podcast_pitch_email (audio appearances), conference_talk_pitch (in-person speaking), and cold_pitch (client sales). Does not count against your monthly draft limit.

Review a proposal draft and get specific, actionable improvements. Surfaces weak sections, unclear pricing, vague scope, and missed persuasion opportunities. Run after draft_proposal or on any proposal you're about to send. Does not count against your monthly draft limit.

Write the reply-all when a mutual contact introduces you to a potential client over email. A specific, high-stakes email: the introducer is on CC, so you need to acknowledge them briefly while making a strong direct impression on the prospect — all in under 120 words. Fills the workflow gap between a referral and the discovery call. Does not count against your monthly draft limit.

Write the professional email to send a client when you need to correct an invoice you already sent — wrong amount, wrong line item, wrong date, or a missing item. Brief apology (one line — not grovelling), clear instruction to disregard the original, and the corrected details. Gets this right where most freelancers fumble: either they don't send anything (client pays the wrong amount) or they send a confusing email that makes the situation worse. Distinct from invoice_dispute_response_email (the client disputes your invoice — this is when YOU caught the error) and invoice_cover_email (first send of a new invoice). Does not count against your monthly draft limit. Required: client_name, original_invoice_number, corrected_invoice_number, correction_description (e.g. 'the total was listed as $1,200 instead of $1,450 due to a line item error'). Optional: correct_amount, project_name, payment_due_date, payment_link, your_name.

Write the short professional email that accompanies a sent invoice. Most freelancers attach invoices to a blank or one-line email — this tool generates the cover email that frames the invoice, states the amount and due date, and gives the client a clear next step. Under 80 words. Does not count against your monthly draft limit.

Write the professional reply when a client disputes or questions a charge on an invoice — 'I thought this was included', 'We agreed on a lower price', 'I don't recognise this line item'. Three response modes: 'explain' (default — the charge is valid and correct, explain clearly and calmly why), 'adjust' (you'll credit or reduce the invoice as a goodwill gesture or because of a genuine error), 'clarify' (you need more information from them before you can respond fully). Distinct from late_payment_reminder (client hasn't paid but hasn't disputed), budget_update_email (you're informing of a cost increase before invoicing), and scope_change_email (formal change order for extra work) — this is the specific situation where a client has received your invoice and is pushing back on a line item. Professional, calm, not defensive — resolves the dispute without damaging the relationship. Does not count against your monthly draft limit.

Write a polite but firm reminder for an overdue or unpaid invoice. Generates the right tone for the reminder number — first reminder is friendly and assumes an oversight, second is firmer, third adds urgency. Does not count against your monthly draft limit.

Write a professional email when you are going to miss a deadline or are already late. Takes ownership without over-apologising, gives a clear revised timeline, and keeps the client's trust intact. The tone is direct and accountable — no excuses, no grovelling. Does not count against your monthly draft limit.

Write the email confirming receipt of client materials or feedback that arrived after the agreed deadline, and formally noting the revised delivery timeline as a result. Sends an email that (a) confirms what arrived and when, (b) briefly and professionally notes the impact without accusing the client, (c) states the revised delivery date, and (d) keeps the relationship warm. This is the email that protects your timeline while avoiding confrontation — most freelancers skip it and then get blamed for the delay, or send something that reads as passive-aggressive. Distinct from client_material_chase_email (chasing materials you haven't received yet) and project_delay_notification_email (your own delay — not client-caused). Three routes: brief (default — short professional note, minimal friction, just sets the new expectation), significant_impact (major delay needing a substantial timeline revision — more formal, important for contract protection), repeated (materials are late for the second or more time — firmer tone while still professional, makes clear the pattern affects deadlines). Does not count against your monthly draft limit. Required: client_name, materials_received (what arrived — e.g. 'your brand guidelines and copy'), original_deadline (when materials were due — e.g. 'Monday 16 June'), revised_delivery_date (your new delivery date — e.g. 'Wednesday 25 June'). Optional: project_name, route ('brief' | 'significant_impact' | 'repeated' — default brief), your_name.

Write a professional email escalating an unpaid invoice to a senior contact, the client's finance team, or as a pre-legal notice. Use this after a final payment reminder has gone unanswered — it signals that the matter is now being formally escalated. Calibrated by route: 'manager' addresses the client's manager or director by name; 'legal' is a pre-action letter signalling that formal recovery steps will follow; 'agency' notifies the client that the debt is being passed to a collection or credit-control agency. Tone is firm, factual, and free of emotion — no threats beyond the escalation itself. Distinct from payment_reminder_email (which is sent to the original contact before escalation). Does not count against your monthly draft limit. Required: client_name, amount_due. Optional: invoice_number, due_date, days_overdue, escalation_route ('manager' | 'legal' | 'agency' — defaults to 'legal'), senior_contact_name (first name of the escalation target — omit if unknown), senior_contact_role (e.g. 'Finance Director', 'Head of Operations'), your_name.

Write the email chasing an unpaid invoice — professionally, without damaging the relationship. Three routes: gentle (first nudge — invoice is a few days past due, tone is friendly and assumes an oversight, no pressure), firm (second or third follow-up — invoice is significantly overdue, tone is clear and direct, includes a deadline to respond), final_notice (last step before escalating — state what happens next: work pause, late fee, collections, or legal — be factual, not emotional). Distinct from re_engagement_email (chasing a prospect who went quiet before signing) and contract_renewal_email (renewing an ongoing relationship). Does not count against your monthly draft limit. Required: client_name, invoice_number, amount, days_overdue. Optional: route ('gentle' | 'firm' | 'final_notice' — default gentle based on days_overdue if not specified), due_date (original due date), project_name, next_step (for final_notice — what you'll do if unpaid: e.g. 'pause work on all active projects', 'add a 2% monthly late fee', 'refer to collections'), your_name.

Write a professional overdue-payment reminder when a client has not paid an invoice by the due date. States the invoice details clearly, keeps the tone firm but not hostile, and gives a direct path to pay. A second-reminder variant adds a firmer note about next steps (late fee, pausing work). Distinct from invoice_cover_email (accompanying a fresh invoice) and deposit_request_email (requesting upfront payment). Does not count against your monthly draft limit.

Write a LinkedIn connection request message (max 300 characters) to a potential client or collaborator. The best connection requests are specific, low-pressure, and name a real reason to connect — not a pitch. Bad ones read like a cold email jammed into 280 characters. This tool keeps it human: one genuine hook, no fluff. Does not count against your monthly draft limit.

Write a concise, authentic LinkedIn post about a project win, lesson learned, or professional insight. LinkedIn is where freelancers get inbound leads — but most avoid posting because writing feels awkward. This generates a post in a natural professional voice (150–250 words): specific hook, the story, the takeaway, a soft CTA. Does not count against your monthly draft limit.

List all saved proposals available as style references

Load bundled example proposals into your library to use as style references immediately. Run this on first use to get started without needing your own past proposals yet.

Write a professional email to cancel or reschedule a meeting. Required: client_name, meeting_description (e.g. 'our Thursday check-in call', 'the kick-off meeting on Friday'). Optional: reason (brief, honest one-line — omit if no clean reason), action (default 'cancel' — use 'reschedule' to propose a new time), new_time (proposed replacement slot if rescheduling, e.g. 'next Tuesday at 2pm'), your_name. Pairs with meeting_request_email (scheduling) and meeting_recap_email (after a meeting that did take place). Does not count against your monthly draft limit.

Write a professional post-meeting recap email to send to a client after a discovery call, check-in, kickoff, or project review. Summarises what was discussed, confirms decisions, and lists next steps with owners. Creates a paper trail and keeps the project moving. Does not count against your monthly draft limit.

Write a short, focused email requesting a meeting — a discovery call with a new prospect, a check-in with an existing client, or a catch-up with a collaborator. Fills the workflow gap between sending a cold pitch or initial enquiry and running the actual discovery_call_prep. Offers specific time slots if provided, otherwise makes a flexible open ask. Does not count against your monthly draft limit.

Write a professional response when a client cancels a project mid-engagement. Acknowledges the cancellation without drama, summarises work completed to date, states the kill fee amount if your contract includes one, and confirms the final invoice. Protects you professionally and financially by putting the key facts in writing. Distinct from project_pause_email (temporary stop), project_closure_email (natural end at completion), client_offboarding_email (relationship wind-down), and end_client_relationship_email (you ending it). Does not count against your monthly draft limit.

Write the email asking a client to review and formally approve a completed milestone, concept, or phase before work continues. For when you need a clear go-ahead — not just a 'looks good' in a message thread — to protect against scope disputes and mid-project reversals. Three routes: milestone_complete (default — a defined project milestone or phase is done; you're requesting sign-off before proceeding to the next stage; tone is confident and forward-looking, frames approval as the natural next step), design_concepts (presenting early-stage creative work — wireframes, mockups, logo concepts, visual designs — for client approval before you move into build or refinement; sets expectations that this is a decision gate, not a preview), staged_delivery (you're delivering a discrete unit of work in a multi-phase project and need the client to accept it before phase two or three begins; useful for retainer work, development sprints, or content batches). Distinct from deliverables_sign_off_email (final project handover, not a mid-project checkpoint), brief_confirmation_email (confirms scope before work starts, not approval during), and project_status_update_email (an FYI update, not a decision gate). Does not count against your monthly draft limit. Required: client_name, milestone_description (what you're asking them to approve — e.g. 'the homepage wireframes', 'Phase 1: the discovery and strategy document', 'Sprint 1 deliverables: user auth and dashboard'). Optional: project_name, next_phase (what starts after approval — e.g. 'full visual design', 'development build', 'Phase 2: content migration'), deadline (when you need a decision by — e.g. 'by Friday', 'end of this week', 'before we lose our build slot'), route ('milestone_complete' | 'design_concepts' | 'staged_delivery' — default milestone_complete), your_name.

Write the email sent when delivering a project milestone or phase — not the final delivery, but a defined stage with its own deliverables and sign-off. Tells the client exactly what's included, asks for their review and sign-off by a specific date, and states what's next. Distinct from project_completion_email (final handover) and project_status_update (progress report during execution). Does not count against your monthly draft limit.

Write the email you send when you're connecting two people in your network — as the connector, not the person being introduced. Distinct from introduction_email (your reply when someone introduces you to a prospect). Common use: connecting a past client with a supplier, two founders who share a problem, a contact with a potential collaborator, or two clients who'd benefit from knowing each other. Two modes: double_opt_in (default — send to each person separately first, checking they're open to the intro before making it; standard best practice for high-value relationships and mutual respect) or direct (one email to both people at the same time; fine when you know both parties well and the introduction is low-stakes). For double_opt_in, use the target parameter to specify which person this individual email is addressed to. Required: person_a_name (first person being introduced), person_b_name (second person), reason_to_connect (why these two people should meet — be specific; 'they're both in tech' is weak, 'you're both solving the same cold-outreach problem from opposite angles' is strong). Optional: person_a_description (what Person A does — one line), person_b_description (what Person B does — one line), mode ('double_opt_in' | 'direct' — default double_opt_in), target (for double_opt_in only: 'a' or 'b' — which person this email is going to; default 'a'), your_name. Does not count against your monthly draft limit.

Generate a simple, plain-English Non-Disclosure Agreement for freelance client work. Covers what's confidential, duration, exceptions, and a basic remedies clause. One-way (client's info stays confidential) or mutual. Not a substitute for legal advice — suitable for most standard freelance engagements. Does not count against your monthly draft limit.

Write a personal announcement email to an existing client introducing a new service you're now offering. Warmer than cold outreach because you already have a relationship — the goal is to let trusted clients hear first, plant the seed for future work, and feel like insiders. Reads as personal and considered, not a mass newsletter blast. Workflow: draft here → send individually with personalised why_relevant per client. Does not count against your monthly draft limit.

Write the 'just closing the loop' email to a prospect who has gone dark after one or more follow-ups. Counter-intuitively, this email often gets a reply when earlier follow-ups didn't — it removes pressure, gives a clear out, and makes it easy for the prospect to re-engage if timing changes later. Calm, friendly, no guilt-tripping, under 80 words. Does not count against your monthly draft limit.

Write the onboarding questionnaire email sent to a new client right after they sign the contract. Gathers everything you need to start work: goals, target audience, brand assets, access credentials, tone/style preferences, examples they like or dislike, key contacts, and approval workflow. Includes optional custom questions for project-specific needs. Avoids the back-and-forth that slows down project starts and sets a professional tone from day one. Does not count against your monthly draft limit.

Write a professional heads-up email to clients before you go on leave. Confident and matter-of-fact — doesn't apologize for taking time off. Sets clear expectations on dates, response time, and what (if anything) to do for urgent matters. Different from an auto-reply: this is the proactive note you send to active clients a few days before you leave. Does not count against your monthly draft limit.

Write the proactive email when YOUR delivery is running behind the agreed deadline — sent before the client has to chase you. The hardest email a freelancer has to write: most either avoid it (and let the client discover the delay themselves) or over-apologise (which damages confidence more than the delay does). This generates a clear, confident update that acknowledges the slip, gives a realistic new date, and briefly states the cause without excessive excuse-making. Tone: matter-of-fact, not panicked, not grovelling. Keeps the relationship intact. Distinct from scope_change_email (change to scope, not timeline), client_waiting_email (client chasing you for an update — reactive), and project_kickoff_email (confirming start of a new project). Does not count against your monthly draft limit. Required: client_name, original_deadline (e.g. 'Friday 20 June', 'end of this week'), new_deadline (your revised commitment), project_name. Optional: delay_reason (brief honest explanation — e.g. 'a technical issue took longer to resolve than expected', 'I underestimated the scope of the research phase'; omit for a shorter email that skips the cause), mitigation (what you're doing to prevent further slippage — e.g. 'I've cleared my schedule for the next two days to focus on this', 'I've already completed X to make up ground'), your_name.

Write a peer-to-peer outreach email to a complementary service provider — a designer reaching out to a copywriter, a developer to a designer, a consultant to an agency. Proposes a referral partnership where you both send clients each other's way. Warm, not transactional, under 150 words. Referral partnerships are one of the highest-ROI growth moves a freelancer can make — one good partner can generate years of warm inbound. Does not count against your monthly draft limit.

Write the formal final notice email when a client has not responded to previous payment reminders and the invoice is significantly overdue. This is the last professional communication before escalating to a collection agency, pausing all work, or seeking legal remedy — so the tone is firm, factual, and unambiguous without being hostile. States the outstanding amount, the number of days overdue, and a clear deadline for payment before you take the next step. Named 'final notice' so the client understands this is the last communication in the sequence. Distinct from late_payment_reminder (earlier, softer reminders) and invoice_dispute_response_email (client disputes the charge — this is non-payment, not dispute). Does not count against your monthly draft limit. Required: client_name, invoice_number, amount, days_overdue. Optional: original_due_date, payment_deadline (days from this email before next step — defaults to 7), next_step (collection_agency | legal_action | work_suspension — defaults to work_suspension), project_name, payment_link, your_name.

Write the professional email proposing an installment payment plan when a client cannot pay an invoice in full immediately — either proactively offered when you sense payment difficulty, or as a structured reply when a client has asked for more time. States the plan clearly (number of payments, amounts, schedule), confirms the arrangement in writing, and keeps the tone solution-focused rather than punitive. Distinct from late_payment_reminder (chasing an already-overdue invoice), invoice_dispute_response_email (client is disputing a charge), and deposit_request_email (requesting upfront payment before work begins). Does not count against your monthly draft limit.

Write the email proposing or confirming payment installments for a project. For when a client can't pay the full fee upfront, or when you want to proactively offer a payment plan to remove a barrier to closing the deal. Three routes: propose_plan (default — you initiate a structured installment proposal: milestone-based or monthly splits; works for high-value projects where budget is not the issue but cash flow is), respond_to_request (client has already asked for installments and you're confirming what you can offer — tone is helpful and collaborative, not reluctant), negotiate_back (client wants different terms than you proposed — e.g. smaller upfront, more splits — and you're counter-proposing or finding a middle ground while protecting your interests). Distinct from deposit_request_email (collecting an agreed deposit that's already been discussed), budget_negotiation_email (negotiating the total fee, not the payment structure), and payment_reminder_email (chasing a payment already due). Does not count against your monthly draft limit. Required: client_name, total_amount (total project fee — e.g. '$4,500', '£3,000'). Optional: project_name, plan_description (your proposed structure — e.g. '50% upfront, 50% on delivery', '30% to start, 30% at midpoint, 40% on completion', '$500/month over 3 months'), installment_count (number of payments — e.g. '2', '3', 'monthly for 4 months'), client_plan (for negotiate_back route — the terms the client asked for), route ('propose_plan' | 'respond_to_request' | 'negotiate_back' — default propose_plan), your_name.

Write a short, professional email acknowledging receipt of a client payment. Most freelancers say nothing when they get paid — this brief confirmation closes the loop, gives the client a paper trail, and signals what happens next. Under 80 words. Does not count against your monthly draft limit.

Write a professional payment reminder email for an overdue or upcoming invoice. Calibrated by tone: 'friendly' for a first nudge (1-7 days late), 'firm' for a second reminder (8-21 days late), or 'final' for a late-stage notice that signals escalation. Always polite but clear — avoids passive-aggression while leaving no ambiguity about what is owed and when. Does not count against your monthly draft limit. Required: client_name, amount_due. Optional: invoice_number, due_date, days_overdue (used to auto-select tone if tone not specified), tone ('friendly' | 'firm' | 'final'), payment_method (e.g. 'bank transfer', 'PayPal'), your_name.

Write a compelling cold pitch to appear as a guest on a podcast. Podcast appearances are a powerful freelancer marketing channel — authority-building, warm inbound leads, and backlinks — but most pitches are generic and get deleted within seconds. This generates a host-first pitch that leads with why their audience wins (not why you want exposure), references a specific episode to prove you're a genuine listener, and ends with a concrete, low-friction ask. Distinct from conference_talk_pitch (formal CFP submission for in-person events) and cold_pitch (client sales outreach). Does not count against your monthly draft limit.

Write the email asking a client for permission to feature their project in your portfolio — the ask most freelancers either skip (and get caught out later) or make feel bigger than it needs to be. Three routes: add_to_portfolio (default — asking to name the client and list the project type in your portfolio; lowest-friction ask, single question, done in under 60 words), show_work_samples (asking to display actual screenshots, documents, or design files publicly — needs specific approval because you're sharing their outputs; names exactly what you want to show), full_case_study (requesting to write a detailed breakdown with results, metrics, or outcomes — warrants a slightly longer email with what you'd say and a clear opt-out so it doesn't feel like an obligation). Distinct from testimonial_request_email (asking them to write or approve a quote about you) and case_study_outline (an internal document structure). Does not count against your monthly draft limit. Required: client_name. Optional: project_name (helps the client know which project you mean), sample_description (for show_work_samples: what you want to show — e.g. 'the homepage, two interior pages, and the mobile screens'), results_to_share (for full_case_study: the metrics or outcomes you want to highlight — e.g. '40% faster proposal turnaround'), portfolio_url (where their work would appear — makes the ask concrete), route ('add_to_portfolio' | 'show_work_samples' | 'full_case_study' — default add_to_portfolio), your_name.

Write the email asking a past client for permission to feature their project in your portfolio, website, or case studies. Specifies exactly what you want to show, where it will appear, and offers them a preview before it goes live. Gives an easy out if they'd rather not — or offers to anonymise the work instead. Distinct from testimonial_request (asking for a quote) and case_study_outline (writing the case study itself) — this is the consent ask that must happen first. Does not count against your monthly draft limit.

Write the follow-up email sent after a productive discovery or intro call with a prospect — the email most freelancers either skip or fumble. Its job: confirm you listened, recap the key points so nothing gets lost, set the next step clearly, and keep the momentum toward a proposal. Distinct from discovery_call_no_show_email (for when they don't show) and client_followup (for chasing a sent proposal). Three routes: warm (engaged prospect, moving forward — default), interested_but_not_ready (good conversation but they need more time or internal buy-in — play the long game), send_proposal (they asked for one on the call — confirm it's coming and when). Required: contact_name, what_discussed (2-4 bullet points or a brief paragraph of what you covered on the call). Optional: next_steps (what you agreed to do next — e.g. 'send a proposal by Friday', 'schedule a follow-up in two weeks'; defaults to a warm but open close), your_service (what you do — helps personalise the recap line), timeline (their stated timeline or urgency — e.g. 'looking to start in July', 'hoping to launch before Q3'), route, your_name. Does not count against your monthly draft limit.

Write a short check-in email sent 30–60 days after a project went live — the follow-up that most freelancers never send, and that creates the highest-conversion upsell moment in the client lifecycle. Different from project_go_live_email (sent on launch day), project_completion_email (the handover), and upsell_email (which can be sent anytime). This is the specific 4–8 week post-launch window when you have real data to reference, the client is seeing real results (or real problems), and your work is still top of mind. Three goals: check on how the project is performing, offer to help with anything that's surfaced, and naturally open the door to next work without pitching. Under 120 words. Required: client_name, what_launched. Optional: time_since_launch (e.g. '5 weeks', '2 months' — makes timing concrete), result_to_reference (any result or signal you know about — traffic, sign-ups, revenue, feedback — shows you've been paying attention), next_offer (a specific follow-on that fits logically — keep it observation-based, not pitch-based), your_name. Does not count against your monthly draft limit.

Write a short email sent 24 hours before a scheduled meeting to share the agenda and confirm the format. Required: client_name, meeting_description (e.g. 'our discovery call tomorrow at 10am'). Optional: agenda_items (comma-separated list of topics — auto-formatted as a numbered list), meeting_format ('video call', 'phone call', 'in person', etc.), meeting_link (Zoom/Meet/Teams URL), prep_request (one thing you need the client to have ready, e.g. 'your current pricing structure', 'the brief you mentioned'), your_name. Completes the meeting lifecycle: meeting_request_email (scheduling) → pre_meeting_email (day before) → [meeting] → meeting_recap_email (after). Does not count against your monthly draft limit.

Write the email notifying a long-term client that your rates are increasing. One of the hardest emails a freelancer writes — most either avoid it entirely (and undercharge for years) or frame it apologetically (which invites pushback). This email is confident, warm, and forward-looking: gives clear notice (typically 30–60 days), states the new rate plainly, optionally anchors it in specific value delivered, and closes with an offer to discuss. Distinct from budget_proposal (negotiating a project price before signing), discount_request_response (responding to a client's pushback on price), and budget_update_email (explaining a cost overrun on a current project) — this is the proactive rate change communication to an ongoing client or retainer. Does not count against your monthly draft limit.

Write the email you send when a client pushes back on your price — 'can you do it cheaper?', 'we only have X budget', 'that's more than we expected'. Distinct from discount_request_response (which handles a specific ask for a discount — this covers any form of price objection, including vague pushback, sticker shock, and budget gaps) and budget_negotiation_email (which opens a negotiation — this responds to one already in progress). Three routes: hold_rate (defend your rate and the value behind it without apologising — default; works when you're confident in your price and the client is worth keeping on your terms), alternative (offer a reduced scope or phased approach that fits their budget — works when you want the work and can genuinely deliver something smaller), walk_away (decline clearly and warmly — works when the budget gap is too large or the engagement wouldn't be worthwhile at their number). Required: client_name, objection_summary (what they said — e.g. 'said the rate is too high', 'mentioned they only have $2k', 'asked if we can do it for less'). Optional: your_rate (your quoted rate or total — e.g. '$150/hr', '$4,500 fixed'; helps make the hold_rate response specific), their_budget (what they said they have — e.g. '$2,000', 'under $3k'), project_name, alternative_scope (for alternative route — the specific smaller version you'd offer, e.g. 'strategy and wireframes only, no build', 'phase 1 homepage only'), route ('hold_rate' | 'alternative' | 'walk_away' — default hold_rate), your_name. Does not count against your monthly draft limit.

Write a short, confident email sending a price quote or estimate to a prospective client. For situations where a full formal proposal isn't needed — quick projects, hourly work, or a client who just asked 'how much?' Covers: the work, the price, what's included, and a clear next step. Does not count against your monthly draft limit.

Write the final email when a project is fully delivered and complete. Confirms what was delivered, handles any handover items, expresses genuine thanks, and plants seeds for future work. Different from project_kickoff_email (which starts the engagement) — this closes it professionally. Does not count against your monthly draft limit.

Write a professional email to a client when you deliver the final output and close out a project. Confirms what's been delivered, thanks the client, and optionally asks for a testimonial and points toward future work. Does not count against your monthly draft limit.

Write a professional email notifying a client that a project deadline will be missed. The hardest email most freelancers avoid sending — but sending it early, clearly, and without over-apologising is exactly what separates pros from amateurs. Three routes: 'early_warning' (you can see the deadline is at risk before it arrives — best time to raise it, gives the client maximum flexibility), 'on_deadline' (it's the due date and it won't be ready — lead with the new date, short explanation), 'already_late' (you've already missed it — own it, new date, no excuses). Required: client_name, project_name, new_deadline (the revised date you're committing to). Optional: reason (brief, factual — not a list of excuses), what_is_complete (how much is done, reassures the client progress is real), route (early_warning/on_deadline/already_late — defaults to on_deadline), your_name. Does not count against your monthly draft limit.

Write a proactive email warning a client that a deadline is at risk — BEFORE you've actually missed it. The professional middle path between staying silent (and surprising them) and over-apologising (when you're not late yet). Demonstrates that you're on top of the project and gives the client time to adjust. Different from late_delivery_apology (which is sent after you've already missed the deadline). Does not count against your monthly draft limit.

Write the email requesting more time on a project when the agreed deadline can no longer be met — the confirmed ask, not a risk warning. Distinct from project_delay_warning (sent when a deadline is at risk but not yet missed) and late_delivery_apology (sent after you've already missed it): this is the professional middle ground — you know you need more time, you're requesting it before the deadline passes, and you're being specific about the new date. Structure: states the current deadline, requests the specific extension needed, gives a brief honest reason (one sentence), and confirms what will be delivered by the new date. Does not grovel or over-explain. Most freelancers either say nothing until they're late, or send a vague 'I might need a bit more time' — this is the direct, professional ask that respects the client's schedule. Does not count against your monthly draft limit.

Write a professional email asking a client for feedback after completing a project. Two modes: feedback_only (default — a genuine, non-pressuring request for their thoughts; asks 1-2 specific questions to make responding easy), feedback_and_testimonial (combines the feedback ask with a soft request for a testimonial or review, framed as 'if you're happy to' — never demanding). Feedback requests sent within a week of delivery get 3x the response rate of requests sent later. The email is short, specific, and makes the client feel like their opinion matters rather than like they're being harvested for marketing content. Required: client_name, project_name. Optional: specific_question (one focused question about the project — e.g. 'Was the turnaround time what you needed?', 'Did the final copy feel like your voice?'), testimonial_platform (where you'd like a testimonial if they're happy to leave one — e.g. 'LinkedIn', 'Google', 'your website'; used only in feedback_and_testimonial mode), request_mode (feedback_only or feedback_and_testimonial), your_name. Does not count against your monthly draft limit.

Write a short celebratory email to a client when their project goes live — website launch, app release, campaign drop, product ship. Different from project_completion_email (the handover) and project_closure_email (the relationship wrap-up) — this is the real-world moment when the thing you built together is in front of real users and getting real results. Under 100 words. Warm, genuine, forward-looking. Positions you as invested in their success, not just the delivery. Natural moment to plant a seed for next work without pitching. Required: client_name, what_went_live. Optional: live_url (shareable link), early_result (any early metric or signal — e.g. '47 sign-ups in the first hour', '200 views in 3 hours'), next_hook (a natural follow-on if something obvious presents itself — e.g. 'once you have a few weeks of traffic data, it would be worth running an A/B test on the hero'), your_name. Does not count against your monthly draft limit.

Write the email that delivers final project files to a client. Distinct from project_closure_email (which handles the relationship close and testimonial ask) — this is the practical handover: here are your files, here's what's included, here's what you need to do next. Sends with the final deliverables attached or linked. Does not count against your monthly draft limit.

Write the professional reply to an inbound project inquiry from a potential client — the email you send when someone reaches out asking if you're available for work. This is the first email in the client relationship, so tone and structure matter: warm enough to keep them engaged, professional enough to signal expertise, and specific enough to move toward a conversation. Two modes: reply_and_qualify (default — acknowledges the enquiry, asks 1-3 targeted qualifying questions to understand scope/budget/timeline before agreeing to a call, and proposes a next step) and reply_and_book (skip the qualifying questions and go straight to proposing a discovery call — use when the enquiry already includes enough detail). Distinct from cold_pitch (you reach out first), client_followup (chasing a silent prospect), and discovery_call_follow_up_email (sent after the call). Required: client_name, enquiry_summary (a brief description of what they're asking for, e.g. 'website redesign for a law firm' or 'monthly content for their SaaS product'). Optional: qualifying_questions (up to 3 questions you want answered before the call — auto-formatted as a bulleted list), response_mode (reply_and_qualify | reply_and_book), call_scheduling_link (Calendly or equivalent URL for one-click booking), your_name. Does not count against your monthly draft limit.

Write a professional project kickoff email to send after winning a project. Confirms deliverables and timeline, introduces your working process, sets clear expectations, and makes the client feel confident they made the right choice. Use this immediately after the client says yes — before the scope of work is signed. Does not count against your monthly draft limit.

Write the email proposing a maintenance retainer or support agreement after delivering a project. One of the easiest upsells freelancers miss — once the work is live, clients are most open to someone they trust keeping it running. Three routes: standard (regular monthly check-in, defined hours for updates and fixes — most common), priority_support (faster response SLA, reserved hours — for clients who can't afford downtime), or light_touch (a small bank of hours, no monthly commitment — for low-maintenance projects or budget-conscious clients who still want access to you). Distinct from retainer_proposal (which opens an ongoing relationship from scratch) and service_package_email (a general menu of services). Does not count against your monthly draft limit. Required: client_name, project_name. Optional: monthly_hours (hours included per month — e.g. '4 hours'), monthly_rate (proposed monthly fee — e.g. '$350/month'), route ('standard' | 'priority_support' | 'light_touch' — default standard), response_time (SLA for priority_support — e.g. '4 business hours', 'same business day'), what_is_covered (brief summary of what's included — e.g. 'plugin updates, performance monitoring, minor copy edits'), go_live_date (when the project goes live — grounds the timing of the ask), your_name.

Write the email formally pausing work on a project — the hardest email most freelancers delay sending until it's awkward, or send too aggressively and damage the relationship. Three routes: non_payment (default — work is on hold until an outstanding invoice is settled; firm but not aggressive, states the pause clearly and gives a single clear path to resume), blocked_on_client (work can't proceed until the client provides something — a missing brief, asset, decision, or approval; names the specific blocker, sets a soft deadline, and keeps the tone collaborative not accusatory), planned_pause (both parties are pausing the project for a defined period — a client budget gap, seasonal pause, or mutual decision; warm tone, confirms the resume expectation, keeps the relationship intact). Distinct from project_delay_notification_email (your own delay without pausing), late_materials_impact_email (timeline impact from late materials, not a formal pause), and project_scope_reduction_email (reducing scope rather than pausing). Does not count against your monthly draft limit. Required: client_name. Optional: project_name, pause_reason (brief context — omit for non_payment to let the invoice speak), outstanding_invoice (non_payment route: what's owed — e.g. 'Invoice #42 for £1,200 due 5 June'), missing_item (blocked_on_client route: what you need — e.g. 'the final logo files', 'sign-off on the wireframes', 'the content brief for section 3'), response_deadline (blocked_on_client route: by when you need a response to stay on schedule — e.g. 'by end of Wednesday', 'within the next 48 hours'), resume_date (planned_pause route: when you expect to pick up again — e.g. 'early July', 'the week of 14 July'), route ('non_payment' | 'blocked_on_client' | 'planned_pause' — default non_payment), your_name.

Write a professional email restarting a paused project. Pairs with project_pause_email to complete the pause/resume lifecycle. Acknowledges the gap, confirms readiness, states the first concrete action, and addresses any timeline adjustments. Does not count against your monthly draft limit.

Write a professional email restarting a paused project. Pairs with project_pause_email to complete the pause/resume lifecycle. Three routes: payment_received (default — payment has cleared, work is resuming; firm, professional, forward-looking; states the first concrete action so the client knows things are moving), client_unblocked (the missing items or information have now arrived; acknowledges receipt, notes any timeline adjustment, confirms next step), scheduled_restart (the agreed pause period has ended; warm reconnect, confirms restart, sets next milestone). Distinct from project_kickoff_email (starting fresh work) and project_closure_email (ending a project). Does not count against your monthly draft limit. Required: client_name. Optional: project_name, resume_date (when work is resuming — e.g. 'Monday', 'today', 'next week'), first_step (first concrete thing you'll do — e.g. 'I'll have the revised wireframes to you by Thursday', 'I'll pick up the development sprint'), timeline_note (any change to the overall deadline — e.g. 'we're still on track for the original July deadline', 'the revised delivery date is now 28 July'), route ('payment_received' | 'client_unblocked' | 'scheduled_restart' — default payment_received), your_name.

Write the professional email to send when you want to confirm a client's project scope before the formal contract arrives. Bridges the gap between verbal agreement and signed contract — confirms deliverables, timeline, and rate so there are no surprises when the paperwork lands. Does not count against your monthly draft limit. Required: client_name, project_description. Optional: scope_summary (bullet list of specific deliverables), timeline (e.g. 'kick off Monday June 23, deliver by July 18'), rate_summary (e.g. '$4,200 flat, 50% upfront'), next_step (e.g. 'send over the contract and I will countersign same day'), your_name.

Write the email proposing a scope reduction when a project is running over budget or time — you're catching it proactively and offering a clean path rather than letting it overrun or blow up. This is a distinct moment: you're the one raising the issue before it becomes a crisis, and you're offering a concrete proposal (not a vague warning). Three routes: reduce_to_core (trim the scope to the minimum viable deliverable, explicitly stating what stays and what's cut — use when the cut is straightforward and the core is still valuable on its own), phase_it (deliver the agreed core now and scope the remainder as a future phase with a separate budget — use when the client will still want the rest and you want to preserve the relationship and future work), stop_here (deliver what exists now and close the project cleanly — use when continuing clearly doesn't serve the client, when the project has run its course, or when it's better to end well than drag on). Distinct from scope_creep_email (client adding uncosted work), budget_negotiation_email (negotiating budget before work starts), and mid_project_cancellation_response_email (client-initiated stop). Does not count against your monthly draft limit. Required: client_name, reason (what's driving the reduction — e.g. 'we're tracking 30% over budget due to unexpected API complexity', 'the timeline has compressed and the full scope no longer fits'), proposed_reduction (what you're proposing to cut or defer — be concrete). Optional: project_name, current_completion_percentage, phase_2_scope (for phase_it route — what goes into the next phase), route ('reduce_to_core' | 'phase_it' | 'stop_here' — default reduce_to_core), your_name.

Write a professional project status update email to send a client during a longer engagement. Covers what was completed, what's next, any blockers or decisions needed, and the current timeline. Keeps clients informed without requiring a meeting. Does not count against your monthly draft limit.

Write a clear, scannable project status update email to send to a client on a regular cadence (weekly, bi-weekly, or at a milestone). Covers what was completed, what is in progress, and what is coming next — with optional sections for blockers and items needed from the client. Keeps clients informed without requiring a call. Does not count against your monthly draft limit. Required: client_name, project_name, completed. Optional: in_progress, coming_next, blockers, items_needed (what you need from the client), timeline_status (on_track / ahead / at_risk / delayed), your_name.

Write the follow-up email sent when a submitted proposal is approaching — or has reached — its expiry date. Its job: create urgency without pressure, surface any blockers holding up the decision, and keep the door open. Distinct from client_followup (general chasing of a sent proposal with no deadline angle), bid_lost_follow_up (for when you've already lost), and post_discovery_follow_up_email (sent right after a call, before the proposal is written). Three routes: gentle_nudge (default — soft check-in asking if they have questions before the deadline, no hard pressure), firm_deadline (clear statement of expiry, direct ask for a decision — use when the deadline is tomorrow or already passed), extend_offer (proactively offer to extend the deadline if they need more time — use when you'd genuinely rather wait than lose the deal). Required: client_name (prospect's first name), proposal_topic (what the proposal covers — e.g. 'brand identity project', 'Q3 development retainer', 'website redesign'). Optional: expiry_date (when the proposal expires or expired — e.g. 'Friday', 'June 27', 'yesterday'; if omitted, the email references 'the proposal' generically), proposal_value (total value or rate — e.g. '$8,500', '$4,200/mo'; if provided, re-anchors the investment in the reader's mind), route, your_name. Does not count against your monthly draft limit.

Convert a formal proposal document into a concise, scannable pitch email. Distills the key points — problem, solution, price, and next step — into a short email the client can read in 60 seconds and forward to decision-makers. Does not count against your monthly draft limit.

Write the professional email to send when a prospect asks 'what are your rates?' or requests your pricing. Presents your rates clearly and confidently — no apologising, no burying the number. Positions the rate in context of your experience and what the client gets. Distinct from draft_proposal (which responds to a specific brief) and rate_increase_email (which tells an existing client you are raising prices). Does not count against your monthly draft limit. Required: your_rate (e.g. '$150/hr', '$3,500 for a 4-page website', 'from $2,000 per project'). Optional: prospect_name, your_specialty (e.g. 'B2B SaaS copywriting', 'React front-end development'), rate_context (one sentence on what is included, e.g. 'includes two revision rounds and source files'), availability (e.g. 'available from July 14'), next_step (e.g. 'happy to jump on a 20-minute call'), your_name.

Write an email telling an existing client you are raising your rates. One of the most anxiety-inducing tasks for freelancers. Generates a direct, professional email that gives enough notice, explains the new rate without over-explaining, and preserves the relationship. Does not count against your monthly draft limit.

Write the email you send to a past client you haven't worked with in a while — to reopen the relationship, explore new work, or simply stay on their radar. Distinct from cold_pitch (these people already know and trust you — the tone is warm, not selling), referral_request (you're not asking for a name, you're reopening your own relationship), and testimonial_request (you're not asking for a review). Three routes: check_in (low-pressure — catch up, mention what you've been up to, no explicit ask; best for high-value relationships you don't want to pressure), new_service (flag a specific new offering that's relevant to what you did together; works when you have something concrete to offer), availability (you're available and thought of them first; works when you ended on a strong note and timing is the only variable). Required: client_name, last_project (a brief description of what you worked on together — keeps the email from feeling generic). Optional: time_since (how long it's been — e.g. '6 months', 'last year', 'a while'; omit and the copy stays vague), what_you_did (a specific outcome or result from the last project — adds credibility), new_service_name (for new_service route — the specific offering to highlight), new_service_relevance (for new_service route — why it's relevant to this client), route ('check_in' | 'new_service' | 'availability' — default check_in), your_name. Does not count against your monthly draft limit.

Write a short, light-touch email to a prospect who went quiet mid-conversation — a warm lead that stalled before they committed. Not needy, not pushy. Gives them a graceful re-entry point and an easy out. Most freelancers let cold leads die or over-chase awkwardly — this hits the middle: a single, low-pressure nudge that often gets a reply. Under 100 words. Does not count against your monthly draft limit.

Write the email asking a happy client for a LinkedIn recommendation. Different from testimonial_request (which asks for a short quote for your website): a LinkedIn recommendation lives on the client's own profile and carries far more social proof. This email makes the ask easy — keeps it short, gives the client a memory prompt, and optionally suggests a focus so they don't face a blank page. Does not count against your monthly draft limit.

Write a short, warm email asking a happy client to refer you to others in their network. Different from testimonial_request (which asks for a written review) — this asks for an introduction or recommendation to potential new clients. Under 120 words, one clear ask, no pressure. Does not count against your monthly draft limit.

Write a warm, specific thank-you to someone who sent you a referral. Three modes based on where things stand: 'intro' (you've just been introduced, haven't connected yet), 'had_call' (you've spoken with the referral), or 'won_project' (you landed the work — the warmest thank-you). Most freelancers skip this entirely and miss a key moment to strengthen the referral relationship. Does not count against your monthly draft limit.

Write a warm, genuine thank-you email to someone who referred a new client to you. Acknowledges the specific referral, expresses genuine appreciation without being gushing, and optionally offers to return the favour. Works whether the project is just starting, underway, or completed. Does not count against your monthly draft limit.

Write a professional response to a client who has chosen another provider. Keeps the door open for future work without being bitter, clingy, or sycophantic. Short, gracious, and memorable. Does not count against your monthly draft limit.

Write a monthly check-in email to a retainer client. Summarises what was covered during the period, previews upcoming work, and opens the door to new needs — the natural upsell moment in an ongoing relationship. Keeps retainer relationships active without feeling like a report. Required: client_name, period (e.g. 'May', 'last month', 'Q2'). Optional: work_summary (1-2 lines of what you covered this period — omit to keep it brief and open), upcoming_work (what's planned next period — omit if not yet set), new_needs_question (a specific question to surface unmet needs, e.g. 'Are there any new campaigns or projects on your radar for next quarter?' — defaults to a general open-ended check), your_name. Workflow: retainer_proposal (close the deal) → project_kickoff_email (start) → retainer_check_in_email (monthly) → contract_renewal_email (renew). Does not count against your monthly draft limit.

Write a professional response when a retainer client asks to reduce their commitment — fewer hours, a lower tier, or a scaled-back scope. One of the awkward conversations freelancers avoid, but handling it well keeps the relationship intact and sometimes reverses the decision. Three routes: 'accommodate' (accept the reduction professionally, confirm the new terms cleanly — use when the client's situation is clear and fighting it would cost more than the hours lost), 'retain' (make a measured case for keeping the current commitment — summarise the value delivered, flag transition costs, offer a short-term adjustment before a permanent change), 'pause' (propose a temporary pause instead of a permanent downgrade — protects the relationship and keeps the door open for a return to full scope). Required: client_name, reduction_request (what they asked for, e.g. 'halve the monthly hours', 'drop from 20 to 10 hours/month', 'pause for 60 days'). Optional: current_terms (e.g. '20 hours/month at $3,000'), proposed_terms (the reduced version they're asking for), retainer_name (project or retainer label), route (accommodate/retain/pause — defaults to accommodate), your_name. Does not count against your monthly draft limit.

Write the email proposing to expand an existing retainer — adding services, increasing hours, or upgrading to a higher tier. For when you're in an ongoing retained relationship and want to deepen it based on the work done so far. Three routes: add_services (default — propose adding new service lines to the current retainer, e.g. adding SEO audits to a design retainer or copywriting to a strategy retainer), increase_hours (propose increasing the monthly hours allocation — works when you're consistently hitting the cap and both parties are getting value), upgrade_tier (propose moving the client to a higher package that better fits their current usage or needs — works when they've outgrown what they're on). Distinct from retainer_proposal (initial pitch to a new client), retainer_check_in_email (a routine check-in with no commercial ask), and new_service_announcement_email (broadcasting a new service to all clients). Required: client_name. Optional: current_retainer (what they're currently on — e.g. '5 hours/month design support', '$800/month strategy'), proposed_expansion (what you're proposing to add or change — be specific), project_name, route ('add_services' | 'increase_hours' | 'upgrade_tier' — default add_services), your_name. Does not count against your monthly draft limit.

Write a professional email proposing an ongoing retainer relationship to an existing project client. Converts a one-off engagement into a predictable monthly arrangement — gives the client clarity on reserved capacity and you stability of income. Covers: proposed scope, monthly hours, retainer fee, how unused hours roll over (or don't), notice period. Does not count against your monthly draft limit.

Write the email responding to a client's revision request. Three modes: 'in_scope' (happy to revise — confirms what you'll change and when), 'exceeds_rounds' (they've used their included revision rounds — explains what's included and what additional rounds cost), 'out_of_scope' (the request is a direction change that requires a change order, not a revision). Distinct from scope_change_email (formal change order) and scope_warning_email (early creep flag) — this is the specific, policy-in-action response to a concrete revision ask. Does not count against your monthly draft limit.

Write the email when a client requests revisions beyond their contracted allocation — enforcing your revision policy without damaging the relationship. One of the most avoided conversations in freelancing; this email makes it easy by being matter-of-fact, not defensive. Three routes: notify_and_quote (default — inform the client their rounds are used, quote the additional cost, invite them to proceed; works when you want to keep the work and the relationship), offer_upgrade (offer a small add-on package for further revisions — works when the client is likely to need ongoing changes and a bundled approach makes sense), close_and_decline (flag that contracted revisions are complete and the project is considered signed off unless they purchase more; works when revisions are clearly not converging or the client is acting in bad faith). Distinct from revision_response_email (which handles the content of a specific revision), scope_creep_response_email (which is broader scope expansion), and change_order_email (which is a formal contract amendment). Does not count against your monthly draft limit. Required: client_name, project_name. Optional: revisions_included (how many rounds were in the contract — e.g. '2 rounds', '3 rounds of revisions'; default is 'the included'), revisions_used (how many have been used — helps make the email concrete), additional_rate (your rate for extra revision work — e.g. '$85/hr', '$150 per round'; makes the quote concrete), route ('notify_and_quote' | 'offer_upgrade' | 'close_and_decline' — default notify_and_quote), package_name (for offer_upgrade route — name of the add-on, e.g. 'Revision Pack', 'Polish Pass'), package_price (for offer_upgrade route — e.g. '$200', '2 hours at $85'), your_name.

Write the professional email notifying a client that their request for expedited delivery comes with a rush fee — and asking for approval before you start. States the accelerated deadline you can hit, the additional charge, and what it covers (weekend hours, rescheduled commitments, etc.), then makes a clear yes/no ask so the timeline doesn't slip further while waiting for a response. Keeps tone matter-of-fact and collaborative, not apologetic. Distinct from budget_update_email (cost overrun from project complexity), scope_change_email (client requests additional work), and project_extension_email (you requesting more time). Does not count against your monthly draft limit.

Save a winning proposal as a reference example. The more examples you save, the more accurately future drafts match your voice and format.

Write a professional email to a client when work has grown beyond the original scope — new requests, added features, extra rounds of revisions. Raises the issue without accusation, outlines the impact, and presents options (change order, revised quote, or narrowing scope). Does not count against your monthly draft limit.

Write a professional email to a prospective client asking for the information you need before you can quote accurately. Most freelancers either guess (wrong) or send a list of demands (off-putting). This generates a short, confidence-building email with 2–4 targeted questions that signal expertise, not confusion. Does not count against your monthly draft limit.

Write a professional, non-confrontational email addressing a client request that falls outside the agreed project scope. The email acknowledges the request positively, clarifies the scope boundary, and offers a change order or quote for the additional work — without apologising for sticking to the agreement. Handles one of the most common and professionally charged situations for freelancers: when a client treats 'out of scope' as optional. Required: client_name, project_name, scope_change_description. Optional: original_scope_note (what was agreed), quoted_fee (if you already have a price), timeline_impact (if extra work affects delivery), your_name. Does not count against your monthly draft limit.

Write a professional email responding to a client who has requested work that falls outside the agreed project scope. The most common and most mishandled situation in freelancing — most people either give the work away for free (damages business) or say a flat no (damages relationship). Three routes: quote (acknowledge the request, confirm it's outside scope, offer to do it at additional cost — the default), decline (politely decline and redirect to the agreed deliverables), include_once (absorb this one time but set clear expectations going forward). Keeps the relationship intact while protecting your scope. Does not count against your monthly draft limit.

Generate a formal Scope of Work document from an accepted proposal. Produces a structured SOW with deliverables, timeline, payment schedule, revision policy, and a change-order clause — ready to paste into a contract or send directly to the client.

Write a professional email flagging scope creep BEFORE issuing a change order — the early-warning conversation that prevents the surprise-invoice moment. Use this when you notice a client requesting something beyond the original brief; it surfaces the issue collaboratively so the client can confirm they want the extra work (triggering a change order) or clarify it's within scope. Different from change_order (which documents agreed extra work and its cost); this is the conversation that comes first. Does not count against your monthly draft limit.

Write a professional email presenting 2–3 productized service packages to a prospect. Used when you offer fixed-price, structured tiers rather than quoting per project — e.g. Starter / Growth / Scale, or Essential / Pro / Premium. Presents each tier with a clear name, what's included, and price. Distinct from rate_card_email (hourly/day rates sent when asked) and draft_proposal (responding to a specific brief). Does not count against your monthly draft limit.

Decline a request to produce work on spec (unpaid design, copy, or code samples produced as part of a pitch or evaluation) without burning the relationship. Two routes: decline (default — firm but warm no; redirects to your existing portfolio and process; use when you don't want to propose an alternative), counter (no to spec, yes to a small paid discovery or test engagement as the right first step — use when you're genuinely interested in the project but won't work for free). Distinct from competitor_response_email (you've already been engaged and the client is comparing providers), client_decline_email (you're turning down the whole project), and proposal_expiry_reminder_email (chasing a submitted proposal). Does not count against your monthly draft limit. Required: client_name. Optional: project_description (what the spec request was for — e.g. 'a sample homepage design', 'a draft chapter', 'a prototype feature'), portfolio_url (link to existing work — include so the client can self-qualify), discovery_offer (the paid alternative you're proposing — e.g. 'a paid half-day discovery workshop', 'a two-hour paid strategy session', 'a small paid scoping engagement'; default 'a paid discovery session'), route ('decline' | 'counter' — default decline), your_name.

Write the professional email confirming you are accepting a subcontracting role offered by another contractor or agency. Covers: confirming your acceptance, stating the agreed role and start date, and flagging any standard conditions (invoicing process, point of contact, NDA if applicable). Distinct from subcontractor_brief (you briefing someone YOU hired), bid_lost_follow_up (you lost a direct bid), and cold_pitch (you reaching out speculatively). Does not count against your monthly draft limit. Required: prime_name (name of the main contractor or agency), project_description (what the project is, e.g. 'the Acme Corp website redesign'), your_role (your specific role or deliverable, e.g. 'front-end development', 'UX design for the mobile flows'). Optional: start_date, rate_confirmation (e.g. '$120/hr as agreed', '$4,500 fixed fee'), point_of_contact (who you report to), nda_flag (if true, notes you are happy to sign an NDA), your_name.

Generate a clear project brief for a subcontractor or VA you're bringing in for part of a project. Covers their specific scope, deliverable format and deadline, what NOT to include, payment terms, work-for-hire IP clause, and confidentiality note. Getting this right upfront prevents the most common sub problems: scope bleed, missed handoffs, and ownership disputes. Does not count against your monthly draft limit.

Write a gentle follow-up when a testimonial request has gone unanswered — sent one to two weeks after the initial testimonial_request. Distinct from testimonial_request (the first ask): this is the nudge that dramatically increases conversion because most clients meant to respond but let it slip. The key technique: offer to write a short draft for them to edit or approve — this removes the blank-page friction that kills most testimonial requests. Under 80 words, no guilt, no pressure. Optional offer_draft param (default true) adds the draft offer, which is the highest-impact line in the email. Does not count against your monthly draft limit.

Write a short, personal email asking a client for a testimonial after successful project delivery. Not a form, not a survey link — a genuine, specific ask that gets responses. Does not count against your monthly draft limit.

Write a warm, non-pushy email asking a past or current client for a testimonial, case study quote, or LinkedIn recommendation. Sent after a successful delivery or project milestone. Includes a specific angle or prompt to make it easy for the client to say yes without staring at a blank page. Distinct from client_offboarding_checklist_email (which only has a brief optional postscript ask) — this is a standalone, full-effort ask with a tailored hook. Does not count against your monthly draft limit.

Write the email notifying a client of a delay caused by an external dependency outside your control — a subcontractor running late, a third-party API or platform outage, a supplier delay, or a required approval not arriving. Distinct from project_delay_warning (your own work is at risk), project_extension_email (you need more time), and late_delivery_apology (you missed a deadline): this is the specific communication for when the blocker is external. Structure: states what is delayed and why (naming the external cause clearly), what you're doing to manage or mitigate it, and a revised timeline if known. Tone: transparent and proactive, not defensive — you didn't cause this but you own communicating it. Does not count against your monthly draft limit.

Write a proactive heads-up email to an active client before you go away — annual leave, a personal absence, or a conference/training. Sends this BEFORE you leave so the client isn't surprised when you go quiet. Three routes: vacation (default — fully offline; states the exact dates, what you'll complete before you go, and when you'll respond on return; gives the client confidence that active work is handled), conference_or_training (professional development; acknowledges you may check email intermittently; warmer tone since you're still reachable in genuine emergencies), personal (minimal detail — just the dates and return; no explanation required). Distinct from project_pause_email (formal indefinite pause, often for non-payment), availability_announcement_email (announcing new slots for future work), and project_delay_notification_email (your own delay mid-project). Does not count against your monthly draft limit. Required: client_name, return_date (when you'll be back — e.g. 'Monday 7 July', 'next Thursday'). Optional: project_name, from_date (first day away — e.g. 'Friday', '27 June'; omit if sending on the day of departure), pre_absence_deliverable (what you'll complete before you leave — e.g. 'the first-draft wireframes', 'the revised copy'), cover_contact (name + email of someone handling genuine emergencies — omit if you have no cover), route ('vacation' | 'conference_or_training' | 'personal' — default vacation), your_name.

Write the email sent when a client's brief is too vague to start work safely — asks targeted clarifying questions before time is spent. Lists the specific unclear points concisely, explains why each matters (to avoid rework or surprises), and offers a quick call if it's easier than written answers. Professional and collaborative in tone — not a complaint, not a lecture. Prevents scope creep and misaligned deliverables from the start. Distinct from scope_change_email (used mid-project when scope expands) and revision_response_email (used after client feedback). Does not count against your monthly draft limit.

Write a warm, non-pushy email to a happy client suggesting additional services or a retainer after a successful project. Existing clients convert at 3–5x the rate of cold prospects — this is the highest-ROI sales email a freelancer can send. Timing: right after delivering and getting positive feedback. Does not count against your monthly draft limit.

Check your free tier usage: how many proposal drafts you've used this month and how many remain before hitting the limit. Run this before draft_proposal if you're unsure of your remaining quota.

Write a short, warm re-engagement email to a past client you haven't worked with in a while (6+ months). Distinct from availability_announcement (broadcast to all past clients) and reactivation_email (cold prospect from a mid-pitch conversation) — this is a targeted, personal one-to-one note to someone you've already delivered results for. The gap is acknowledged briefly and lightly, not apologised for. Closes with a soft open-ended ask ('are you working on anything at the moment?'), not a pitch. Does not count against your monthly draft limit.

Write a professional email responding to a prospect who has asked to see work samples or portfolio pieces before deciding whether to hire you. Two modes: have_samples (default — you have directly relevant work to share; links or describes the samples with brief context on why they're relevant to this client's situation), no_exact_match (you don't have a perfect example in this specific niche or format, but you have closely adjacent work that demonstrates the same underlying skill; acknowledges the gap honestly without being apologetic, explains what the adjacent work shows, and offers a next step — call, test piece, or scoped pilot). The no_exact_match mode is often more persuasive than it sounds: handled well, it signals integrity and directness. Required: client_name. Optional: project_context (what the prospect is evaluating you for — makes the email specific rather than generic), sample_description (one-line description of what you're sharing or linking — e.g. 'three brand strategy decks for similar-scale clients', 'a website redesign for a professional services firm'), sample_link (direct URL or 'attached' — if omitted, email offers to send on request), adjacent_work (for no_exact_match mode: what you have that's adjacent — e.g. 'I haven't done X specifically, but here are two projects where I did Y under the same constraints'), next_step (what you're proposing after the sample review — e.g. 'happy to jump on a 20-minute call', 'I can put together a short test piece'), your_name. Does not count against your monthly draft limit.

Write a short, friendly email that sets out how you and a client will work together during a project — covering communication preferences, response times, revision process, sign-off protocol, and meeting cadence. Sent before or at project kick-off, this prevents misunderstandings that kill projects mid-flow. Distinct from contract_template (legal obligations), client_onboarding_checklist (tasks to complete before starting), and project_kickoff_email (confirming that work has begun) — this is the 'how we actually work day to day' email that experienced freelancers swear by. Does not count against your monthly draft limit.

Write a brief, professional email setting expectations about your working hours and response times with a client. Confident and matter-of-fact — frames boundaries as something that helps the client get better work, not as a personal restriction. Works for setting hours proactively at project start, responding after a late-night or weekend message, or resetting expectations mid-project. Does not count against your monthly draft limit.