Learn probabilistic forecasting for solo devs: model best, likely, and worst-case revenue scenarios to plan quarters with confidence.
You're staring at last quarter's numbers. Revenue came in at $18K. You need to plan for Q3. The question isn't just "what will happen?" It's "what could happen, and what should I do about each possibility?"
That's where probabilistic forecasting comes in—and it's not as intimidating as it sounds.
Probabilistic forecasting is the practice of modeling multiple potential outcomes for your business, each weighted by likelihood. Instead of betting everything on a single forecast ("I'll hit $22K next quarter"), you build three scenarios: best case, likely case, and worst case. Each scenario gets a probability estimate—maybe 20% chance of best case, 60% likely, 20% worst case. Then you plan your business around all three.
For a solo programmer or small dev team, this matters because your revenue isn't stable. A big client might renew, or they might not. A project scope might expand, or a contract might end early. A new lead might close, or it might stall. Probabilistic forecasting lets you account for that volatility without pretending you have a crystal ball.
The beauty of three-scenario modeling is that it's simple enough to actually do—you don't need fancy software or a statistics degree—but powerful enough to change how you plan. It forces you to think through the levers that move your business. It reveals which outcomes you should prepare for. And it gives you something concrete to track against.
Most solo programmers and indie developers forecast one way: they guess. They look at last month's revenue, add a little for optimism, and call it a plan. Then reality hits—a client churns, a project slips, a deal falls through—and the plan evaporates.
Scenario planning is different. It acknowledges that your business has range. Some quarters will be strong. Some will be weak. Some will surprise you. By modeling all three, you're not being pessimistic or optimistic. You're being realistic.
Consider a concrete example. You're a backend developer with three main clients:
Now you can plan. In the worst case, can you cover your living expenses and stay solvent? In the likely case, can you invest in tooling or marketing? In the best case, should you hire help or save for a dry spell?
This is what scenario planning actually does: it converts uncertainty into actionable decisions.
Let's be precise about what each scenario means. This clarity matters because vague definitions lead to vague forecasts.
Worst case is not "the business fails and you get no revenue." That's not useful. Worst case is the realistic downside—the outcome you'd be surprised not to hit if things go poorly.
For worst case, assume:
If you're more project-based (less stable retainer revenue), worst case might be 50% of likely. If you're heavily retainer-dependent, it might be 80% of likely.
Likely case is what you actually expect to happen. Not optimistic, not pessimistic—the outcome you'd bet your quarter on if you had to pick one.
For likely case, assume:
Best case is not "everything goes perfectly." It's the realistic upside—what happens if a few good things break your way.
For best case, assume:
The key constraint: best case should still feel achievable. If it requires everything to go perfectly and you to work 100-hour weeks, it's not best case—it's fantasy.
Now let's build an actual forecast. You'll use a spreadsheet; you don't need fancy software. The goal is to have three columns—best, likely, worst—with explicit assumptions under each.
Start by itemizing every way money comes in. For most solo developers, this is:
| Revenue Stream | Current Status | Likely Q3 Revenue | |---|---|---| | Client A Retainer | Active, stable | $18K (6K × 3) | | Client B Project | Renewal pending | $8K (if renews) | | Client C Retainer | New, growing | $6K (2K × 3) | | New Project | Pipeline | $0 (not yet booked) | | Total | — | $32K |
Wait—that's $32K, not $24K. Let me adjust: Client B is uncertain (60% likely to renew), and the new project is speculative (not yet booked). So likely case is:
For each revenue stream, write down what has to happen for best, likely, and worst cases. This is the hard part—it forces you to think through the levers.
Client A Retainer ($6K/month):
Add up each scenario:
| Scenario | Client A | Client B | Client C | New Project | Total | |---|---|---|---|---|---| | Worst | $0 | $0 | $0 | $0 | $0 | | Likely | $18K | $8K | $6K | $4K | $36K | | Best | $21.6K | $12K | $9K | $10K | $52.6K |
Hold on—worst case of $0 is too pessimistic. You're not losing all clients. Let me recalculate with more realistic worst-case assumptions:
Worst case: Client A stays (retainer is stable), Client B churns, Client C stays, no new project.
Now estimate the probability of each scenario. This doesn't have to be precise—it's a gut check.
With probabilities, you can calculate an expected value: the weighted average of all scenarios.
Expected Value = (Worst × 20%) + (Likely × 60%) + (Best × 20%) Expected Value = ($24K × 0.2) + ($36K × 0.6) + ($52.6K × 0.2) Expected Value = $4.8K + $21.6K + $10.52K = $36.92K
Your expected quarterly revenue is roughly $37K. That's your planning baseline.
Now that you have three scenarios, you can think about the shape of your forecast. Probabilistic forecasting typically uses a probability distribution—a curve showing the likelihood of each outcome.
For a three-scenario model, you're approximating a distribution with three points. The simplest assumption is a triangular distribution: worst case, likely case, and best case form the vertices of a triangle.
In a triangular distribution:
If you're more uncertain, your distribution is flatter—the peak is lower, and the tails are fatter. If you're more confident, the peak is sharper, and the tails are thinner.
For the backend dev example, the triangular distribution looks like:
Likely ($36K)
/\
/ \
/ \
/ \
Worst Best
$24K $52.6K
The area under the curve represents probability. Most of it is clustered around $36K, with some spread toward the extremes.
Now you have three scenarios and probabilities. How do you actually use this to make decisions?
Your likely case is your baseline plan. If you expect $36K in Q3, you can:
Your worst case is your risk buffer. If worst case is $24K, you need to answer:
Your best case is your upside scenario. If best case is $52.6K, you should ask:
One of the most valuable uses of three-scenario modeling is identifying concentration risk. For solo developers, this is critical: if one client is 50% of your revenue, you're exposed.
Let's revisit the backend dev example. In the likely case:
With three-scenario modeling, you can see this risk clearly. You can then decide: do you want to reduce Client A concentration? If so, how? More sales effort? Higher rates to other clients? A new product line?
This is where scenario planning becomes strategic. You're not just forecasting; you're identifying what risks matter and what you should do about them.
A forecast is only useful if you update it. Here's how to keep your three-scenario model current:
Once a month, check your actual revenue against your forecast. Did you come in above or below likely case? Why?
Halfway through the quarter, you have real data. Use it. If you've booked half your likely case revenue by mid-quarter, you're on track. If you've booked 60%, you're likely to exceed forecast. If you've booked 30%, you're behind.
Adjust your scenarios accordingly. Don't wait until quarter-end to realize you've missed.
At the end of each quarter, rebuild your three scenarios for the next quarter. What did you learn? Which assumptions held? Which were wrong?
Here are pitfalls to watch for:
Best case should be achievable. If it requires you to work 100-hour weeks, land three new clients, and have zero churn, it's not best case—it's fantasy. Recalibrate. Best case should feel like "things went well, I executed well, and I caught some breaks."
Worst case should be realistic, not catastrophic. If worst case is "I lose all clients and have zero revenue," you're not building a useful model. Recalibrate. Worst case should feel like "things went poorly, a major client churned, and deals stalled."
If your business is seasonal (e.g., more project work in Q1, slower in Q4), your scenarios should reflect that. Don't use the same forecast for every quarter.
A forecast is only useful if it's current. If you build it in January and never touch it again, it's worthless by March. Build it, then update it monthly.
Your scenarios aren't predictions. They're possibilities, weighted by likelihood. You're not saying "I will hit $36K." You're saying "I expect to hit $36K, but I could hit anywhere from $24K to $52.6K, and I'm prepared for any of those outcomes."
Once you're comfortable with basic three-scenario modeling, you can add sophistication: correlations between scenarios.
For example, in the backend dev case, Client A and Client B aren't independent. If you're in a recession, both are more likely to churn. If you're in a boom, both are more likely to expand. They're correlated.
Simple three-scenario modeling assumes independence, which is fine for a first pass. But if you want to be more precise, you can model correlations:
You can build a three-scenario forecast in a spreadsheet. But if you're running a business, you're also tracking invoices, expenses, and actual revenue. Pulling all that together into a coherent forecast is tedious.
This is where tools come in. Cashierr is built specifically for solo developers who want to forecast revenue without leaving their spreadsheet behind. Instead of manually updating scenarios each month, Cashierr's AI agents track your invoices, clients, and revenue in real time, then help you model best, likely, and worst cases automatically.
The advantage isn't just convenience. It's that your forecast stays current. As your business changes—a client churns, a deal closes, a rate increases—your scenarios update. You're not forecasting based on stale data.
If you're serious about understanding your business, tools that automate the data layer let you focus on the strategy layer: which scenarios matter? Which risks should you hedge? Where should you invest?
Let's walk through a complete three-scenario forecast for a different solo developer: a full-stack engineer doing contract work.
Current Revenue:
Worst Case (25% probability):
This developer expects to make roughly $30K in Q3, with a range of $24K to $37K. They can plan expenses and goals based on $30K. They can prepare for a worst case of $24K (six months of runway if burn is $4K/month). And they can identify upside (retainer growth and new projects) if things go well.
Three-scenario forecasting is powerful, but it's not enough on its own. To truly understand your business, you need to track it alongside other metrics.
When you're using Cashierr or building your own dashboard, include:
Here's what shifts when you move from single-point forecasting to probabilistic forecasting:
Before: "I'll make $30K next quarter." (Probably wrong. Maybe you make $25K. Maybe $35K. You're frustrated either way.)
After: "I expect to make $30K, but I could make $24K or $37K. Here's what I'll do in each case." (You hit $25K. You're not surprised. You're prepared.)
The difference is psychological and strategic. Psychologically, you're not shocked when things don't go exactly as planned—because you planned for multiple outcomes. Strategically, you're making decisions based on a range of possibilities, not a single guess.
For solo developers and indie teams, this matters because your revenue is volatile. You can't predict it perfectly. But you can model it thoughtfully. And thoughtful modeling beats guessing every time.
Start here:
The goal isn't perfect prediction. It's thoughtful planning. Three-scenario forecasting gets you there.
Master the 3-bucket system for solo developers: operating, tax, and profit accounts. Stop leaving money on the table and make tax season painless.
Master your solo dev finances in 30 minutes every Friday. Track revenue, expenses, goals, and cash flow with this step-by-step ritual.
Master revenue forecasting by tracking just 5 metrics. Learn which data points drive 80% of forecast accuracy for freelance developers.