The SaaS Sprawl Trap: Why Renting 14 Micro-APIs Destroys Software Margins
Modern software development has a seductive pitch: don't build anything, assemble everything. Auth? There's a subscription. Search? Subscription. Billing, queuing, analytics, feature flags, email, logs? Subscriptions, all the way down. The promise is instant speed — glue together a dozen external paid APIs and ship in a weekend.
The reality is quieter and more expensive. Vendor lock-in. Monthly costs that grow every time your product succeeds. Cascading downtime the moment a single third-party provider has a bad day. We call it SaaS sprawl, and it is the quiet killer of custom software margins.
Our position at Kreasi Kita is blunt: rent commodity infrastructure, own core domain mechanics. We build core logic inside self-contained software stacks using Postgres primitives and worker processes, and we rent only the genuinely undifferentiated pipes. This article explains why, where the conventional wisdom breaks down, and where renting still makes sense.
The Anatomy of Sprawl
Nobody approves fourteen subscriptions in one meeting. Sprawl drifts in one locally-rational decision at a time.
┌──────────────┐
│ Your App │
└──────┬───────┘
┌────────┬────────┬────────┼────────┬────────┬────────┐
▼ ▼ ▼ ▼ ▼ ▼ ▼
Auth Search Billing Queue Analytics Email Feature
SaaS SaaS SaaS SaaS SaaS SaaS Flags
│ │ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼ ▼
per-MAU per-query per-txn per-job per-event per-msg per-seat
A prototype needs auth fast, so a managed auth vendor goes in. Search feels slow — untested, but it feels slow — so a search SaaS goes in. Webhooks are annoying, so a managed queue goes in. Then analytics, then feature flags, then session replay, then a maps API, then a PDF renderer. Each decision was defensible in isolation. The aggregate is a product that rents its own heartbeat.
How the Drift Compounds
Every rented API drags a tail behind it: a contract, an SDK, webhook handlers, retry logic, sandbox configuration, an on-call runbook. That glue code is real engineering work — and here's the uncomfortable part — you own it. The vendor owns the primitive; you own every line that connects your domain to theirs.
Worse, your failure domains merge. When your auth vendor goes down, nobody logs in. Your uptime dashboard can say 100% while your product is functionally offline. Customers don't file tickets against your vendor. They file them against you.
The Real Cost Model
SaaS pricing is engineered to look cheap on day one and scale with your success. Per-seat. Per monthly active user. Per event. Per gigabyte. The pitch deck shows the flat starter plan; the invoice at scale shows a line item that grows in direct proportion to your revenue.
That's the subscription tax: a margin leak that compounds precisely when the business is winning. And it's not just unit pricing. Vendors re-tier plans, deprecate APIs, get acquired, and change terms. Every one of those events lands on your roadmap as unplanned migration work.
| Dimension | Rented micro-API | Owned primitive |
|---|---|---|
| Cost driver | Scales with usage and revenue | Mostly flat infrastructure plus dev time |
| Failure domain | Vendor's uptime becomes your uptime | Bounded by your own stack |
| Latency | Extra network hop on every call | In-process or same-datacenter |
| Roadmap control | Vendor's deprecation and pricing cycle | Yours |
| Exit cost | Data export, rewrites, re-integration | None — you already own it |
We're deliberately not quoting dollar figures here, because the numbers are workload-specific and honest benchmarks require measuring your traffic. But the structural math doesn't need them: any cost that scales per-user, per-event, or per-transaction is a tax on growth. Model it at ten times current usage, not at today's usage, and the "cheap" rental frequently loses.
Cascading Downtime Is an Architecture Smell
Sprawled stacks fail in chains. A queue vendor has an incident, so your workers stall, so your billing reconciliation stalls, so your support queue fills up. Each rented dependency is a blast radius you don't control and can't shrink. Resilience bought per-vendor is resilience owned by nobody.
What We Build Instead: Self-Contained Stacks
Our default architecture puts core domain logic inside a self-contained stack built on two things: Postgres primitives and worker processes.
┌─────────────────────────────────────────┐
│ Your App │
│ core domain logic, in-process │
│ no vendor hops inside │
└──────────┬──────────────────┬───────────┘
│ │
┌──────▼──────┐ ┌──────▼───────┐
│ Postgres │◄───┤ Workers │
│ auth tables│ │ job execution│
│ queue │ │ retries │
│ search │ │ scheduling │
│ events │ └───────────────┘
└──────┬──────┘
│ thin rented edges only
┌──────▼───────────────────┐
│ email delivery, payment │
│ rails, SMS, CDN │
└──────────────────────────┘
Concretely:
- Auth. A sessions table, password hashing with a modern algorithm, and a permissions model that actually matches your domain. The moment your authorization logic encodes real business rules, it is domain logic — and domain logic doesn't belong behind someone else's config panel.
- Queues. Postgres with
FOR UPDATE SKIP LOCKEDand a pool of worker processes covers the majority of background-job needs, with transactional enqueue as a free bonus: the job and the state change commit atomically.
-- Worker claims one job safely, even with many concurrent workers
UPDATE job_queue
SET status = 'running', locked_at = now(), attempts = attempts + 1
WHERE id = (
SELECT id FROM job_queue
WHERE status = 'queued'
ORDER BY created_at
FOR UPDATE SKIP LOCKED
LIMIT 1
)
RETURNING id, payload;
- Search. Postgres full-text search with
tsvectorandpg_trgmfor fuzzy matching covers far more real-world product search than the "Postgres can't do search" meme admits. Reach for a dedicated search engine when the workload proves it needs one — not when a vendor's landing page says so. - Feature flags, audit logs, analytics events. A table, an index, a cache, and a rollup job. Boring, inspectable, yours.
The pattern generalizes: prefer the boring primitive inside your trust boundary, and add a vendor only when a measured requirement demands it.
Where Renting Still Wins
This is not an argument for building everything. Some capabilities are genuine commodities, and owning them is a trap in the other direction:
- Payment rails. The regulatory and fraud burden is enormous. Rent it.
- Email deliverability. A black art dominated by sender reputation. Rent it.
- SMS, CDN, object storage. Utility pipes. Rent them.
The test we apply is simple: does this capability differentiate your product, or is it a pipe? Own the domain mechanics that make your product yours. Rent the commodity plumbing that every product needs and no customer chooses you for. Teams pre-product-market-fit may rationally rent more of everything — but they should know which rentals are temporary and design the exit seam on day one.
Conventional Wisdom, Reality-Checked
"Don't reinvent the wheel." Your domain model is not a wheel. Generic auth SaaS cannot express your permission logic without contortions; a managed queue cannot give you transactional enqueue with your business tables. The wheel metaphor flatters vendors and obscures the actual trade.
"Buying is always faster." You still write the integration, the webhooks, the reconciliation, the migration path. Count that glue code honestly and the marginal cost of owning the primitive is routinely smaller than the pitch suggests.
"Postgres can't scale." For most products, it is never given the chance to be the bottleneck, because it was replaced on day one by an assumption.
Actionable Takeaways
- Audit every subscription quarterly. Classify each as core-domain or commodity-pipe. No "we'll look at it later."
- Apply the differentiation test before any new vendor: would a customer pay for this capability being yours?
- Reach for Postgres primitives first — queue, search, flags, events — before adding a rental.
- Design exit seams for every vendor you keep. Data export, abstraction boundary, documented replacement path.
- Model costs at 10x usage. If the rental's pricing unit is your growth metric, it's a tax, not a tool.
- Treat vendor incidents as your incidents. If a dependency can log your product out, architect as if it will.
Own Your Core
SaaS sprawl is not a tooling problem; it's an ownership problem. Every capability you rent is a margin you've agreed to share and a failure mode you've agreed to absorb. Rent the pipes. Own the mechanics. Build software that compounds into an asset instead of a stack of rental agreements.
If your margins are leaking into a wall of subscriptions and you want a pragmatic architecture review, talk to us at Kreasi Kita. We build self-contained software stacks that keep your core where it belongs — in your hands.<p class="blog-internal-links">For the implementation path, explore our <a href="/services/software-modernization">software modernization for reducing platform sprawl</a>. Continue with <a href="/blog/software-rewrite-trap-refactor-vs-rebuild">how to choose between refactoring and rebuilding software</a>.</p>
ABOUTPROJECTS