Skip to content
Hands-on IT IT Drills

Appendix C: Interview Preparation Applied AI / SRE

This appendix turns the 16 training days into answers. The explanations are the guidance; everything you say in the interview is in English. You fill the «…» placeholders with your real projects – do not invent anything, interviewers will ask follow-up questions. Check product and model names on mistral.ai shortly before the interview; ask the recruiter for details about the process.

a) Typical process

This is how interviews for SRE and Applied AI roles at AI companies typically run. This is not inside knowledge about Mistral – ask about the concrete stages in the recruiter call.

Stage Duration What it is typically about Your preparation
Recruiter call 30 min Motivation, salary, start date, remote Pitch, questions, numbers
Hiring manager 45–60 min Experience, ownership, team fit 3 STAR stories, questions
Technical deep dive 60 min One project down to the details Stories 1, 3, 5
Live debugging 60–90 min A broken system, thinking out loud Day 15, section d
System design 60 min Sketch a platform, do the math Section c
Coding (possible) 45–60 min A small tool in Python or Go Days 3, 4
Behavioral / values 45 min Conflicts, mistakes, autonomy All 8 STAR stories
Team / leadership 30–45 min Culture, mutual fit Section h

The recruiter call almost always checks: why this company, why now, why a permanent position, salary expectations, earliest start date, remote within EMEA, English. Your earliest start: your current project ends in December 2026.

b) Requirements, evidence, gaps

Requirement Your evidence Gap Day
5+ yrs SRE/DevOps, tools 20+ yrs IT, platform eng. «tools» Show tools 3, 4
Multi-tenant K8s OpenShift operations, Vault namespaces Upstream K8s 6, 7
On-call, post-mortems HA Vault/OpenBao «on-call» Own PMs 10, 11
Prometheus, Grafana «monitoring at customers» PromQL depth 8
OTel, Loki, Tempo, Signoz «…» Tracing hands-on 9
Terraform, Ansible Terraform and Ansible in projects OpenTofu details 12
Python and/or Go «automation, which language?» Go service 3, 4
Secure SDLC, CVE response Secrets, PKI, regulated customers SBOM, VEX 13
Strong written communication Training books, operations docs English 11
Autonomy Freelancer since «year» – –
Linux, networking, distributed Raft HA, TLS/PKI, Linux operations GPU load patterns 1, 2
CI/CD GitLab, Jenkins, Argo CD – 13
LLM/model serving (nice) New, this book Practice with vLLM 5, 7
Hybrid/on-prem (nice) Regulated customers on-prem Air gap for models 14
Open source (nice) Books, e.g. “OpenBao hands-on” Upstream PR –
Fluent English B1–B2 Speaking practice g

The biggest levers before the interview: calculate LLM serving numbers confidently (Day 5, section c), a post-mortem in English as a work sample (Day 15), and 20 minutes of speaking English out loud every day. A small upstream contribution (a docs fix in a project you use) honestly closes the OSS gap.

c) System Design: Multi-Tenant LLM Inference Platform

Task: “Design a multi-tenant LLM inference platform for enterprise customers, in our cloud and on-prem.” Plan 45 minutes: 5 clarifying, 10 calculating, 15 architecture, 10 operations and failure cases, 5 summary. Write numbers down, state assumptions out loud.

