标签：#freelance

Scope creep usually does not start with a dramatic disagreement. It starts with a reasonable-sounding request: "Can we also add this small thing?" For freelancers, consultants and small agencies, the hard part is often not the work itself. The hard part is that nobody has a clean shared record of what changed, what was included originally, what is now extra, and whether the timeline or price should move. The workflow I find most useful is deliberately simple. 1. Write the baseline before work starts Before the project begins, write down: the goal of the work what is included what is excluded assumptions dependencies what the client needs to provide This does not need to be legal language. Plain language is often better because both sides can understand it quickly. 2. Separate included and excluded work Many scope problems happen because "not included" was never written down. For example: Included: one landing page with copy and layout Excluded: email automation, paid ad setup, analytics dashboard, extra page variants That makes later conversations less emotional. You are not saying "no" from nowhere. You are comparing the new request to the original scope. 3. Pause before doing the extra work When a new request appears, write it down before starting. A useful change note can be short: requested change why it is needed impact on price impact on timeline what will be delivered approval status The point is not bureaucracy. The point is to stop invisible work from becoming normal. 4. Make timeline impact explicit Freelancers often talk about price but forget schedule. Even if the client accepts the extra cost, the original delivery date may no longer be realistic. A small change can still interrupt review cycles, dependencies or other client work. 5. Get written approval before starting This can be as simple as: "Confirmed. Please go ahead with this change at the updated price and timeline." The approval does not need to be fancy. It just needs to exist before the addit

The first time a client said yes to a quote without hesitating, I felt sick. This was early on. I'd sent over a rate for a batch of articles, my palms were actually sweaty over the email, and the reply came back in under an hour. "Sounds great, when can you start?" No pushback, no negotiation, nothing. I should have been thrilled. Instead, I sat there doing the math on how much more I could have charged, and I knew, the way you just know sometimes, that I'd priced it too low. His enthusiasm was the tell. That queasy feeling taught me more than any pricing guide ever did. If a client says yes instantly and happily, you were cheap. I've been freelancing for about eight years now, all of it writing and content work, most of it solo from a spare room in my house. I've priced my work a dozen different ways over that stretch, and I've gotten most of them wrong at some point. So here's what I actually believe about pricing, after enough scars to have earned an opinion. Per-word pricing quietly punishes you for getting better I started out charging by the word, like a lot of writers do. Five cents a word, sometimes six if I was feeling brave. It felt safe because it was easy to explain and easy for a client to say yes to. A 1,500-word article costs this much. Clean. Predictable. The problem showed up slowly. The better I got, the worse that model treated me. Early on I'd pad a piece to hit a word count because more words meant more money, which is a genuinely insane thing to be incentivized toward as a writer. Then I spent years learning to cut. Learning that the sharpest version of an article is usually the shortest one that still does the job. And every ounce of that hard-won skill made me poorer, because a tight 900-word piece that took real judgment to shape paid less than a bloated 1,400-word one I could have written half-asleep. Think about how backwards that is. I was being paid the least for the writing I was proudest of. The stuff that took a decade to be able to d

