Stratco

Model any SaaS pricing scenario in two minutes

Comment

Inspiration

Not every pricing decision requires weeks of spreadsheet modeling or expensive analytics infrastructure. A founder preparing for a board meeting needs to know what a 15% price increase will do to their ARR. A growth operator needs to model conversion trade-offs before submitting a proposal. A finance lead needs confidence intervals for an investor deck, not just a single optimistic number.

Stratco was built for these moments — rigorous pricing scenario analysis that runs in under two minutes, with live industry benchmark context built in from the start.

The goal was to make quantitative pricing analysis as accessible as asking the question.

What It Does

Stratco is an Apify Actor that models SaaS pricing scenarios with probabilistic projections, real-time industry benchmarks, AI-powered narrative and scenario optimization via Apify OpenRouter, rich always-on insights, and a self-contained HTML report with Chart.js visualizations.

Core Capabilities:

Baseline unit economics calculation — Accepts five input metrics (CAC, ARPU, gross margin, churn rate, customer count) and calculates derived values: Lifetime Value (LTV), CAC payback period, LTV:CAC ratio, Monthly Recurring Revenue (MRR), and Annual Recurring Revenue (ARR). These baseline metrics establish the starting point for scenario modeling.

Pricing scenario simulation — Models the impact of a price change. The simulation engine recalculates all unit economics under the new pricing structure and produces delta values showing the change from baseline for every metric

Live industry benchmark collection — Before every simulation run, the actor queries authoritative SaaS benchmark sources using Apify's Google Search Scraper. It extracts current industry ranges for monthly churn rate, CAC payback period, and LTV:CAC ratio from search result snippets. If live scraping returns insufficient data, the actor falls back to verified benchmark ranges from published 2024 reports.

Monte Carlo confidence intervals — Runs up to 200 probabilistic simulation iterations, adding controlled variance to ARPU, churn rate, and customer count in each run, then projecting ARR forward across the specified time horizon. This produces honest uncertainty rather than a single-point forecast.

Month-by-month ARR projection — Projects MRR and ARR across 6 to 60 months, applying compounding churn month-over-month based on the scenario's adjusted churn rate.

Benchmark positioning context — Every benchmark metric returned includes not just the quartile position, but a visual position indicator (relative placement between low/median/high benchmark values) and a metric-specific note that contextualizes what the position means for the business. For example, a churn rate in the bottom quartile will include a note like "5.8% churn — bottom quartile. Significantly above the median of 2.3%. This is the primary constraint on your unit economics."

Rich insights engine (always on) — Every run produces a plain-English verdict summarizing the scenario outcome, a risk score (low/moderate/high) derived from the Monte Carlo p10/p90 spread, identification of the binding constraint limiting unit economics, confidence-weighted recommendations combining risk and benchmark position, and gap-to-next-tier values showing exactly what each metric needs to reach the next benchmark quartile. These insights require no API key and run on every simulation.

AI narrative layer (optional) — When enabled, the selected LLM receives the full simulation results and writes a board-ready 3-paragraph executive summary covering what the numbers say, the key risk, and the top 2 recommended actions. Appended to the dataset output and rendered in the HTML report.

AI scenario optimizer (optional) — Instead of defining a single scenario manually, the LLM analyzes baseline metrics and benchmark gaps to propose 3 pricing strategies

Model selection — AI features are powered by Apify OpenRouter, an OpenAI-compatible proxy that gives access to any LLM model. No separate API key is needed; authentication uses the APIFY_TOKEN automatically. Users can select any OpenRouter-supported model via the model input field

HTML report — Every run generates a self-contained dark-themed HTML page with Chart.js visualizations, shareable with no external dependencies.

How It Was Built

Stratco is a single-file Apify Actor built with Node.js and the Apify SDK v3.

Single-file architecture — All simulation logic is consolidated into one file (main.js) with inline modules: input parser validates and normalizes input, baseline engine calculates unit economics from raw inputs, pricing simulation engine applies scenario parameters and recalculates metrics, Monte Carlo engine runs probabilistic iterations with variance, benchmark collector orchestrates live scraping and fallback logic, insights engine generates verdicts and risk scores, AI narrative and scenario optimizer functions handle LLM calls via OpenRouter, HTML report generator builds the Chart.js visualization page, and results generator assembles the final output object.

