TL;DR: A five-person team can run private LLM chat, code completion, and document RAG on one used-RTX-3090 box for roughly $2,100–2,600 cash in year one, against ~$2,940/year for the equivalent SaaS seats (Copilot Business + ChatGPT Team). The cash math favors self-hosting from month 10 or so — but only if you don’t price the 45–75 admin hours someone on the team will spend running it.

	Self-hosted (one RTX 3090 box)	SaaS seats (Copilot Business + ChatGPT Team)	Rented GPU (Vast.ai)
12-month cash cost	~$2,100–2,600 (year one, incl. hardware)	~$2,940 ($245/mo × 12)	3090 from ~$0.07/hr, pay per use
Hardware threshold	24GB VRAM, 32GB system RAM	None	None
Admin time, year one	45–75 hours	~0 hours	5–10 hours
Data leaves your network	No	Yes	Yes
Year-two cash cost	~$200 (electricity)	~$2,940 again	usage-based

Honest take: If one of the five genuinely wants to own a server, self-host — year two costs $200 instead of $2,940 and nothing leaves your network. If nobody wants the pager, buy the SaaS seats; unpaid sysadmin work done grudgingly is the most expensive line item on this page, and it never shows up on an invoice.

Team-of-five is an awkward size: too big for everyone to run Ollama on their own laptop, too small to justify a proper platform engineer. Every cost breakdown we could find prices either a solo hobbyist or a 50-seat enterprise. Here is the complete 12-month bill for the middle case — one shared GPU box serving five developers — next to what the same five seats cost on SaaS, with every price verified September 2026.

What does a five-person self-hosted AI stack cost over 12 months?

About $2,100–2,600 in cash for year one, of which 85%+ is one-time hardware. The stack this prices out is the standard team trio — Ollama (v0.34.0, September 2026) as the model backend, Open WebUI (v0.11.1) for multi-user chat with per-user logins, and Tabby for IDE code completion — all on a single machine:

Line item	Cost (verified Sep 2026)
Used RTX 3090 24GB	~$1,050–1,350
32GB DDR5 kit (e.g., Corsair Vengeance 32GB DDR5)	$399–479
1TB NVMe SSD	~$80
Used CPU + board + PSU + case (skip if repurposing a PC)	~$400–550
Electricity, 24/7 operation, 12 months	~$180–240
Software (all Apache 2.0 / MIT / BSD licensed)	$0
Year-one cash total	~$2,100–2,600

Two of those numbers moved hard in 2026 and will sink you if you budget from an older guide. Used RTX 3090s ran ~$850 in mid-2026; September 2026 eBay sold prices sit near $1,050 with asking prices up to $1,350+. And the DDR5 line is not a typo: 32GB kits cost $399–479 as of September 2026 (Tom’s Hardware RAM price index, Sep 11) — roughly 4× their 2025 price, because HBM demand ate the fab capacity. RAM is now a real budget line, not a rounding error, and no forecast has it recovering before late 2027.

Electricity is the only recurring cash cost. At the September 2026 US average of ~18.3¢/kWh, a box idling at ~80W with a few hours of aggregate daily inference on a 350W GPU draws $15–20/month — more than a solo setup because five users keep the GPU busier, but still under one SaaS seat. Regional math is in our electricity cost by region breakdown.

What do the same five seats cost on SaaS?

$245/month — $2,940/year — for the closest like-for-like bundle, billed monthly:

SaaS line item	Per seat	5 seats / month	12 months
GitHub Copilot Business	$19	$95	$1,140
ChatGPT Team	$30	$150	$1,800
Total	$49	$245	$2,940

That bundle maps to what the self-hosted stack replaces: Copilot Business covers what Tabby does (IDE completion), ChatGPT Team covers what Open WebUI + Ollama do (chat, drafting, internal Q&A). If your team only needs one of the two, the comparison collapses accordingly — five Copilot Business seats alone run $1,140/year, and the self-hosted box does not beat that on cash inside year one.

