Build1 distinct publisher3 min readPublished
A proxied session costs about 320 KB of buffers and goroutine stacks, so peak load for a mid-size engineering organisation is tens of megabytes, and the constraint that actually bites is the controller's network interface.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
Start with what the process is actually holding. Tessera's own accounting puts a proxied session at about 256 KB of copy buffers plus six to ten goroutines at roughly 8 KB of stack each, rounded to 320 KB, sitting on a base Go process of about 30 MB [3][4]. That figure is indexed to connections open right now, not to headcount. Run the 200-person organisation through it. The planning rule in the post is that 10 to 20 percent of a team is connected on a normal working day, which is 20 to 40 concurrent sessions [5]. At 320 KB apiece that is 6.4 to 12.8 MB of live session data [1]. Add the base process and you are near 36 to 43 MB, and Go's residency behaviour roughly doubles it, so expect something like 73 to 86 MB resident [2]. A 512 MB VM is about six times that [7]. That is a large cluster for a total of 13 MB of buffers. The doubling is the part to understand before you write a limit. Go does not hand memory back to the operating system promptly, and at the default GOGC=100 the collector lets the heap grow to roughly twice the live set before it collects, so resident memory settles at about double the arithmetic [8]. The author treats that gap as headroom for spikes rather than a hidden cost [9]. The chart's defaults agree with him: requests 256Mi, limits 1Gi [10]. For the 200-session case his arithmetic is 94 MB [7], which lands near 188 MB resident, making 1Gi about five times the expected figure [3]. These are one vendor's numbers, disclosed as such by the author, who says the reasoning applies to any proxy in a session path [1]. Two constants have to hold for the 320 KB to transfer: buffer size per session and goroutine count per session [3]. A proxy that allocates a megabyte per direction, or an OS thread per session, has a different constant, and the GOGC doubling is specific to a Go runtime [8]. That is why the two questions the post tells you to ask, per-session memory and base process size, are the right ones, and why the "thousands of users" line answers neither [11][2]. The proxy terminates TLS with the client and runs SSH to the target, so every byte is encrypted and decrypted twice [12]. AES-NI does that in hardware on any CPU of the last decade, and the post's figure is one vCPU per 50 concurrent sessions, four for 200-plus [13]. Forty sessions therefore fits inside a single vCPU [6]. The traffic is the real limit: everything crosses the controller twice, so moving N bytes costs 2N on its interface, and that interface saturates first [15]. Interactive shells are a few KB/s each, single-digit Mbit/s even at 200 sessions [16]. One RDP session runs 0.5 to 5 Mbit/s and is sustained, so 20 of them is 100 to 200 Mbit/s through the controller [17]. At the top of that range a single RDP session, doubled, is 10 Mbit/s, which on its own exceeds the whole 200-shell load [5]. So the link gets sized from RDP alone [18], while memory and CPU come off the session count. Sustained file transfer sits in the same non-interactive category [14]. Latency is separate from all of it. The double hop adds a round trip to every keystroke echo, so a controller in a different region from its targets is a tool users will call laggy, correctly, and three regions of targets argues for three controllers [19].
Ranked by verification strength, evidence, and original report placement.
The author discloses that the figures come from Tessera, a session broker product he works on, and states the reasoning applies to any proxy that sits in a session path.
Vendor pages in this category typically claim to scale to thousands of users; the author argues that is a useless number because a user who is not connected costs nothing.
A proxied session in Tessera is mostly buffers: about 256 KB of copy buffers plus 6 to 10 goroutines at roughly 8 KB of stack each, which the author rounds to 320 KB per session.
The author says the difference between the seat count and the concurrent-session count is the difference between a 512 MB VM and an argument about whether you need a cluster.
The author's arithmetic for 200 concurrent sessions: 200 x 320 KB is about 64 MB of live data, plus 30 MB base, about 94 MB.
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 31, 2026
Follow any of these and your For You feed starts watching them — no settings page required.
build
A NetworkPolicy in another repo broke invoicing while every dashboard reported success1 distinct publisher
build
Three attackers hide behind one connect button, and encryption only stops one of them1 distinct publisher
build
The ICO fines what you cannot prove: Article 32 makes encryption and erasure an engineering liability1 distinct publisher
build
A 100-worker PHP-FPM pool tops out at 500 req/sec on a 200ms endpoint1 distinct publisher
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Checkable arithmetic on unverified inputs
The chain is honest and reproducible on paper: 320 KB a session, 30 MB base, double it for Go's residency, compare against a 1Gi limit. What nobody outside the vendor has checked is the first two terms, and the loopback benchmark that produced the 20 percent overhead figure arrives without the table behind it — the reader gets the characterisation and the method, not the measurement. The general-world assertions, 50 sessions per vCPU and 0.5-5 Mbit/s per RDP session, carry no data at all.
No deployments in view
Nothing in this reporting says who runs a session broker at any of these session counts. A chart default and an internal loopback run are artefacts of a product, not evidence that anyone is operating it — and the concurrency rule is offered as something that has held up for the author, with no deployment behind it that we can see.
Argued down, not up
The unusual thing about this piece is the direction of the distortion. A vendor engineer sizes his own product onto a 512 MB VM, calls the category's thousands-of-users promise useless, and tells readers to route database dumps and CI artefacts around the broker entirely. Claims sit slightly below what the visible evidence would license. It does not go further below zero because deflation is itself a sales posture — 'ask my competitor for per-session memory' is a competitive move dressed as arithmetic.
Vendor arithmetic, disclosed in line one
Every measurement belongs to the product the author builds, the recommended sizing happens to match that product's shipped chart, the reproduction path runs through its load-test tool, and the two questions readers are told to put to competitors are the two this post already answers. The mitigating detail is placement: the disclosure is the first sentence, not a footer, and the numbers offered are the unflattering kind.
Confident in the reasoning, not the inputs
We can be firm about what was claimed, how it was derived, and where it stops being verifiable — the writing leaves no ambiguity on any of those. We cannot be firm about whether 320 KB per session, 50 sessions per vCPU, or a 10-20 percent concurrency ratio survive contact with anyone else's system. One independent measurement of any session proxy would move this figure more than a hundred more paragraphs from the same author.