客戶開價太低嗎？Freelancer 接案前的 3 問決策樹 客戶說：「就改幾行代碼，收這麼多？」 你是不是也曾這樣懷疑過自己？ 每個 freelancer 都遇過這種時刻——客戶開了一個數字，你直覺「好像太低了」，但又說不出具體原因。以下是三個問題，幫你在 30 秒內判斷一個報價是否值得接。 3 問決策樹 Q1：這個價格是否覆蓋你的實際時間成本？ 別只算「改了幾行代碼」。真實成本包括： 讀懂陌生的 codebase（新手可能 3 小時起跳） 本地環境折騰（特別是別人維護的老項目） 測試和部署風險（部署壞了誰負責？） 客戶來回溝通的成本（「再大一點」「這個藍再淺一點」） 未知因素：如果代碼原作者已經不在，你是在維修「別人的技術債」 快速算法 ：把報價 ÷ 你估計的總小時數 = 每小時實際時薪。拿這個數字和你的底線比（建議：不是你「想要」的時薪，而是你「能接受吃飯」的時薪）。 如果低於底線 30%，進 Q2。 Q2：需求是否清楚到可以控制風險？ 報價低且需求模糊 = 高危信號。 以下任一癥狀存在，提高風險溢價或拒絕： 「就簡單改一下」——沒有定義邊界 沒有明確定義「完成」的標準——上線了算完成？客戶滿意了算完成？ 對方說「你先做再說」——這句話幾乎等於「我打算白嫖你」 沒有提供任何文件或代碼庫 access——等於讓你盲開 決策樹 ： 需求不清楚 + 報價低 → 報價必須上浮 50%，否則不接 需求不清楚 + 報價合理 → 可以談，先付定金再動工 需求清楚 + 報價低 → 進 Q3 Q3：這個案子是否帶來明確後續價值？ 有兩種情況可以在低報價下仍然接： 確定的後續項目 ：客戶明確說「這個做好了，下個月還有 X 個功能要做」 戰略性客戶 ：這個客戶有公開作品價值（大厂案例、知名公司、能寫進 portfolio 的上線項目） 如果兩者都沒有，低報價等於純粹的自我低估。 真實案例：隱藏成本解析 案例 1：$200 改 3 行 CSS 客戶說：「就改導航列的顏色，$200 應該夠了吧？」 表面看：3 行 × $66/行 = 天價。 現實： 理解整個樣式系統、找到正確的 CSS 檔案：2 小時 本地環境折騰（別人的專案，Node 版本衝突）：1 小時 反覆修改確認視覺效果：3 小時（客戶說「那個藍再淺一點、再加個 hover 效果」） 部署時發現壞了其他頁面：2 小時 客戶最後說「還是原來的好」：情緒成本 實際時薪 ：$200 ÷ 8 小時 = $25/小時，低於 freelancer 最低生存線。 案例 2：$2,000 報價改 2 天的「簡單項目」 客戶說：「做一個登入系統，就基本功能，2 個禮拜夠了吧？」 報價 $2,000，看起來還不錯。 現實： 需求訪談：4 小時（客戶一開始說「就登入」，後來才說「還要有第三方登入、密碼重置、邀請機制」） 設計資料庫結構：3 小時 實現 Registration + Login + OAuth：6 小時 測試覆蓋：4 小時 文件撰寫和交接：2 小時 實際 ：19 小時 × $105/小時 = $1,995 ——這個案子壓根不賺錢 常見陷阱：為什麼低報價 freelancer 總是吃虧 1. 「就幾行代碼」陷阱 代碼行數 ≠ 工作量。真正的成本在「理解上下文」——你得讀懂別人的代碼邏輯，這可能比你自己寫慢三倍。 2. 「簡單的 SQL」陷阱 每一條看似簡單的 UPDATE 語句，背後可能是： 凌晨 3 點資料庫突然鎖死 備份失敗、沒有測試環境 正式資料一個失误就沒了 3. 「長期合作」陷阱 客戶說「我們長期合作」通常是好事，但前提是—— 報價不能因為「長期」而打折 長期合作應該帶來穩定收入，不是穩定低價 你現在有一個具體報價嗎？ 如果客戶給了你一個數字，你不確定是否該接—— For $10, I'll review one client offer and tell you whether it looks underpriced, risky, or worth taking. 直接發報價截圖或文字到 paypal.me/cheapuno ，標註「報價審查」，24 小時內回覆具體分析。 快速決策檢查表（列印出來放桌邊） □ 報價 ÷ 預估時數 > 我的底線時薪？ □ 需求有明確定義邊界嗎？ □ 有隱藏的技術債或未知因素嗎？ □ 客戶有明確的後續項目或品牌價值？ □ 我有權利說「不」嗎？ 如果以上有任何一個「否」，這個報價需要重新談。 如果你想系統性学会如何報價、報價低了怎麼談、客戶不接受怎麼辦——歡迎從 Freelance Pricing Master Index 開始，這裡有 14 篇文章覆蓋 freelancer 定價的各種場景。

