Solo Pricing Floor Calculator (Airtable + Sheet): Capacity × Utilization × Ops/LLM Buffer

Give each deal a short name so you can compare scenarios (mini‑project vs retainer).

Choose your working currency for the outputs. If a vendor shows EUR (e.g., n8n Cloud), set [EUR→USD FX] below or your preferred cross-rate.

Hours you expect to spend actively delivering this deal in the billing period (project total or monthly for retainers). Valid range: 1–200. Example defaults: mini‑project 12; retainer 30.

Your realistic share of time that ends up billable in the period. Default 0.70 (70%). Range: 0.55–0.80 for solos depending on sales/admin load. Note: SPI Research (press release) reported 68.9% average billable utilization, below a 75% target (retrieved 2026‑06‑05).

Your target effective hourly earnings for delivered work, before profit/reserve. This should already reflect your personal draw and overhead. Default: [150] (example). Range: 75–350 depending on market. Optional helper below can compute this from monthly capacity.

If you don’t have a confident hourly, compute one here and paste it into [Target Effective Hourly Rate].

• [Monthly Personal Draw $]
• [Monthly Overhead $] (software, tools, infra, insurance; exclude per‑deal ops/LLM)
• [Tax Reserve %] (e.g., 0.25)
• [Profit/Owner Reserve %] on labor (e.g., 0.10–0.20)
• [Weekly Capacity Hours] (e.g., 35)
• [Working Weeks/Month] (default 4.33)
• [Utilization Target %] (reuse) Formulas:
• Available Billable Hrs/Month = Weekly Capacity × Weeks/Month × Utilization
• Required Monthly Revenue (pre‑profit) = (Draw + Overhead) × (1 + Tax Reserve)
• Target Effective Hourly Rate = Required Monthly Revenue ÷ Available Billable Hrs × (1 + Profit/Owner Reserve)

Paste the official page link and date you checked prices. Don’t hardcode plan tiers—use the live slider/UI when you update costs.

