29 August 2026
An SFU — a selective forwarding unit — is a server that receives one video stream from each participant and forwards copies of the streams every other participant needs, without decoding or re-encoding any of them. It sits between two other designs, mesh and MCU, and the difference between all three comes down to one question: who does the work of turning one person's camera into everyone else's screen, and where does that work land — your laptop, or a server rack somewhere.
Every video call has to solve the same problem: N people each producing a stream, and N-1 copies of every other stream that need to arrive somewhere to be decoded. Mesh, SFU and MCU are three different answers to who carries that load.
In a mesh call, your laptop connects directly to every other participant's laptop. There is no server in the media path at all — each device encodes its own camera once, then uploads a copy of that encode to every other participant individually. An SFU replaces those direct connections with a server: you upload once, the server fans that single stream out to whoever needs it, and downloads the streams you need in return. An MCU goes further still — it decodes everyone's video, mixes it into one composite picture, and sends each participant a single pre-built stream, the way a TV broadcast works.
Mesh looks cheap because there's no server to run, but the cost doesn't disappear — it moves onto every participant's own upload connection. With 8 people on a mesh call, your device isn't uploading once; it's uploading 7 separate copies of your camera stream simultaneously, one addressed to each other participant, because there's no server to duplicate it for you.
At a modest 700 kbps per copy, that's close to 5 Mbps of sustained upload just for your own video — before you add the download side, where you're decoding 7 incoming streams at once. Most home connections have far more download capacity than upload, so mesh calls tend to degrade from the upload side first, and they degrade for everyone at once, because one weak connection is broadcasting garbled video to the whole group. This is why mesh mostly survives for two or three people and starts visibly fraying by five or six.
An SFU changes the arithmetic on the upload side completely. You send your camera stream once, to the server, regardless of how many people are on the call. The server holds that single upload and forwards a copy to each participant who needs it — the duplication happens on server bandwidth, not yours.
Your download cost still scales with the size of the call, because you're receiving one stream per other participant, and your browser is decoding all of them. That's real work — decoding is CPU, not just bandwidth — which is why large SFU calls often shrink tiles, drop resolution on people who aren't speaking, or cap how many video feeds render at once. The ceiling in an SFU design isn't your upload anymore; it's your download bandwidth and your device's decode capacity, and both of those are considerably more forgiving than upload was in mesh.
An MCU takes the SFU idea one step further and removes the download scaling problem too. It decodes every incoming stream, composites them into a single picture — the classic gallery-view rectangle — and sends each participant one pre-mixed stream. Your bandwidth and decode cost stay flat no matter how many people join, which used to matter a great deal on mobile networks and older hardware.
The trade-off lands entirely on the server. Decoding and re-encoding every stream for every layout is expensive compute, it scales with call size in a way SFU forwarding never has to, and every re-encode adds a small amount of latency and a small amount of quality loss — the picture you see was rebuilt, not passed through. MCUs also make it harder to give one participant a different layout than another, since the composite is usually built once and shared.
Mesh breaks first and breaks hardest, because the cost is on the weakest link's upload, and it's paid by every participant simultaneously — practical limits sit around 4 to 6 people before someone's connection can't keep up. SFU pushes the ceiling out to the dozens, because upload no longer scales with headcount and download degrades gracefully — you can drop resolution on tiles you're not actively watching long before the call becomes unusable. MCU can, in principle, support very large one-to-many broadcasts, since the participant side never scales at all — but the ceiling just moves to whatever compute the operator is willing to pay for.
Most modern meeting products, AVAY included, run on an SFU for exactly this reason: it keeps the cost on infrastructure you control rather than on whoever happens to have the worst upload in the room. In AVAY's case, the AI participant that transcribes the call and answers questions is itself just another subscriber pulling a stream off the same SFU — it doesn't add a second, heavier media path alongside the human one.
| Your upload cost | Your download/decode cost | Typical ceiling | |
|---|---|---|---|
| Mesh | Scales with N-1 (one copy per peer) | Scales with N-1 (one stream per peer) | ~4-6 people |
| SFU | Fixed — upload once regardless of size | Scales with N-1, but can be reduced per tile | Dozens, layout-dependent |
| MCU | Fixed — upload once | Fixed — one composite stream | Server compute is the limit, not you |
An SFU is one type of media server — the type that forwards streams without decoding them. MCUs are also media servers, but they decode, composite, and re-encode, which is a heavier and different job. When people say "media server" without qualifying it, they usually mean whichever of the two a given platform actually runs.
Not directly — it doesn't touch the video itself, since it forwards streams without decoding them. What it improves is reliability at scale: because your upload cost stays fixed regardless of call size, you're less likely to run out of bandwidth and start dropping frames as more people join.
Because your download bandwidth and your device's decode capacity still scale with the number of streams you're receiving, even though your upload doesn't. Lowering resolution on tiles you're not actively watching — a technique called simulcast — is how SFU-based calls keep the download side manageable as headcount grows.
Yes — some platforms use an SFU for the live call and route a copy through an MCU-style mixer only for recording or for a single broadcast stream to viewers who aren't full participants. The two designs solve different problems, so combining them for different outputs is common, even if the live call itself runs on one architecture.
An SFU is the server that lets you upload your video once and never again, no matter how many people are watching — which is why it, not mesh or MCU, is what makes a call of more than a handful of people hold together.
AVAY is a video meeting platform that transcribes the call itself — no bot joins, because there is nothing to join. Start one at avay.ai, read how each part works in the documentation, or see what it costs.