WebRTC Architecture Cost in 2026: Custom Development vs SDK

Why Fora Soft wrote this playbook

Most WebRTC cost estimates are wrong in the same direction: they price the build and forget the run-rate, or they price the run-rate and forget the ops team it takes to keep a self-hosted stack alive. We wrote this because we have shipped WebRTC products on every route there is, and we keep watching founders sign up for the expensive one by accident.

Fora Soft has built real-time video since 2005: 250+ projects, 50 in-house engineers, a 100% job-success score on Upwork. We have shipped on managed SDKs (Vonage/OpenTok, Twilio Video, Daily, Agora) and on self-hosted media servers (Kurento, mediasoup, Janus, LiveKit OSS), plus hybrids that start managed and migrate later. BrainCert’s EdTech platform (100K+ customers, 500M+ classroom minutes) and ProVideoMeeting’s enterprise conferencing are public examples; most of the rest sit under NDA.

This is the cost model we hand a CTO before they pick a stack. It separates the up-front engineering number from the per-participant-minute run-rate, maps both to architecture, and shows the crossover where a custom build stops being an indulgence and starts being the cheaper option. If you only read one section, read the crossover. Everything else is how you get there. For the deeper mechanics, we lean on video-encoding fundamentals and our guide to what WebRTC actually is.

Two cost lines: build vs run-rate

A WebRTC budget is two questions that people keep collapsing into one. First: what does it cost to build the thing (engineering, once)? Second: what does it cost to run it per participant-minute (fees or infrastructure, forever)? The trap is that the two move in opposite directions. Managed SDKs make the build cheap and the run-rate expensive. Self-hosting makes the build expensive and the run-rate cheap.

Figure 1. WebRTC cost is an up-front build number plus a per-minute run-rate. Total cost of ownership is build + (run-rate × minutes × months).

So the real question is never “build or buy?” in the abstract. It is: at your volume, over your next two years, which mix is cheaper? A pre-seed team doing 50K minutes a month and a Series B doing 20M minutes a month should make opposite calls, and both are right. The rest of this article is how to find your number.

SDK costs: what managed platforms charge

A managed SDK (a CPaaS video platform) hands you signalling, media servers, TURN, recording and SDKs for every client. You pay per participant-minute and skip the ops entirely. Here is what the major platforms charge in 2026, cross-checked against their public rate cards (Daily’s is a clean example). Note the free tiers: most give you 10,000 minutes a month, which covers a real MVP for $0.

Two things worth flagging because most competitor guides get them wrong. First, Twilio Video is not dead. Twilio announced end-of-life in December 2024, pushed it to December 2026, then reversed course and confirmed the product stays a standalone offering. If a 2025 blog told you to panic-migrate, that advice is stale (per Twilio’s own changelog). Second, Vonage’s headline rate hides a publisher multiplier: the base is ~$0.0041 per participant-minute, but past 25 active publishers it steps up sharply, so a busy 40-person room bills far above the list price.

LiveKit Cloud is the outlier in that table on purpose. Its per-minute rate is roughly a tenth of the pure CPaaS crowd, and the same open-source core runs on your own servers when you outgrow it. That portability is why it anchors the hybrid path later. We break the numbers down further in our LiveKit vs Agora cost analysis.

Custom build cost: the self-hosted number

“Custom WebRTC” does not mean writing WebRTC from scratch. It means self-hosting an open-source media server (mediasoup, LiveKit OSS, Janus or Kurento) and building the signalling, clients and ops around it. You trade a bigger up-front bill for near-zero marginal cost per minute. Here is what that build actually runs, by scope.

Those ranges assume a team that has shipped media servers before. If yours has not, add a discovery spike and a load-test budget, because the expensive surprises in a custom SFU are never the happy path. They are the 15–20% of sessions that can’t connect peer-to-peer and fall back to TURN relay, the simulcast layer that doubles your egress, and the on-call rotation you now own at 3am.

We quote conservatively here because Fora Soft runs Agent Engineering: our engineers pair with AI agents on the repetitive parts of a build (client scaffolding, test suites, deploy scripts), which compresses the calendar and the cost versus a hand-cranked shop. If a number in a proposal looks padded, ask what the agents are doing.

Topology drives cost: P2P, SFU, MCU

Before you price anything, pick a topology, because it sets both your server bill and your latency. There are three, and the P2P vs SFU vs MCU choice is the single biggest lever on cost per minute.

Figure 2. The media architecture sets your server cost and latency. SFU forwards streams cheaply; MCU mixes them at 10–20x the CPU.