One of the hardest things about going freelance as a developer isn't writing code — it's knowing what to charge. Charge too little and you're basically doing a salaried job without the benefits. Charge too much without backing it up and you scare off clients. Most developers I've spoken to either guessed their rate or copied someone else's. Neither is a great strategy. In this article I want to walk you through exactly how to calculate your freelance day rate properly — based on real numbers, not gut feeling. Why Most Freelancers Get Their Rate Wrong The most common mistake is this: taking your old salary and dividing it by 260 working days. That ignores: Taxes (you now pay both sides of self-employment tax in the US) Unpaid days — holidays, sick days, slow months with no clients Business costs — software, hardware, insurance, accountant fees No employer pension or benefits — you fund all of this yourself If you were earning $80,000 as a salaried developer and you divide that by 260, you get roughly $307/day. But that's actually a pay cut once you factor everything in. The Right Formula Here's the framework: Step 1 — Work out your actual billable days A year has 260 working days. Subtract: Public holidays (~10 days in the US) Your own holiday allowance (~15 days) Estimated sick days (~5 days) Non-billable time: admin, chasing invoices, marketing yourself (~20 days) That leaves roughly 210 billable days. Step 2 — Calculate your real income target Take what you want to take home and gross it up for tax. If you want $70,000 net and your effective tax rate is around 30%, your gross target is roughly $100,000. Step 3 — Add your business costs Software subscriptions, hardware depreciation, liability insurance, accountant — easily $5,000–$10,000/year for a freelance developer. Step 4 — Divide by billable days $110,000 ÷ 210 = $524/day That's your minimum. Price below that and you're losing money compared to employment. A Faster Way — Use a Free Calculator If that maths mad

"Fractional CTO" has become the title people put on their LinkedIn profile when "senior developer" doesn't sound senior enough. I play this role for some of my clients, so I have opinions about what it actually means — and what it doesn't. The confusion isn't just semantics. If you hire the wrong thing under this label, you pay consulting rates for work that a good contractor would have done better. The Problem with the Label The term covers a surprisingly wide range of people and arrangements. At one end, you have experienced technical leaders — people who have actually run engineering organizations, made architectural decisions that constrained companies for years, hired and let go technical staff, and owned the consequences. At the other end, you have developers who decided their day rate felt more justifiable with a fancier title. Both call themselves fractional CTOs. The market hasn't sorted this out yet. The reason it matters: these are fundamentally different services with different prices, different deliverables, and different risks. Mixing them up is how companies end up paying €200/hour for someone to help them choose a JavaScript framework. What a Real Fractional CTO Actually Owns Owns is the operative word. Not "advises on." Not "contributes to." Owns. Technical architecture decisions. When you're building a system that will handle real volume, real users, and real money — the decisions made in the first few months constrain everything that follows. What database, what caching strategy, how the services are separated, where the complexity lives. A fractional CTO makes those calls and stakes their reputation on them. They're not writing a report about options. They're deciding. Tech stack and vendor selection. When a vendor pitches you something, someone needs to evaluate it who has seen enough vendors to know which ones are overselling. When a developer suggests a library, someone needs to know whether it's the right tool or just the tool that developer

