Contents
  1. Purpose and development
    1. A useful offer within limited means
    2. Learning methods and purchased capabilities
  2. Problem and commitment
    1. Choose a reachable customer problem
    2. Test the commitment you need
  3. Scope and responsibility
    1. Complete one useful workflow
    2. Choose what to own
    3. Make the operating promise explicit
  4. Reach and repeated use
    1. Match distribution to buying
    2. Reach the first meaningful result
    3. Measure continued usefulness
  5. Support and repeatability
    1. Account for continuing human work
    2. Separate shared product from service
  6. Delivery economics and pricing
    1. Cost the complete customer relationship
    2. Price and bound the offer
    3. Define a billable outcome
  7. Margins and cash
    1. Separate margin, profit, and payback
    2. Finance the remaining obligations
  8. The next commitment
    1. Expand what remains supportable
  9. Check understanding
  10. Open questions
  11. Selected talks
  12. References
  13. Talk library
← All topics

AI startups & small teams

A small AI team must solve two connected problems: make something useful, and sustain the work required to deliver it. A convincing demonstration answers neither completely. Customers still need a reason to switch, a practical way to adopt the product, and terms they will accept. The team needs enough time, money, and operating capacity to serve them after the first successful result.

Purpose and development

A useful offer within limited means

An AI business sells an improvement in customer work. A workflow is the set of activities leading to a useful result, including preparation, decisions, checking, and follow-up—not just the automated step. Identifying who does the work and decides makes that result concrete. An application that drafts a record has a different promise from one that delivers an accepted record into the customer's system.

AI supplies behavior learned from examples rather than fully specified through application rules. Instructions and examples can guide a trained model without changing the internal values learned during training; Prompting and In-Context Learning explains that distinction. Guidance does not guarantee a correct result, so the product must also support the checking and correction its task requires.

Keep four claims separate: the capability works; it benefits a customer; someone will pay for that benefit; and the team can deliver it on the promised terms. Customer value concerns improvement relative to the customer's alternatives. Compare against existing software, manual work, a general-purpose AI tool, and leaving the task unchanged. Faster generation may offer little improvement when checking or installation absorbs the saved effort.

Opportunity cost is the value of the next-best alternative forgone, as the St. Louis Fed explains. A customer commitment consumes time that could serve another purpose even when it creates no new invoice. Discovery, distribution, and economics must consequently inform one another: a useful feature is not automatically the best next investment.

Learning methods and purchased capabilities

Today's small AI teams combine two established approaches: testing customer assumptions before committing extensive resources, and purchasing capabilities that would otherwise require substantial infrastructure or specialist work. Their development addressed different problems. Cheaper access made more products feasible; customer-learning methods helped determine which products deserved to exist.

DevelopmentDateContribution
Amazon EC2 betaAugust 24, 2006Amazon offered adjustable computing capacity with usage-based payment: teams could rent infrastructure instead of first acquiring servers.
Customer Development and minimum viable product guidesPublished August 3 and November 30, 2009Eric Ries explained minimum scope as a means of learning what customers want. Steve Blank explained testing customer problems and purchase decisions rather than collecting feature requests.
Google Prediction API updateSeptember 15, 2010Travis Green described expanded prediction capabilities in an invitation-only preview, with proposed moderation combining automated decisions and manual review—before general-purpose generative APIs.
OpenAI API private betaJune 11, 2020Greg Brockman, Mira Murati, Peter Welinder, and OpenAI introduced hosted GPT-3-family text capabilities guided through examples; OpenAI handled execution and controlled access and permitted uses.

These approaches coexist. Buying a powerful component can reduce what a team must implement without settling demand, integration, or responsibility. Likewise, a customer experiment can reveal that the right solution requires ordinary software or manual assistance rather than more sophisticated AI.

Problem and commitment

Choose a reachable customer problem

Customer discovery investigates actual work, current alternatives, and purchasing conditions before committing to a solution. A customer segment groups people or organizations with sufficiently similar needs and constraints to make one offer meaningful. Job titles alone are insufficient: two operations managers may perform similar tasks while facing very different permissions, budgets, and integration requirements.

Jobs to Be Done describes the progress someone seeks in particular circumstances. It directs attention toward why a person would change behavior, including functional, social, and emotional considerations. Investigate the last real occurrence of the work: what triggered it, which alternative was used, what went wrong, and what made the outcome matter.

Separate the user who experiences the problem, the purchaser who controls spending, and the person who can authorize access or process changes. Observe repeated transfers between tools and recurring manual effort as leads, not proof that automation is desirable. Learning from work as it happens develops that observation practice.

Consider two possible segments for preparing records from documents. This is a comparison to investigate, not a description of measured customers.

ConditionIndependent operatorDepartment in a large organization
User and purchaserMay be the same personUser, budget owner, and approver may differ
Required inputsFiles the operator can authorizeShared records requiring approved access
Current alternativeManual entry or an existing applicationAn established process with several participants
Buying obstacleEnough benefit to justify payment and setupBenefit plus organizational approval and integration

Assess frequency, urgency, consequences, current expenditure, reachability, and permitted access separately. A frequent task with no reachable purchaser may be a worse starting point for this team than a less frequent task with clear authority and strong demand. Do not hide these differences inside an unsupported opportunity score.

Test the commitment you need

Customer validation tests whether people undertake the actions needed to use and purchase the offer. Willingness to pay concerns an actual commercial choice under stated terms, not merely approval of the idea. Match the requested commitment to the uncertainty: evidence that someone wants a demonstration is different from evidence that they will supply real work or release a budget.

