WhenToProfit

Know when your small business makes money.

Comment

Inspiration

Recently, I spent a lot of time learning Finance, especially financial modeling.

Building a financial model was much harder than I expected. It requires you to think about assumptions, scenarios, how metrics (COGS, Cash Conversion Cycle, Liabilities, etc.) relate to each others, and many other things at the same time.

But I realized something: I was learning this because I had the time and motivation to study finance. Many builders and small business owners around me don't.

They often have much simpler questions:

  • How much money do I need to survive if I quit my job?
  • How much cash do I need to sustain my business before it becomes profitable?
  • When will my business break even?
  • If I increase my price by 20%, will it actually help?
  • What happens if I hire someone next month?
  • What can I change to improve my profit?

These are financial questions, but they shouldn't require everyone to become a financial analyst first.

That became the inspiration for WhenToProfit.

My ambition is to eventually build a financial guide and decision-support tool for builders and small business owners — something that helps them understand their business financially and make better decisions without needing a finance background.

What it does

WhenToProfit is a simple financial planning and decision-support tool for builders and small business owners.

I built it around a few questions that I think many entrepreneurs have but often struggle to answer:

  • How much money do I need to survive if I quit my job?
  • How much cash do I need to sustain the business before it becomes profitable?
  • When will the business break even?
  • What happens if I increase my price?
  • What happens if I hire someone?
  • What can I change to improve my profit?
  • How much could the business be worth under a simple valuation approach?

The goal is not to replace accounting software or build a complete financial system. Instead, WhenToProfit focuses on turning financial modeling into something more understandable and actionable for people who don't have a finance background.

The tool supports two common business types:

  • Tech / Solo businesses, such as SaaS and mobile apps
  • Retail / F&B businesses, where revenue can be estimated from visitors, conversion rate, operating days, customers, and average order value

At the core, the model connects simple assumptions to practical financial outcomes:

$$ Revenue = Volume \times Price $$

$$ Gross\ Profit = Revenue - Variable\ Costs $$

$$ Operating\ Profit = Gross\ Profit - Fixed\ Operating\ Expenses $$

$$ Cash\ Flow = Operating\ Cash\ Flow - CapEx + Financing $$

From these inputs, WhenToProfit estimates monthly revenue, gross profit, operating profit, cash flow, cash balance, break-even timing, cash-flow-positive timing, runway, and a simplified valuation.

The other important part is scenario planning.

Instead of forcing users to build a complicated 24-month financial spreadsheet, they can describe business changes as events. For example:

  • Increase the price by 20% in July
  • Hire 5 engineers in January
  • Improve monthly churn from 5% to 3%
  • Raise $2M in March

The user can then compare different scenarios and see how those decisions change the financial outcome.

I also built WebMCP into the product so an AI agent can interact with the financial model instead of only talking about it. The agent can read assumptions and results, analyze the business, simulate decisions, compare scenarios, and perform structured actions such as creating scenarios or adding and moving scenario events.

This creates an experience where the agent can help the user explore financial decisions while the user remains in control of the actual business plan.

How I built it

I built WhenToProfit in about two days, from the initial idea to the final submission.

The project uses Next.js, TypeScript, a client-side financial calculation engine, local project storage, and WebMCP.

I deliberately kept the architecture simple because the goal was to build a useful prototype quickly rather than create a large backend system.

The financial model is separated from the UI so that the same calculation logic can be used by the dashboard, scenario simulations, and WebMCP tools.

The project uses a scenario-based approach. A base case contains the original assumptions, while other scenarios describe changes to those assumptions over time.

For WebMCP, I designed the tools around three stages:

Read → Analyze → Act

The agent can first understand the current project and financial model, then analyze or simulate possible decisions, and finally make structured changes to scenarios when the user wants to act.

I also wanted WebMCP actions to use the same mutation paths as the normal application UI whenever possible. This means an action performed by an agent updates the same application state and persistence layer rather than creating a separate system just for AI.

One important design decision was keeping the Base Case immutable. Agents can create and modify other scenarios, but they cannot directly modify the original base assumptions.