Benchmark collection layer — Uses Apify's Google Search Scraper to query targeted search phrases across authoritative SaaS benchmark sources. If parsing produces fewer than two valid values for a given metric, the actor uses the hardcoded fallback benchmark from verified 2024 published reports.

Monte Carlo projection logic — For each simulation run, the engine generates normally distributed noise (Box-Muller transform) and applies it to ARPU, churn rate, and customer count within an 8% variance band. It then projects MRR forward month-by-month, compounding churn at each step, and converts the final MRR to ARR. Mean and standard deviation are calculated using the simple-statistics library.

Input validation — All baseline fields are validated at parse time.

AI integration via Apify OpenRouter — Rather than requiring users to supply their own OpenAI API key, Stratco routes all LLM calls through Apify's OpenRouter proxy (https://openrouter.apify.actor/api/v1). This is an OpenAI-compatible endpoint authenticated via the platform's APIFY_TOKEN, so AI features work out of the box on Apify with zero configuration. The OpenAI Node SDK is used as the client — only the baseURL and auth header change. Users select any OpenRouter-supported model via the model input field.

Rich insights engine — A deterministic analysis layer that runs on every simulation with no LLM dependency. It evaluates the scenario delta, Monte Carlo spread, and benchmark position to produce a verdict string, risk score, binding constraint identification, confidence-weighted recommendation, and gap-to-next-tier values for each benchmark metric.

HTML report generation — The actor builds a self-contained HTML string with inline CSS and Chart.js loaded from CDN.

What It Solves

Quantitative grounding for pricing decisions — Stratco takes real baseline metrics and produces concrete before/after projections with delta values, making the downstream impact of a pricing decision visible before implementation.

Benchmark context in internal models — A team running a pricing model in a spreadsheet can calculate that their new LTV will be $1,500, but Stratco enhances that by detailing if the position is strong or weak relative to the industry. A 5% monthly churn rate has very different implications if the industry median is 2.3% than if it is 4.8%. Without benchmark positioning, the team cannot assess whether their baseline is fragile before modeling changes on top of it. Stratco integrates benchmark context directly into the output, surfacing whether the baseline metrics are top quartile, median, or below median before the scenario runs.

Uncertainty is not communicated in pricing projections — Traditional pricing models produce a single ARR number based on a set of assumptions. This creates false precision. If conversion drops more than expected or churn rises faster than modeled, the single-number forecast becomes misleading. Stratco uses Monte Carlo simulation to produce three projections that communicate the range of probable outcomes rather than a single optimistic estimate. This allows leadership and investors to see best-case, base-case, and worst-case scenarios explicitly rather than treating a single forecast as guaranteed.

The gap between asking "what if we raise prices?" and getting a rigorous answer is too large — For most teams, answering this question requires building a custom spreadsheet model, finding benchmark data manually, and running sensitivity analysis by hand. This takes hours or days and requires fluency in unit economics modeling. Stratco reduces the entire process to a two-minute actor run with structured inputs and a complete output dataset, making quantitative pricing analysis accessible to anyone who can define the scenario parameters.

Interpreting results still requires expertise — Even with good data, translating simulation output into a clear recommendation requires understanding unit economics trade-offs, benchmark context, and risk tolerance. Stratco's rich insights engine automates this: every run produces a plain-English verdict, risk score, binding constraint, and confidence-weighted recommendation. The optional AI narrative layer goes further, generating a board-ready executive summary that synthesizes all results into three actionable paragraphs.

Exploring the scenario space manually is slow — Teams typically test one or two scenarios they've already decided on, missing better alternatives. The AI scenario optimizer solves this by analyzing baseline metrics and benchmark gaps to propose 3 optimal pricing strategies, running the full simulation on each, and returning them ranked — turning a manual exploration process into an automated one.

Challenges