Customer actionWhat it helps establishWhat remains unresolved
Interview or registrationInterest and an opportunity to investigatePractical adoption and payment
Authorized access and repeated real tasksParticipation in the intended workflowPurchasing and independence from special assistance
Paid trial or purchaseAcceptance of those commercial termsRenewal and sustainable delivery
RenewalContinued purchasing at a later decisionWhether other customers will behave similarly

A design partner contributes access, time, and feedback to shape an early product. That relationship fits an offer requiring close workflow discovery. It can mislead when the eventual product must work without founder assistance. For self-service software, observe representative people attempting the task without that assistance as well.

Gong's founder account illustrates several distinct tests. Beginning in 2015, the founders investigated why sales managers could not explain failed deals from their existing records. Twelve design partners joined a January 2016 beta. Complaints about missing recordings exposed a need to capture every conversation rather than a sample; Eilon Reshef reports that eleven partners paid after the beta. Those payments strengthened the commercial case without establishing long-term retention or margins.

A paid pilot is a time-bounded, paid trial of specified work. Agree on a baseline—how the work is completed now—and acceptance criteria, the results and quality conditions the trial must satisfy. Also name the customer participants, duration, commercial terms, and decision at the end: purchase, revise the offer, or stop. Defining success with the customer develops these comparisons. Named collaborators make the customer's participation concrete and help reveal when a supposed partnership would instead leave the product team doing all the work.

Scope and responsibility

Complete one useful workflow

Product scope specifies the supported users, work, inputs, outputs, integrations, acceptance conditions, and exclusions. Narrow scope can still complete a task. Broad capability can remain incomplete when customers must invent the missing review, correction, or delivery process themselves.

A minimum viable product, or MVP, exists to test an important business assumption with limited effort. Ries's 2009 explanation places learning—not feature count—at its center. Minimum scope is therefore not permission to omit essential correctness. A concierge approach deliberately uses team labor to deliver part of the result while learning what deserves automation.

For example, a document-to-record product might accept one document type, prepare a candidate record, let a customer check and edit it, and deliver the approved record to one destination. The original document and the derived candidate are different objects. Unsupported documents return to the customer with a reason; rejected candidates require correction rather than being silently treated as completed work. A failed destination write remains incomplete even after approval.

The offer extends beyond preparation

Example

A candidate record is only an intermediate representation; review and confirmed delivery establish the promised result.

Submitted documentOriginal source supplied with permission.
Check supported inputThe product checks whether the document belongs to the promised input scope.
Candidate recordA representation derived by the product from the source; not yet accepted.
Customer reviewThe customer checks the candidate against its source and the task requirements.
Approved recordThe reviewed version is eligible for delivery.
Confirmed destination recordThe destination confirms delivery of the accepted record.
Returned as unsupportedThe customer receives the reason; the automated task ends without claiming completion.
Correction requiredThe current attempt stops for a separate correction and review process.
In this example, eligible documents yield candidate records for customer review. Unsupported documents return with a reason; rejected candidates stop for correction. Approval permits delivery, but completion requires confirmation from the destination. Error recovery is separate from this ordinary path.
Read the diagram as text
  • Submitted document. Original source supplied with permission.
  • Check supported input. The product checks whether the document belongs to the promised input scope.
  • Candidate record. A representation derived by the product from the source; not yet accepted.
  • Customer review. The customer checks the candidate against its source and the task requirements.
  • Approved record. The reviewed version is eligible for delivery.
  • Confirmed destination record. The destination confirms delivery of the accepted record.
  • Returned as unsupported. The customer receives the reason; the automated task ends without claiming completion.
  • Correction required. The current attempt stops for a separate correction and review process.
  • Submitted document → Check supported input: Data: source input.
  • Check supported input → Candidate record: Eligible: product derives candidate.
  • Check supported input → Returned as unsupported: Outside supported scope.
  • Candidate record → Customer review: Data: candidate and source.
  • Customer review → Approved record: Customer accepts reviewed version.
  • Customer review → Correction required: Customer rejects candidate.
  • Approved record → Confirmed destination record: Data: approved write confirmed.

That boundary reveals what the offer actually saves: perhaps initial transcription, but not all checking or exception handling. Test those retained activities in the uncertain interaction, then exercise a complete working slice. The result should teach whether customers value the whole workflow, not merely whether a model can produce a candidate.

Choose what to own

Build versus buy is a decision about continuing work, not just who writes the first implementation. Buying a managed service transfers specified operating duties to a supplier, while the team still integrates it into the product. Compare total cost of ownership: acquisition, integration, operation, maintenance, and eventual replacement. That last item includes vendor lock-in, the difficulty or expense of leaving. Replacing an API call may be easy while preserving the product's behavior and data handling is not.

AWS's shared-responsibility model makes the distinction concrete. EC2 customers retain guest operating-system and application duties; more abstracted services transfer additional platform work. Customers still own responsibilities for data and permissions. The exact boundary depends on the service, so this is a method for examining an offer, not a universal allocation for every supplier.

Hosting location and operating ownership can also differ. In Gitpod's deployment account, broad self-hosting support created configuration variance and adoption work. An intermediate design restricted deployment to AWS while the vendor managed the service on customer infrastructure. Workloads remained there, but operating telemetry reached the vendor; substantial infrastructure complexity remained.

Gitpod’s historical intermediate deployment, shown conceptually: workloads stayed on customer infrastructure while operating telemetry reached the vendor. AWS-only support narrowed configuration variance without eliminating infrastructure complexity. The dashed arrow denotes responsibility, not a specified access protocol.

