View all articles
Open WebUIvLLMOllamaSelf-hostedBenchmarks

Open WebUI for a 10-Person Office: Accounts, Models and Logs

JG
Jacobo González Jaspe
|
Abstract illustration: two paths of light diverging; one faint white, one bright amber. Measure and decide
Illustration generated with AI on our own machine.
This article is also available in Spanish:Open WebUI para una oficina de 10: cuentas, modelos y registros

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.

YAML
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:
bash
export WEBUI_SECRET_KEY=$(openssl rand -hex 32)
docker compose up -d
curl -s http://localhost:3000/api/version

The 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:

  1. The first account created on a fresh install becomes Admin. Create yours before you share the address.
  2. Every other account gets the role in DEFAULT_USER_ROLE. With pending, a new sign-up has no access until an admin activates it in the Admin Panel. With user, they get in at once.
  3. 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:

GroupModelsPermissions worth changing
StaffOne general modelChat export on, chat delete off
FinanceGeneral model + a document modelSame as Staff
AdminsEverythingDefault

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=false turns that off.
  • ENABLE_ADMIN_CHAT_ACCESS=false stops 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=METADATA writes 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:

bash
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 onceFirst token, median (max)Full answer, median (max)Tokens/s per userTokens/s total
10.08 s (0.08 s)18.2 s (18.3 s)13.813.7
20.08 s (0.08 s)14.8 s (15.4 s)17.033.5
50.10 s (0.17 s)14.9 s (15.0 s)16.982.2
100.19 s (4.79 s)15.2 s (19.8 s)16.6159.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

Want this sized and installed for your team? Book a 15-minute call or see how we work in consulting.

Diagram
Share: LinkedIn X
Veredicto semanal

Get new guides before anyone else

Subscribe and we tell you when new guides, templates and workflows go up. One email a week, no spam.

Already published: 91 guides and 25 templates. All free, no signup.

Bonus: the local-AI starter pack PDF when you subscribe
Once a week No spam Unsubscribe anytime

See what you get