I also added persistence for the active scenario so that the user's current planning context remains after switching projects or reloading the application.

For development, I used AI heavily and treated it as a coding partner. I broke the work into small steps, gave it detailed product requirements, reviewed the generated implementation, ran builds and tests, and corrected the direction when something didn't match the intended product.

Challenges we ran into

1. Building a financial model without making the product too complicated

Financial modeling can become extremely complex very quickly.

I deliberately avoided trying to build:

  • Full accounting
  • Tax calculations
  • Double-entry bookkeeping
  • Complex debt models
  • Detailed cap tables
  • Banking integrations

Instead, I focused on the financial questions that are most useful for an early-stage builder.

That constraint helped me keep the product understandable and practical.

2. Making WebMCP actually useful

I didn't want to add WebMCP just because the hackathon required it.

I had to think carefully about which parts of the product an agent should actually be able to interact with.

This led me to think about the experience in three stages:

Read → Analyze → Act

The agent should first understand the business, then help analyze possible decisions, and finally be able to take structured actions when appropriate.

This was an important design challenge because I wanted WebMCP to feel like a natural extension of the product rather than a separate feature added for the hackathon.

3. Controlling AI while working under a very short deadline

My biggest development challenge was probably not writing code.

It was controlling the scope.

I had only two days, so I had to continuously ask:

"Is this feature actually necessary?"

"Does this help the core financial question?"

"Will this make the user experience better?"

"Is WebMCP actually useful here?"

I had to guide the AI step by step instead of letting it build too much at once.

Accomplishments that I'm proud of

The biggest accomplishment is going from an idea to a working financial planning product in about two days. Building it helped me revisit my financial knowledge in a much more practical way, while also learning how to use AI to build a real product under a very tight deadline.

I'm especially proud of seeing a possible future of work where people can collaborate with AI without being technical. I see WebMCP as a smooth bridge toward a more AI-native web, where existing websites can become tools that AI can understand and interact with.

More importantly, I see this as a way for small entrepreneurs to leverage AI more naturally — not by learning how to code, but by simply working with AI through the tools they already use.

What we learned

This project gave me two very different kinds of learning: financial modeling and building with AI.

Financial modeling

Before this project, I mostly understood financial modeling as something you study.

Building WhenToProfit made me understand it as a way to support decisions.

The important flow became:

Assumptions → Model → Scenarios → Financial Results → Decisions

A financial model becomes much more useful when the numbers help someone decide what to do next.

I also learned how difficult it is to simplify a financial model without making it meaningless. Every metric and assumption needs to have a reason to exist.

Building with AI

I also learned a lot about vibe-coding.

AI can make implementation incredibly fast, but it doesn't remove the need for product thinking.

In fact, I found that clear direction becomes even more important.

When my requirements were specific, AI helped me move extremely quickly. When my requirements were vague, it was easy for the implementation to grow in the wrong direction.

So one of my biggest lessons from this project is:

AI can dramatically accelerate implementation, but product thinking and clear direction are still the bottleneck.

I also learned that building with AI is not just about generating code. It is about continuously communicating the product intent, reviewing the result, testing assumptions, and keeping the system aligned with the original goal.

What's next for WhenToProfit

WhenToProfit is currently a focused prototype, but I see it becoming much more than a break-even calculator.

My long-term goal is to turn it into a financial guide and decision-support tool for builders.

Future directions could include:

  • More business models
  • Better financial planning guidance
  • More advanced scenario analysis
  • Customer and unit-economics metrics
  • More useful business health diagnostics
  • AI-guided financial planning
  • Goal-based business planning
  • More agent capabilities through WebMCP

Ultimately, I want WhenToProfit to help someone go from:

"I have an idea, but I don't know if I can afford to build it."

to:

"I understand my numbers, I know what I need to survive, and I know what I can change to improve my chances."

That's the problem I'm excited to keep working on.

Built With

  • chatgpt
  • deepseek
  • openrouter
  • vercel
  • vscode
Share this project:

Updates

Submission history