Compare the same required capability across time to usefulness, available skills, quality, permitted data handling, ongoing support, and replacement effort. Gong initially purchased transcription rather than owning that technology. Existing libraries may likewise remove implementation work while leaving operation with the team. Omission is a valid choice when the capability is unnecessary to the first useful offer.

Revisit the boundary when an actual constraint changes. Similar provider interfaces still require behavioral evaluation and sometimes revised instructions. Maintaining unused alternatives also creates work. Keep model adaptation and serving engineering as specialized options, not prerequisites for starting a product.

Make the operating promise explicit

Operational ownership means being responsible—and able—to detect problems, make decisions, communicate, and restore useful service. A service-level agreement, or SLA, states agreed service commitments. A response commitment concerns when help begins; a resolution commitment concerns the result or restoration promised. Neither should be inferred from a supplier's availability figure.

Translate the workflow into named responsibilities. Incorrect outputs need a correction owner. Interrupted work needs a known disposition. Supplier outages need customer communication and a supported recovery path. Spending needs limits. Customer data needs accountable handling. State support hours, escalation coverage, required customer review, and work that the team cannot safely accept. Reducing the offer is preferable to making a promise with no owner.

Some responsibilities require controls outside the model. Prompt injection occurs when untrusted content influences behavior as though it were an instruction. A support agent reading external messages cannot safely police all its own production actions. Independent permission checks and approval boundaries limit what it can do; control placement explains the mechanism.

Operational records preserve the information needed to reconstruct a problem: which task ran, under which version, what happened, and what remains unresolved. Start with the questions observability must answer, not indiscriminate logging. Assign accountable data decisions for access, retention, and deletion. Recovery then needs verified restoration of the affected service, not merely a successful restart; detailed incident recovery belongs with the security controls.

Reach and repeated use

Match distribution to buying

Distribution is how suitable customers encounter the offer and reach a purchase. Positioning explains whom it serves, which result it provides, and why it is preferable to relevant alternatives. These choices start during discovery: the reachable audience and its buying process constrain what a small team can sell.

Founder-led selling keeps founders directly involved in finding prospects, demonstrating value, learning objections, and securing commitments. In Do Things That Don't Scale, published in July 2013, Paul Graham described Stripe founders installing their product for willing prospects and Viaweb learning by operating its software for merchants. Direct assistance can expose barriers a signup link leaves hidden. Founder visibility can build trust, but an audience is not itself a repeatable sales process.

Self-service acquisition lets customers understand, try, and buy with little direct assistance; product-led growth relies on the product experience to support that acquisition and expansion. It fits differently from an organizational purchase involving budget owners, access approval, and integration. The sales cycle is the elapsed time and steps leading to a buying decision. Evaluate whether the team can sustain those steps, not just whether the eventual contract looks attractive. Enterprise AI covers adoption across established organizations.

Partners and marketplaces reach buyers through another organization's channel, making admission, discovery, and control of the customer relationship part of the distribution decision. One possibility is discovery inside an AI application. The Model Context Protocol, or MCP, gives applications reusable interfaces to external tools. In his 2026 MCP Apps talk, Pietro Zullo reported that Claude could search a connector registry when a task needed a missing capability. That discovery behavior belongs to the host application, not the protocol itself. It offers a way to encounter prospective users at a moment of need, but discovery alone establishes neither a purchase nor permission to act.

Reach the first meaningful result

A customer with an account or a paid subscription may still be unable to complete useful work. Onboarding covers what they must do to begin successful use. To see whether it works, define activation as an observable first meaningful result, then measure time to value from a stated starting point to that result. Reaching it once is different from adoption, when the product becomes part of the customer's actual work.

PostHog's June 2026 onboarding account used receipt of a first event as activation and tracked paid conversion separately. Recordings of installation difficulties led to an integration assistant, but framework knowledge and stale documentation then became maintenance responsibilities. Removing setup work from customers did not make that work disappear from the business.

Locate the obstacle before shortening the interface. Waiting for access adds elapsed time without necessarily consuming continuous labor. Preparing data consumes customer effort. Repairing an integration consumes team effort. Checking a generated result can remain necessary after every use. These quantities matter differently and should not be combined into one vague onboarding score.

Remove premature qualification questions and competing feature introductions when they delay the first useful interaction. Preserve genuinely required steps, explain their purpose, and update effort estimates when choices add work. Guided assistance may be appropriate when it teaches a repeatable process; bounded paid implementation may fit substantial setup. If every activation requires exceptional engineering, reconsider the scope or segment. Evaluate the complete human workflow, including correction, rather than celebrating a shorter signup form.

Measure continued usefulness

Retention is continued use or purchasing under a stated time rule. A cohort groups customers by a shared starting condition. Churn means discontinuation under an explicit definition. For behavioral retention, specify the starting event, qualifying return event, denominator, and observation window. Returning during one particular interval differs from returning in that interval or later; Amplitude's retention documentation explains these alternatives.

Use a cadence that matches the task. Monthly reporting software should not be judged by daily visits. A usage-interval estimate can help investigate timing, but Amplitude's calculation includes repeat users only. It cannot reveal how many entrants never returned.

Constructed weekly-workflow example. Cohorts enter on their first accepted task; a return means another accepted task during the indicated week after entry. Every percentage uses the original entrant count.
Entry cohortEntrantsWeek 1 returnWeek 2 return
Earlier106/10: 60%4/10: 40%
Later2012/20: 60%Not yet observable

