Disclosure first: we make Reactor, one of the services compared below, so this part has a stake in the outcome. The method in part one does not, and you can re-run all of this with your own numbers using the calculator in part one. Treat the figures here as a worked argument with its assumptions shown, not as neutral fact.
In part one we costed out building and running a multiplayer backend yourself. For a 32-player 3D shooter at 300 MACCU (1,000 peak), the recurring infrastructure came to about $1,465 a month, and the labor to build and maintain a custom stack came to about $8,650 a month amortized: roughly $10,100 all in, dominated by labor.
Now the build-versus-buy question. Buying a managed service changes two things, and they pull in opposite directions.
What buying changes
It removes the labor lines. A fully managed engine ships the netcode, serialization, hosting, and scaling already built and operated. The ~$8,650 a month of build-and-maintain in our example drops to roughly zero. For most teams that is the entire decision, because it dwarfs everything else.
It reprices the infrastructure. In exchange you pay the service’s rates for bandwidth and compute, which can run much higher or much lower than your own depending on how the service is built. This is where the options diverge sharply.
The pricing models
Three shapes, and knowing which one you are buying matters more than the sticker:
- Per-CCU relay (Photon): you pay for connected-user-time. The relay moves messages, it does not run your game logic, so for server authority you run your own dedicated servers on top.
- Credits across CCU, compute, and bandwidth (Coherence): you pay for connected users, simulator compute, and egress, all metered as credits.
- Per-room compute, metered by the minute (Reactor): you pay for the compute a room uses, plus bandwidth, and capacity tracks MACCU rather than peak.
Per-CCU and credit models bill against connected-user-time, so they map to MACCU directly. Per-room compute maps to MACCU only when the service scales rooms to demand, which metered billing does.
The same game, four ways
Our 32-player shooter at 300 MACCU, run through each option. Infrastructure is monthly; labor is build amortized plus maintenance. The assumptions are stated because they are what move the numbers.
| Option | Infrastructure | Build + maintain | Still on the hook for |
|---|---|---|---|
| Roll your own | ~$1,465 | ~$8,650 | everything |
| Photon Fusion (relay only) | ~$250 | most of it | building and running server authority yourself |
| Photon Fusion (server-authoritative) | ~$1,715 | partial | building and operating your own authoritative servers |
| Coherence | ~$5,500 to $6,500 | ~$0 | a dev-tools fee if you are funded |
| Reactor | ~$820 | ~$0 | nothing |
Photon Fusion, in pure relay mode, is the cheapest line in the table at ~$250 a month, but that buys the lowest capability: the relay moves messages between clients, with no server authority and no cheat protection. The moment you need an authoritative server, which our example does, the relay fee stays but you add back most of the roll-your-own costs it does not cover. You build the authoritative server layer (Fusion gives you a netcode framework, so this is reduced, not removed). You stand up and operate dedicated server instances (~$310 of compute), and their egress is your cloud bill (~$1,005 of bandwidth). You carry the ops to keep them running. So Photon for an authoritative game is roughly the roll-your-own infrastructure plus a per-CCU relay fee on top, with build-and-maintain only partly reduced. Its real value is the proven netcode framework and ecosystem, not a smaller bill.
Coherence is fully managed, so the labor goes away. Assume it compresses about as well as any competent engine, the same ~67 GB per CCU-month as the baseline. The cost is the rate, not the volume: Coherence bills bandwidth at roughly $0.20 to $0.32 per GB, four to six times a typical egress rate, which puts bandwidth alone near $5,000 a month for this game. Per-CCU connection charges add about $216, and simulator compute adds more, though how much is hard to pin down because Coherence does not publish clear simulator pricing. That uncertainty is what the $5,500 to $6,500 range absorbs. On top of that, studios over $200k in revenue or funding pay a $1,000 a month developer-tools fee. The exact credit math is in their pricing docs.
Reactor is fully managed and built to attack the bandwidth line specifically. In our deployments a 3D transform consistently compresses to two bytes or less, against the 12-byte general figure from part one, and that transform line is the single biggest input to the bandwidth number. At two bytes the per-player rate falls to about 6,900 bytes a second, and bandwidth drops to ~$270 a month. Compute is metered by the minute and tracks usage rather than peak: the ~9.4 rooms this game averages at 300 MACCU come to ~$550 at Reactor Cloud’s per-room rate. Together that puts infrastructure near $820. This is our engine, so verify it against your own game with the calculator in part one rather than taking our word, and see the per-unit detail in our Reactor versus Coherence comparison.
So, build or buy?
Two things fall out of the table:
Labor decides it more often than infrastructure does. The ~$8,650 a month of build-and-maintain in rolling your own is larger than any infrastructure difference between the services. A fully managed engine (Coherence or Reactor) removes that line entirely; Photon only reduces it, because you still build and run the authoritative servers. Unless you have netcode expertise in-house and a reason to own the stack, buying a fully managed engine wins on cost before the per-unit rates even come up.
Among managed services, bandwidth is the swing. Compute and per-CCU fees land in a similar range; egress does not. A service with no compression, on a data-heavy 3D game, can cost several times one that compresses well. That is the number to model carefully for your specific game, because it is the one that varies most.
Roll your own if you need to own the stack and can afford to: full control, data residency, or a scale that justifies amortizing the build. Buy if you want to ship multiplayer instead of building infrastructure, which is most teams. Either way, run the method from part one on your own numbers before you commit. The calculator in part one makes it a five-minute exercise.