ESM module compatibility — The simple-statistics library does not export a default, so import ss from 'simple-statistics' fails at runtime in Node.js ESM mode. The error only surfaced when the actor ran on the Apify platform (Node 20), not during local syntax checks. The fix was switching to named imports (import { mean, standardDeviation } from 'simple-statistics'), but diagnosing it required understanding the difference between CommonJS and ESM export semantics.

Structured Outputs and model portability — The AI scenario optimizer originally used OpenAI's Structured Outputs (response_format: { type: 'json_schema', strict: true }) to guarantee valid JSON from the LLM. When migrating to OpenRouter — where users can select non-OpenAI models — this became a compatibility concern, since not all models support the json_schema response format. Balancing strict output guarantees against model flexibility required careful consideration of fallback strategies.

Benchmark scraping reliability — Live benchmark collection depends on Google Search Scraper returning relevant snippets from specific SaaS data sources. Search result formats vary, snippets sometimes omit the numeric values, and rate limits can cause timeouts. Building a robust fallback system with verified 2024 benchmark data ensured the actor always returns useful benchmark context even when live scraping fails.

Accomplishments I'm Proud Of

Zero-config AI — By integrating Apify OpenRouter, AI features work immediately on the platform with no API key setup. A user clicks "Start" and gets an AI-generated executive summary and optimized scenarios without configuring anything beyond their existing Apify account. This removes the biggest friction point for AI-powered features in an actor.

The insights engine runs without any LLM — Verdict language, risk scoring, binding constraint identification, and gap-to-goal calculations are all deterministic. Every run gets actionable, specific insights regardless of whether AI features are enabled or whether the user has credits for LLM calls. The AI layer enhances but never gates the core value.

End-to-end in one actor run — From raw baseline metrics to a shareable HTML report with charts, benchmarks, Monte Carlo projections, AI narrative, and ranked scenario comparisons — all in a single actor execution under two minutes. No multi-step pipelines, no external dependencies to configure.

The scenario optimizer closes the loop — Most pricing tools require the user to already know what scenario to test. Stratco's AI optimizer inverts this: it analyzes the baseline, identifies gaps, proposes 3 strategies, runs the full simulation on each, and ranks them. The user gets answers to questions they didn't know to ask.

What I Learnt

Apify actor architecture — Building on Apify for the first time meant learning the full actor lifecycle: how Actor.init() and Actor.exit() bracket execution, how the key-value store and dataset APIs work, how input schemas drive the Console UI, and how prefill vs default behave differently (prefill is cosmetic, default is functional). Understanding that actors are Docker containers with a specific directory structure (.actor/actor.json pointing to the Dockerfile) was essential for getting builds to work.

Apify's scraping ecosystem — Using the Google Search Scraper actor as a sub-actor (called via ApifyClient.actor().call()) to collect live benchmark data was a powerful pattern. Learning how to pass input, wait for results, and read the output dataset of another actor from within your own actor opened up a composable approach to building on the platform.

INPUT_SCHEMA.json nuances — The input schema is more than validation — it generates the entire Console UI. Field types, editors, descriptions, prefill values, and the isSecret flag all affect how users interact with the actor. Getting this right is as important as the code itself, because a confusing input form means users won't run the actor correctly.

OpenRouter as an abstraction layer — Apify's OpenRouter proxy means actors can offer AI features without asking users for API keys, without hardcoding a specific model, and without managing LLM billing separately. The OpenAI SDK works unchanged — only the baseURL and auth header differ. This pattern makes AI features a natural extension of any actor rather than a separate integration burden.

Monte Carlo as a communication tool — The p10/p50/p90 confidence intervals aren't just statistical rigor — they're a communication device. Presenting a range instead of a point estimate changes how stakeholders engage with projections. The worst-case number grounds optimism; the best-case number justifies ambition. This framing is more valuable than the precision of any single forecast.

Who It's For

Early-stage founders preparing for fundraising conversations, board meetings, or pricing page updates who need to model the ARR impact of a proposed price change quickly and rigorously.

Growth operators who need to understand the unit economics consequences of a pricing proposal before it goes to leadership, including conversion and churn trade-offs.