The later cohort supplies twice as many first-week returners, but its retention rate is unchanged. Customer and revenue retention also differ: net revenue retention includes expansion among existing accounts, so increased spending by some customers can offset losses elsewhere. It does not mean nobody left.

Product-market fit means sustained demand for a particular offer in a particular market, not a universal survey threshold. Investigate whether returns reflect useful work rather than automated activity, contractual inertia, or founder prompting. Interview customers who leave and upgrade about corrections, alternatives, and price. Their explanations suggest hypotheses; live comparisons help test changes. Feedback may justify a different segment, simpler onboarding, or narrower promises—it does not automatically improve model parameters.

Support and repeatability

Account for continuing human work

Support burden includes the labor, expense, interruptions, and expertise required to keep customers successful. Operational toil is repetitive operating work that consumes capacity without producing a lasting improvement. Support also includes valuable discovery and novel investigation; not every conversation is toil. An exception workload is the work that cannot proceed through the ordinary path and needs another decision or intervention.

Separate initial onboarding, routine questions, product defects, manual fulfillment, integration maintenance, and urgent incidents. A repeated question may need documentation; a repeated defect needs repair; promised manual fulfillment may need an explicit service price. Customer review is a separate burden: it affects the customer's benefit even when it consumes none of the supplier's staff time.

Time-driven activity-based costing, explained by Robert Kaplan and Steven Anderson in their 2004 working paper, assigns service costs using supplied capacity and the time activities consume. Equal transaction counts can conceal unequal effort. Unused capacity remains visible rather than being charged entirely to customers.

For a simple capacity illustration, reserve 20 staff-hours per week for recurring support. Compare an assumed average of 15 minutes per account with one hour per account. The first consumes that allowance at 80 accounts; the second at 20. Neither is a staffing target. Uneven arrivals, specialist availability, and incident peaks can constrain delivery before average weekly hours do; bursts and recovery develops those limits.

Automation and community assistance can complement product repair. Bolt's operating account describes moving beyond founder-handled email to automated support and places where users helped one another build. Those are distinct ways to assist customers, not interchangeable proof of sufficient coverage. Difficult cases still need an owner.

Separate shared product from service

Customization tailors behavior to a customer. Configuration selects variation already supported by the product. Productization makes a capability repeatable, supported, and usable beyond its first delivery. A productized service instead makes human-assisted delivery a bounded, repeatable offer. Service-heavy work can be a legitimate business; its labor and maintenance must be priced and staffed honestly.

Similar feature names do not establish shared requirements. Compare permitted inputs, decision rules, acceptance conditions, access, and ongoing support. The Software Engineering Institute's product-line guidance explains why shared components reduce duplication while also creating testing, release, documentation, and coordination obligations. Generalization is worthwhile when common need and reduced separate maintenance justify that work.

Possible dispositions for requests around a record-preparation product.
RequirementDispositionContinuing obligation
Several customers need the same source-linked correction behaviorCommon product improvementSupport and test it across those customers
A customer needs a different supported destination mappingConfigurationValidate the mapping and preserve it through updates
One customer needs a unique legacy integrationSeparately scoped implementationName delivery, acceptance, and maintenance responsibilities
A request requires authority or coverage the team cannot provideDecline or narrowKeep the existing promise credible

GitLab's professional-services terms illustrate a commercial boundary: services have defined scope and deliverables, customer responsibilities, and agreed changes. A quick useful fix needs a destination too—maintained product, owned customer-specific work, or retirement. Otherwise temporary delivery can become years of unsupported obligation. Validating a shared capability covers the detailed engineering decision.

Customer concentration means dependence on a small number of customers. Test the exposure conditionally: if one account leaves, the lost revenue may threaten financing; if its exceptional promises absorb scarce engineers, it may constrain other work. A large contract deserves both analyses, not automatic acceptance or rejection.

Delivery economics and pricing

Cost the complete customer relationship

Unit economics compares revenue and costs per meaningful business unit: an account, plan, project, or service period. Cost to serve includes the work required to deliver that offer. Begin with complete outcome costs, including failed attempts, multiple model calls, and material human work. Then add account-level obligations such as onboarding and recurring support. Falling per-call prices do not guarantee lower totals when the workflow invokes more calls.

Keep marginal cost, the added cost of more work, separate from allocated shares of existing costs and avoidable cost, future spending a decision can eliminate. Released salaried time creates capacity without necessarily reducing payroll. Separate savings from allocation develops that distinction.

Constructed monthly comparison in dollars. Both accounts pay for the same offer. Staff are salaried within existing capacity; their time is assigned at $50 per hour. Supplier charges include all attempts. Shared delivery capacity is committed. Acquisition and general company expenses are excluded.
Account-period itemAccount AAccount B
Revenue earned$1,000$1,000
Metered supplier services$100$200
Human fulfillment2 hours: $1006 hours: $300
Recurring support1 hour: $505 hours: $250
Shared delivery allocation$50$50
Recurring delivery total$300$800
Revenue less recurring delivery$700$200
Initial onboarding, shown separately4 hours: $20010 hours: $500

Account B requires $500 more recurring resources: $100 in supplier charges and $400 in assigned staff time. In its first month, subtracting its separate $500 onboarding effort leaves a negative $300 resource balance before acquisition or company overhead. That is not necessarily an additional $300 cash outflow; much of the cost is assigned capacity.

