• 

  Hero

• 

  Tiers

Inspiration

Most freelancers I know lose money on every project. Not because they're bad at their craft, but because they're bad at pricing.

I'm a freelance AI automation consultant in Italy. I send quotes every week, and it's still painful, every time. I watch colleagues across the industry undercharge by 30 to 50 percent versus market rates. They send one-line proposals with a single number, no rationale, no framing. Then they get negotiated down to nothing because there's nothing in the document to defend.

The pain shows up at three moments. Staring at a blank document and not knowing where to start. Picking a number out of thin air and immediately doubting it. Watching the client come back with "can you do it for less?" and having no leverage to push back.

Agencies and consultancies have entire pricing teams to solve this. Independent professionals get nothing. So I built the tool I wished I had when I started.

What it does

FairQuote is an AI pricing co-pilot for freelancers and independent professionals.

You describe your client project in a guided chat. An AI assistant interviews you adaptively, asking 6 to 10 smart questions one at a time, branching follow-ups based on your answers. A designer gets asked about handoff format and revision rounds. A developer gets asked about deployment and post-launch maintenance. A copywriter gets asked about voice samples and SEO scope. Same skeleton, branched limbs.

Once the interview is complete, FairQuote generates a structured proposal with three pricing tiers: Lean, Standard, and Premium. Each tier is genuinely different in scope, not just price. Lean covers exactly what was asked, no extras, longer timeline. Standard adds best-practice extras and is the suggested choice. Premium is the value-driven upsell with post-launch support and faster turnaround.

Every tier comes with a defensible rationale built from three elements:

• Hourly equivalent at the freelancer's stated target rate
• Market benchmark for similar scope and country
• Value justification tied to the client's stated needs

The user exports the proposal as a clean PDF and copies a ready-to-send cover email. The whole flow takes 5 minutes versus the usual hour of staring at a blank document.

How we built it

FairQuote is built entirely with MeDo, Baidu's agentic no-code app builder, and the Baidu LLM Plugin powered by ERNIE.

I started with a single master prompt that defined the entire app in one shot: data model, three-section single-page layout (landing, chat, three-tier output), AI behavior rules, and visual direction. MeDo scaffolded the working app from that one prompt: a deployed URL, a wired chat interface, a comparison view for the three tiers.

From there I iterated in granular multi-turn refinements. Each prompt touched one behavior at a time. Tightening the conversation flow ("ask one question at a time, never a wall of text"). Adapting follow-ups by project type. Tuning the three-tier generation logic so the differences between Lean, Standard, and Premium come out as scope variations rather than flat price multipliers. Polishing the side-by-side comparison view.

For the visual direction I went deliberately against the typical AI startup aesthetic. No purple gradients, no neon glow. Instead: a warm dark base, generous whitespace, an editorial serif for headings, monospace for prices. The reference points were Linear, Vercel, and Stripe pricing pages. The narrative is "your work is a serious business decision, treat it like one", and the visual language reinforces that.

The conversational layer runs entirely through the ERNIE plugin. No agent orchestration code on my side. MeDo wires the chat-to-state transitions, persists the conversation log, and renders the generated proposal into the three-card output.

Challenges we ran into

The first challenge was getting MeDo to scope changes narrowly. Some prompts caused the platform to regenerate sections of the app I didn't want touched. The fix was discipline: explicit "do not change X, Y, Z" framing on every iteration, and saving versions before any prompt that might cascade.

The second was the chat-to-state transition. The interview happens, then the proposal section needs to populate and become visible. Out of the box, MeDo handled the chat well but the handoff to the output state needed explicit instructions. Once I described the transition in plain English, it locked in.

The third was making the three tiers feel genuinely different. Easy version: just multiply Standard by 0.7 and 1.5 to get Lean and Premium. That's exactly what I didn't want, because clients see through it instantly. The harder version: each tier has a different scope, different deliverables, different timeline. I had to push the prompt to generate scope variations first, then price the variations, not the other way around.

The fourth was the rationale text. Generic AI fluff like "this tier offers great value" was useless. The freelancer needs language they can paste into a negotiation email. I instructed ERNIE to anchor every rationale on three concrete elements (hourly equivalent, market benchmark, value justification) and the output became defensible.

Accomplishments that we're proud of

The whole v0.1 went from idea to public deployed URL in a few hours of conversation with MeDo. No frontend code, no backend code, no infrastructure setup.

The adaptive interview actually works. Run it three times with different project types and you get three meaningfully different conversations. That's a serious technical accomplishment for a no-code build, and it would have taken me a week to wire by hand.

The visual direction landed. The app doesn't look like an AI hackathon throwaway. It looks like a real SaaS tool, the kind you'd expect to pay for. Several people who saw the demo asked if it was a product I was already selling.

And the rationale generation is doing what I built it to do: producing pricing arguments a freelancer can actually use in a real negotiation, not generic copy.

What we learned

Granular multi-turn iteration beats master-prompt rewriting in MeDo. Once the scaffold exists, every change should be the smallest possible explicit instruction. Trying to "redo with these new requirements" causes the platform to regenerate too much.

ERNIE handles complex conversational logic with surprisingly little orchestration. The branching interview, the adaptive follow-ups, the structured proposal generation all came from prompt structure, not from an agent framework. For a problem that is 70% AI behavior and 30% UI, MeDo plus ERNIE is a serious accelerator.

The constraint of shipping a single-page demo with no signup forced better UX decisions than a fully featured SaaS would have. No onboarding to design, no auth flow to break, no dashboard to populate. The user is in the chat in 2 clicks. That constraint became a feature.

Visual direction matters more than feature breadth in hackathon judging, and probably in real-world user adoption. A polished demo of a narrow flow beats a wide flow that feels half-built.

What's next for FairQuote

Before May 20 I want to ship into the v1:

• User accounts and persistent quote history, so freelancers can revisit and reuse past quotes
• PDF templates customized per profession (designer, developer, copywriter, consultant)
• Cover email generator with tone variants (formal, friendly, assertive)
• Mobile-first polish for the chat experience

Beyond the hackathon:

• Negotiation mode. Paste the client's response, get suggested replies that hold the price.
• Localization. Italian first (my home market), then Spanish and French.
• Profession packs with industry-specific question trees and rationale templates.
• Integration with Stripe and Wise so an accepted tier becomes an invoice in one click.
• A quiet learning loop where FairQuote remembers which tiers got accepted and refines future quotes for that user.

If you're a freelancer who's tired of quote anxiety, try the demo and tell me what's missing. I'm building this in public.

Built with MeDo and ERNIE for the Build with MeDo Hackathon.

BuiltWithMeDo

Built With

• gemini
• medo
• tailwind
• typescript