Clarifying (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?”

Calculating (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

A line to remember for the interview: “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.”

Architecture (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

Say one sentence for each box about why it is there:

  • 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 (Day 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 (Day 14).”

Isolation

Tier Isolation For whom Price
Shared pool Namespaces, quotas, limits, no shared cache Standard low
Dedicated pool Own GPU nodes (taints), own models Premium medium
Dedicated cluster Own cluster, own keys (KMS) Regulated high
On-prem At the customer, air gap Data sovereignty Operations at the customer

In English: “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.”

Scaling, observability, SLOs

  • Gateway: HPA on CPU. Model pools: KEDA on vllm:num_requests_waiting and KV-cache usage, long cooldown, because a model start takes minutes (Day 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 (Day 10).
  • Signals for capacity: queue depth, KV-cache usage near 1 (preemption), GPU memory and XID errors from DCGM (Day 8).
  • Traces carry tenant and token counts, never prompt content (Day 9).

Failure cases

Failure Detect Handle
GPU/node fails DCGM XID, pods NotReady N+1 node, PDB, router avoids the replica
Noisy neighbor One tenant’s TTFT p95 rises Token limits, priorities, queues
KV cache full kv_cache_usage_perc ≈ 1 Limit context, scale
Bad model version Eval gate, error rate in the canary Pull the canary, rollback
Retry storm Request rate without user growth Retry-After, backoff in the SDK
Rollout cuts streams curl 18, missing [DONE] preStop, drain, grace period
Region outage Synthetic probes from outside Second region, DNS failover

Security

  • Keys hashed and rotatable, better OIDC/mTLS for enterprise; secrets from OpenBao.
  • No prompts in logs, labels or spans; encryption in transit and at rest.
  • Supply chain: signed images and model weights (checksums, cosign), an SBOM per release, admission policy, a CVE process with VEX (Day 13).
  • Prompt injection as a permissions problem: tools run with tenant permissions.
  • Audit log for admin actions, a break-glass process, EU data residency.

Rollout

  • New model version: offline eval, then shadow traffic, then a canary for one pilot tenant, comparing error rate, TTFT and eval score, then step by step.
  • Platform changes via GitOps, the error budget as a gate (llmctl slo, Day 3).
  • On-prem: supported versions N and N-1, a tested upgrade path, a preflight in the bundle, --rollback-on-failure (Day 14).

Two-minute summary

“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: thinking out loud

In live debugging, your approach counts more than the solution. The interviewer wants to hear how you form and test hypotheses. This pattern carries you through every case:

  1. Make the symptom precise: what exactly, for whom, since when, how often?
  2. Impact and mitigation: is it an incident? Is there a cheap way back?
  3. Recent changes: deploys, config, certificates, traffic.
  4. From the outside in: client → DNS/TLS → gateway → model server → kernel.
  5. Before every command, say what you expect – and afterwards, what it means.
  6. One hypothesis at a time, cheapest check first.
  7. Summarize: cause, evidence, fix, what you would change permanently.

Example “TTFT for one tenant has doubled”:

"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."

Typical traps: typing commands right away without a hypothesis, going silent, changing several things at once, chasing the cause instead of mitigating. If you are stuck, say so and ask a targeted question: “I’m considering two directions – network or model server. Would you like me to go deeper into one of them?”

e) STAR stories

Eight frameworks from your own practice. Fill «…» with real details and numbers, and practice each story in 2 minutes. Keep situation and task short, action detailed (with “I”, not “we”), result with a number.

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».”
  • Fits: 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.»”
  • Fits: 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».”
  • Fits: 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».”
  • Fits: 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».”
  • Fits: 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».”
  • Fits: 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».”
  • Fits: ownership, learning, blameless culture.

Story 8: Learning a new domain fast – and teaching it

  • Situation: “I wrote training books such as «OpenBao hands-on» 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.»”
  • Fits: why this role, learning agility, writing, OSS mindset.

f) 30 questions with model answers

The answers are frameworks: short, with one concrete detail. Replace «…» with your experience.

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. Closing line: “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) English phrases for technical interviews

At B1–B2 level: short sentences, one idea per sentence, announce your structure. Speaking slowly comes across as confident, not insecure.

Clarifying

  • “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?”

Buying time and structuring

  • “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.”

Thinking out loud

  • “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.”

Admitting knowledge gaps

  • “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: …”

Disagreeing politely

  • “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 …”

Summarizing and wrapping up

  • “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?”

False friends

German word meant Wrong Right
eventuell eventually (= in the end) possibly, maybe
aktuell actual (= real) current
bekommen become (= turn into) get, receive
kontrollieren control (= steer) check, verify
sensibel sensible (= reasonable) sensitive
Chef chef (= cook) manager, lead

Pronunciation that comes up often in interviews: cache like “cash”, queue like “kyoo”, Kubernetes “koo-ber-NET-eez”, tenant “TEN-ent”, latency “LAY-ten-see”.

h) Your questions for the team

Ask two or three per interview, matched to the 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.”

Salary and terms

  • The recruiter named €120–150k base salary plus equity. Never name a number below this range – otherwise you negotiate against yourself.
  • Goal: the upper half, justified by experience in regulated on-prem environments and security.
  • Equity, bonus, on-call compensation and remote budget are part of the total package – ask about them before you accept.

“Based on the range you shared and my experience with regulated on-prem platforms, I’m targeting the upper half of that range – around «number in the upper half» base, plus equity. I’m flexible on the structure if the overall package is right.”

i) One week of preparation

Day Focus Book Result
1 Pitch, motivation, questions Sections a, b, h 2-minute pitch in English
2 Refresh Linux and networking Days 1, 2, Drills 1 and 6 OOM and TLS explained out loud
3 LLM serving and sizing Days 5, 7, Appendix A Sizing without notes
4 System design Section c 45 min in one go, recorded
5 Observability, SLOs, on-call Days 8, 10, 11, Drill 5 Burn rate explained freely
6 Live debugging, security Days 13, 15, section d 2 drills in English
7 STAR stories, 30 questions, rest Sections e, f, g 8 stories with numbers

Every day in addition: 20 minutes of speaking English out loud (record your answers and listen to them) and rephrase one question from section f. The evening before the interview: test your tech setup, have your list of questions ready, go to bed early.