The first developer I hired ran with $14,000 of mine and shipped a half-broken WordPress site I had to throw away. The second one was great. Between the two, I learned roughly everything that's now in this article.
Hiring developers in Australia in 2022 isn't hard because the market is bad, it's hard because the signals founders use to evaluate other professional services don't carry over. Here's a working framework, plus the warnings I wish I'd had.
Where to actually find them
Six channels are worth your time, in roughly this order:
- Trusted networks (FindDevs, Toptal, top-tier agencies): highest quality, most expensive. Worth it for anything mission-critical.
- Referrals from other founders: highest signal, slowest to mature. Always ask in your founder Slack/WhatsApp first.
- LinkedIn: reasonable for senior contractors. Worse for agencies because everyone looks identical.
- X (Twitter), Bluesky, Indie Hackers: excellent for finding senior individuals with track records you can read.
- Upwork, Freelancer: last resort for small jobs. Ignore for anything over $5k. The signal-to-noise is too low.
- Local meetups: Sydney JavaScript, Melbourne Devs, Brisbane Dev, surprisingly effective for finding mid-senior devs who aren't actively job-hunting.
The shortlist test
Before you ever get on a call, look at three things:
- Their last three projects. Real URLs, real screenshots, ideally a case study. "I worked on X" without a link is meaningless.
- How they write. Not their grammar, their reasoning. Read their proposal email. Do they ask the right questions? Do they push back where they should? Or do they just say yes to everything?
- Their reference list. Two or three Australian clients you can actually call. Anyone who can't produce that has either no clients or no Australian ones, and either is a problem.
The clearest predictor of a successful project is the developer pushing back on something in your brief during the first call.
The first call
Half an hour is enough. Cover four things:
- Walk them through the brief. Watch which parts they ask follow-up questions on. Good developers probe scope, integrations, and edge cases. Bad ones nod and quote.
- Ask about a similar project they've done. Specific timeline, specific budget, specific outcome. If they can't give you all three, they probably haven't done one.
- Ask what could go wrong. Senior developers can list five risks in your project off the top of their head. Junior or dishonest developers will tell you nothing will go wrong.
- Ask about handover. Where will the code live? Whose accounts? What happens if they get hit by a bus? Anyone who doesn't have a clean answer to handover is going to lock you in.
Seven warning signs to walk away
- They quote without asking questions. Means they're not actually scoping; they're estimating from a template.
- The quote is one number, not a breakdown. No design line, no testing line, no handover line. They're hiding either complexity or thin margins.
- They want 50%+ upfront. Industry standard is 25–40% deposit, milestones thereafter. Anyone insisting on more is either undercapitalised or planning to disappear.
- "You don't need a contract, we'll just keep it simple." Always a contract. Always.
- The portfolio is "under NDA" for everything. One or two NDAs is normal. A whole portfolio behind NDA usually means there's nothing to show.
- They want to host everything on their account. Subtle lock-in. The code, the cloud, the domain, anything they "manage for you" is something you can't take away.
- They commit to your timeline without arguing. Six weeks for ten weeks of work means you'll get six weeks of work in ten weeks.
The shape of a healthy contract
The contract you want has, at minimum:
- A scope you can read in fifteen minutes.
- Fixed deliverables with milestone payments, not hourly billing for fixed-scope work.
- An IP transfer clause that says the code is yours from the moment you pay.
- A no-poach clause if you care about it (most don't, but it's standard to ask).
- A get-out clause: you can end the engagement at any milestone, paying only for completed work.
- A bug warranty: 30–90 days post-launch where they fix bugs free.
Working together once they're hired
Three habits that double your hit rate:
- Weekly demos, not weekly status reports. Status reports lie. Working software doesn't.
- Stage early. A staging environment from week one means you spot issues at week two, not week ten.
- Push back on scope creep, yours. The biggest reason projects blow timelines is the founder adding "just one more thing" every Friday. If it's not in the original scope, it's a re-quote.
The bottom line
Hiring developers in Australia is reference-driven, not credential-driven. Find someone whose last three projects look like yours, who pushes back on your brief, and who has a clean handover plan. The rest is just discipline.
If you don't have time for the search, FindDevs does it for you, three vetted Australian developers, hand-matched to your scope, in 24 hours. Free.