By the end of this guide your office will have one private chat page for ten people: each person with their own account, only the models you chose, and every conversation stored on a machine you own. You can start on the computer that already runs Ollama; the numbers below come from our own DGX Spark, and we say where they stop applying.
What you need
- A machine already serving a model: Ollama on a laptop or mini PC is enough to start. An OpenAI-compatible server such as vLLM also works.
- Docker with Docker Compose.
- About 30 minutes, plus one more for the group setup.
Step 1: run Open WebUI with persistent storage
This compose file follows the Open WebUI quick start. The volume keeps users, chats and settings across updates. The secret key keeps people logged in when the container is recreated.
services:
open-webui:
image: ghcr.io/open-webui/open-webui:main
ports:
- "3000:8080"
environment:
- WEBUI_SECRET_KEY=${WEBUI_SECRET_KEY} # openssl rand -hex 32, set once
- OLLAMA_BASE_URL=http://host.docker.internal:11434
- DEFAULT_USER_ROLE=pending # new sign-ups wait for approval
# For a vLLM or other OpenAI-compatible server instead:
# - OPENAI_API_BASE_URL=http://192.168.1.50:8000/v1
extra_hosts:
- "host.docker.internal:host-gateway"
volumes:
- open-webui:/app/backend/data
restart: always
volumes:
open-webui:export WEBUI_SECRET_KEY=$(openssl rand -hex 32)
docker compose up -d
curl -s http://localhost:3000/api/versionThe last line should print a JSON version string. Ours answered {"version":"0.9.6"} on 2026-10-08. If it hangs, check docker compose logs open-webui for a port clash on 3000.
Step 2: accounts and the pending role
The roles page is short and worth reading. Three facts matter for an office:
- The first account created on a fresh install becomes Admin. Create yours before you share the address.
- Every other account gets the role in
DEFAULT_USER_ROLE. Withpending, a new sign-up has no access until an admin activates it in the Admin Panel. Withuser, they get in at once. - Admins have access to everything by default.
For ten people, pending is the calm choice. Colleagues sign up themselves, you approve each one, and nobody outside the office gets in by guessing the URL.
Step 3: groups and which models each group sees
Groups live under Admin Panel > Users > Groups. Permissions are additive: a person gets the global defaults plus whatever any of their groups grants, as the permissions page explains.
A layout that works for a small office:
| Group | Models | Permissions worth changing |
|---|---|---|
| Staff | One general model | Chat export on, chat delete off |
| Finance | General model + a document model | Same as Staff |
| Admins | Everything | Default |
To restrict a model, set its visibility to Private and grant read access to the groups that should see it, as the groups page describes. “Public” simply means a read grant for every signed-in user.
Two shortcuts help people start in the right place. In Settings > Admin > Models you choose the instance’s default models, and from a model’s menu you can Set as Pinned Model so it appears in the sidebar for users without their own pins (models page). One warning: the BYPASS_MODEL_ACCESS_CONTROL variable gives every user every model. Leave it unset if you want the table above to mean anything.
Step 4: where the logs live, and who can read them
Chats are stored in Open WebUI’s database: a SQLite file (webui.db) inside the /app/backend/data volume, or PostgreSQL if you configure one. That is the whole point of self-hosting: the history stays on your disk.
What each person and the admin can do, per the import and export page and the chat data privacy page:
- Users export their own chats as JSON from Settings > Data Controls > Export Chats, if the export permission is on.
- Admins can export data, chats and (on SQLite) the database from the Admin Panel.
ENABLE_ADMIN_EXPORT=falseturns that off. ENABLE_ADMIN_CHAT_ACCESS=falsestops admins reading employee chats in the product. Anyone with access to the host, the volume or unencrypted backups can still read them, so treat those as part of the same trust circle.AUDIT_LOG_LEVEL=METADATAwrites an audit trail of requests without chat content.- Temporary Chat keeps a conversation out of history, and an admin can enforce it for a group.
We found no automatic retention period in those pages. Decide one yourself (for example, “chats older than 12 months are deleted”) and write it down with your GDPR records. Back up the volume like any other database:
docker run --rm -v open-webui:/data -v "$PWD":/backup alpine \
tar czf /backup/open-webui-$(date +%F).tgz -C /data .What we measured: ten people at once
Open WebUI does not run the model. It forwards each chat to the backend, so the backend sets the speed. On our stack that backend is vLLM on the second DGX Spark, and we measured it directly with the requests Open WebUI sends.
Method. spark2: NVIDIA DGX Spark, GB10, 128 GB unified memory. vLLM 0.19.0 (NVIDIA container 26.04), Qwen/Qwen2.5-7B-Instruct in BF16, --gpu-memory-utilization 0.16. Prompt: a client email plus reply instructions, 384 tokens in; 250 tokens out; streaming; 3 repetitions per level; 2026-10-08. Command: python3 scripts/bench/openwebui_concurrency.py --levels 1,2,5,10 --reps 3 --max-tokens 250. Raw results: openwebui-concurrency-2026-10-08.json.
| Users at once | First token, median (max) | Full answer, median (max) | Tokens/s per user | Tokens/s total |
|---|---|---|---|---|
| 1 | 0.08 s (0.08 s) | 18.2 s (18.3 s) | 13.8 | 13.7 |
| 2 | 0.08 s (0.08 s) | 14.8 s (15.4 s) | 17.0 | 33.5 |
| 5 | 0.10 s (0.17 s) | 14.9 s (15.0 s) | 16.9 | 82.2 |
| 10 | 0.19 s (4.79 s) | 15.2 s (19.8 s) | 16.6 | 159.9 |
Two honest notes. One user alone was slower per token than two to ten users; we ran that level again with the GPU idle and got the same 13.7 tokens/s, so it is not noise, and we have not dug into why. And during the main run the GPU was shared with another model server, which is normal on our box and probably on yours.
What it means for a 10-person office
Ten people rarely press Enter in the same second. Even when they all did, each person got a full reply to a typical email task in about 15 seconds, and the first words appeared in under 0.2 seconds at the median. The worst case in 30 requests at ten users waited 4.8 seconds for its first token. For drafting emails, summaries and short answers, one 7B model is enough for this team.
When this stops holding
- Long documents. We sent 384 tokens. Paste a 30-page contract and each request carries thousands of tokens, so the first token takes longer and memory per user grows. We have not measured that case yet; test it with your real files before promising anyone anything.
- Bigger models. A 70B model reads roughly ten times more weights per token than a 7B one, so expect far fewer tokens per second. Our Llama 3.3 70B review shows what that costs.
- Smaller machines. These numbers come from a GB10. A mini PC or a laptop will be slower; size the memory first and run the same script on it.
Next steps
- Keep your local AI patched: updates and exposure checks for the server behind Open WebUI.
- Benchmark a local model on your own machine to get your own version of the table above.
Want this sized and installed for your team? Book a 15-minute call or see how we work in consulting.