The average knowledge worker switches between apps 1,200 times per day, according to a 2024 Harvard Business Review analysis. Each switch is small. The cumulative cost is not. For freelancers managing their own tool stack, the problem is both a productivity drain and a billing leak. What the Research Actually Says The most cited figure comes from Gloria Mark at the University of California, Irvine: it takes an average of 23 minutes and 15 seconds to fully refocus after an interruption. That number gets quoted a lot, but the context matters. Not every app switch is a full context switch. Checking Slack for two seconds is different from switching from deep coding work to a client call. A more useful framing comes from the American Psychological Association, which distinguishes between task switching (changing what you are working on) and tool switching (changing which app you are using for the same task). Both have costs, but tool switching is uniquely wasteful because it does not change the work -- only the interface. You are still working on the same problem but spending cognitive effort navigating a different app. For freelancers, the most expensive switches are the ones between a task manager and a time tracker, between a calendar and a task list, and between a project view and a communication tool. These happen multiple times per hour during active work, and each one breaks the low-level focus that produces billable output. How to Audit Your Current Tool Stack Before consolidating tools, figure out what you actually use. For one week, keep a simple log: every time you open an app to do work (not social media or entertainment), note it. At the end of the week, tally the list. Most freelancers find they use 6-10 tools daily. The typical list looks something like this: Task manager (Todoist, Asana, Notion) Time tracker (Toggl, Clockify, Harvest) Calendar (Google Calendar, Outlook) Communication (Slack, email) File storage (Google Drive, Dropbox) Invoicing (FreshBook

Here's the maths most calculators get wrong Most freelance rate calculators are wrong. Not buggy — conceptually wrong. They take your income goal, divide by hours, and hand you a number that will quietly lose you money all year. I got tired of explaining the correct calculation to freelancer friends, so I built a tool that does it properly. Here's the logic behind it, and a bit about how I built it. The flawed formula The typical calculator does this: hourly_rate = annual_income_goal / annual_hours_worked So if you want $80,000 and work 2,080 hours a year (40 × 52), it tells you to charge ~$38/hr. This is wrong in three separate ways. Fix 1: Tax is not optional Your income goal is a net number — what you want to keep. But you're taxed on gross. So the first correction is grossing up: const grossIncome = netTarget / ( 1 - taxRate ); // $80,000 / (1 - 0.28) = $111,111 That's already a $31,000 gap the naive formula ignores. Fix 2: You don't bill every hour you work This is the big one. Freelancers bill roughly 55–65% of their working hours. The rest is admin, proposals, invoicing, sales calls, and learning. const totalHours = weeksWorked * hoursPerWeek ; // 46 * 40 = 1840 const billableHours = totalHours * billableRatio ; // 1840 * 0.6 = 1104 So your real billable capacity isn't 2,080 hours. It's closer to 1,104. Pricing on the wrong denominator is how people end up working 50-hour weeks and still missing their income target. Fix 3: Business expenses come out of gross Software, hardware, insurance, courses — all real costs that need covering before you pay yourself: const totalNeeded = grossIncome + annualExpenses ; The corrected formula Putting it together: function minimumRate ({ netTarget , taxRate , expenses , weeks , hoursPerWeek , billableRatio }) { const gross = netTarget / ( 1 - taxRate ); const totalNeeded = gross + expenses ; const billableHours = weeks * hoursPerWeek * billableRatio ; return totalNeeded / billableHours ; } minimumRate ({ netTarget : 80000 ,

For the past year I worked on a remote contract with a US tech company. Paid in USD, ultimately needing Korean won. Simple, right? Then a year in, I actually reconciled what landed in my account. The exchange rate had gone up — and yet my real received amount was lower than I'd expected. I traced it, and money was leaking at every step of the transfer path I hadn't been watching. This is what I learned switching routes over that year: from a direct bank wire to Wise, the real cost difference, and one right buried in my contract. If you're a freelancer or contractor in any country earning USD from abroad, this should save you something. Money leaks in more than one place Getting USD from overseas into local currency looks like one step. It's actually at least four: The wire fee from the US bank, through correspondent banks, to the receiving bank. The exchange rate the receiving bank applies — this is the big one. The receiving fee on the destination side. A hidden "lifting charge" some correspondent banks skim. The largest is the rate. Banks quote two rates, and the "buyer rate" applied when an individual sells dollars is worse than the mid-market reference — typically a 1.5–2% spread . On $1,000, that's $15–20 gone to the rate alone. That number looks small. Accumulated over a year, it stops looking small. Route A — receiving directly through a major US bank My first setup was the simplest: the company wired USD to my US bank account, and I wired it on to my Korean bank. I picked this at contract start without much thought, assuming the client would conventionally cover fees anyway. (Lesson one: specify the transfer method, route, and who pays in the contract. ) The problem was the bank's exchange rate. It applied the buyer rate straight up, with a wider-than-usual spread versus mid-market — plus a send fee, plus the Korean receiving bank's fee. I only noticed months in. Comparing statements, there was a steady 2–3% gap between the won I'd expect at mid-market and t

Two years ago, when I got my first freelance client, I was still in my final semester of college. A...