P2P (mesh) sends every stream directly between peers. No media server, so it is nearly free, but it collapses past ~4–6 participants because each client uploads to every other. Good for 1:1 calls, useless for group video. SFU (Selective Forwarding Unit) receives each stream once and forwards it, spending ~0.5–1 CPU core per 100 users and adding 50–150ms. It is what Google Meet, Zoom and almost every modern platform run. MCU (Multipoint Control Unit) decodes and re-mixes every stream into one, which burns 12–20 cores per 100 users and adds 200–500ms, but hands weak clients a single stream to render.

The cost gap is not subtle. At 1,000 concurrent users, an SFU needs roughly 5–10 CPU cores; an MCU needs 120–200. That is the difference between one Hetzner box and a small rack. Build SFU-first unless you have a specific reason (heavy server-side recording, ultra-low-power clients) to mix.

Per-minute run-rate at scale

The run-rate is the line that scales linearly with usage, so it decides your gross margin at scale. Here is what each path actually costs per participant-minute and per million minutes, with the volume where it stops making sense.

Read that table as a ladder, not a menu. A product climbs it as it grows: pure CPaaS while minutes are small and engineering time is precious, LiveKit Cloud in the mushy middle, self-hosted once volume makes the fixed ops cost worth amortising. The blended self-hosted number includes servers plus a slice of an on-call engineer, which is why it is a range and not a single figure. Ignore anyone who quotes self-hosting at “just the server cost”: the people cost is the cost.

The 500-concurrent crossover

Here is the whole decision in one chart. SDK cost starts near zero and climbs in a straight line with usage. Self-hosted cost starts high (you paid to build it and you pay to keep it alive) but climbs slowly. The two lines cross around 500 concurrent users at steady load, which lands in the 1M–5M participant-minutes-a-month range depending on how many hours a day your rooms stay busy.

Figure 3. Below ~500 concurrent users a managed SDK is cheaper; above it, a self-hosted stack wins because fixed costs amortise.

Below the crossover, the SDK premium is smaller than the cost of the engineer who would run your servers, so managed wins. Above it, the per-minute fees overtake the fixed cost of self-hosting, and every additional user is nearly free on your own infrastructure. The exact point moves with your call patterns (a webinar with 1 publisher and 500 viewers crosses later than a 500-person mesh of active cameras), but 500 concurrent is a reliable planning anchor.

The mistake we see most: teams self-host at 50 concurrent users because it feels “more serious,” then spend their seed round babysitting mediasoup instead of building product. The chart says wait. Cross the line first, then migrate. Our build-vs-buy TCO playbook works this math for a specific migration.

Bandwidth math: the hidden line item

Egress is the line item that surprises CFOs, because it is invisible until the invoice. Every forwarded stream is bytes leaving a data centre, and cloud providers bill egress by the gigabyte. Here is the math, which you can run yourself.

Worked example: a 10-person room at 720p, 8 hours a day, 22 working days. Downlink is ~9 Mbps, so per hour that room moves ~9 Mbps × 3,600s / 8 = ~4 GB down per participant-hour, call it ~40 GB for the room-hour across 10 users. Over 176 hours a month that is ~7 TB. At AWS’s first-tier ~$0.09/GB, that one busy room costs ~$630 a month in egress alone, before compute. Run twenty of them and egress dwarfs your server bill.

This is why serious self-hosting lives on providers with cheap or included egress. Hetzner’s dedicated boxes (an AX41-NVMe is ~€42/month, an AX102 ~€122/month in 2026) bundle generous traffic, which is how the self-hosted per-minute number gets so low. The same room on hyperscaler egress can cost more in bandwidth than the entire Hetzner server.

Hidden cost lines teams forget

Four cost lines never make it into the first spreadsheet, and all four are bigger than people expect.

1. TURN relay. Roughly 15–20% of sessions can’t establish a direct connection (symmetric NATs, corporate firewalls) and must relay through a TURN server. That “free” P2P call is now metered egress, and TURN bandwidth is the same price as any other egress.

2. Recording and post-processing. Cloud recording runs $0.01–$0.03 per minute on managed platforms; self-hosted recording means a transcoding box that is idle most of the day and saturated during peak. Transcription and RTMP/HLS restreaming stack on top.

3. On-call and upgrades. A self-hosted media stack needs someone who wakes up when it breaks and who tracks upstream security releases. Budget a fraction of a senior salary indefinitely. This is the line that makes small-scale self-hosting a false economy.

4. Client-side surprises. Safari and iOS handle WebRTC differently from Chrome; native mobile clients are a separate build. The interoperability tax is real and it lands late, during QA, when it is most expensive to fix.

Compliance: the silent cost line

If you touch healthcare, finance, education or EU personal data, compliance is a cost line, not a checkbox. Managed platforms bundle it: Vonage, Daily and LiveKit Cloud will sign a HIPAA BAA and hand you SOC 2 Type 2 reports, and that is a genuine reason to pay their per-minute premium. Self-hosting means you build parity yourself.

