How I Get Freelance Clients (Without Upwork or Fiverr)

I've made $15K freelancing in the past year. Zero of it came from platforms.

Why I Avoid Freelance Platforms

Platform	Fee	My Experience
Upwork	5-20% + connects fee	Race to the bottom, 50+ proposals per job
Fiverr	20%	$5 gigs, nightmare clients
Toptal	Screened out	Elite only, takes months to join
My approach	0%	Direct relationships, repeat clients

The math is simple: A $1,000 project on Upwork = $800 to you. The same client direct = $1,000.

Strategy 1: Build in Public

Everything I build, I share:

// I built this rate limiter for a client's API.
// Then I wrote about it on Dev.to.
// That article brought me 3 similar inquiries.

// The code itself became a portfolio piece
// that attracted better clients than any resume could.

What to share:

• Problems you solved (not just "I built X")
• Before/after metrics ("Reduced API response time from 2s to 200ms")
• Technical decisions and trade-offs
• Honest post-mortems of failures

Where to share:

• Dev.to / Hashnode (developer audience)
• LinkedIn (business decision-makers)
• Twitter/X (both audiences)
• Your own blog (SEO long-term)

Strategy 2: The "Free Sample" Funnel

This single tactic got me my first 5 clients:

1. Find a small business with a bad website/slow API/broken feature
2. Fix it for free (takes 2-3 hours)
3. Send them a video explaining what you fixed and why
4. Say: "I noticed [problem] and fixed it. No obligation. If you need more work like this, I'm available."

Email template:

Hi [Name],

I was browsing [their website/app] and noticed 
[specific issue: slow load time / broken form / error].

I went ahead and built a fix — here's a 2-minute 
video showing before/after: [Loom link]

No strings attached. Just wanted to help.

If you ever need development work, I specialize in 
[stack]. My typical projects are [type].

Best,
[Your name]

Conversion rate: ~20% of free samples turned into paid work.

Why it works: You're proving value BEFORE asking for money. It's the opposite of every other freelancer's approach.

Strategy 3: Niche Down Hard

"I do web development" → ignored
"I optimize Node.js APIs for fintech startups" → interesting

// Generalist profile (low value):
"Full-stack developer. React, Node.js, Python, AWS. 
5 years experience. Available for projects."

// Specialist profile (high value):
"I help fintech startups reduce API latency by 60%+.
Specialized in Node.js performance optimization and 
PostgreSQL query tuning. 
Last project: Cut response times from 1.8s to 120ms 
for a payments API processing $2M/month."

Niches that pay well:

• Payment/fintech integrations
• Performance optimization
• Data pipelines & ETL
• API design & documentation
• Security audits & hardening
• Migration projects (legacy → modern)

Strategy 4: Pricing That Works

Hourly vs Project-Based

// ❌ Hourly billing (bad incentives)
// Client worries: "Is he working slowly to bill more?"
// You worry: "Did I undercount this task?"

// ✅ Project-based pricing (aligned incentives)
// Fixed price for defined deliverables
// Both parties know exactly what they're getting

How I Price Projects

Project Type	Price Range	Time Estimate
Bug fix / small feature	$200-500	2-4 hours
API endpoint / integration	$500-1500	1-3 days
Full feature module	$2000-5000	1-2 weeks
MVP / small app	$5000-15000	2-6 weeks
Performance audit + fixes	$1000-3000	3-7 days

The "Good/Better/Best" Pricing Tiers

Option 1: Basic ($X)
- Core functionality only
- 1 round of revisions
- 2-week support after delivery

Option 2: Standard ($Y) ← Most clients pick this
- Everything in Basic +
- Extra features (admin panel, export, etc.)
- 3 rounds of revisions  
- 30-day support + bug fixes
- Documentation

Option 3: Premium ($Z)
- Everything in Standard +
- Priority delivery
- Source code ownership transfer
- 90-day support + 1 hour of training
- Monthly maintenance option available

Psychology: Most people pick the middle option. Make that your target margin.

Strategy 5: Turn One-Time Projects into Recurring Revenue

One-off projects are feast-or-famine. Recurring revenue is stability:

// From one-time project to retainer:
// 
// Phase 1: Deliver great work (over-deliver)
// Phase 2: At handoff, say:
//   "This will need updates as your user base grows. 
//    I can check in weekly for $X/month to handle 
//    bugs, small features, and monitoring."
//
// Phase 3: Retainer income covers your baseline expenses
// while you hunt for new projects

// My current retainer structure:
const retainers = [
  { client: "FintechApp", amount: 1500, scope: "Weekly maintenance + 8hrs dev time" },
  { client: "SaaSStartup", amount: 800, scope: "Bug fixes + small features" },
  // Total: $2300/month baseline (covers all my bills)
];

Strategy 6: The Referral Engine

Every completed project should generate the next one:

// Upon project completion:
async function closeoutProject(client, project) {
  // 1. Deliver more than promised
  await overDeliver(project);

  // 2. Ask for a testimonial (with specific metrics)
  const testimonial = await requestTestimonial(client, {
    template: "What problem did Alex solve? What was the result?",
    format: "LinkedIn recommendation or email",
  });

  // 3. Ask for referrals (timing matters!)
  await askForReferrals(client, {
    script: `I'm looking for more projects like yours. 
Do you know anyone who might need [what you do]?`,
  });

  // 4. Add to portfolio (with permission)
  await addToPortfolio(project, { testimonial });
}

When to ask for referrals: Right after a successful delivery when satisfaction is at its peak.

The Outreach System That Actually Works

// My weekly outreach routine (every Monday):
const targets = findProspects({
  sources: [
    'Hacker News "Hiring" threads',
    'Indie Hackers "Looking for developer" posts',
    'Twitter search: "need a developer" OR "looking for freelancer"',
    'Cold email from Crunchbase/AngelList startups',
  ],
  filters: {
    funded: true,           // Has money to pay
    teamSize: { min: 2, max: 20 },  // Not too big, not solo
    techStack: ['Node.js', 'React', 'TypeScript'], // Match my skills
  },
});

// Send 10 personalized messages per week
for (const prospect of targets.slice(0, 10)) {
  const message = personalize(prospect, {
    mentionTheirWork: true,
    referenceSimilarProject: true,
    specificValueProposition: true,
    softCallToAction: true, // "Open to chatting?" not "Hire me now!"
  });
  sendViaLinkedInOrEmail(message);
}

// Expected conversion: 1-2 conversations per week
// Expected close rate: 20% of conversations → 0.2-0.4 new clients/week

What I Wish I Knew Earlier

1. Say no to bad clients. One toxic client drains more energy than 5 good ones earn.
2. Get 50% upfront. Always. No exceptions. This filters out non-serious inquiries.
3. Have a contract. Even a simple one. Scope, timeline, payment terms, revision limits.
4. Over-communicate. Weekly status updates prevent "why isn't this done yet?" emails.
5. Raise prices annually. Your best clients won't leave over a 10-15% increase.
6. Build multiple channels. Don't rely on one source of leads.

---

What's your experience with freelance work? Platform or direct?

Follow @armorbreak for more career content.