The break-even against the full $245/month bundle lands around month 9–11, depending on where in the hardware range you bought. From month 12 onward the self-hosted box costs ~$200/year against $2,940/year — a 15× gap that only widens as SaaS vendors raise per-seat prices. Which paid tiers actually earn their keep is a separate question we covered in Open-Source AI Paid Tiers: Which Are Worth It.

What you give up is model quality at the frontier. A 30B-class open-weight model on Q4 quantization is genuinely good for completion, drafting, and internal RAG in 2026; it is not GPT-5.4 or Opus-class reasoning. Teams whose daily work leans on frontier reasoning should read the when NOT to self-host guide before spending anything.

What hardware threshold does a five-person team actually need?

One 24GB-VRAM GPU and 32GB of system RAM. That is the floor, and it is worth being precise about why:

• 24GB VRAM fits a 30B-class chat model at Q4_K_M (~19GB) or a 7B coder model (~5GB) plus a mid-size chat model side by side. Five people do not generate five simultaneous requests often; Tabby’s request queuing and Ollama’s scheduler absorb the overlap. Our 10-person stack guide measured a single 24GB card handling up to 20 concurrent users on a 7B model — five is comfortable.
• 32GB system RAM covers Docker, Open WebUI’s database, embedding jobs for RAG, and OS overhead. At 2026 DDR5 prices, resist the old “just get 64GB” reflex — a 64GB kit is $680–1,070 now, more than a used RTX 3060. Buy for the workload; 32GB is enough here.
• 16GB-VRAM cards don’t scale to teams. A lone developer tolerates the 13B-class ceiling; five people sharing it will not. If the 3090 budget isn’t there, rent until it is (decision table below).

Bringing the stack up is two commands per service. Ollama plus the chat model:

$ ollama pull qwen3:30b
$ ollama ps
NAME         ID            SIZE     PROCESSOR    UNTIL
qwen3:30b    4a5c3e8f2b1d  20 GB    100% GPU     4 minutes from now

100% GPU is the line that matters — if you see a CPU percentage there, the model didn’t fit in VRAM and every user’s tokens just got 5–10× slower. Open WebUI and Tabby then run as Docker containers pointed at Ollama’s API on port 11434. Full parts lists and case/PSU choices are hardware-site territory: runaihome.com covers GPU server builds at current prices.

How many admin hours does a team stack really eat?

Budget 10–20 hours for the first month and 3–6 hours per month steady-state — call it 45–75 hours across year one. That is ~50% above the solo-stack numbers from our maintenance hours log, because a team stack adds user management, uptime expectations (four other people notice when it’s down), and backup duty for the shared chat history and RAG documents.

Priced at a developer rate, this dwarfs everything else on the page:

Effective rate	Year-one admin cost (45–75 hrs)	vs. year-one SaaS ($2,940)
$0/hr (someone enjoys it)	$0	self-host wins month 10
$50/hr	$2,250–3,750	roughly a wash
$100/hr	$4,500–7,500	SaaS wins year one outright

This table is the honest core of the whole decision. The five-person self-host case is strong only when the admin hours are cheap — a team member who tinkers with home labs anyway, or slack time you’d never bill. If maintaining the box displaces billable work at $100/hour, year one costs more than three years of SaaS seats. Run your own rate, not ours.

Where does the one-GPU setup actually break?

Model-swap thrashing was the failure we hit first. Tabby wants its 7B coder model resident; Open WebUI users summon the 30B chat model; on one 24GB card Ollama evicts one to load the other, and if both arrive within the same minute every request pays a 3–5 second reload. With five users this happened several times an hour by week two.

The fix costs nothing: pin the coder model permanently and stop Ollama from evicting it.

$ OLLAMA_MAX_LOADED_MODELS=2 OLLAMA_KEEP_ALIVE=24h ollama serve

Then drop the chat model one quant level (Q4_K_M → smaller 14B-class, or a Q3 quant of the 30B) so both fit in 24GB simultaneously. Quality loss at that step is measurable but small for chat workloads — the trade-offs are mapped in our quantization guide. The alternative fix is a second GPU, which restarts the whole budget conversation.

