Buy a capability when it lets the team focus on the workflow customers value and its operating constraints fit the product. Build it when the required behaviour, control, or economics justify owning the full maintenance burden.
For a small SaaS, the boundary matters more than the slogan. Using a provider does not remove application-specific responsibilities such as deciding who may access a record or what happens when a payment notification is delayed.
Compare the whole responsibility package
For each capability, list required behaviour, data handled, expected volume, provider limits, integration effort, failure recovery, and exit path. Include the people who will operate it. A service that appears inexpensive can still require substantial reconciliation and support work.
Identify what makes the product distinctive. A customer-study tool may win through a thoughtful study and review workflow. Building an email delivery system from scratch is unlikely to test that advantage, while a custom respondent experience may be central to it.
Evaluate a fictional billing decision
Suppose a founder wants to sell access to individual research studies. A provider can handle checkout, but the application still needs to decide which purchase grants access to which study, how refunds affect access, and what the user sees if entitlement updates are delayed.
Compare buying checkout with building a custom payment flow around the same acceptance cases. Include successful purchase, repeated notification, refund, cancelled checkout, and temporary provider unavailability. Official Stripe event guidance illustrates why receiving external events is its own integration responsibility; verify the contract of whichever provider you actually choose.
The build option should include ongoing changes, incident response, and account reconciliation. The buy option should include integration, plan constraints, data export, and a fallback when the provider is unavailable. Comparing only subscription fees with initial development cost produces a misleading result.
Keep the boundary replaceable where it matters
Store your own stable identifiers and a clear mapping to provider records. Keep business rules such as study ownership and access duration explicit in the application. That makes future migration easier, although it does not make switching free.
Avoid speculative abstraction around every provider. A thin, understandable boundary can be enough for a pilot. A universal adapter system may cost more than the migration risk it is supposed to reduce.
There are limits to this method. Early usage estimates can be wrong, and some providers impose approval or regional requirements that need separate verification. Revisit the decision when real customer behaviour or a critical requirement changes.
StackFlight's case study describes a shipped application using external services alongside custom product work. It is evidence of that implementation, not an endorsement of one universal stack.
Questions about buy versus build
Should a pilot always buy infrastructure?
No. Evaluate constraints and learning goals. Buying is often practical, but an unsuitable provider can make the core workflow impossible.
Does using a provider transfer responsibility for permissions?
Only for the responsibilities the provider actually handles. Your application still needs to enforce its resource ownership and business rules.
What is the best first comparison artefact?
Write one capability boundary with acceptance cases, failure behaviour, and an exit path. Bring that to a product architecture discussion.