Keep trial costs visible in a separate acquisition or delivery ledger according to the chosen convention, including trials that never convert. Do not count them again in both places. Likewise, assigned staff time is a share of payroll, not a second expense on top of the same payroll. The purpose is reconciliation: identify the customers and activities consuming resources without hiding unused capacity.

Price and bound the offer

The charge metric is the unit determining the bill. Packaging specifies included capabilities, allowances, support, and restrictions. The billing model determines how charges accumulate. Stripe's pricing framework, published by Kunal Mahajan and Helen Lee in September 2025, separates these choices from customer value. Supplier cost constrains feasibility; it does not establish willingness to pay.

Alternative ways to charge for the same record-preparation offer.
BasisCustomer advantageExposure to resolve
SubscriptionPredictable recurring paymentSupplier bears heavier use within the package
Per userBudget follows the number of authorized usersUser count may poorly track processing demand
Metered usagePayment follows a stated activity unitCustomer faces variable bills, including any chargeable unsuccessful work
Project feeA known price for bounded deliveryChanges and unexpected effort need explicit treatment
Accepted outcomePayment follows an agreed completion conditionSupplier funds unsuccessful attempts; completion can be disputed
Base fee plus usageAn included allowance with a defined expansion pathOverages still require understandable terms and controls

Choose a unit customers can relate to their work. A token is a model-specific unit of encoded text, explained in Tokenization; it is not a completed customer task. Technical buyers may understand resource units, while others need examples translating intended work into expected charges.

Controls address different risks. Alerts communicate consumption; caps stop covered use; rate limits constrain how quickly it accumulates. Included allowances and bounded trials make the initial commitment legible. Additional spending should follow a clear customer choice to top up, enable automatic top-ups, or wait. Paid implementation and support limits should describe real obligations, not conceal them in a supposedly unlimited package.

Cursor's July 4, 2025 clarification shows the communication burden. Michael Truell explained that the June 16 change moved from request allowances toward usage credits as resource consumption per request became more variable. Cursor acknowledged confusion about unlimited access and extra usage, offered refunds for unexpected charges, and described spending limits. This historical episode illustrates why cost alignment and customer understanding must change together.

Treat a pricing test as a test of the segment and complete offer. Interviews with departing and upgrading customers help distinguish a price objection from an unsuitable product. A lower price cannot repair a workflow customers cannot use, and frequent changes are not inherently beneficial.

Define a billable outcome

Outcome-based pricing charges when an agreed result occurs. It requires more than a label such as resolution or successful task. Define the observable completion condition, how the result is attributed to the service, what happens when work reopens, and how a disputed charge is handled. If those conditions cannot be explained clearly, a different charge metric may be more workable.

A contractual billing outcome, verified task success, and customer economic benefit remain distinct. Intercom's Fin support agent provides a concrete example: its outcome documentation, dated July 30, 2026, allows not only confirmed resolutions but also assumed resolutions and certain configured handoffs to count. The conditions explain what the customer pays for; they do not independently establish how much the service helped.

Documented conditionFin billing treatment
Customer confirms resolution, or leaves without seeking more helpA confirmed or assumed resolution may count
Customer returns to the conversation for assistanceResolution is not charged or is deducted, including across billing periods
Configured procedure intentionally hands off workThe handoff can itself qualify as an outcome
Several qualifying events in one conversationAt most one outcome is counted

An assumed resolution is a billing condition, not independent verification that the underlying problem disappeared. The useful design lesson is to make the charge rule inspectable and connect later contradictory information to a defined adjustment. Measuring actual customer benefit remains separate work.

Margins and cash

Separate margin, profit, and payback

Gross profit is revenue less cost of sales; gross margin expresses that remainder as a share of revenue. State which delivery costs are included. Operating profit also subtracts operating expenses such as research, marketing, and administration. The SEC's financial-statement guide explains these boundaries. Moving support between categories changes the presentation, not the resources consumed.

If the recurring delivery rows in the earlier ledger are classified as cost of sales, Account A produces $700 gross profit and a 70% gross margin; B produces $200 and 20%. Together they leave $900 before other expenses. If those other operating expenses total $1,000, the company has a $100 operating loss despite both accounts' positive recurring gross margins.

Contribution margin instead subtracts specified variable costs, leaving an amount to cover fixed costs and then profit. OpenStax's explanation distinguishes this boundary. In the example, if only metered supplier charges vary within existing capacity, contribution is $900 for A and $800 for B. Those figures do not make staff time free: salaries still need funding, and extra volume can require additional capacity.

Customer acquisition cost, or CAC, divides acquisition spending by new customers acquired over a stated scope. Include material sales and marketing labor, including assigned founder effort, rather than only advertising. Shopify's published convention includes acquisition software and allocated internal labor. Match spending and customer cohorts carefully when sales cycles are long.

CAC payback needs a named recovery measure. The 2018 SaaS survey's implied payback uses subscription gross profit, not revenue. With $1,400 CAC and A's unchanged $700 monthly gross profit, that measure gives two months; dividing by revenue gives a misleading 1.4 months. Contribution-based recovery would be a different calculation. All such projections depend on continued revenue and costs; uncertain retention makes distant lifetime-value estimates fragile.

Finance the remaining obligations

An invoice requests payment. Collection brings cash into the company. Earned revenue reflects delivered goods or services under the applicable accounting rules. The IFRS 15 overview ties revenue to satisfying performance obligations—promises to transfer distinct goods or services—which may occur at a point in time or over time. Receiving an annual payment does not by itself establish that a year's service has been earned.