• [Zapier Pricing URL] (e.g., https://zapier.com/pricing)
• [Make Pricing URL] (e.g., https://www.make.com/en/pricing)
• [n8n Pricing URL] (e.g., https://n8n.io/pricing)
• [OpenAI API Pricing URL] (e.g., https://openai.com/api/pricing/)
• [Retrieved Date: YYYY‑MM‑DD] (default today)

If any plan cost is shown in EUR, provide a conversion for unified outputs.

• [EUR→USD FX] (default 1.10) or leave 1.00 to keep vendor currency native.

Decide if you model Zapier for this deal. If no, set Runs/Month = 0.

• [Zapier Plan Price $/mo] (from pricing slider)
• [Included Tasks/Month] (from plan)
• [Tasks per Run] (successful action steps only; triggers/filters often don’t count; see Zapier Help updated 2026‑05‑29)
• [Runs/Month Attributable to Deal]
• [Overage Task Unit Price $] (if you buy task add‑ons or use pay‑as‑you‑go)
• [Share Method] = Pro‑rata by tasks or Flat % allocation Cost logic (monthly, attributable to this deal):
• Monthly Tasks (deal) = Tasks/Run × Runs/Month
• Plan Share $ = (Monthly Tasks (deal) ÷ Total Account Tasks) × Plan Price (if pro‑rata)
• Overage $ = max(Monthly Tasks (account) – Included Tasks, 0) × Overage Unit Price × Deal’s % of overage
• Zapier Cost $ = Plan Share $ + Overage $

Decide if you model Make for this deal. If no, set Runs/Month = 0.

• [Make Plan Price $/mo]
• [Included Credits/Month]
• [Credits per Run (non‑AI modules)]
• [AI Extra Credits per Run] (for AI features; see Make Help: credits vs operations)
• [Runs/Month Attributable to Deal]
• [Extra Credit Unit Price $] (if you auto‑purchase or buy packs)
• [Apply +25% Overage Surcharge?] (toggle; Make Help states extra credits include a 25% additional cost) Cost logic (monthly, attributable):
• Monthly Credits (deal) = (Credits/Run + AI Extra Credits/Run) × Runs/Month
• Plan Share $ = (Monthly Credits (deal) ÷ Total Account Credits) × Plan Price (if pro‑rata)
• Overage $ = max(Monthly Credits (account) – Included Credits, 0) × Extra Credit Unit Price × (1 + 0.25 if surcharge on)
• Make Cost $ = Plan Share $ + Overage $

Choose Cloud or Self‑host. If Cloud and priced in EUR, convert with [EUR→USD FX]. If Self‑host, enter infra costs. Cloud fields:

• [n8n Cloud Plan Price €/mo]
• [Included Executions/Month]
• [Executions per Run]
• [Runs/Month Attributable to Deal]
• [Overage Unit Price €] (if applicable) Self‑host fields:
• [VM/Server $/mo], [Bandwidth $/mo], [Other $/mo] Cost logic (monthly, attributable):
• Monthly Executions (deal) = Executions/Run × Runs/Month
• Cloud Plan Share $ = (Executions (deal) ÷ Total Executions) × (Plan Price € × FX)
• Overage $ = max(Total Executions – Included, 0) × Overage Unit Price × FX × Deal’s % of overage
• Self‑host $ = Sum of infra costs × Deal’s % allocation
• n8n Cost $ = Cloud Plan Share $ + Overage $ OR Self‑host $

LLM tokens and optional container sessions for agents/batch jobs.

• [Model Selector] (e.g., GPT‑5.5 / GPT‑5.4 / GPT‑5.4 mini)
• [Input $/M tokens], [Output $/M tokens] (from OpenAI Pricing; retrieved 2026‑06‑05)
• [Batch Mode?] (toggle; Batch API applies 50% discount to token rates when on)
• [Avg Input Tokens per Run], [Avg Output Tokens per Run]
• [Runs/Month Attributable to Deal]
• [Container Price $/session], [Sessions per Run], [Minutes per Session] (OpenAI containers bill per 20‑minute session; pricing changed effective 2026‑03‑31) Cost logic (monthly):
• Token Cost/Run = ((InputTokens/1e6 × Input $/M) + (OutputTokens/1e6 × Output $/M)) × (0.5 if Batch on else 1)
• Container Sessions/Run = ceil(Minutes per Run ÷ 20) × Sessions per Run
• Container Cost/Run = Container Sessions/Run × Container Price
• LLM Cost/Month (deal) = (Token Cost/Run + Container Cost/Run) × Runs/Month

A conservative cushion for ops variance and overage mechanics. Default 0.30 (30%). Justification: Make’s extra credits carry a documented +25% surcharge; spikes happen mid‑month and LLM usage varies, so 25–30% protects margin.

Pick the tightest promise you’ll make for this deal. If the tier is infeasible for a solo operator, the calculator will force a hard reject.

• Standard (next business day response, no uptime guarantee) → Multiplier ×1.00
• Priority (same‑day response, reasonable hours) → ×1.20
• Critical (≤4‑hour response, extended hours or on‑call) → ×1.50–2.00 and feasibility gate Feasibility gates (edit to taste):
• If coverage requires 24×7 or <2‑hour response without shared on‑call → Reject
• If target availability commitment >99.9% without redundant infra/runbooks → Reject Note: Tighter SLAs shrink error budgets and raise cost (Google SRE guidance).

Owner’s profit or contingency on top of labor+ops. Default 0.20 (20%). Range: 0.10–0.35 depending on risk.

Choose how you’ll present the number.

• [Rounding Rule] = Nearest $50 / $100 / $500
• [Proposed/Quoted Price $] (optional for Accept/Reject gate)

Covers non‑billable time so your hours don’t underprice the work. Formula:

• Utilization Uplift = 1 ÷ [Utilization Target %]
• Labor Floor $ = [Estimated Delivery Hours] × [Target Effective Hourly Rate] × Utilization Uplift

Break out by platform to see drivers. Formulas (monthly, attributable to this deal):

• Zapier Cost $ (see Zapier Model)
• Make Cost $ (see Make Model)
• n8n Cost $ (Cloud or Self‑host model)
• OpenAI LLM Cost $ (tokens + containers)
• Ops/LLM Subtotal $ = Sum of above
• Ops/LLM Buffer $ = Ops/LLM Subtotal × [Ops/LLM Buffer %]

Pre‑SLA Floor $ = [Labor Floor $] + [Ops/LLM Subtotal $] + [Ops/LLM Buffer $] Owner Reserve Added $ = Pre‑SLA Floor × [Profit/Reserve %] Pre‑Round, Pre‑SLA Total $ = Pre‑SLA Floor + Owner Reserve Added $

Final Floor (Before Rounding) $ = [Pre‑Round, Pre‑SLA Total $] × [SLA Multiplier] Final Floor (Rounded) $ = Apply [Rounding Rule]

If [SLA Tier] violates any feasibility gate → Status = HARD REJECT. Else if [Proposed/Quoted Price $] < [Final Floor (Rounded) $] → Status = REJECT (Below Floor). Else → Status = ACCEPT (Meets Floor).

Auto‑generate plain‑language notes to paste in your quote:

• "Floor assumes [Model] with [Batch on/off], avg [InputTokens]/[OutputTokens] tokens per run."
• "Ops buffer set to [X%] to cover Make/Zapier/n8n overage variance."
• "SLA tier: [Standard/Priority/Critical]; price includes ×[multiplier]."
• "Vendor pricing pages checked on [Retrieved Date] — links in calculator."

Pseudocode you can copy into a Sheet or Airtable formula fields.

• Uplift = 1 / Utilization
• Labor$ = Hours × Rate × Uplift
• Zapier$ = Zap_PlanShare$ + Zap_Overage$
• Make$ = Make_PlanShare$ + Make_Overage$
• n8n$ = n8n_CloudShare$ + n8n_Overage$ OR n8n_SelfHost$
• TokenRun$ = ((InTok/1e6 × In$/M) + (OutTok/1e6 × Out$/M)) × IF(Batch, 0.5, 1)
• ContainerRun$ = CEILING(MinPerRun / 20) × SessionsPerRun × Container$/Session
• LLM$ = (TokenRun$ + ContainerRun$) × RunsPerMonth
• OpsSubtotal$ = Zapier$ + Make$ + n8n$ + LLM$
• Buffer$ = OpsSubtotal$ × Buffer%
• PreSLA$ = Labor$ + OpsSubtotal$ + Buffer$
• WithReserve$ = PreSLA$ × (1 + ProfitReserve%)
• FinalFloor$ = ROUND_TO(WithReserve$ × SLAMultiplier, RoundingRule)
• Status = IF(HardGate, "HARD REJECT", IF(Quoted < FinalFloor$, "REJECT", "ACCEPT"))

Use these to sanity‑check your build. Replace numbers with your own. Scenario A — 12‑hour mini‑project:

• Hours = 12; Utilization = 0.70; Rate = $180/hr ⇒ Labor$ = 12 × 180 × (1/0.70) = $3,086
• Zapier: 2 tasks/run × 120 runs = 240 tasks (pro‑rata share from plan) ⇒ Zapier$ = $[calc]
• Make: 5 credits/run × 60 runs = 300 credits ⇒ Make$ = $[calc]
• n8n: not used ⇒ $0
• OpenAI: 2k in/800 out tokens/run × 120 runs; Model = 5.4 mini; Batch = on ⇒ LLM$ = $[calc]
• OpsSubtotal$ = Sum platform costs; Buffer = 30%
• Profit/Reserve = 20%; SLA = Standard ×1.00
• Final Floor (Rounded $100) ≈ $[result] Scenario B — 30‑hour monthly retainer:
• Hours = 30; Utilization = 0.65; Rate = $160/hr ⇒ Labor$ = 30 × 160 × (1/0.65) = $7,385
• Zapier: 3 tasks/run × 300 runs = 900 tasks (see Zapier Help example pattern)
• Make: 4 credits/run (non‑AI) + 1 AI credit/run × 200 runs = 1,000 credits
• n8n Cloud in EUR: 1 execution/run × 600 runs = 600 executions (convert via FX)
• OpenAI: 4k in/1k out tokens/run × 200 runs; Model = 5.4; Batch = off
• Buffer = 30%; Profit/Reserve = 20%; SLA = Priority ×1.20
• Final Floor (Rounded $100) ≈ $[result] Note: The [calc]/[result] cells are computed by your sheet from the live vendor inputs you paste in. Do not hardcode vendor prices here.

• Link fields to official pages and set [Retrieved Date].
• Re‑check OpenAI, Zapier, Make, n8n pages quarterly or before large quotes.
• If this deal will consume most of an account’s plan allowance, switch from pro‑rata to direct attribution for fairness.
• Log actual tokens/tasks/credits for 2–4 weeks post‑launch; adjust buffer and model mix. Official references (paste into your calculator’s "Sources" sheet):
• OpenAI API Pricing — models, Batch, containers (retrieved 2026‑06‑05)
• Zapier Help — task measurement and plan selection example (updated 2026‑05‑29; retrieved 2026‑06‑05)
• Make Help — credits and +25% extra‑credit cost (retrieved 2026‑06‑05)
• n8n — pricing and "executions" definition (retrieved 2026‑06‑05)
• SPI Research press release — utilization 68.9% (retrieved 2026‑06‑05)
• Google SRE Book — SLA/SLO trade‑offs (evergreen)