Distributed teams hit a second wall: the box lives in one office, and exposing Open WebUI to the internet safely means a reverse proxy, TLS, and auth you now also maintain. The clean pattern is hosting the UI layer on a small VPS (a Vultr instance at a few dollars a month does it) with a WireGuard tunnel back to the GPU box — the GPU stays behind your firewall, the login page doesn’t.

When should a five-person team NOT self-host?

• Nobody wants to own the server. Not “someone could” — someone wants to. A stack maintained resentfully gets abandoned by month four, and you’ll have paid for the hardware and crawled back to SaaS.
• Your daily work needs frontier-model quality. Open-weight 30B models are excellent for completion and internal chat; they are not Opus or GPT-5.4 for hard reasoning. Hybrid (self-host chat, keep two frontier API seats) often beats purity.
• Usage is light. If the team’s real usage is a few prompts a day each, metered API keys cost $10–30/month total. Measure for 60 days before buying anything.
• Electricity runs 35¢+/kWh. At German-level residential rates a 24/7 box approaches $400–500/year in power alone; rent GPU time instead.
• Compliance requires audit trails you’d have to build. SaaS team tiers ship SSO, retention policies, and admin logs. Rebuilding those around Open WebUI is real engineering work, not an afternoon.

What to actually buy

Prices as of September 2026, all taken from the comparison above:

Your situation	The machine	Price	Where
5 devs, one location, someone owns the box	Used RTX 3090 24GB + 32GB DDR5 build	~$2,100–2,600 all-in	Check price
Same box, 2× inference speed and warranty matter	Used RTX 4090 24GB (card only)	~$2,150–2,350	Check price
Distributed team — UI layer off the GPU box	Small VPS + WireGuard to the box	a few $/mo	Vultr
Unsure the team will actually use it	Rented RTX 3090, test for a month	from ~$0.07/hr	Vast.ai
Want dedicated cloud GPU, zero hardware ownership	Dedicated RTX 4090 instance	~$700–800/mo	RunPod

The Vast.ai row is where undecided teams should start: a month of rented 3090 time at market rates costs less than one ChatGPT Team seat and produces real usage data. If the team quietly stops using it by week three, you just saved $2,400.

FAQ

Is self-hosting AI cheaper than SaaS for a small team? On cash, yes from roughly month 10: ~$2,100–2,600 year one for a used-RTX-3090 stack vs $2,940/year for Copilot Business + ChatGPT Team at five seats (September 2026 prices). Counting admin labor at $50–100/hour, year one is a wash or a loss — the savings case rests on cheap admin hours and on year two, which costs ~$200 vs $2,940.

What GPU does a five-person team need for a shared LLM server? One 24GB card — a used RTX 3090 (~$1,050–1,350, September 2026) is the value pick. It runs a 7B code-completion model and a mid-size chat model simultaneously, which covers five developers’ realistic concurrency. 16GB cards cap you at 13B-class models and don’t share well across a team.

Can one Ollama server handle five simultaneous users? Yes. Ollama v0.34.0 queues and batches requests, and five users rarely collide; measured setups run 15–20 concurrent users per 24GB GPU on 7B models. The practical problem is model swapping, not concurrency — pin your completion model with OLLAMA_KEEP_ALIVE so chat requests don’t evict it.

Sources

• Tom’s Hardware RAM price index — DDR5 pricing, September 11, 2026
• GitHub Copilot plans — Copilot Business per-seat pricing
• OpenAI ChatGPT pricing — ChatGPT Team per-seat pricing
• Ollama releases — v0.34.0, September 9, 2026
• EIA Electric Power Monthly — US average residential electricity rate

Recommended Gear

• Used RTX 3090 24GB — ~$1,050–1,350, the card this whole budget is built around
• RTX 4090 24GB — ~$2,150–2,350 used, same VRAM ceiling at ~2× the speed
• Corsair Vengeance 32GB DDR5 — $399–479 in the current RAM market; buy 32GB, not 64GB

What self-hosting actually costs

Real cost breakdowns for self-hosted AI: hardware floors, power, maintenance hours, and the honest comparison against paying for it. No spam, unsubscribe anytime.

Email address Subscribe