Separate cash illustration: assume $12,000 collected upfront, service earned evenly at $1,000 per month, and $400 of delivery cash payments each month. No other expenses, refunds, or taxes are included. This is not a recognition ruling for a particular contract.
PeriodCash collectedRevenue earnedDelivery cash paidService months remaining
Before service begins$12,000$0$012
Month 1$0$1,000$40011
Months 2–12 combined$0$11,000$4,4000

After the first month, $11,600 of the collected cash remains before other spending, but eleven months of service remain too. The initial receipt helps finance delivery; it is not an unrestricted measure of profit. Company cash flow also depends on when payroll, suppliers, and other obligations must be paid.

Net cash burn is the excess of operating cash outflows over inflows during a stated period. Runway estimates how long available cash lasts under specified burn assumptions. Mercury's implementation uses a selected historical spending window, excludes internal transfers, and allows financing proceeds to be excluded from operating analysis. If cash is $60,000 and continuing net burn is $10,000 monthly, the simple estimate is six months—not a forecast of new commitments.

Recalculate before hiring, signing supplier commitments, or accepting work with delayed collections. Lower burn can preserve time for further product attempts, as Bolt's founder argues, but it is not a rule against hiring. Removing a real delivery bottleneck may justify spending; merely reallocating existing staff hours does not create cash savings.

The next commitment

Expand what remains supportable

Sustainable growth expands work the business can continue delivering and financing. Premature scaling expands commitments before the underlying selling and delivery process is sufficiently repeatable. Neither definition prescribes a speed or headcount. Pete Kazanjy's Founding Sales emphasizes repeating both the sale and customer success: buying, implementing, obtaining value, and continuing use.

Observed constraintCandidate commitmentWhat would justify it
Suitable customers obtain value, but few are reachedImprove acquisitionA repeatable route to similarly suitable buyers
Interested customers fail during setupRepair onboardingMore customers reach the defined result with manageable assistance
Exceptions consume delivery capacityNarrow scope, improve the product, or price service separatelyThe revised offer reduces burden or funds its continuing owner
Several customers share a validated unmet requirementExtend the productCommon behavior remains useful across their differing conditions
Demand persists only under uneconomic or unstaffable termsChange segment or stopA revised commitment customers accept and the team can sustain

Temporary founder effort can buy learning. Permanent unpriced fulfillment is part of the business model, whether acknowledged or not. Small teams can act quickly when members share context and decision authority, but headcount alone does not create that advantage. Bolt's account explicitly involved high trust and years of working together.

An annual-prepaid customer requesting extensive customization combines several constraints. The cash arrives early, yet implementation and support may consume capacity before the shared product benefits. Separate the reusable requirement from bespoke work, establish who maintains each, and test whether the customer accepts bounded terms. Also examine the consequences of losing that account or delaying service to existing customers. Prepayment alone does not settle the decision.

Finally, compare the offer with improving alternatives. Domain understanding, integration, and trusted execution are advantages only when they produce benefits customers still choose and pay for. Revisit that choice through real tasks and later purchasing behavior. The next commitment should strengthen the connection between useful work, repeatable delivery, and financing. Broader portfolio and organizational choices belong in AI Engineering Leadership.

Open questions

  1. Support automation can reduce routine work while leaving a smaller, more difficult exception workload. Progress requires measuring unresolved cases, specialist effort, and customer outcomes together, rather than reporting only the share handled automatically.

  2. Outcome billing becomes harder when results are delayed, jointly produced, or disputed. Useful progress would make attribution and later correction understandable to both parties without making verification more expensive than the service.

  3. Customer-specific adaptation may become cheaper to generate without becoming cheaper to maintain. The consequential test is whether bounded variations remain independently inspectable, supportable, and reversible as the shared product changes.

  4. Durable differentiation remains uncertain as general-purpose alternatives improve. Progress would be repeated task-matched comparisons followed by observed purchasing and retention, establishing which integration, operating, or domain-specific benefits customers continue to value.

Follow the curated reading path through the speakers and demonstrations behind this entry.

Explore more talks

The rest of the library, beyond the curated path. Cited talks support this entry; reviewed transcripts were processed in full. Metadata candidates have not been reviewed as sources or verified as topic members.

31 matching talks

TalkSpeakerEventYear
Hamel Husain, Greg CeccarelliAI Engineer Summit 20252025
Jeremy Silva, Chris HernandezAI Engineer World's Fair 20252025
Kevin BaiAI Engineer World's Fair 20262026
Patricija ŽemaitytėAI Engineer World's Fair 20262026
The New Lean Startup

Transcript reviewed

Sid BendreAI Engineer World's Fair 20252025
Amir HaghighatAI Engineer World's Fair 20252025
Dan BjornnAI Engineer World's Fair 20262026
Sandipan BhaumikAI Engineer Europe 20262026
Cornelia DavisAI Engineer Code 20252025
Security Firewall for Agents

Cited in this entry

Ryan DahlAI Engineer World's Fair 20262026
Victoria MelnikovaAI Engineer World's Fair 20262026
The Weekend AI Engineer

Transcript reviewed

Hassan El MghariAI Engineer Summit 20232023
Pietro ZulloAI Engineer World's Fair 20262026
Dax RaadAI Engineer Code 20252025
John PhamAI Engineer World's Fair 20252025
OpenAI for VPs of AI

Transcript reviewed

Prashant Mital, Toki SherbakovAI Engineer Summit 20252025
Quinn SlackAI Engineer World's Fair 20242024
Rafal Wilinski, Vitor BaloccoAI Engineer World's Fair 20252025
Vinoo GaneshAI Engineer World's Fair 20262026
The Pipeline Is Dead