Finance leads building board decks or investor updates who need confidence intervals and benchmark-positioned projections rather than single-point forecasts.

Strategy consultants and advisors working with multiple SaaS clients who need a standardized, repeatable pricing model they can run with any client's metrics in minutes.

Product managers evaluating pricing tiers or packaging changes who need to model the downstream revenue and retention effects before committing to a roadmap decision.

Use Cases

Pre-fundraise pricing check
A founder is preparing for Series A meetings. An investor asks, "What happens to your ARR if you raise prices 15%?" The founder runs Stratco with their baseline metrics and a 15% price increase scenario with an estimated 8% conversion drop. The actor returns a full projection showing ARR at 12, 18, and 24 months with p10/p50/p90 confidence intervals. The founder includes the p50 projection in the deck and references the worst-case (p10) when addressing downside risk questions.

Pricing page decision
A SaaS team is deciding between two pricing strategies: a 20% increase with an aggressive volume assumption, or a 10% increase with conservative estimates. They run both scenarios in Stratco. The benchmark panel shows their baseline churn rate is already above the industry median, making the high-volume assumption in the 20% scenario risky. The team chooses the 10% option, prioritizing retention over aggressive growth given their current churn position.

Board update scenario modeling
A growth lead needs to include a pricing sensitivity slide in the next board deck. Rather than building a spreadsheet model, they run Stratco with three scenarios: no change, +10%, and +15%. They export the confidence interval results and benchmark positioning for each scenario and present them as a comparison table, showing the board the range of outcomes under each pricing option with industry context.

Client advisory session
A consultant is working with a SaaS client evaluating a pricing restructure. They run the client's numbers through Stratco during the session. The benchmark output immediately surfaces that the client's LTV:CAC ratio is 1.8x — well below the 3.0x healthy minimum. This reframes the conversation from "how much should we raise prices?" to "we need to fix retention and payback before any pricing change will materially improve unit economics."

Investor diligence response
A Series B company receives a diligence question from a lead investor: "Your deck shows 35% ARR growth. What assumptions drive that, and what's the downside case?" The team runs their baseline pricing scenario in Stratco, exports the Monte Carlo results, and responds with p10/p50/p90 ARR projections, showing the investor that even in the worst-case (p10) scenario, they still hit 28% growth. The benchmark positioning data shows their churn and payback are both top quartile, supporting the growth projection credibility.

Integration Options

Direct API calls — Use the Apify Client to call Stratco programmatically from any application, passing baseline and scenario parameters as JSON and receiving structured results.

HTML report — Every run saves a self-contained HTML report to the key-value store as report.html. Download or embed it directly — no external dependencies needed.

Webhook triggers — Configure Stratco to run automatically when triggered by external events (e.g., monthly metrics update, pricing page change detection).

Web App — A lightweight web application built using Lovable is available as a reference implementation and is still being actively developed. The current version provides a form-based input UI, calls the actor via the Apify API, and renders core simulation results in a dashboard layout. The app does not yet surface the full set of actor capabilities — rich insights, AI narrative, AI scenario optimizer, benchmark tier badges, and the HTML report are not yet integrated into the web interface.

What's Next

Future development roadmap includes:

CSV baseline import — Upload a monthly metrics CSV from any finance tool. The actor parses the file, averages across rows, and derives baseline metrics automatically rather than requiring manual entry.

Cohort-based churn modeling — Replace the single-period churn assumption with cohort retention curves for more accurate long-term projections.

Sensitivity analysis — Automatically identify which input assumption (price change, conversion impact, or churn impact) drives the most variance in the outcome and generate edge-case variations.

Sector-specific benchmarks — Filter benchmark ranges by company stage (early-stage vs. growth vs. mature), business model (PLG vs. sales-led), and market segment (SMB vs. mid-market vs. enterprise) for more precise comparisons.

Stratco Web App — full suite companion — The current web app covers basic input and results display. The completed version will be a full companion to the actor, integrating every capability, providing the full set of value for founders, growth operators, finance leads, and consultants who need a visual interface on top of the actor's analytical engine.

Built With

Share this project:

Updates