Parity is not just encryption. It is audit logging of every session, encryption at rest for recordings, access controls that survive an auditor, data-residency guarantees, and the paperwork trail behind all of it. On a self-hosted stack, budget an extra $50K–$150K and 6–12 weeks for HIPAA or SOC 2 readiness, on top of the base build. We have shipped HIPAA-grade video (VALT serves 770+ US organisations under HIPAA) and the compliance layer is always a real slice of the project, never a rounding error.

The hybrid path: ship now, self-host later

The most under-used option is not build or buy. It is buy, then build, on purpose. Ship on LiveKit Cloud today because the OSS core is the same code you will run on your own servers. When volume crosses the line, you migrate the media plane to self-hosted infrastructure without rewriting your app. Same SDK, same signalling, different deploy target.

This path front-loads almost none of the self-hosting cost while keeping the escape hatch open. You get managed reliability during the risky early months when you can least afford a 3am outage, and you keep the option to halve your per-minute cost the moment it matters. The only discipline it requires is choosing an OSS-portable platform on day one instead of locking into a proprietary SDK you can never leave.

Worked example: a budget at three stages

Put the whole WebRTC architecture cost together for one product across three growth stages. Same app, three different right answers, because the crossover moves as you scale.

Figure 4. One product, three cost regimes. The right WebRTC path changes as concurrency grows; most teams migrate at least once.

Stage 1 — MVP (< 100 concurrent). Ship on a managed SDK (Daily or Zoom Video SDK). Year-1 cost: ~$30K–$60K to build the app and UX, plus ~$3.5K–$5K a month in per-minute fees. You spend zero time on servers.

Stage 2 — Series A (100–500 concurrent). Move to LiveKit Cloud or go hybrid. Year-1 cost: ~$50K–$90K to migrate and harden, plus ~$1K–$3K a month. Per-minute cost drops by 5–10x while you are still fully managed.

Stage 3 — Scale (> 500 concurrent). Self-host LiveKit OSS or mediasoup on dedicated servers. Year-1 cost: ~$80K–$220K to build and operate, plus under $1K a month in infrastructure. Marginal cost per new user is now nearly zero, which is what makes the unit economics work at scale.

Mini case: cutting a per-minute bill

A pattern we run often: a scaling platform on a managed SDK watching per-minute fees eat the gross margin. Take the arithmetic at EdTech scale. A product doing 500M classroom minutes a year (the order of magnitude of BrainCert’s platform) pays roughly $0.004 × 500M = ~$2M a year on a mid-tier CPaaS rate. Move the media plane to a self-hosted LiveKit OSS stack at a blended ~$0.0006 per minute and the same volume runs ~$300K, servers and on-call included. That is the shape of the saving, and it is why platforms migrate.

The plan we use is boring on purpose. Weeks 1–3: instrument current usage and pin the real per-minute cost, including egress and TURN. Weeks 4–9: stand up the OSS SFU behind the same signalling, run both stacks in parallel, shift traffic by percentage. Weeks 10–12: cut over, keep the managed path as hot failover, tune autoscaling. No big-bang rewrite, no weekend outage.

The result is a per-minute line that drops by roughly 5–7x with the managed reliability kept as a safety net during the switch. Want the same assessment on your numbers? Book a 30-minute call and we will model your before-and-after.

A decision framework in five questions

Five questions decide the stack. Answer them top to bottom; the first strong signal usually settles it.

Figure 5. Pick your WebRTC path in five questions. The first strong signal (core product, concurrency, volume, ops, control) usually decides the stack.

Q1. Is real-time video the core product? If no, use a managed SDK and put your effort into the UX on top. Video is a feature, not your moat.

Q2. Under ~500 concurrent users for the next year? If yes, managed SDK (Daily, Zoom, Agora). You are below the crossover; self-hosting would cost more, not less.

Q3. Over ~1M participant-minutes a month and cost-sensitive? If no, LiveKit Cloud gives you managed reliability at a tenth of CPaaS per-minute pricing.

Q4. In-house WebRTC ops, or budget to hire it? If no, go hybrid: LiveKit Cloud now, self-host when you can staff the on-call.

Q5. Need full control (data residency, a custom SFU)? If yes, self-host mediasoup or LiveKit OSS. You have the scale and the reasons to justify the build.

Pitfalls that wreck WebRTC budgets

1. Self-hosting too early. Building your own SFU at 50 concurrent users to “save money” costs you an engineer’s time worth more than years of SDK fees. Cross the line first.