Cited in this entry

Iris ten TeijeAI Engineer World's Fair 20262026
Alvaro MoralesAI Engineer World's Fair 20252025
Kshitij GroverAI Engineer Summit 20252025
Mayank PantAI Engineer Europe 20262026
Howie Liu, Shawn "swyx" Wang, Joshua XuAI Engineer World's Fair 20262026
Brian LewisAI Engineer World's Fair 20262026
Rania KhalafAI Engineer World's Fair 2026Unknown
Aliisa RosenthalAI Engineer World's Fair 20262026
Nilofer RajpurkarAI Engineer World's Fair 20262026
Evan ConradEvent unknownUnknown
Dor SassonAI Engineer World's Fair 20262026
Affaan Mustafa, Alejandro Soumah FernandezEvent unknownUnknown

References

Coverage and source review
Processed transcripts
28 processed in full · 5 in the curated path
Automated source review
Passed
Metadata candidates
8 unreviewed; not verified topic membership
Corpus version
1bd8e407b26a07b33815594e1b2db5f41827119a2b3cb6fbf240f9fc571fc767

Automated review checks source support; it is not publication approval.

A synthesis of selected conference talks and technical references. Citations link to the source material; they do not imply that every talk on this subject is included.

  1. Kaplan and Anderson: Time-Driven Activity-Based Costing

    https://www.hbs.edu/ris/Publication%20Files/04-045_d62528d4-7931-4ea1-a205-d9683c639d6e.pdf

  2. Language Models are Few-Shot Learners

    https://arxiv.org/html/2005.14165v4

  3. The Build-Operate Divide: Bridging Product Vision and AI Operational Reality

    https://www.youtube.com/watch?v=1__V4KTv_Gw&t=129

  4. How To Build an AI Strategy That Fails

    https://www.youtube.com/watch?v=89aQ7T6cMwA&t=186

  5. Building CISO-approved agent fleet architecture

    https://www.youtube.com/watch?v=d9rsC6_VLoA&t=333

  6. St. Louis Fed: Real-Life Examples of Opportunity Cost

    https://www.stlouisfed.org/open-vault/2020/january/real-life-examples-opportunity-cost

  7. AWS: Announcing Amazon Elastic Compute Cloud—Beta

    https://aws.amazon.com/about-aws/whats-new/2006/08/24/announcing-amazon-elastic-compute-cloud-amazon-ec2---beta/

  8. Eric Ries: Minimum Viable Product—A Guide

    https://www.startuplessonslearned.com/2009/08/minimum-viable-product-guide.html

  9. Steve Blank: Customer Development Is Not a Focus Group

    https://steveblank.com/2009/11/30/customer-development-is-not-a-focus-group/

  10. Google: Prediction API—Make Smart Apps Even Smarter

    https://developers.googleblog.com/prediction-api-make-smart-apps-even-smarter/

  11. OpenAI API

    https://openai.com/index/openai-api/

  12. Christensen Institute: Jobs to Be Done

    https://www.christenseninstitute.org/theory/jobs-to-be-done/

  13. How Forward Deployed Engineering is done at Kepler — Vinoo Ganesh

    https://www.youtube.com/watch?v=1OMHGsUZiqA&t=614

  14. Revenue Engineering: How to Price (and Reprice) Your AI Product

    https://www.youtube.com/watch?v=1C3sZbaxOmw&t=358

  15. Strategyzer: Testing Your Business Model—A Reference Guide

    https://strategyzr.s3.amazonaws.com/assets/resources/testing-your-business-model-a-reference-guide.pdf

  16. Forward Deployed Engineering at Cursor — Pauline Brunet

    https://www.youtube.com/watch?v=APqXGyCoGW4&t=578

  17. Forward Deployed Engineering 101

    https://www.youtube.com/watch?v=KwhgfwOSToQ&t=467

  18. First Round Review: Gong's Path to Product-Market Fit

    https://review.firstround.com/gongs-path-to-product-market-fit/

  19. GitLab Professional Services Terms

    https://handbook.gitlab.com/handbook/legal/professional-services-agreement/

  20. How Web Data Infrastructure Powers the Next Generation of AI

    https://www.youtube.com/watch?v=1UmZHb_E_SM&t=187

  21. Paul Graham: Do Things That Don't Scale

    https://www.paulgraham.com/ds.html

  22. FinOps terminology: ownership, depreciation and utilization

    https://framework.finops.org/assets/terminology/

  23. The Rise of Open Models in the Enterprise

    https://www.youtube.com/watch?v=3WV1vT0B0cg&t=335

  24. AWS Shared Responsibility Model

    https://aws.amazon.com/compliance/shared-responsibility-model/

  25. Building CISO-approved agent fleet architecture

    https://www.youtube.com/watch?v=d9rsC6_VLoA&t=408

  26. Revenue Engineering: How to Price (and Reprice) Your AI Product

    https://www.youtube.com/watch?v=1C3sZbaxOmw&t=841

  27. NIST SP 800-61r3: incident response and verified recovery

    https://doi.org/10.6028/NIST.SP.800-61r3

  28. Mastering AI Pricing — Mayank Pant, Stripe

    https://www.youtube.com/watch?v=CrqPcIZOOXA&t=832

  29. NIST Privacy Framework 1.0: lifecycle and minimized audit evidence

    https://nvlpubs.nist.gov/nistpubs/CSWP/NIST.CSWP.01162020.pdf

  30. Security Firewall for Agents

    https://www.youtube.com/watch?v=MkRYPFIMCSA&t=196

  31. GTM Is You - Victoria Melnikova, Evil Martians

    https://www.youtube.com/watch?v=G6IlDzj8OjA&t=28

  32. MCP Apps: Primitives, Discovery, and the Future of Software

    https://www.youtube.com/watch?v=sAOBXCDiDOs&t=1508

  33. PostHog: We Used Context Engineering to 5x Conversion and 2x Activation

    https://newsletter.posthog.com/p/we-used-ai-to-5x-conversion-and-2x

  34. The AI emperor has no DAUs: why most devs still don't use code AI

    https://www.youtube.com/watch?v=Up6WVA07QdE&t=831

  35. AI changes *Nothing* — Dax Raad, OpenCode

    https://www.youtube.com/watch?v=o3gmwzo-Mik&t=428

  36. Good design hasn’t changed with AI

    https://www.youtube.com/watch?v=7e7eVtcygCM&t=611

  37. Amplitude: Interpret Your Retention Analysis

    https://amplitude.com/docs/analytics/charts/retention-analysis/retention-analysis-interpret

  38. Amplitude: Retention Analysis Usage Interval

    https://www.amplitude.com/docs/analytics/charts/retention-analysis/retention-analysis-interpret-usage

  39. For Entrepreneurs and KBCM: 2018 SaaS Private Survey Results—Part 1

    https://www.forentrepreneurs.com/2018-saas-private-survey-results-part-1/

  40. Mastering AI Pricing — Mayank Pant, Stripe

    https://www.youtube.com/watch?v=CrqPcIZOOXA&t=943

  41. Google SRE Workbook: Eliminating Toil

    https://sre.google/workbook/eliminating-toil/

  42. Bolt.new: How we scaled $0-20m ARR in 60 days, with 15 people

    https://www.youtube.com/watch?v=s8RM8uYxkoY&t=738

  43. Bolt.new: How we scaled $0-20m ARR in 60 days, with 15 people

    https://www.youtube.com/watch?v=s8RM8uYxkoY&t=810

  44. SEI: Governance of a Software Product Line—Complexities and Goals

    https://www.sei.cmu.edu/blog/governance-of-a-software-product-line-complexities-and-goals/

  45. How Forward Deployed Engineering is done at Kepler — Vinoo Ganesh

    https://www.youtube.com/watch?v=1OMHGsUZiqA&t=1052

  46. The Rise of Open Models in the Enterprise

    https://www.youtube.com/watch?v=3WV1vT0B0cg&t=358

  47. Stripe: A Framework for Pricing AI Products

    https://stripe.com/blog/a-framework-for-pricing-ai-products

  48. Mastering AI Pricing — Mayank Pant, Stripe

    https://www.youtube.com/watch?v=CrqPcIZOOXA&t=703

  49. Monetizing AI — Alvaro Morales, Orb

    https://www.youtube.com/watch?v=6WQYLQB0odc&t=354

  50. The Price of Intelligence - AI Agent Pricing in 2025

    https://www.youtube.com/watch?v=In7K-4JZKR4&t=530

  51. Cursor: Clarifying Our Pricing

    https://cursor.com/en-US/blog/june-2025-pricing

  52. Monetizing AI — Alvaro Morales, Orb

    https://www.youtube.com/watch?v=6WQYLQB0odc&t=511

  53. Intercom: Fin AI Agent Outcomes

    https://www.intercom.com/help/en/articles/8205718-fin-ai-agent-outcomes

  54. SEC: Beginners' Guide to Financial Statements

    https://www.sec.gov/about/reports-publications/beginners-guide-financial-statements

  55. OpenStax: Explain Contribution Margin

    https://openstax.org/books/principles-managerial-accounting/pages/3-1-explain-contribution-margin-and-calculate-contribution-margin-per-unit-contribution-margin-ratio-and-total-contribution-margin

  56. Shopify: Ecommerce Customer Acquisition—Channels and Formula

    https://www.shopify.com/blog/ecommerce-customer-acquisition

  57. IFRS Foundation: IFRS 15—Revenue from Contracts with Customers

    https://www.ifrs.org/issued-standards/list-of-standards/ifrs-15-revenue-from-contracts-with-customers/

  58. Mercury: Insights Page Overview

    https://support.mercury.com/hc/en-us/articles/44277089544084-Insights-page-overview

  59. Bolt.new: How we scaled $0-20m ARR in 60 days, with 15 people

    https://www.youtube.com/watch?v=s8RM8uYxkoY&t=302

  60. Pete Kazanjy: Founding Sales—Early Sales Management and Scaling Concepts

    https://www.foundingsales.com/10-early-sales-management

  61. Bolt.new: How we scaled $0-20m ARR in 60 days, with 15 people

    https://www.youtube.com/watch?v=s8RM8uYxkoY&t=259

  62. Forward Deployed Engineering 101

    https://www.youtube.com/watch?v=KwhgfwOSToQ&t=970

  63. The Price of Intelligence - AI Agent Pricing in 2025

    https://www.youtube.com/watch?v=In7K-4JZKR4&t=774

  64. The Pipeline Is Dead

    https://www.youtube.com/watch?v=bRnoEpoK5m4&t=482

  65. LLM codegen fails and how to stop 'em

    https://www.youtube.com/watch?v=juoNbJiZUi0&t=448

  66. LLM codegen fails and how to stop 'em

    https://www.youtube.com/watch?v=juoNbJiZUi0&t=675