Anhang C: Interview-Vorbereitung Applied AI / SRE
Dieser Anhang macht aus den 16 Trainingstagen Antworten. Erklärungen auf Deutsch, alles, was du im Gespräch sagst, auf Englisch. Platzhalter «…» füllst du mit deinen echten Projekten – erfinde nichts, Interviewer fragen nach. Prüfe Produkt- und Modellnamen kurz vor dem Gespräch auf mistral.ai; Details zum Prozess erfragst du beim Recruiter.
a) Typischer Ablauf
So laufen Gespräche für SRE- und Applied-AI-Rollen bei KI-Firmen typischerweise ab. Das ist kein Wissen über Mistral – frag im Recruiter-Call nach den konkreten Stufen.
| Stufe | Dauer | Worum es typischerweise geht | Deine Vorbereitung |
|---|---|---|---|
| Recruiter-Call | 30 min | Motivation, Gehalt, Start, Remote | Pitch, Fragen, Zahlen |
| Hiring Manager | 45–60 min | Erfahrung, Ownership, Teamfit | 3 STAR-Stories, Fragen |
| Technical Deep Dive | 60 min | ein Projekt bis in die Details | Story 1, 3, 5 |
| Live-Debugging | 60–90 min | kaputtes System, laut denken | Tag 15, Abschnitt d |
| System Design | 60 min | Plattform skizzieren, rechnen | Abschnitt c |
| Coding (möglich) | 45–60 min | kleines Tool in Python oder Go | Tag 3, 4 |
| Behavioural / Values | 45 min | Konflikte, Fehler, Autonomie | alle 8 STAR-Stories |
| Team / Leadership | 30–45 min | Kultur, gegenseitiger Fit | Abschnitt h |
Im Recruiter-Call wird fast immer geprüft: Warum diese Firma, warum jetzt, warum fest angestellt, Gehaltsvorstellung, frühester Start, Remote innerhalb EMEA, Englisch. Dein frühester Start: Dein aktuelles Projekt endet im Dezember 2026.
b) Anforderungen, Nachweise, Lücken
| Anforderung | Dein Nachweis | Lücke | Tag |
|---|---|---|---|
| 5+ J. SRE/DevOps, Tools | 20+ J. IT, Platform Eng. «Tools» | Tools zeigen | 3, 4 |
| Multi-Tenant K8s | OpenShift-Betrieb, Vault-Namespaces | Upstream-K8s | 6, 7 |
| On-Call, Post-Mortems | HA-Vault/OpenBao «Rufbereitschaft» | eigene PMs | 10, 11 |
| Prometheus, Grafana | «Monitoring bei Kunden» | PromQL-Tiefe | 8 |
| OTel, Loki, Tempo, Signoz | «…» | Tracing hands-on | 9 |
| Terraform, Ansible | Terraform und Ansible im Projekt | OpenTofu-Details | 12 |
| Python und/oder Go | «Automatisierung, Sprache?» | Go-Service | 3, 4 |
| Secure SDLC, CVE-Response | Secrets, PKI, regulierte Kunden | SBOM, VEX | 13 |
| Starke schriftliche Kommunikation | Trainingsbücher, Betriebsdoku | Englisch | 11 |
| Autonomie | Freelancer seit «Jahr» | – | – |
| Linux, Netz, verteilt | Raft-HA, TLS/PKI, Linux-Betrieb | GPU-Lastbilder | 1, 2 |
| CI/CD | GitLab, Jenkins, Argo CD | – | 13 |
| LLM/Model Serving (nice) | neu, dieses Buch | Praxis mit vLLM | 5, 7 |
| Hybrid/On-Prem (nice) | regulierte Kunden on-prem | Air-Gap für Modelle | 14 |
| Open Source (nice) | Bücher, z. B. „OpenBao zum Anfassen” | Upstream-PR | – |
| Fließendes Englisch | B1–B2 | Sprechpraxis | g |
Größte Hebel bis zum Gespräch: LLM-Serving-Zahlen sicher rechnen (Tag 5, Abschnitt c), ein Post-Mortem auf Englisch als Arbeitsprobe (Tag 15) und jeden Tag 20 Minuten laut Englisch sprechen. Ein kleiner Upstream-Beitrag (Doku-Fix in einem Projekt, das du nutzt) schließt die OSS-Lücke ehrlich.
c) System Design: Multi-Tenant LLM Inference Platform
Aufgabe: „Design a multi-tenant LLM inference platform for enterprise customers, in our cloud and on-prem.” Plane 45 Minuten: 5 Klären, 10 Rechnen, 15 Architektur, 10 Betrieb und Fehlerfälle, 5 Zusammenfassung. Schreibe Zahlen auf, sprich Annahmen aus.
Klären (5 min)
- “Which models and sizes – one dense 24B model, or several including large MoE models?”
- “What traffic do we expect: requests per second at peak, prompt and output length, streaming or not?”
- “What are the latency targets – time to first token and inter-token latency?”
- “How strict is isolation: shared GPUs are fine for most tenants, or do regulated customers need dedicated hardware?”
- “On-prem: do customers run it themselves, air-gapped, or do we operate it remotely?”
- “Do we need fine-tuned or customer-specific models, and data residency in the EU?”
Rechnen (10 min)
Assumptions (say them out loud, then confirm)
Peak traffic 100 req/s chat completions, all tenants
Tokens per request 1,500 in (prompt), 300 out (completion)
Model 24B dense (Mistral Small class), FP8 weights, 1 GPU per replica
Latency SLO TTFT p95 < 1.5 s, inter-token latency p95 < 50 ms
Availability SLO 99.9 % per 30 days -> 43 min error budget
Token throughput
output 100 x 300 = 30,000 tok/s (decode, the expensive part)
input 100 x 1,500 = 150,000 tok/s (prefill, cheaper per token)
Concurrency (Little's Law: L = lambda x W)
W ~ TTFT + 300 x 30 ms = 0.5 s + 9 s = 9.5 s
L = 100 req/s x 9.5 s ~ 950 sequences in flight
KV cache (FP16)
per token 2 x 40 layers x 8 KV heads x 128 dim x 2 B = 160 KiB
per sequence 1,800 tokens x 160 KiB ~ 0.27 GiB
total 950 x 0.27 GiB ~ 260 GiB
per H100 80 GB x 0.9 - 24 GB weights ~ 48 GB -> ~160 sequences
GPUs (assumption: ~2,500 output tok/s per H100 at target ITL; validate by load test)
decode 30,000 / 2,500 = 12 GPUs
+ prefill, burst headroom (x 1.3) ~ 16 GPUs
/ 70 % target utilisation ~ 23 -> 24 GPUs = 3 nodes x 8 H100
+ 1 node for failures and rollouts = 4 nodes = 32 GPUs
KV check: 24 x 160 = 3,840 sequences >> 950 -> compute-bound, not memory-bound
Merksatz fürs Gespräch: “I size for decode tokens per second, check KV-cache memory with Little’s Law, and add one node of headroom for failures and rollouts. The per-GPU throughput is an assumption I would replace with a load test in week one.”
Architektur (15 min)
Enterprise tenants (API keys / OIDC) On-prem customer site
| +-------------------------+
+--------v---------+ | same Helm chart + values|
| Edge: TLS, WAF, | | signed air-gap bundle |
| authN, tenant ID | | local registry, mirror |
+--------+---------+ | telemetry export opt-in |
+--------v---------+ +-------------------------+
| API gateway | quotas, token-based rate limits, priorities,
| stateless, HPA | usage metering, logs without prompts
+--------+---------+
+--------v---------+
| Model router | model + version, prefix/KV-aware, canary split
+---+----------+---+
+-------v------+ +v-----------------+
| Shared pool | | Dedicated pools | GPU node pools with taints,
| vLLM x N | | per tenant/tier | KEDA on queue depth
+--------------+ +------------------+
Control plane: GitOps (Argo CD), model registry (OCI), OpenBao, Kyverno, OpenTofu
Telemetry: OTel -> Prometheus/Thanos, Loki, Tempo -> SLO burn alerts -> on-call
Sag zu jedem Kasten einen Satz, warum er da ist:
- Gateway: “Tenant identity, quotas and rate limits live in one stateless layer. Limits are counted in tokens, not requests, and enforced globally, not per pod (Tag 7).”
- Router: “Routes by model and version, keeps requests with the same prefix on the same replica for cache hits, and does canary splits.”
- Serving: “vLLM with continuous batching and paged attention; one model per pool, so a model upgrade never touches another tenant’s model.”
- Hybrid: “One Helm chart for cloud and on-prem, only values differ. On-prem gets a signed bundle with images, weights and checksums (Tag 14).”
Isolation
| Stufe | Isolation | Für wen | Preis |
|---|---|---|---|
| Shared pool | Namespaces, Quotas, Limits, kein geteilter Cache | Standard | niedrig |
| Dedicated pool | eigene GPU-Nodes (Taints), eigene Modelle | Premium | mittel |
| Dedicated cluster | eigener Cluster, eigene Keys (KMS) | reguliert | hoch |
| On-prem | beim Kunden, Air-Gap | Datenhoheit | Betrieb beim Kunden |
Auf Englisch: “Isolation is a product tier, not a single switch. In the shared tier I isolate identity, quota, network and data paths, and I never share prefix caches or logs across tenants.”
Skalierung, Observability, SLOs
- Gateway: HPA on CPU. Model pools: KEDA on
vllm:num_requests_waitingand KV-cache usage, long cooldown, because a model start takes minutes (Tag 7). - Warm capacity: keep one spare replica loaded; scale-from-zero only for rare models.
- SLIs per tenant and model: availability without 4xx, TTFT p95, inter-token latency p95, tokens per second. Multi-window burn-rate alerts, page only on fast burn (Tag 10).
- Signals for capacity: queue depth, KV-cache usage near 1 (preemption), GPU memory and XID errors from DCGM (Tag 8).
- Traces carry tenant and token counts, never prompt content (Tag 9).
Fehlerfälle
| Fehler | Erkennen | Abfangen |
|---|---|---|
| GPU/Node fällt aus | DCGM-XID, Pods NotReady | N+1-Node, PDB, Router meidet Replica |
| Noisy Neighbor | TTFT p95 eines Mandanten steigt | Token-Limits, Prioritäten, Queues |
| KV-Cache voll | kv_cache_usage_perc ≈ 1 |
Kontext begrenzen, skalieren |
| Schlechte Modellversion | Eval-Gate, Fehlerquote im Canary | Canary zurück, Rollback |
| Retry-Sturm | Request-Rate ohne Nutzerwachstum | Retry-After, Backoff im SDK |
| Rollout kappt Streams | curl 18, fehlendes [DONE] |
preStop, Drain, Grace Period |
| Region-Ausfall | synthetische Proben von außen | zweite Region, DNS-Failover |
Security
- Keys gehasht, rotierbar, besser OIDC/mTLS für Enterprise; Secrets aus OpenBao.
- Keine Prompts in Logs, Labels oder Spans; Verschlüsselung in Transit und at rest.
- Supply Chain: signierte Images und Modellgewichte (Checksummen, cosign), SBOM pro Release, Admission-Policy, CVE-Prozess mit VEX (Tag 13).
- Prompt Injection als Berechtigungsproblem: Tools laufen mit Mandantenrechten.
- Audit-Log für Admin-Aktionen, Break-Glass-Prozess, EU-Datenhaltung.
Rollout
- Neue Modellversion: Offline-Eval, dann Shadow-Traffic, dann Canary für einen Pilot-Mandanten, Vergleich von Fehlerquote, TTFT und Eval-Score, dann schrittweise.
- Plattform-Änderungen per GitOps, Fehlerbudget als Gate
(
llmctl slo, Tag 3). - On-prem: unterstützte Versionen N und N-1, Upgrade-Pfad getestet,
Preflight im Bundle,
--rollback-on-failure(Tag 14).
Zwei-Minuten-Zusammenfassung
“We need roughly 24 H100s for 100 requests per second of a 24B model, plus one node of headroom. Tenants hit a stateless gateway that owns identity, quotas and token-based limits; a router sends traffic to model pools that scale on queue depth, not CPU. Isolation is tiered – shared, dedicated pool, dedicated cluster, on-prem – and the same Helm chart serves cloud and on-prem through signed air-gap bundles. We alert on TTFT and availability burn rates per tenant, we never log prompts, and every model version goes through eval, canary and automatic rollback. The biggest open assumption is the per-GPU throughput; that is the first thing I would measure.”
d) Live-Debugging: laut denken
Im Live-Debugging zählt dein Vorgehen mehr als die Lösung. Der Interviewer will hören, wie du Hypothesen bildest und prüfst. Dieses Muster trägt durch jeden Fall:
- Symptom präzisieren: Was genau, für wen, seit wann, wie oft?
- Impact und Mitigation: Ist es ein Incident? Gibt es einen billigen Rückweg?
- Letzte Änderungen: Deploys, Config, Zertifikate, Traffic.
- Von außen nach innen: Client → DNS/TLS → Gateway → Modellserver → Kernel.
- Vor jedem Befehl sagen, was du erwartest – und danach, was es bedeutet.
- Eine Hypothese nach der anderen, die billigste Prüfung zuerst.
- Zusammenfassen: Ursache, Beleg, Fix, was du dauerhaft ändern würdest.
Beispiel „TTFT für einen Mandanten hat sich verdoppelt”:
"Let me first make sure I understand the symptom. Time to first token doubled –
for one tenant or for all? Since when, and did anything change at that time?"
"Before I touch anything: is this customer-facing right now? If yes, I'd look for a
cheap mitigation first, like rolling back a recent change."
"I'll start from the outside. I expect the gateway p95 per tenant to show the same
jump. If it doesn't, the problem is before the gateway – DNS, TLS or the network."
"Okay, only acme is slow, and tokens per second are normal. So generation is fine,
the time is spent before the first token. That points to queueing or prefill.
My next check is the queue depth on the model server."
"Requests waiting went from 0 to 30 at 14:05, the same time globex started a batch
job. My hypothesis: a noisy neighbour. To confirm it, I compare per-tenant request
rates across all gateway replicas."
"Confirmed. Mitigation: lower globex's effective limit. Long term: a global limit
in tokens, priority classes, and a separate queue for batch traffic."
Typische Fallen: sofort Befehle tippen ohne Hypothese, still werden, mehrere Dinge gleichzeitig ändern, Ursache jagen statt mitigieren. Wenn du feststeckst, sag es und frag gezielt: “I’m considering two directions – network or model server. Would you like me to go deeper into one of them?”
e) STAR-Stories
Acht Gerüste aus deiner Praxis. Fülle «…» mit echten Details und Zahlen, übe jede Story in 2 Minuten. Situation und Task kurz, Action ausführlich (mit „I”, nicht „we”), Result mit Zahl.
Story 1: Outage of a central secrets platform
- Situation: “At «customer, e.g. a bank / public sector / energy company», we ran HashiCorp Vault Enterprise as a central secrets platform: HA with integrated Raft storage and auto-unseal, used by «number» teams. One «day/night» it «symptom: sealed nodes / lost quorum / expired certificate».”
- Task: “I was «role: on-call / lead engineer» and had to restore service and keep the dependent teams informed.”
- Action: “I first «mitigation, e.g. stepped down / restored from snapshot / renewed the certificate». Then I «diagnosis steps with commands/metrics». I sent updates every «interval» to «audience».”
- Result: “Service was back after «minutes». We added «alert / runbook / automation», and the issue «did not recur / was detected «x» days earlier next time».”
- Passt zu: incident you led, working under pressure, distributed systems (Raft).
Story 2: A post-mortem that changed something
- Situation: “After «incident» at «customer», there was pressure to find someone to blame.”
- Task: “I wrote the post-mortem.”
- Action: “I built the timeline from logs, not memory, separated root cause from contributing factors, and turned each factor into an action item with owner and date. «What you did in the review meeting.»”
- Result: “«Number» action items, «number» done within «weeks». «Measurable effect.»”
- Passt zu: blameless culture, writing, ownership.
Story 3: A tool I built and shipped
- Situation: “Teams at «customer» needed «task, e.g. onboarding to Vault, secret rotation, certificate requests» and did it manually, «time per request».”
- Task: “I wanted to make it self-service and safe.”
- Action: “I built «tool: Terraform module / Ansible role / CLI / pipeline» with «tests, review, versioning», rolled it out to «number» teams and documented it.”
- Result: “«Time from x to y», «errors avoided», «adoption».”
- Passt zu: shipping tooling, Python/Go, IaC, autonomy.
Story 4: PKI and certificates done right
- Situation: “Certificates at «customer» were issued manually and had «long lifetimes / outages from expiry».”
- Task: “Introduce an automated PKI with Vault/OpenBao.”
- Action: “I designed «root/intermediate structure», «roles with short TTLs», «automation via agent / cert-manager / pipeline», and «monitoring for expiry».”
- Result: “«Lifetime from x to y days», «zero expiry incidents since», «audit findings closed».”
- Passt zu: security mindset, TLS debugging, regulated environments.
Story 5: Multi-tenancy in a regulated environment
- Situation: “«Number» teams or business units shared one secrets platform and one OpenShift environment at «customer».”
- Task: “Each tenant had to be isolated, auditable and able to self-serve.”
- Action: “I used «Vault namespaces / policies / auth mounts per tenant», «OpenShift projects with RBAC, quotas, network policies», and managed everything as code with «Terraform / GitOps».”
- Result: “«Onboarding time», «audit result», «number of tenants».”
- Passt zu: multi-tenant Kubernetes, least privilege, policy as code.
Story 6: Disagreement with a stakeholder
- Situation: “«Security team / customer manager» wanted «stricter rule / faster delivery», which would have «impact».”
- Task: “Find a solution both sides could accept.”
- Action: “I asked for the underlying risk, proposed «compromise, e.g. phased rollout, compensating control», and backed it with «data / test / PoC».”
- Result: “«Decision», «outcome after weeks», «relationship afterwards».”
- Passt zu: communication, disagree and commit, customer-facing work.
Story 7: A mistake I made
- Situation: “In «project», I «what you did, e.g. changed a config / ran a script in the wrong environment».”
- Task: “Limit the damage and be transparent.”
- Action: “I reported it immediately to «whom», «mitigation», and wrote down what the system allowed to go wrong.”
- Result: “«Impact limited to …». I added «guardrail: review, dry-run, policy».”
- Passt zu: ownership, learning, blameless culture.
Story 8: Learning a new domain fast – and teaching it
- Situation: “I wrote training books such as «OpenBao zum Anfassen» to make complex platforms hands-on. For this role I applied the same method to LLM serving.”
- Task: “Get productive with model serving, GPU sizing and LLM observability.”
- Action: “I built a lab: Ollama and vLLM, a multi-tenant Go gateway, Prometheus, Loki, Tempo, SLO alerts and disaster drills – everything tested and documented.”
- Result: “I can size a deployment, explain KV-cache memory and debug TTFT issues. «Optional: link to repo or sample chapter.»”
- Passt zu: why this role, learning agility, writing, OSS mindset.
f) 30 Fragen mit Modellantworten
Antworten sind Gerüste: kurz, mit einem konkreten Detail. Ersetze «…» durch deine Erfahrung.
1. Tell me about yourself. “I’m a platform engineer with over 20 years in IT, the last «years» as a freelancer. My focus is secrets management with Vault and OpenBao, Kubernetes and OpenShift, and automation with Terraform, Ansible and CI/CD – mostly in regulated environments like banks, public sector and energy. I also write hands-on training books. Now I want to bring that reliability and security background to LLM serving.”
2. Why Mistral? “Three reasons. Open-weight models and self-deployment mean customers can run models where their data is – that is exactly the regulated, on-prem world I know. I want to work on a European AI platform where reliability is part of the product. And an Applied AI SRE role combines my platform work with customer-facing problem solving.”
3. Why a permanent role after years of freelancing? “As a freelancer I usually leave when the platform is built. I want to own a platform long-term – including on-call, the post-mortems and the roadmap – and grow with one team. My current engagement ends in December 2026, so the timing is right.”
4. Describe your on-call experience. “«Rotation, size, scope.» For me good on-call means few, actionable pages, a runbook for every alert and a weekly review of noisy alerts. «One concrete night: what paged, what you did, how long it took.»”
5. Tell me about a post-mortem you wrote. Story 2. Schluss: “The most useful part was the contributing factors list – each one got an owner and a date.”
6. Python or Go – which do you use when? “Python for CLIs, automation and data work – fast to write, great SDKs. Go for long-running services like proxies and controllers: one static binary, strong concurrency, small distroless images. In my lab I wrote the load tester in Python and the multi-tenant gateway in Go.”
7. How would you isolate tenants on a shared Kubernetes cluster? “In layers: RBAC so tenants manage workloads but never their guardrails, quotas and limit ranges including GPU quotas, default-deny network policies with explicit allows, Pod Security Admission restricted, and separate secrets. For stricter needs: dedicated node pools, vCluster or separate clusters.”
8. A NetworkPolicy change broke traffic. How do you debug it? “Check what changed, then test from the source pod: DNS first, then the service IP directly. Policies are additive and need both egress at the source and ingress at the destination. I fix by adding an allow, not by deleting the deny, and I add a connectivity test to CI.”
9. A model server keeps restarting. What do you check? “Exit codes and events: 137 with OOMKilled points to memory – weights plus KV cache against the limit. A failed startup probe points to load time versus probe budget. On a VM the same evidence is in journald and the cgroup memory.events.”
10. How do you size GPU memory for a model? “Weights are parameters times bytes per parameter, so 24B in FP8 is about 24 GB. The KV cache per token is 2 × layers × KV heads × head dim × bytes – for a 24B model with 40 layers about 160 KiB. Multiply by context and concurrent sequences, add 10 to 20 percent overhead.”
11. Why vLLM instead of a simple server for production? “Continuous batching and paged attention give much higher throughput at the same latency, plus Prometheus metrics, tensor parallelism and an OpenAI-compatible API. Ollama is great for CPU, edge and PoCs.”
12. How do you autoscale LLM inference? “Not on CPU. On queue depth and KV-cache usage, with a long cooldown because a model start takes minutes. I keep warm spare capacity and size for decode tokens per second. The gateway itself scales on CPU.”
13. What would your SLOs be for an inference API? “Availability without client errors, time to first token p95 for streaming, maybe inter-token latency – per tenant and model. I alert on burn rate with multiple windows and only page on fast burn.”
14. Explain burn-rate alerting. “Burn rate is the error rate divided by the error budget. At 14.4 a 30-day budget is gone in about two days – that’s a page. I combine a long window for significance with a short one so the alert resolves quickly after the fix.”
15. What metrics matter for an LLM endpoint? “RED per tenant – rate, errors, duration – plus TTFT, tokens per second, queue depth, KV-cache usage and GPU memory. And token usage per tenant for capacity and cost.”
16. Metrics, logs and traces – how do they work together? “Metrics tell me that something is wrong, traces tell me where, logs tell me why. The trace ID in every log line connects Loki and Tempo. OpenTelemetry keeps us vendor neutral, so a customer can use Tempo, SigNoz or Datadog.”
17. What is high cardinality, and how do you avoid it? “Every label combination is a time series. Tenant, model and status code are fine; user IDs, request IDs or prompts are not – they belong in logs and traces, without content.”
18. How do you manage infrastructure with Terraform or OpenTofu safely? “Modules with validated inputs, remote state with locking and encryption, plan in CI and apply after review. I import existing resources instead of recreating them, and a nightly plan with detailed exit code detects drift.”
19. When Ansible, when Terraform? “Terraform or OpenTofu for declarative APIs – cloud, Kubernetes, IAM. Ansible for the state inside a machine – packages, systemd, firewall. Idempotency is proven by a second run with zero changes.”
20. A critical CVE is published on Friday afternoon. What do you do? “Inventory from SBOMs, then reachability: is the package present, loaded, exposed? EPSS and the CISA KEV list tell me how urgent it is. Exploited and exposed means we patch today; otherwise I document a VEX and fix in the next release. And I tell customers early, especially on-prem customers who must patch themselves.”
21. What does a secure software supply chain mean to you? “Every production image is built by CI, has an SBOM attestation, is signed – ideally keyless – and the cluster rejects anything else through admission policy. Model weights need the same: checksums, signatures, provenance and license.”
22. How do you handle secrets on a platform like this? “Secrets live in OpenBao or Vault, not in manifests or environment files. Workloads authenticate with their Kubernetes identity, secrets are short-lived and rotated, and access is audited. This is my strongest area: «example».”
23. How do you deliver to an air-gapped customer? “A versioned bundle: Helm chart, images, model weights, checksums and a signature. The customer verifies it, runs a preflight against their registry and installs with one registry setting. Upgrades are new bundles with automatic rollback.”
24. A customer says “the model is slow”. Where do you start? “I separate time to first token from tokens per second. Slow first token means network, queueing or prefill. Slow tokens mean hardware, quantization or batching. Then I check whether it is one tenant or everyone, and what changed.”
25. How do you debug a latency problem on Linux? “From the outside in: curl timings to split DNS, connect, TLS and server time. Then ss for queues, PSI and cgroup CPU throttling, and strace or perf only briefly and targeted.”
26. Explain Raft in two minutes. “A leader replicates a log to followers; an entry is committed when a majority has it. With three voters you survive one failure, with five two. Lose the majority and you lose writes. I ran Vault with integrated Raft storage, so «example: quorum loss, snapshot restore, upgrades».”
27. How do you communicate with a customer during an incident? “Symptoms, not internals; a time for the next update and I keep it; no speculation and no other customers’ names. The final update has the time range, impact in numbers, data impact and whether retries are safe.”
28. Describe a time you worked autonomously. “As a freelancer I am usually the one who scopes the problem. «Example: you found an unplanned risk, decided, informed, delivered.» I write down decisions so others can follow them later.”
29. What is your biggest gap for this role? “Production experience with GPU fleets and LLM serving at scale. I closed the basics with a hands-on lab – sizing, vLLM, KV cache, LLM observability – and I learn fastest in production with a good team.”
30. Do you contribute to open source? “I write hands-on training books, including one on OpenBao. «Upstream contributions: issues, docs, PRs.» I’d like to contribute upstream more – vLLM and the observability ecosystem are good places for an SRE.”
g) Englisch-Phrasen für technische Interviews
Für B1–B2 gilt: kurze Sätze, eine Idee pro Satz, Struktur ansagen. Langsam sprechen wirkt souverän, nicht unsicher.
Klären
- “Just to make sure I understand: you mean …, right?”
- “Could you repeat the last part? I want to get the numbers right.”
- “Is it okay if I make an assumption here and we validate it later?”
- “What matters more in this case – latency or cost?”
Zeit gewinnen und strukturieren
- “Let me think about that for a moment.”
- “I’d like to approach this in three steps: first …, then …, finally …”
- “Let me draw this quickly.”
- “Before I go into details, here is the big picture.”
Laut denken
- “My first hypothesis is … because …”
- “If that’s true, I would expect to see … Let me check.”
- “That rules out … So the next most likely cause is …”
- “This is surprising. Let me step back for a second.”
Wissenslücken zugeben
- “I haven’t used that in production, but here’s how I would approach it.”
- “I’m not sure about the exact flag; I’d check the docs. The idea is …”
- “I don’t know, but I know how to find out: …”
Höflich widersprechen
- “I see your point. One concern I have is …”
- “That works for most cases. What about …?”
- “Could we look at the trade-off? Option A gives us …, option B gives us …”
- “I’d push back a little on that, because in my experience …”
Zusammenfassen und abschließen
- “To summarize: the root cause was …, we mitigated by …, and long term I’d …”
- “If I had more time, I would also look at …”
- “Does that answer your question, or should I go deeper?”
Falsche Freunde
| Deutsch gemeint | Falsch | Richtig |
|---|---|---|
| eventuell | eventually (= schließlich) | possibly, maybe |
| aktuell | actual (= tatsächlich) | current |
| bekommen | become (= werden) | get, receive |
| kontrollieren | control (= steuern) | check, verify |
| sensibel | sensible (= vernünftig) | sensitive |
| Chef | chef (= Koch) | manager, lead |
Aussprache, die im Gespräch oft vorkommt: cache wie „cash”, queue wie „kju”, Kubernetes „koo-ber-NET-eez”, tenant „TEN-ent”, latency „LAY-ten-see”.
h) Deine Fragen an das Team
Stelle pro Gespräch zwei bis drei, passend zur Person.
- “How is on-call organised – rotation size, follow-the-sun across EMEA and US, typical pages per week, and how is on-call compensated?”
- “What is the mix between customers on your cloud and self-hosted or on-prem deployments? Who operates the on-prem ones?”
- “How big is the team, and how do SRE and Applied AI engineers split the work?”
- “What does the GPU fleet look like – which accelerators, which clouds, how is scheduling and capacity planning done?”
- “Which serving stack do you use, and who owns rate limiting and tenant isolation?”
- “What is your policy on open-source contributions, for example to vLLM?”
- “How often does the remote team meet in Paris or elsewhere?”
- “What would success look like after 90 days in this role?”
- “Equity: what is the vesting schedule, is there a cliff, and are there refreshers?”
- “What notice period or start date do you expect? My current project ends in December 2026.”
Gehalt und Konditionen
- Der Recruiter hat €120–150k Grundgehalt plus Equity genannt. Nenne nie eine Zahl unterhalb dieser Spanne – sonst verhandelst du gegen dich selbst.
- Ziel: obere Hälfte, begründet mit Erfahrung in regulierten On-Prem-Umgebungen und Security.
- Equity, Bonus, On-Call-Vergütung und Remote-Budget gehören zum Gesamtpaket – frag danach, bevor du zusagst.
“Based on the range you shared and my experience with regulated on-prem platforms, I’m targeting the upper half of that range – around «Zahl in der oberen Hälfte» base, plus equity. I’m flexible on the structure if the overall package is right.”
i) Eine Woche Vorbereitung
| Tag | Fokus | Buch | Ergebnis |
|---|---|---|---|
| 1 | Pitch, Motivation, Fragen | Abschnitte a, b, h | 2-Minuten-Pitch auf Englisch |
| 2 | Linux und Netz auffrischen | Tag 1, 2, Drill 1 und 6 | OOM und TLS laut erklärt |
| 3 | LLM-Serving und Sizing | Tag 5, 7, Anhang A | Sizing ohne Zettel |
| 4 | System Design | Abschnitt c | 45 min am Stück, aufgenommen |
| 5 | Observability, SLOs, On-Call | Tag 8, 10, 11, Drill 5 | Burn Rate frei erklärt |
| 6 | Live-Debugging, Security | Tag 13, 15, Abschnitt d | 2 Drills auf Englisch |
| 7 | STAR-Stories, 30 Fragen, Ruhe | Abschnitte e, f, g | 8 Stories mit Zahlen |
Jeden Tag zusätzlich: 20 Minuten laut Englisch sprechen (Antworten aufnehmen und anhören) und eine Frage aus Abschnitt f neu formulieren. Am Abend vor dem Gespräch: Technik testen, Fragenliste bereitlegen, früh schlafen.