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_waitingand 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:
- Make the symptom precise: what exactly, for whom, since when, how often?
- Impact and mitigation: is it an incident? Is there a cheap way back?
- Recent changes: deploys, config, certificates, traffic.
- From the outside in: client → DNS/TLS → gateway → model server → kernel.
- Before every command, say what you expect – and afterwards, what it means.
- One hypothesis at a time, cheapest check first.
- 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.