Early in my freelancing journey — back when I was still figuring out how working from Luxor actually operates — I billed hourly because it felt safe. It took me embarrassingly long to notice the trap: the better I got, the less I earned. A refactor I quoted at 15 hours started taking six. Same quality, same outcome, 60% of the money — effectively a punishment for competence.
The hourly trap, stated plainly
Hourly billing converts your efficiency into the client's discount. Worse, it invites micro-audits: itemized timesheets, questions about why Tuesday took four hours, silent suspicion around fast turnarounds. And it caps income at hours × rate — a ceiling you can only push by working more or raising rates incrementally, forever, against resistance.
The client isn't buying hours. Nobody wants hours. They want the checkout flow that stops leaking carts, the admin panel their team stops complaining about, the AI agent that handles tier-one tickets. Price that.
Anchoring on value, honestly
I'm not talking about magic multipliers or charging whatever desperation allows. Practical version:
- Ask what the problem costs monthly — abandoned orders, support hours burned, opportunities missed.
- Estimate what fixing it is worth over a conservative window (say, 3–6 months).
- Set the fee at a fraction of that, low enough that saying yes is easy arithmetic for the client.
A booking system that recovers even $800/month in missed appointments justifies a $4,000 build in five months of pure recovered revenue. Framing it that way changes the negotiation from "why so much?" to "when can you start?"
Tiered proposals do the selling for me
Every proposal now ships with three options:
- Essential — the core problem solved, nothing else. Safe floor price.
- Complete — essential plus the polish, analytics, handover docs, training. Priced ~1.8× essential. This is what most clients pick.
- Partnership — complete plus a retainer for iterations and priority support. For the minority who say yes, it's the best revenue in the business.
Anchoring works: the middle option reads as obvious once it sits between two others. Without tiers, clients anchor on the single number and negotiate downward. With them, they self-select upward.
Estimating without lying to myself
Fixed-price billing lives or dies on estimation discipline:
- Break work into deliverables no bigger than two days each; vague line items hide unknowns.
- Add a 25–40% buffer for integration friction, feedback loops, and the client's cousin who has opinions about fonts.
- Keep a private log of estimate vs. actual for every project. After ten entries, you know whether you're systematically optimistic (you are) and by how much.
Scope creep gets handled with scope, not suffering: "Happy to include that — here's how it adjusts the timeline and price." New requirement, new line item. Discounts get traded for something: a testimonial, a case study, flexible deadlines, faster payment terms.
Where hourly still earns its place
Two cases: genuinely open-ended discovery, where nobody knows the shape of the work yet (time-boxed sprint, fixed maximum); and legacy archaeology — inheriting a codebase someone else haunted, where estimates are astrology until you're inside it. Even then, I convert to fixed price as soon as the fog lifts.
And some red flags mean raise the price or walk: unlimited revisions requested upfront, refusal to do any discovery, "budget is tight but scope is flexible," or a story about how the last three developers failed them.
Clients don't pay for your hours — those are gone either way. They pay for the version of their business that exists after you've left. Bill accordingly.