2. Forgetting the run-rate. Teams sweat the build quote and ignore that per-minute fees compound monthly. At scale the run-rate dwarfs the build. Model both.

3. Pricing the server, not the on-call. The expensive part of self-hosting is the human who keeps it up, not the €42 box. A self-hosted estimate without an ops line is fiction.

4. Choosing a locked-in SDK. Pick a proprietary platform and you can never migrate without a rewrite. An OSS-portable core (LiveKit) keeps the exit cheap.

5. Ignoring egress and TURN. Bandwidth is usually the biggest self-hosted line, and 15–20% of sessions relay through TURN. Both are invisible until the invoice arrives.

KPIs: what to measure and budget

Quality KPIs. Track median and p95 join time (target < 2s), packet loss recovery, and freeze rate. A cheap stack that drops calls is not cheap; it is a churn engine. Budget for a QoE monitoring line from day one.

Business KPIs. Cost per participant-minute (blended, all-in) is the number that decides your margin. Track it monthly against active minutes. When it stops falling as you scale, you have hit the crossover and it is time to consider self-hosting.

Reliability KPIs. Uptime of the media plane (target 99.9%+), TURN fallback rate, and mean time to recovery. On a self-hosted stack these are your responsibility, so budget the on-call rotation and the observability tooling that makes 3am debuggable.

When NOT to build custom WebRTC

Skip the custom build when any of these hold: concurrent users stay below ~200; the team has no WebRTC ops experience and no plan to hire it; time-to-market is under 8 weeks; or total budget is under $50K. In every one of those cases, the right move is a managed SDK with a custom UX layer on top, which is exactly what our custom video conferencing development delivers without forcing the full SFU lift.

Honesty sells better than a pitch, so we will say it plainly: most products that ask us to build custom WebRTC should not, yet. They should ship managed, prove the volume, and migrate when the crossover chart says the money is real. The custom build is a scaling decision, not a starting one.

FAQ

What is the cheapest credible path for a WebRTC MVP in 2026?

A managed SDK on its free tier. Daily, Zoom Video SDK and Agora each give ~10,000 free participant-minutes a month, which covers a real MVP for $0 in run-rate. Your only cost is the ~$25K–$60K to build the app around it.

When does building a custom SFU become cheaper than an SDK?

Around 500 concurrent users, or ~1M participant-minutes a month. Below that, SDK fees are smaller than the cost of the engineer who would run your servers. Above it, self-hosted marginal cost is near zero and the fixed ops cost amortises.

How much does a custom WebRTC build cost?

A self-hosted SFU build runs ~$80K–$220K depending on media server (LiveKit OSS is cheaper to stand up than bare-metal mediasoup), plus $25K–$50K for SOC 2/HIPAA compliance and $35K–$80K for native mobile clients.

Is Twilio Video shutting down?

No. Twilio announced end-of-life in December 2024, extended it to December 2026, then reversed the decision and confirmed Twilio Video stays a standalone product. Guides that tell you to migrate away are out of date.

Should we use LiveKit Cloud or LiveKit OSS?

Start on LiveKit Cloud (managed, ~$0.0004–$0.0005 per minute) and migrate to LiveKit OSS on your own servers when you cross ~1M minutes a month. Because the core is the same open-source code, the migration is a deploy change, not a rewrite.

How much does compliance add to a WebRTC build?

On a self-hosted stack, HIPAA or SOC 2 readiness adds ~$50K–$150K and 6–12 weeks for audit logging, encryption at rest, access controls and data-residency guarantees. Managed platforms bundle this into their per-minute price.

What drives the per-minute cost most: topology or provider?

Topology first, provider second. An MCU costs 10–20x the CPU of an SFU for the same room, which dwarfs the difference between two SDK vendors. Pick SFU, then shop providers.

Does Fora Soft build on our chosen stack or push its own?

Yours. We have shipped on Vonage, Twilio, Daily, Agora, Kurento, mediasoup, Janus and LiveKit. We recommend the stack your volume and compliance profile call for, not the one that is easiest for us.

What to read next

Model your WebRTC cost honestly

WebRTC architecture cost comes down to two numbers and one line. The two numbers are the up-front build and the per-minute run-rate; the line is the ~500-concurrent crossover where self-hosting overtakes managed SDKs. Below it, buy. Above it, build. The hybrid path (LiveKit Cloud now, OSS later) is the safest way to sit on the fence without paying for it.

Pick the topology first (SFU for almost everyone), price both cost lines, add the hidden ones (TURN, egress, compliance, on-call), and check which side of the crossover your real traffic sits on. Do that and the “build or buy” argument answers itself. If you want the numbers run on your specific assumptions, that is a 30-minute call, and we will tell you honestly when staying on a managed SDK is the smarter move.