...
Pregătire interviuri

100 de întrebări de interviu System Design, cu răspunsuri

Întrebările despre System Design care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs System Design: primele 10 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 143 minde citit
Întrebări de interviu System Design cu răspunsuri

Interviul de system design este o discuție de 45–60 de minute în care primești o problemă deschisă („proiectează un URL shortener”, „proiectează un chat”, „proiectează feed-ul unei rețele sociale”) și o rezolvi la tablă împreună cu intervievatorul: clarifici cerințele, faci estimări de trafic și de stocare, desenezi componentele, apoi aprofundezi una-două părți grele și discuți compromisurile. Nu există un singur răspuns corect; se urmărește cum gândești, cum îți justifici deciziile cu cifre și cerințe și cum reacționezi la întrebări de tipul „și dacă pică baza de date?”. Pe lângă problema mare apar și întrebări scurte de teorie: cache, replicare, sharding, CAP, cozi, rate limiting.

La nivel de junior se așteaptă să cunoști piesele de bază (load balancer, cache, replici, CDN, cozi), să faci estimări simple corect și să desenezi o arhitectură coerentă pentru o problemă cunoscută. La nivel de mid apar compromisurile: strategii de caching și invalidare, chei de sharding, garanții de livrare și idempotență, consistență eventuală, observabilitate. La senior discuția merge spre multi-regiune, consistență între servicii, migrări fără downtime și operarea sistemelor la scară.

Întrebările sunt grupate pe teme, de la junior la senior în fiecare temă, iar ultimele două capitole conțin studii de caz clasice și situații de interviu. Fiecare are un răspuns scurt, bun de spus în primele secunde, și unul detaliat, cu raționamentul, calculele și compromisurile de care ai nevoie la întrebările de continuare. Exersează studiile de caz cu voce tare și cu ceasul pornit: structura răspunsului se învață doar repetând-o.

Cerințe și estimări pe șervețel

1 Junior

Primești la interviu cerința „Proiectează un serviciu de scurtare a linkurilor”. Ce faci în primele 5 minute, înainte să desenezi vreo componentă?

Răspuns scurt: Pui întrebări de clarificare: ce funcții intră în discuție, câți utilizatori și câte cereri sunt, ce latență și ce disponibilitate se așteaptă, ce se poate ignora. Notezi răspunsurile ca cerințe și abia apoi desenezi.

Interviul de system design este o discuție despre compromisuri, iar compromisurile depind de cifre și de priorități. Dacă desenezi imediat, riști să proiectezi pentru altă problemă decât cea din capul intervievatorului.

În primele minute acoperi, pe scurt:

  • Funcțiile: scurtare, redirecționare, linkuri personalizate, expirare, statistici? Alegi împreună 2–3 funcții principale și spui explicit ce lași deoparte.
  • Scara: câți utilizatori activi pe zi, câte linkuri noi și câte redirecționări pe zi, cât timp se păstrează datele.
  • Calitatea: latența acceptabilă a redirecționării, disponibilitatea dorită, dacă un link nou trebuie să funcționeze imediat.
  • Constrângeri: există o anumită tehnologie impusă, un buget, o regiune?

Scrie răspunsurile pe tablă, într-o listă scurtă. Ele devin criteriile după care îți justifici fiecare decizie: „pun un cache aici pentru că raportul citiri/scrieri e 100:1 și vrem redirecționări sub 50 ms”.

Dacă intervievatorul răspunde „alege tu”, alege o valoare rezonabilă și spune-o cu voce tare: „presupun 100 de milioane de linkuri noi pe lună”. O presupunere declarată e mult mai bună decât una tacită.

Ce urmărește intervievatorul: Verifică dacă știi să transformi o cerință vagă în cerințe concrete. Greșeala tipică: candidatul începe direct cu baza de date și microserviciile.

2 Junior

Care este diferența dintre cerințele funcționale și cele nefuncționale? Dă câte două exemple pentru o aplicație de rezervări la restaurant.

Răspuns scurt: Cerințele funcționale spun ce face sistemul (rezervi o masă, anulezi o rezervare), iar cele nefuncționale spun cât de bine o face (latență, disponibilitate, consistență, securitate, cost).

Cerințele funcționale descriu comportamentul vizibil pentru utilizator: acțiunile pe care le poate face și rezultatele lor. Pentru aplicația de rezervări:

  • clientul caută restaurante libere la o dată și o oră;
  • clientul rezervă o masă și primește confirmare pe email.

Cerințele nefuncționale descriu calitățile sistemului, adică ce trebuie să fie adevărat în timp ce funcțiile merg:

  • o masă nu poate fi rezervată de două persoane pentru același interval (consistență);
  • căutarea răspunde în sub 300 ms pentru majoritatea cererilor (latență);
  • aplicația funcționează 99,9% din timp (disponibilitate);
  • datele personale sunt transmise doar prin HTTPS (securitate).

De ce contează distincția la interviu: cerințele funcționale îți dau entitățile și API-ul (restaurant, masă, rezervare; POST /rezervari), iar cele nefuncționale îți dau arhitectura. Faptul că nu ai voie să vinzi aceeași masă de două ori te duce spre o bază cu tranzacții și constrângeri de unicitate. Faptul că citirile sunt de sute de ori mai multe decât rezervările te duce spre cache și replici.

Un sfat practic: cerințele nefuncționale se formulează măsurabil. „Aplicația trebuie să fie rapidă” nu ajută; „p95 sub 300 ms la căutare” se poate verifica.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi de unde vin deciziile de arhitectură. Mulți candidați uită complet cerințele nefuncționale sau le lasă nemăsurabile.

3 Junior

Un serviciu are 10 milioane de utilizatori activi pe zi, fiecare face în medie 20 de cereri. Câte cereri pe secundă are în medie și cât la vârf?

Răspuns scurt: 10.000.000 × 20 ÷ 86.400 ≈ 2.300 de cereri pe secundă în medie. Vârful îl estimezi cu un factor de 2–3 față de medie (presupunere declarată), deci în jur de 5.000–7.000 de cereri pe secundă.

Formula de bază pentru QPS (queries per second):

QPS mediu = DAU × cereri pe utilizator pe zi ÷ 86.400
          = 10.000.000 × 20 ÷ 86.400
          = 200.000.000 ÷ 86.400 ≈ 2.315 cereri/s

La interviu rotunjești curajos: o zi are aproximativ 100.000 de secunde (de fapt 86.400), deci 200 de milioane de cereri pe zi înseamnă aproximativ 2.000–2.300 pe secundă. Rotunjirea simplifică restul calculelor și arată că gândești în ordine de mărime.

Traficul nu e uniform: oamenii folosesc aplicațiile ziua și seara, iar campaniile sau evenimentele creează vârfuri. De aceea dimensionezi pentru vârf, nu pentru medie. Factorul de vârf depinde de produs, iar la interviu îl alegi și îl spui: „presupun că vârful e de 3 ori media, adică aproximativ 7.000 de cereri pe secundă”.

Separă apoi cererile pe tipuri, pentru că au costuri diferite:

  • dacă 95% sunt citiri, ai circa 6.600 de citiri pe secundă la vârf, potrivite pentru cache și replici;
  • restul de 5% sunt scrieri, circa 350 pe secundă, care merg în baza primară.

Aceste cifre îți spun ulterior câte servere, ce cache și dacă o singură bază face față.

Ce urmărește intervievatorul: Verifică dacă faci calcule pe șervețel rapid și declari presupunerile. Greșeala tipică este dimensionarea după medie, nu după vârf.

4 Junior

Ce cifre de latență ar trebui să știi aproximativ la un interviu de system design și de ce te ajută?

Răspuns scurt: Ordinele de mărime: memoria RAM răspunde în sute de nanosecunde, SSD-ul în zeci sau sute de microsecunde, un apel în același centru de date sub o milisecundă, iar un drum între continente în jur de 100 ms. Ele arată unde se pierde timpul.

Nu ți se cer valori exacte, ci ordine de mărime, pentru că diferențele dintre niveluri sunt de 10–1.000 de ori. Un set util (aproximativ, depinde de hardware):

citire din memoria RAM                ~100 ns
citire aleatoare de pe SSD            ~10-100 µs
apel de rețea în același centru de date  ~0,5 ms
citire secvențială 1 MB de pe SSD     ~1 ms
seek pe hard disk clasic              ~10 ms
drum dus-întors Europa - America      ~100-150 ms

Ce concluzii tragi din ele:

  • Un cache în memorie (Redis) răspunde în sub o milisecundă, inclusiv rețeaua, iar o interogare SQL fără index poate dura zeci sau sute de milisecunde. De aici câștigul unui cache.
  • Un apel între continente costă cât sute de apeluri interne. Utilizatorii din altă regiune au nevoie de CDN sau de servere aproape de ei.
  • O pagină care face 30 de apeluri secvențiale la alte servicii adună 30 de latențe de rețea. Paralelizează apelurile sau reduce-le numărul.

La interviu folosești cifrele ca să-ți justifici deciziile: „citirea din cache e de ordinul unei milisecunde, deci redirecționarea rămâne sub 20 ms chiar și cu trei salturi în rețea”. Dacă nu ești sigur de o cifră, spune ordinul de mărime și precizează că e aproximativ.

Ce urmărește intervievatorul: Intervievatorul verifică intuiția de performanță. Candidații fără aceste repere pun cache-uri sau CDN-uri „pentru că așa se face”, fără să poată spune ce câștigă.

5 Junior

Estimează stocarea pe 5 ani pentru o aplicație care primește 1 milion de poze pe zi, în medie de 500 KB fiecare. Ce mai adaugi peste rezultatul brut?

Răspuns scurt: 1.000.000 × 500 KB = 500 GB pe zi; × 365 × 5 ≈ 900 TB, adică aproape 1 PB. Peste el adaugi copiile (replicare, de obicei de 3 ori), variantele redimensionate ale pozelor și metadatele.

Calculul pas cu pas:

pe zi:   1.000.000 × 500 KB = 500.000.000 KB ≈ 500 GB
pe an:   500 GB × 365 ≈ 180 TB
5 ani:   180 TB × 5 ≈ 900 TB ≈ 0,9 PB

Rotunjește peste tot: 365 devine 400 dacă vrei o margine de siguranță, iar rezultatul „aproape 1 PB” e suficient de precis pentru decizia de arhitectură.

Ce adaugi:

  • Redundanța: un object storage sau un sistem de fișiere distribuit păstrează mai multe copii (sau folosește coduri de corecție). Dacă îți faci singur stocarea cu 3 replici, ajungi la circa 3 PB brut.
  • Variantele: miniaturi și dimensiuni pentru telefon. De obicei sunt mici față de original, dar se înmulțesc cu numărul de variante.
  • Metadatele: id, autor, dată, descriere, câteva sute de octeți pe poză. 1 milion × 1 KB = 1 GB pe zi, neglijabil față de poze, dar merg în altă bază (SQL/NoSQL), nu în object storage.
  • Creșterea: dacă produsul crește, 1 milion de poze pe zi azi poate deveni de câteva ori mai mult. Spune explicit că estimarea e la volumul actual.

Concluzia de design: la ordinul petabyte-ului, pozele merg într-un object storage (S3 sau echivalent), servite printr-un CDN, iar baza de date ține doar metadatele și cheia obiectului.

Ce urmărește intervievatorul: Verifică dacă știi să lucrezi cu unitățile (KB, GB, TB, PB) și dacă te gândești la replicare. Greșeala tipică: pozele puse direct într-o bază relațională.

Eroarea, în practică:No space left on device (fișiere în bază / pe disc)

6 Junior

Ce înseamnă raportul dintre citiri și scrieri al unui sistem și cum îți schimbă el arhitectura?

Răspuns scurt: Raportul spune de câte ori sunt mai multe citiri decât scrieri. Un sistem dominat de citiri (feed, catalog) câștigă din cache, CDN și replici; unul dominat de scrieri (loguri, senzori) are nevoie de partiționare, cozi și stocare optimizată pentru scrieri.

Majoritatea aplicațiilor web citesc mult mai des decât scriu: un produs dintr-un catalog se modifică rar, dar se vede de mii de ori. Alte sisteme stau invers: o platformă de telemetrie primește permanent date de la senzori și le citește doar în rapoarte.

Sistem cu multe citiri (de exemplu 100:1):

  • cache (Redis) în fața bazei, cu rată de hit mare;
  • CDN pentru conținutul static și chiar pentru răspunsuri publice;
  • replici de citire pentru baza SQL;
  • date denormalizate sau precalculate, ca fiecare citire să fie ieftină.

Sistem cu multe scrieri:

  • partiționare (sharding) ca scrierile să se împartă pe mai multe noduri, pentru că replicile nu ajută la scrieri;
  • o coadă sau un log (Kafka) care absoarbe vârfurile;
  • baze optimizate pentru scrieri (de exemplu cele bazate pe LSM-tree, ca Cassandra);
  • scrieri în loturi (batching) în loc de câte un rând.

La interviu întrebi raportul sau îl estimezi din cerințe („un link se creează o dată și se accesează de 100 de ori”) și îl folosești ca argument: „pentru că raportul e 100:1, investesc în cache și replici, nu în sharding de la început”.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că deciziile pornesc de la forma traficului. Greșeala tipică este o arhitectură identică pentru orice problemă.

Eroarea, în practică:Baza primară la 100% din cauza citirilor

7 Mid

De ce calculezi separat banda de ieșire (bandwidth) față de numărul de cereri? Estimează-o pentru 5.000 de cereri pe secundă cu răspunsuri de 200 KB.

Răspuns scurt: Cererile mici și cele mari costă la fel în QPS, dar foarte diferit în rețea și bani. 5.000 × 200 KB = 1 GB/s, adică aproximativ 8 Gbps de trafic de ieșire, prea mult pentru câteva servere și un motiv clar pentru CDN.

QPS-ul îți spune câtă procesare ai, dar nu cât transferi. O cerere de 1 KB și una de 2 MB sunt amândouă „o cerere”, însă a doua încarcă de 2.000 de ori mai mult placa de rețea și factura de trafic.

Calculul:

5.000 cereri/s × 200 KB = 1.000.000 KB/s ≈ 1 GB/s
1 GB/s × 8 biți = 8 Gbps
pe zi: 1 GB/s × 86.400 s ≈ 86 TB

Ce înseamnă pentru design:

  • Placa de rețea a unui server are o limită (de exemplu 10 Gbps), iar la 8 Gbps ai rămâne fără margine. Distribui pe mai multe servere sau, mai bine, scoți conținutul din drumul serverelor.
  • Traficul de ieșire spre internet se plătește la furnizorii de cloud. La zeci de TB pe zi, costul contează în decizie.
  • Dacă răspunsurile sunt fișiere statice (poze, video, JS), un CDN le servește din apropierea utilizatorului; originea ta vede doar miss-urile.
  • Dacă sunt răspunsuri de API, compresia (gzip, brotli) și câmpurile selective reduc mult mărimea.

Separă și banda de intrare: la un serviciu de upload video, intrarea poate fi mai mare decât ieșirea și dictează alt design (upload direct în object storage cu URL presemnat).

Ce urmărește intervievatorul: Verifică dacă te gândești la rețea și cost, nu doar la CPU. Candidații omit des banda și propun servere care nu ar putea transmite datele.

Eroarea, în practică:Fișiere statice servite de server, fără CDNX-Cache: Miss from cloudfront (hit rate mic)

8 Mid

Cum estimezi câtă memorie îți trebuie pentru cache-ul unui URL shortener cu 100 de milioane de redirecționări pe zi?

Răspuns scurt: Presupui că o mică parte din linkuri primesc majoritatea traficului și ții în cache doar acea parte. De exemplu 20% din cererile zilnice × 500 de octeți ≈ 10 GB, care încap în memoria unui singur nod Redis, cu replică.

Ideea de pornire este distribuția inegală a accesărilor: câteva linkuri virale primesc o mare parte din trafic, iar majoritatea sunt accesate rar. Regula 80/20 e o presupunere de lucru, nu o lege, dar e potrivită la interviu dacă o spui explicit.

Calculul:

redirecționări pe zi:          100.000.000
partea fierbinte (presupunere): 20%  -> 20.000.000 de intrări
mărimea unei intrări:          ~500 B (cod, URL lung, overhead)
memorie:                       20.000.000 × 500 B = 10 GB

Observații care arată experiență:

  • Estimarea e acoperitoare: aceeași cheie apare de mai multe ori în cele 20 de milioane de cereri, deci numărul real de chei distincte e mai mic.
  • Redis are overhead per cheie (structuri interne), deci nu poți calcula doar lungimea textului. Lasă o marjă.
  • 10 GB încap într-un singur nod, dar pentru disponibilitate pui o replică. Dacă estimarea ar fi de sute de GB, ai împărți cache-ul pe mai multe noduri cu consistent hashing.
  • Politica de evacuare LRU păstrează automat linkurile populare, iar TTL-ul elimină ce nu se mai accesează.

Concluzia: cache-ul e ieftin față de câștig, pentru că preia majoritatea citirilor și lasă baza să trateze doar miss-urile.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să dimensionezi un cache plecând de la setul de date fierbinte. Greșeala tipică: „pun toată baza în cache”.

Eroarea, în practică:OOM command not allowed (maxmemory)Rată de hit mică: cache-ul nu ajută

9 Mid

Cum calculezi câte servere de aplicație îți trebuie pentru vârful de trafic? Ce presupuneri spui cu voce tare?

Răspuns scurt: Împarți QPS-ul de vârf la capacitatea măsurată a unui server, la o încărcare țintă de 60–70%, apoi adaugi cel puțin un server de rezervă (N+1). Spui de unde vine capacitatea pe server și ce factor de vârf ai presupus.

Formula:

servere = QPS la vârf ÷ (capacitate pe server × încărcare țintă) + rezervă

exemplu: 7.000 ÷ (1.000 × 0,7) = 10 servere
         + 1 pentru căderea unuia (N+1)  = 11
         + încă unul dacă ai două zone   = 12

Presupunerile pe care le declari:

  • Capacitatea pe server: vine dintr-un test de încărcare, nu din ghicit. La interviu spui „presupun 1.000 de cereri pe secundă pe server pentru un endpoint simplu, cu acces la cache”.
  • Încărcarea țintă: nu rulezi serverele la 100%. Latența crește abrupt aproape de saturație, iar ai nevoie de loc pentru rafale și pentru deploy (când o parte din servere se repornesc).
  • Rezerva: dacă un server pică, restul trebuie să ducă traficul fără să se supraîncarce.
  • Factorul de vârf: diferența dintre medie și vârf, sau un eveniment cunoscut (Black Friday).

Spune și că serverele stateless permit autoscalarea: ții un minim pentru vârful normal și lași autoscaler-ul să adauge servere la evenimente. Cifra calculată e punctul de plecare, iar testele de încărcare și metricile din producție o corectează.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre capacitate și încărcarea la care rulezi în siguranță. Greșeala tipică: împărțirea simplă, fără marjă și fără rezervă.

Eroarea, în practică:503 Service UnavailableFactura de cloud: servere supradimensionate

10 Senior

De ce un obiectiv de latență pe medie este periculos? Explică p50, p95, p99 și efectul de amplificare când o cerere atinge multe servicii.

Răspuns scurt: Media ascunde cozile: câteva cereri foarte lente nu o mișcă mult, dar utilizatorii le simt. Percentilele arată ce primește majoritatea (p50) și cel mai lent procent (p99). Când o cerere așteaptă după multe servicii, probabilitatea să lovească măcar unul lent crește rapid.

p99 = 300 ms înseamnă că 99% din cereri se termină în cel mult 300 ms, iar 1% durează mai mult. p50 e mediana, cererea „tipică”. Media poate fi 80 ms chiar dacă 1% din cereri durează 5 secunde, pentru că sunt puține.

De ce contează coada:

  • Un utilizator face zeci de cereri pe sesiune, deci aproape sigur va lovi cererile lente din p99.
  • Cererile lente sunt adesea cele ale clienților cu cele mai multe date (coșuri mari, conturi vechi), adică exact clienții valoroși.

Amplificarea la fan-out: dacă o pagină cheamă în paralel 100 de servicii și fiecare are 1% șanse să fie lent, probabilitatea ca măcar unul să fie lent este:

1 - 0,99^100 ≈ 0,63

Deci aproximativ 63% din pagini vor fi lente, deși fiecare serviciu „are p99 bun”.

Ce faci în design:

  • definești SLO-uri pe percentile (p95, p99), nu pe medie;
  • reduci fan-out-ul sau folosești rezultate parțiale cu timeout;
  • hedged requests: trimiți aceeași cerere la a doua replică dacă prima întârzie peste p95;
  • elimini sursele de coadă: pauzele GC, cozile de conexiuni, cheile fierbinți.

Măsurarea se face cu histograme, nu cu medii de percentile, pentru că percentilele nu se pot media între servere.

Ce urmărește intervievatorul: Intervievatorul verifică experiența cu sisteme reale, unde problemele sunt în coada distribuției. Candidații propun des un SLO de tip „latență medie sub 100 ms”.

Eroarea, în practică:upstream timed out while reading response header499 Client Closed Request

Scalare, load balancing și servere stateless

11 Junior

Ce alegi întâi pentru o aplicație care începe să nu mai facă față: un server mai mare sau mai multe servere? Argumentează.

Răspuns scurt: Pentru o aplicație mică, un server mai mare (scalare verticală) e cel mai simplu pas, fără schimbări de cod. Treci la mai multe servere (scalare orizontală) când ai nevoie de redundanță, când ajungi la limita hardware-ului sau când costul unui server mare crește prea mult.

Scalarea verticală înseamnă mai mult CPU, memorie sau disc pe aceeași mașină. Avantaje: nu schimbi nimic în cod, nu ai probleme de sincronizare, baza de date rămâne una singură. Dezavantaje:

  • există o limită fizică (cea mai mare mașină disponibilă);
  • prețul crește mai repede decât capacitatea la mașinile foarte mari;
  • rămâi cu un singur punct de eșec, iar upgrade-ul înseamnă adesea o repornire.

Scalarea orizontală înseamnă mai multe mașini identice în spatele unui load balancer. Avantaje: crești aproape liniar, ai redundanță (pică una, merg celelalte), poți adăuga și scoate servere după trafic. Dezavantaje: aplicația trebuie să fie stateless, ai nevoie de load balancer, de deploy pe mai multe mașini și de observabilitate mai bună.

La interviu, răspunsul matur e „depinde, dar uite cum aleg”:

  • serverele de aplicație le faci orizontale devreme, pentru că e ieftin și îți dă și disponibilitate;
  • baza de date o scalezi întâi vertical, apoi cu replici de citire, și abia la final cu sharding, pentru că fiecare pas adaugă complexitate.

Precizează că una nu o exclude pe cealaltă: alegi mărimea potrivită a fiecărui server (vertical) și numărul de servere (orizontal).

Ce urmărește intervievatorul: Intervievatorul verifică dacă vezi compromisurile, nu doar „orizontal e mereu mai bun”. Greșeala tipică e să sari direct la zeci de microservicii pentru o aplicație mică.

Eroarea, în practică:Factura de cloud: servere supradimensionateCPU 100%: scalarea verticală a ajuns la limită

12 Junior

Ce face un load balancer și ce algoritmi de distribuire a cererilor cunoști?

Răspuns scurt: Load balancer-ul primește cererile clienților și le împarte între mai multe servere, ocolindu-le pe cele căzute. Algoritmi uzuali: round robin, round robin ponderat, least connections, hash pe IP sau pe o cheie.

Un load balancer stă între clienți și serverele tale. Clienții cunosc o singură adresă, iar el decide ce server tratează fiecare cerere. Pe lângă distribuire, face de obicei și:

  • health checks: verifică periodic serverele și nu mai trimite cereri celor care nu răspund;
  • terminare TLS (decriptează HTTPS o singură dată, la intrare);
  • limitarea conexiunilor, timeout-uri, uneori rescrierea cererilor.

Algoritmii principali:

  • Round robin: pe rând, la fiecare server. Simplu și bun când serverele sunt identice și cererile seamănă între ele.
  • Round robin ponderat: serverele mai puternice primesc mai multe cereri.
  • Least connections: cererea merge la serverul cu cele mai puține conexiuni active. Bun când unele cereri durează mult (rapoarte, upload-uri), pentru că nu încarcă un server deja ocupat.
  • Hash pe IP sau pe o cheie: același client ajunge la același server. Util pentru cache local sau sesiuni, dar distribuția poate deveni inegală.
  • Least response time / power of two choices: alege dintre două servere aleatoare pe cel mai puțin încărcat; distribuție bună cu informație puțină.

La interviu spui de ce alegi algoritmul. Pentru un API stateless cu cereri scurte, round robin e suficient; pentru cereri de durate foarte diferite, least connections.

Ce urmărește intervievatorul: Verifică înțelegerea de bază a distribuirii traficului. Candidații uită des de health checks, care sunt jumătate din rostul load balancer-ului.

Eroarea, în practică:502 Bad GatewayHealth checks failed: target unhealthy

13 Junior

Vrei să rulezi aplicația pe 5 servere în spatele unui load balancer. Ce stare trebuie scoasă din memoria serverelor și unde o muți?

Răspuns scurt: Tot ce trebuie să supraviețuiască unei cereri: sesiunile utilizatorilor, fișierele încărcate, cache-urile care trebuie să fie identice, joburile programate. Sesiunile merg în Redis sau în token-uri, fișierele în object storage, joburile într-o coadă.

Un server stateless nu ține între cereri nimic de care o cerere următoare ar avea nevoie. Atunci orice server poate trata orice cerere, iar load balancer-ul e liber să le distribuie oricum, să scoată un server sau să adauge altele.

Ce stare găsești de obicei într-o aplicație „de pe un singur server” și unde o muți:

  • Sesiunile (cine e logat, coșul): într-un store comun, de obicei Redis, sau în token-uri semnate (JWT) pe care clientul le trimite la fiecare cerere.
  • Fișierele încărcate pe discul local: în object storage (S3 sau echivalent). Altfel o poză încărcată pe serverul 2 nu se vede de pe serverul 4.
  • Cache-ul local din memorie: e acceptabil dacă e doar o optimizare și datele pot fi ușor depășite; altfel mută-l într-un cache comun.
  • Joburile programate (cron pe un server): într-un scheduler unic sau într-o coadă, ca să nu ruleze de 5 ori.
  • Contoarele și lock-urile în memorie: în Redis sau în baza de date.

Starea nu dispare, doar se mută în componente specializate, care la rândul lor trebuie să fie redundante. Câștigul e că serverele de aplicație devin interschimbabile: le poți reporni, înlocui sau înmulți fără să pierzi nimic.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce te împiedică practic să scalezi orizontal. Greșeala frecventă: candidatul se gândește doar la sesiuni și uită fișierele și joburile.

Eroarea, în practică:Delogări aleatorii după scalare (sesiuni în memorie)Fișiere încărcate dispar (disc local)

14 Junior

Care este diferența dintre un load balancer de nivel 4 și unul de nivel 7? Când îl alegi pe fiecare?

Răspuns scurt: Nivelul 4 distribuie conexiuni TCP/UDP după IP și port, fără să citească conținutul; e foarte rapid. Nivelul 7 înțelege HTTP: poate ruta după cale, antet sau cookie, poate termina TLS și reîncerca cererile, cu un cost mai mare de procesare.

Numele vin din modelul OSI: nivelul 4 este transportul (TCP, UDP), nivelul 7 este aplicația (HTTP, gRPC).

Load balancer L4:

  • vede doar adrese IP și porturi, deci decide o singură dată, la deschiderea conexiunii;
  • nu decriptează traficul și nu știe ce URL cere clientul;
  • e foarte rapid și ieftin, potrivit pentru volume mari, pentru protocoale non-HTTP (baze de date, jocuri, MQTT) sau ca prim nivel în fața altor load balancere.

Load balancer L7:

  • citește cererea HTTP, deci poate ruta /api/* la un grup de servere și /imagini/* la altul;
  • termină TLS, adaugă antete (de exemplu X-Forwarded-For), comprimă, face cache;
  • poate distribui fiecare cerere separat, chiar pe aceeași conexiune HTTP/2 sau gRPC, ceea ce un L4 nu poate;
  • poate reîncerca o cerere eșuată pe alt server, poate aplica rate limiting sau autentificare.

Exemple: un Network Load Balancer în AWS lucrează la nivelul 4, un Application Load Balancer, Nginx sau Envoy la nivelul 7.

O capcană practică: cu gRPC, care ține conexiuni lungi, un L4 trimite toate cererile unei conexiuni la același server și distribuția devine inegală. De aceea, pentru gRPC alegi un L7 sau echilibrare în client.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce informație are load balancer-ul la fiecare nivel. Mulți candidați știu doar că „L7 e mai deștept”, fără consecințe concrete.

Eroarea, în practică:Încărcare inegală cu IP hash / sticky sessionsLoad balancer-ul supraîncărcat

15 Junior

Ce rol are DNS-ul în distribuirea traficului? Ce limitări are round robin-ul pe DNS?

Răspuns scurt: DNS-ul traduce numele domeniului în adrese IP și poate întoarce mai multe adrese sau adrese diferite după regiune (GeoDNS). Limita principală: răspunsurile sunt păstrate în cache de clienți și de resolvere pe durata TTL-ului, deci schimbările și ocolirea serverelor căzute sunt lente.

Când utilizatorul scrie magazin.ro, browserul întreabă un resolver DNS, care întoarce una sau mai multe adrese IP. Pe acest mecanism se construiesc câteva forme de distribuire:

  • Round robin DNS: întorci mai multe adrese, în ordine diferită, iar clienții se împart între ele.
  • GeoDNS / routing după latență: utilizatorii din Europa primesc adresa centrului de date din Europa, cei din America pe cea din America.
  • Failover DNS: furnizorul verifică periodic endpoint-urile și nu mai întoarce adresa unuia căzut.

Limitările:

  • TTL-ul și cache-urile: resolverele furnizorilor de internet, sistemul de operare și browserul păstrează răspunsul. Dacă un server pică, unii clienți vor continua să-l folosească până expiră cache-ul, iar unele resolvere nu respectă TTL-ul mic.
  • Nicio informație despre încărcare: DNS-ul clasic nu știe că un server e ocupat.
  • Distribuție grosieră: un resolver mare servește mulți utilizatori cu același răspuns.

De aceea, în practică, DNS-ul alege regiunea sau centrul de date, iar în interiorul lui un load balancer adevărat distribuie cererile pe servere, cu health checks de ordinul secundelor. TTL-urile se scad din timp (de exemplu la 60 de secunde) înainte de o migrare planificată.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce se întâmplă înainte ca cererea să ajungă la load balancer. Greșeala tipică: DNS-ul văzut ca failover instantaneu.

Eroarea, în practică:Instanțe noi fără trafic (lipsește load balancer-ul)

16 Mid

Ce sunt sticky sessions, ce probleme îți aduc și cum scapi de ele?

Răspuns scurt: Sticky sessions trimit toate cererile unui utilizator la același server, de obicei pentru că sesiunea e în memoria lui. Problemele: încărcare inegală, sesiuni pierdute la căderea serverului, deploy-uri și autoscalare greoaie. Le elimini mutând sesiunea într-un store comun sau în token-uri.

Load balancer-ul implementează afinitatea cu un cookie (de exemplu un cookie propriu cu id-ul serverului) sau cu hash pe IP-ul clientului. Aplicația „merge”, pentru că utilizatorul își găsește mereu sesiunea, dar plătești în mai multe feluri:

  • Încărcare inegală: câțiva utilizatori foarte activi sau un IP comun (o firmă întreagă în spatele unui NAT) pot încărca un singur server.
  • Pierderea sesiunilor: când serverul pică sau e oprit la deploy, toți utilizatorii lui sunt delogați sau își pierd coșul.
  • Scalare lentă: serverele noi primesc doar utilizatori noi, iar cele vechi nu se pot opri fără să deranjezi pe cineva. Autoscalarea în jos devine riscantă.
  • Depanare grea: comportamentul diferă de la server la server.

Soluțiile:

  • sesiunea într-un store comun și redundant (Redis cu replică), citit de orice server;
  • sesiune fără stare pe server: un token semnat (JWT) cu datele minime, plus o listă de revocare dacă ai nevoie de logout imediat;
  • datele importante (coșul) direct în baza de date, legate de utilizator.

Afinitatea are totuși locul ei: conexiunile WebSocket stau oricum pe un server, iar un cache local cald poate beneficia de rutare consistentă. Diferența este că acolo pierderea serverului nu pierde date, doar performanță.

Ce urmărește intervievatorul: Verifică dacă înțelegi costurile ascunse ale unei soluții care pare să meargă. Candidații propun sticky sessions ca soluție finală, nu ca o cârjă temporară.

Eroarea, în practică:Delogări aleatorii după scalare (sesiuni în memorie)Încărcare inegală cu IP hash / sticky sessions

17 Mid

Cum funcționează autoscalarea serverelor de aplicație și ce metrică alegi pentru ea? Ce capcane cunoști?

Răspuns scurt: Autoscaler-ul adaugă sau scoate instanțe când o metrică trece de un prag (CPU, cereri pe instanță, lungimea cozii). Alegi metrica care urmărește direct încărcarea reală. Capcane: pornirea lentă a instanțelor, oscilațiile, limitele din aval (baza de date) și costul.

Un grup de autoscalare are un minim, un maxim și o politică: „ține CPU-ul mediu în jur de 60%” sau „cel mult 500 de cereri pe secundă pe instanță”. Când metrica depășește ținta, se pornesc instanțe noi, se înregistrează în load balancer după ce trec health check-ul, iar când scade, unele sunt oprite.

Alegerea metricii:

  • CPU merge pentru servicii care consumă procesor, dar nu vede serviciile care așteaptă după rețea sau după baza de date.
  • Cereri pe secundă pe instanță sau latența urmăresc mai bine un API web.
  • Lungimea cozii (sau vechimea celui mai vechi mesaj) e metrica potrivită pentru workeri.

Capcanele:

  • Timpul de pornire: dacă o instanță are nevoie de 3 minute să pornească și să se încălzească, un vârf brusc te lovește înainte să apară. Ții un minim mai mare, folosești scalare programată înaintea evenimentelor cunoscute și imagini care pornesc repede.
  • Oscilațiile: praguri prea apropiate și ferestre scurte fac grupul să crească și să scadă continuu. Pui perioade de așteptare (cooldown) și scazi mai încet decât crești.
  • Gâtul de sticlă din aval: 50 de instanțe noi deschid 50 de pool-uri de conexiuni spre aceeași bază, care poate ceda. Plafonezi maximul și dimensionezi pool-urile.
  • Costul: un atac sau un bug poate scala grupul la maxim; ai nevoie de alerte și de un maxim rezonabil.

Ce urmărește intervievatorul: Intervievatorul verifică experiența practică cu scalarea automată, nu doar definiția. Greșeala frecventă: autoscalare pe CPU pentru workeri care stau după o coadă.

Eroarea, în practică:Autoscalarea nu ține pasul cu vârful

18 Mid

În diagrama ta, load balancer-ul pare să fie un punct unic de eșec. Cum îl faci redundant?

Răspuns scurt: Rulezi cel puțin două instanțe de load balancer, active-pasiv cu o adresă IP care se mută automat (VRRP, keepalived) sau active-activ în spatele DNS-ului ori al unei adrese anycast. În cloud, load balancer-ul gestionat e deja distribuit pe mai multe zone.

Orice componentă prin care trece tot traficul trebuie să aibă rezervă, inclusiv cea care oferă redundanță celorlalte. Variantele:

  • Active-pasiv cu IP flotant: două mașini cu HAProxy sau Nginx, iar o adresă IP virtuală stă pe cea activă. Cu VRRP (de exemplu prin keepalived), dacă activa nu mai trimite semnale, pasiva preia adresa în câteva secunde. Simplu, dar jumătate din capacitate stă nefolosită.
  • Active-activ: mai multe load balancere primesc trafic în același timp, împărțit prin DNS (mai multe adrese) sau prin anycast (aceeași adresă IP anunțată din mai multe locuri, rețeaua alege cel mai apropiat). Folosești toată capacitatea, dar ai nevoie de configurație identică pe toate.
  • Load balancer gestionat în cloud: furnizorul îl rulează pe mai multe noduri și zone de disponibilitate. Tu configurezi doar regulile; redundanța e responsabilitatea lui, dar tu alegi să activezi mai multe zone.

Ce mai verifici:

  • configurația e sincronizată între instanțe (altfel failover-ul te duce la reguli vechi);
  • certificatele TLS există pe toate;
  • capacitatea: dacă unul pică, celălalt duce singur tot traficul?

La interviu e suficient să spui că marchezi load balancer-ul ca redundant, alegi una dintre variante și explici cum se face trecerea.

Ce urmărește intervievatorul: Verifică dacă îți cauți singur SPOF-urile din propriul design. Mulți candidați adaugă load balancer-ul ca soluție și uită că și el poate cădea.

Eroarea, în practică:no live upstreamsLoad balancer-ul supraîncărcat

19 Senior

Cum ai proiecta un serviciu care rulează activ-activ în două regiuni? Ce probleme apar la scrieri?

Răspuns scurt: Ambele regiuni servesc utilizatorii apropiați. Citirile sunt simple; scrierile sunt problema: fie fiecare înregistrare are o regiune „acasă”, fie accepți scrieri în ambele și rezolvi conflictele, fie plătești latența unei baze consistente global.

Componentele fără stare (servere de aplicație, cache-uri locale) se dublează simplu în fiecare regiune. Greul este la date, pentru că latența dintre regiuni (zeci sau sute de milisecunde) face replicarea sincronă scumpă.

Opțiunile pentru scrieri:

  • Regiune proprietară pe înregistrare (home region): utilizatorul sau contul are o regiune de bază și toate scrierile lui merg acolo, iar cealaltă regiune are o copie pentru citire. Fără conflicte, dar un utilizator aflat departe de regiunea lui plătește latența. Failover-ul unei regiuni înseamnă mutarea proprietății.
  • Multi-master cu rezolvarea conflictelor: ambele regiuni acceptă scrieri și le replică asincron. Ai nevoie de o regulă pentru conflicte (last-write-wins cu ceasuri, CRDT-uri, logică de business). Potrivit pentru date care se combină ușor (contoare, liste de favorite), periculos pentru solduri sau stocuri.
  • Bază consistentă global (Spanner, CockroachDB): consens între regiuni, fiecare scriere așteaptă un cvorum. Corect, dar scrierile au latența unui drum între regiuni.

Ce mai discuți:

  • datele care trebuie să fie strict corecte (plăți, stocuri) pot avea o regiune unică, chiar dacă restul e activ-activ;
  • capacitatea: fiecare regiune trebuie să poată duce tot traficul dacă cealaltă pică;
  • testarea periodică a căderii unei regiuni, nu doar pe hârtie;
  • cache-urile și invalidarea lor în ambele regiuni.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că problema grea a multi-regiunii sunt scrierile și conflictele. Greșeala tipică: „replic baza sincron în ambele regiuni” fără să discuți latența.

20 Senior

Ai un monolit care ține sesiunile în memorie, salvează fișierele pe discul local și rulează joburi cron pe același server. Cum îl duci la mai multe instanțe fără downtime?

Răspuns scurt: Pas cu pas, cu fiecare schimbare livrată separat: muți sesiunile într-un store comun, fișierele în object storage cu migrare în fundal, joburile într-un scheduler cu lock, apoi pui load balancer-ul și adaugi instanțe. Fiecare pas are o perioadă de compatibilitate în care merg ambele variante.

Cheia este să nu schimbi totul deodată. Ordinea care merge de obicei:

  • Sesiunile: aplicația începe să scrie sesiunile noi în Redis, dar încă le citește și pe cele vechi din memorie. După durata maximă a unei sesiuni, memoria nu mai conține nimic util și scoți codul vechi.
  • Fișierele: noile upload-uri merg în object storage. Pentru cele vechi, un job copiază fișierele în fundal, iar aplicația citește întâi din object storage și, dacă lipsește, de pe disc. Când copierea e completă și verificată, renunți la disc.
  • Joburile cron: le muți într-un scheduler extern sau le protejezi cu un lock distribuit, ca să ruleze o singură dată chiar dacă există mai multe instanțe. Joburile trebuie să fie idempotente.
  • Configurația: secretele și setările ies din fișierele locale în variabile de mediu sau într-un serviciu de configurare.
  • Load balancer-ul: întâi în fața instanței unice (fără schimbare de comportament), cu health check. Apoi adaugi a doua instanță și urmărești erorile, latența și logurile.

Pe tot parcursul ai metrici și o cale de întoarcere pentru fiecare pas. Testează că o instanță poate fi oprită oricând (un mic exercițiu de chaos): dacă utilizatorii nu observă nimic, migrarea e reușită.

Ce urmărește intervievatorul: Verifică experiența de migrare reală, nu designul de la zero. Candidații tind să propună o rescriere completă, cu risc mare și fără pași intermediari.

Eroarea, în practică:Delogări aleatorii după scalare (sesiuni în memorie)

Caching și CDN

Exersează capitolul cu exerciții reale: Curs System Design online →
21 Junior

Unde poate exista un cache într-o arhitectură web? Dă exemple de la browser până la baza de date.

Răspuns scurt: Pe tot drumul cererii: în browser (antete HTTP), în CDN, în reverse proxy, în memoria aplicației, într-un cache distribuit (Redis) și în baza de date. Cu cât e mai aproape de utilizator, cu atât câștigi mai mult, dar invalidarea e mai grea.

Fiecare nivel evită munca nivelurilor de după el:

  • Browserul: antetele Cache-Control, ETag, Last-Modified permit refolosirea fișierelor fără nicio cerere sau cu o cerere de validare (304 Not Modified).
  • CDN-ul: păstrează fișierele statice și uneori răspunsuri publice de API în puncte de prezență apropiate de utilizatori.
  • Reverse proxy-ul / gateway-ul (Nginx, Varnish): poate păstra pagini întregi pentru utilizatori nelogați.
  • Memoria aplicației: un dicționar local cu configurații, liste de categorii, cursuri valutare. Foarte rapid, dar fiecare instanță are copia ei și pot diferi.
  • Cache-ul distribuit (Redis, Memcached): partajat între toate instanțele; aici stau de obicei rezultatele interogărilor, sesiunile, obiectele scumpe de calculat.
  • Baza de date: păstrează paginile citite des în memorie (buffer pool); unele baze au și cache de rezultate.

Regula de bază: pui cache unde datele se citesc mult mai des decât se schimbă și unde poți tolera o mică întârziere a actualizării. Pentru fiecare nivel decizi cât timp poate fi vechi un răspuns și cum îl invalidezi. Datele personale nu ajung în cache-uri publice (CDN, proxy) fără grijă: un răspuns cu datele contului cuiva, păstrat greșit, poate fi servit altui utilizator.

Ce urmărește intervievatorul: Verifică imaginea de ansamblu a caching-ului. Candidații se gândesc des doar la Redis și uită cache-ul HTTP din browser și CDN.

Eroarea, în practică:Cache local diferit pe fiecare serverRată de hit mică: cache-ul nu ajută

22 Junior

Explică pattern-ul cache-aside. Ce se întâmplă la o citire și ce face aplicația la o scriere?

Răspuns scurt: La citire, aplicația caută în cache; dacă nu găsește (miss), citește din bază și pune rezultatul în cache cu un TTL. La scriere, actualizează baza și apoi șterge cheia din cache, ca următoarea citire să încarce valoarea nouă.

În cache-aside (lazy loading), cache-ul nu știe nimic de baza de date: aplicația le coordonează pe amândouă.

PYTHON
def produs(id):
    cheie = f"produs:{id}"
    valoare = cache.get(cheie)
    if valoare is not None:
        return valoare                      # hit
    valoare = db.query("SELECT * FROM produse WHERE id = %s", id)
    cache.set(cheie, valoare, ttl=300)      # miss: încarcă și păstrează 5 minute
    return valoare

def schimba_pret(id, pret):
    db.execute("UPDATE produse SET pret = %s WHERE id = %s", pret, id)
    cache.delete(f"produs:{id}")            # invalidare după scriere

Avantaje:

  • în cache ajung doar datele cerute efectiv;
  • dacă pică cache-ul, aplicația merge în continuare (mai încet), pentru că baza are totul.

Dezavantaje:

  • prima citire după expirare sau după ștergere e lentă (miss);
  • pot exista ferestre scurte în care cache-ul are valoarea veche, mai ales cu scrieri concurente;
  • dacă o cheie populară expiră, multe cereri simultane lovesc baza (cache stampede).

De ce se șterge cheia în loc să fie actualizată: dacă două scrieri concurente pun fiecare valoarea ei în cache, ordinea poate fi greșită și rămâne valoarea veche. Ștergerea lasă următoarea citire să ia valoarea din bază. TTL-ul e plasa de siguranță: chiar dacă o invalidare se pierde, datele vechi expiră.

Ce urmărește intervievatorul: Verifică dacă știi mecanica exactă a celui mai folosit pattern de caching. Greșeala tipică: actualizarea cache-ului înainte de scrierea în bază.

Eroarea, în practică:Cache penetration: chei inexistenteDate vechi în cache după actualizare

23 Junior

Ce este TTL-ul unei chei din cache și cum îl alegi?

Răspuns scurt: TTL (time to live) este durata după care cheia expiră automat. Îl alegi după cât timp poate fi vechi un răspuns fără să deranjeze și după cât de des se schimbă datele: secunde pentru stocuri, minute pentru produse, ore pentru configurații.

TTL-ul răspunde la întrebarea „cât timp accept să arăt o valoare posibil depășită?”. E o decizie de business, nu doar tehnică.

Exemple de raționament:

  • Prețul afișat în listă: câteva minute sunt acceptabile dacă la plasarea comenzii prețul se verifică din bază.
  • Stocul: câteva secunde sau deloc în cache la finalizarea comenzii, pentru că un stoc greșit înseamnă comenzi pe care nu le poți onora.
  • Lista de categorii, setările: ore, pentru că se schimbă rar și se pot invalida explicit la modificare.
  • Sesiunile: cât durează sesiunea, reînnoit la fiecare activitate.

Compromisul:

  • TTL mic: date proaspete, dar mai multe miss-uri și mai multă încărcare pe bază;
  • TTL mare: mai puține miss-uri, dar date mai vechi și memorie ocupată de chei nefolosite.

Două practici utile:

  • TTL cu variație aleatoare (jitter): în loc de exact 300 de secunde, alegi între 270 și 330. Altfel cheile încărcate în același moment (de exemplu după un deploy) expiră toate odată și lovesc baza simultan.
  • Invalidare explicită + TTL: ștergi cheia când se schimbă datele, iar TTL-ul rămâne ca plasă de siguranță pentru invalidările pierdute.

Ce urmărește intervievatorul: Intervievatorul verifică dacă legi TTL-ul de cerințe reale. Candidații dau des o valoare fixă pentru tot, fără argument.

Eroarea, în practică:Cache avalanche: baza cade când cache-ul se goleșteDate vechi în cache după actualizare

24 Junior

Ce este un CDN, cum ajunge un fișier în el și ce fel de conținut pui pe un CDN?

Răspuns scurt: O rețea de servere răspândite geografic, care păstrează copii ale conținutului aproape de utilizatori. La primul acces, CDN-ul cere fișierul de la origine și îl păstrează; următorii îl primesc direct. Pui acolo fișiere statice, media și răspunsuri publice.

Fără CDN, un utilizator din Asia care descarcă o imagine de pe un server din Europa plătește de fiecare dată drumul lung prin internet. Cu CDN, cererea ajunge la cel mai apropiat punct de prezență (PoP).

Cum ajunge conținutul acolo:

  • Pull (cel mai des): CDN-ul are configurată o origine (serverul tău sau un object storage). La un miss, cere fișierul de la origine, îl păstrează conform antetelor Cache-Control și îl servește.
  • Push: încarci tu fișierele în CDN dinainte, util pentru fișiere mari și cunoscute (o actualizare de joc lansată la o oră anume).

Ce pui pe CDN:

  • imagini, video, fonturi, CSS, JavaScript, fișiere de descărcat;
  • pagini și răspunsuri de API publice, identice pentru toți (de exemplu pagina unui articol pentru vizitatorii nelogați), cu TTL scurt;
  • segmentele video la streaming.

Ce nu pui (sau doar cu mare grijă): răspunsuri personalizate, date ale contului, orice depinde de cookie-ul utilizatorului.

Beneficiile: latență mică pentru utilizatori, trafic mult mai mic la origine (doar miss-urile) și protecție la vârfuri și la unele atacuri. Costul: plătești traficul CDN-ului și trebuie să gestionezi invalidarea când schimbi conținutul.

Ce urmărește intervievatorul: Verifică dacă știi cum funcționează efectiv un CDN, nu doar că „face site-ul mai rapid”. Greșeala tipică: conținut personalizat pus în cache public.

Eroarea, în practică:Fișiere statice servite de server, fără CDNX-Cache: Miss from cloudfront (hit rate mic)

25 Junior

Cache-ul s-a umplut. Cum decide ce chei elimină? Compară LRU, LFU și FIFO și spune când ai alege LFU.

Răspuns scurt: LRU scoate cheia folosită cel mai demult, LFU pe cea folosită cel mai rar, FIFO pe cea mai veche introdusă. LRU e alegerea implicită; LFU e mai bun când popularitatea e stabilă și un val de chei citite o singură dată ar goli cache-ul.

Un cache are memorie limitată, deci la fiecare inserare peste limită trebuie să renunțe la ceva.

  • LRU (Least Recently Used): elimină cheia accesată cel mai demult. Se bazează pe ideea că ce ai folosit recent vei folosi iar. Funcționează bine pentru majoritatea aplicațiilor web.
  • LFU (Least Frequently Used): elimină cheia cu cele mai puține accesări. Păstrează cheile constant populare chiar dacă nu au fost cerute în ultimele secunde.
  • FIFO: elimină cea mai veche cheie introdusă, indiferent cât e folosită. Simplu, dar poate scoate tocmai cheile cele mai populare.
  • Doar TTL: cheile ies numai când expiră; la memorie plină, scrierile noi pot eșua (în Redis, politica noeviction întoarce eroare).

Când alegi LFU: un catalog în care câteva produse sunt mereu populare, iar un crawler sau un raport parcurge o dată mii de produse rare. Cu LRU, parcurgerea împinge afară cheile populare (cache pollution); cu LFU, cheile citite o singură dată ies primele.

În Redis setezi politica cu maxmemory-policy, de exemplu allkeys-lru sau allkeys-lfu. Varianta volatile-* evacuează doar cheile cu TTL, util dacă unele chei nu au voie să dispară. Indiferent de politică, monitorizezi rata de hit și numărul de evacuări: multe evacuări înseamnă că cache-ul e prea mic.

Ce urmărește intervievatorul: Verifică dacă știi că alegerea politicii depinde de forma accesărilor. Greșeala tipică e să nu știi ce se întâmplă când memoria cache-ului se umple.

Eroarea, în practică:OOM command not allowed (maxmemory)

26 Mid

Compară write-through, write-behind și write-around. Ce riscă fiecare și când îl alegi?

Răspuns scurt: Write-through scrie sincron în cache și în bază: date proaspete, scrieri mai lente. Write-behind confirmă din cache și scrie în bază mai târziu: rapid, dar poți pierde date. Write-around scrie doar în bază: următoarea citire e un miss.

Strategiile diferă prin locul în care ajunge întâi o scriere.

Write-through: aplicația (sau cache-ul) scrie în cache și în bază în aceeași operație; confirmarea vine după ambele.

  • plus: cache-ul are mereu valoarea curentă, citirile imediate după scriere sunt hit-uri;
  • minus: fiecare scriere plătește două latențe, iar cache-ul se umple și cu date scrise, dar niciodată citite.
  • potrivit pentru: profilul utilizatorului, soldul afișat imediat după o tranzacție.

Write-behind (write-back): scrierea se confirmă după ce ajunge în cache; baza e actualizată asincron, adesea în loturi.

  • plus: scrieri foarte rapide, baza primește mai puține operații (mai multe actualizări ale aceleiași chei devin una);
  • minus: dacă nodul cache pică înainte de golire, pierzi scrieri; ordinea și consistența devin complicate.
  • potrivit pentru: contoare de vizualizări, like-uri, statistici, unde o pierdere mică e tolerabilă.

Write-around: scrierea merge doar în bază, iar cache-ul se încarcă la citire (de obicei împreună cu cache-aside).

  • plus: nu umpli cache-ul cu date rar citite;
  • minus: citirea imediat următoare e un miss.
  • potrivit pentru: loguri, istorice, date scrise des și citite rar.

La interviu legi alegerea de toleranța la pierderea datelor: pentru o comandă sau o plată nu folosești write-behind, pentru un contor de vizualizări da.

Ce urmărește intervievatorul: Verifică dacă înțelegi riscul de pierdere a datelor din fiecare strategie. Candidații recomandă des write-behind pentru performanță, fără să menționeze durabilitatea.

Eroarea, în practică:Write-behind: date pierdute la căderea cache-ului

27 Mid

Ce este cache stampede (thundering herd) și cum îl previi?

Răspuns scurt: Când o cheie foarte populară expiră, mii de cereri au miss simultan și lovesc baza cu aceeași interogare. Îl previi cu un singur proces care reîncarcă cheia (lock), reîmprospătare înainte de expirare, servirea valorii vechi și TTL-uri cu variație aleatoare.

Scenariul: pagina principală a unui magazin e în cache cu TTL de 60 de secunde și primește 5.000 de cereri pe secundă. În secunda în care expiră, toate cererile constată miss, toate rulează interogarea scumpă care o generează, baza se încarcă, interogările durează mai mult, iar fereastra în care cache-ul e gol se lungește.

Tehnici:

  • Lock pe reîncărcare (single flight): doar prima cerere care găsește miss obține un lock (de exemplu SET cheie:lock 1 NX EX 10 în Redis) și reface valoarea; celelalte așteaptă scurt și citesc din nou cache-ul sau primesc valoarea veche.
  • Stale-while-revalidate: păstrezi valoarea și după „expirarea logică”, cu un timp de expirare în interiorul ei. Cine o găsește expirată o servește în continuare și declanșează o singură reîncărcare în fundal.
  • Expirare probabilistică timpurie: pe măsură ce cheia se apropie de expirare, fiecare cerere are o mică probabilitate să o reîmprospăteze, deci de obicei se reface înainte să expire efectiv.
  • Încălzire (warm-up): după un deploy sau o repornire, populezi cheile cunoscute ca populare înainte să intre traficul.
  • Jitter pe TTL: chei create în același moment nu expiră în același moment.

Mai e un caz înrudit: căderea completă a cache-ului. Atunci baza trebuie protejată cu limitarea interogărilor concurente, cu circuit breaker și eventual cu degradarea funcțiilor neesențiale.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce se întâmplă cu cache-ul sub trafic mare, nu doar în cazul fericit. Greșeala tipică: „pun TTL și gata”.

Eroarea, în practică:Cache stampede / thundering herdCache avalanche: baza cade când cache-ul se golește

28 Mid

De ce se spune că invalidarea cache-ului e grea? Ce se poate întâmpla dacă ștergi cheia înainte să scrii în bază?

Răspuns scurt: Scrierea în bază și operația pe cache nu sunt atomice și se pot intercala cu citiri concurente. Dacă ștergi cheia întâi, o citire concurentă poate pune la loc valoarea veche. Ordinea mai sigură: scrii în bază, apoi ștergi cheia, cu TTL ca plasă de siguranță.

Secvența problematică, cu ștergerea înainte de scriere:

1. scriitorul: DELETE produs:7 din cache
2. cititorul:  miss pe produs:7, citește din bază prețul VECHI
3. scriitorul: UPDATE produse SET pret = 120 WHERE id = 7
4. cititorul:  SET produs:7 = preț vechi (TTL 1 oră)

Rezultatul: o oră de preț greșit, deși toți pașii „au mers”.

Cu ordinea „întâi baza, apoi ștergerea”, fereastra se micșorează mult, dar nu dispare complet: un cititor care a citit valoarea veche chiar înainte de UPDATE o poate scrie în cache după DELETE. E rar, pentru că cititorul trebuie să fie mai lent decât scrierea plus ștergerea.

Tehnici pentru cazurile care contează:

  • TTL pe orice cheie, ca eroarea să aibă o durată maximă;
  • ștergere dublă întârziată: ștergi după scriere și încă o dată după câteva sute de milisecunde;
  • versiuni: valoarea din cache are versiunea rândului, iar o scriere mai veche nu poate înlocui una mai nouă;
  • invalidare din fluxul de modificări al bazei (CDC): un consumator citește binlog-ul sau WAL-ul și șterge cheile, deci nicio scriere nu e ratată, chiar dacă vine din alt serviciu;
  • pentru datele critice (stoc la plată, sold), citești direct din baza primară, nu din cache.

Pe lângă concurență, dificultatea vine și din dependențe: o modificare a unui produs poate afecta zeci de chei (pagina produsului, listele, căutările), iar fiecare trebuie găsită și invalidată.

Ce urmărește intervievatorul: Verifică dacă înțelegi condițiile de cursă dintre cache și bază. Candidații descriu invalidarea ca pe o singură linie de cod, fără să vadă intercalările.

Eroarea, în practică:Date vechi în cache după actualizare

29 Mid

Ai publicat o versiune nouă a site-ului, dar unii utilizatori văd încă vechiul CSS și JavaScript din CDN. Cum previi asta de la început?

Răspuns scurt: Folosești nume de fișiere cu versiune sau hash (app.3f9a2c.js) și le dai un TTL foarte lung, iar HTML-ul care le referă are TTL scurt. La un deploy se schimbă numele, deci CDN-ul și browserul cer automat fișierul nou. Purge-ul pe CDN rămâne pentru excepții.

Problema apare când același URL (/static/app.js) are conținut diferit în timp. CDN-ul și browserul au o copie validă după antetele lor și nu au de unde ști că s-a schimbat.

Soluția standard este versionarea în nume (cache busting):

/static/app.3f9a2c.js      Cache-Control: public, max-age=31536000, immutable
/static/style.8b1d07.css   Cache-Control: public, max-age=31536000, immutable
/index.html                Cache-Control: no-cache   (se revalidează la fiecare cerere)

Unealta de build (Vite, webpack) pune în nume un hash al conținutului. Un fișier cu un nume dat nu se mai schimbă niciodată, deci poate sta în cache un an. HTML-ul e mic și se revalidează, iar la un deploy referă noile nume, care sunt simple miss-uri.

Ordinea de deploy contează: încarci întâi fișierele noi, apoi publici HTML-ul nou. Păstrezi și fișierele vechi o vreme, pentru utilizatorii care au deja pagina deschisă.

Purge-ul (invalidarea explicită în CDN) e util pentru greșeli sau pentru conținut fără versiune (o imagine înlocuită cu același nume), dar durează și uneori costă pe operație. Unele CDN-uri permit și purge pe etichete (surrogate keys), util pentru pagini de API.

Pentru răspunsurile dinamice publice folosești TTL scurt plus stale-while-revalidate, ca utilizatorii să primească imediat un răspuns, iar reîmprospătarea să se facă în fundal.

Ce urmărește intervievatorul: Verifică dacă știi mecanismul practic care elimină problema, nu doar purge-ul manual după fiecare deploy.

Eroarea, în practică:CDN-ul servește conținut vechi după deploy

30 Senior

Într-un cluster Redis cu 6 noduri, un singur nod este la 100% CPU, iar celelalte sunt aproape libere. Ce s-a întâmplat și cum rezolvi?

Răspuns scurt: Probabil o cheie fierbinte: un produs viral sau un contor global primește o mare parte din trafic, iar cheia locuiește pe un singur nod. Rezolvi cu cache local în aplicație, copii ale cheii citite aleator și contoare împărțite în mai multe chei.

Într-un cache distribuit, fiecare cheie aparține unui singur slot, deci unui singur nod primar. Partiționarea împarte bine cheile, dar nu poate împărți o singură cheie. Când un produs devine viral sau toate cererile citesc aceeași configurație, nodul ei devine gâtul de sticlă, indiferent câte noduri adaugi.

Cum confirmi: metricile pe nod, redis-cli --hotkeys (cu politica LFU activă) sau eșantionarea comenzilor, plus logurile aplicației.

Soluții pentru citiri:

  • cache local în aplicație (câteva secunde) pentru cheile cunoscute ca fierbinți: majoritatea citirilor nu mai ajung la Redis;
  • replici ale cheii: scrii valoarea în produs:7#0 … produs:7#9, care ajung pe noduri diferite, iar cititorii aleg aleator unul;
  • citiri de pe replicile nodului, dacă poți tolera o întârziere mică.

Soluții pentru scrieri (de exemplu un contor de like-uri):

  • împarți contorul în N sub-contoare (likes:7:0 … likes:7:15), incrementezi unul aleator și aduni la citire;
  • agregi în aplicație și scrii periodic, în loc de o scriere pe eveniment.

Pe termen lung: detecție automată a cheilor fierbinți și protecție la nivelul aplicației, pentru că un eveniment neprevăzut (o campanie, un link distribuit masiv) poate crea oricând una nouă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi limitele partiționării. Greșeala tipică: propunerea de a adăuga noduri, care nu ajută la o singură cheie.

Eroarea, în practică:Hot key în Redis

Baze de date: SQL, NoSQL, replicare, sharding

31 Junior

Cum alegi între o bază SQL și una NoSQL pentru un serviciu nou? Ce întrebări îți pui?

Răspuns scurt: Pornești de la relații, tranzacții și tiparele de acces. SQL e alegerea implicită pentru date relaționale cu tranzacții și interogări flexibile; NoSQL se potrivește la acces simplu după cheie, volum foarte mare, schemă variabilă sau scrieri peste ce duce o singură bază.

Întrebări utile:

  • Ce relații există? Comenzi, clienți, produse, facturi legate între ele, cu join-uri și rapoarte: SQL.
  • Am nevoie de tranzacții pe mai multe rânduri? Transfer între conturi, rezervarea unui loc: SQL (sau o bază NoSQL care oferă explicit tranzacțiile necesare).
  • Cum citesc datele? Dacă aproape toate citirile sunt „dă-mi obiectul cu cheia X” sau „ultimele 50 de mesaje din conversația Y”, un model cheie-valoare sau wide-column (DynamoDB, Cassandra) se potrivește.
  • Ce volum de scrieri am? Milioane de evenimente pe secundă de la senzori sau loguri depășesc ușor o singură bază relațională; bazele NoSQL distribuite sunt construite să partiționeze scrierile.
  • Cât de stabilă e schema? Documente cu structură variabilă (atribute de produs diferite pe categorii) se modelează natural într-o bază de documente, deși și Postgres are JSONB.
  • Ce știe echipa? O bază pe care echipa o operează bine valorează mult.

La interviu, un răspuns bun nu e „NoSQL scalează, SQL nu”. Bazele relaționale scalează mult cu replici, partiționare și hardware bun, iar bazele NoSQL cer să-ți proiectezi datele după interogări, cu mai puțină flexibilitate. Adesea un sistem le folosește pe amândouă: SQL pentru comenzi și plăți, un store cheie-valoare pentru sesiuni sau feed-uri, un motor de căutare pentru căutare.

Ce urmărește intervievatorul: Verifică dacă alegi baza după cerințe, nu după modă. Greșeala tipică: NoSQL ales „pentru scalare” fără să discuți tranzacțiile și interogările.

32 Junior

Ce este un index într-o bază de date, cum accelerează o interogare și ce costă?

Răspuns scurt: Un index este o structură separată, de obicei un B-tree, ordonată după una sau mai multe coloane, care permite găsirea rândurilor fără să parcurgi tot tabelul. Costă spațiu și încetinește scrierile, pentru că fiecare INSERT sau UPDATE trebuie să actualizeze și indexul.

Fără index, SELECT * FROM comenzi WHERE client_id = 42 citește fiecare rând din tabel (full table scan). La un tabel de 100 de milioane de rânduri, asta înseamnă secunde sau minute. Cu un index pe client_id, baza coboară în arbore în câțiva pași (adâncimea unui B-tree crește logaritmic) și citește direct rândurile potrivite.

SQL
CREATE INDEX idx_comenzi_client ON comenzi (client_id, creat_la);

-- folosește indexul: filtrare pe prima coloană, sortare pe a doua
SELECT id, total FROM comenzi
WHERE client_id = 42
ORDER BY creat_la DESC
LIMIT 20;

Ordinea coloanelor contează: indexul de mai sus ajută la filtrarea după client_id și la sortarea după dată, dar nu ajută o interogare care filtrează doar după creat_la.

Costurile:

  • scrieri mai lente: fiecare index în plus înseamnă încă o actualizare la fiecare scriere;
  • spațiu pe disc și în memorie;
  • indexuri nefolosite care doar consumă resurse.

Din perspectiva system design-ului, indexul e primul pas când baza e lentă la citiri, înaintea cache-ului sau a replicilor. Verifici cu EXPLAIN că interogarea îl folosește. Pentru căutare de text liber (LIKE '%telefon%'), un index B-tree nu ajută; acolo pui un index full-text sau un motor de căutare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi primul instrument de optimizare a bazei. Candidații propun des cache sau sharding înainte să se întrebe dacă interogarea are index.

Eroarea, în practică:Paginare lentă cu OFFSET mareSlow query: Seq Scan (index lipsă)

33 Junior

Ce este replicarea primar–replică și ce probleme rezolvă? Ce nu rezolvă?

Răspuns scurt: Primara primește toate scrierile și le trimite replicilor, care țin copii ale datelor. Replicile preiau citirile și pot deveni primară dacă aceasta pică. Nu rezolvă însă problema scrierilor multe, pentru că toate scrierile trec tot prin primară.

Fiecare modificare făcută pe primară ajunge în jurnalul ei (WAL în PostgreSQL, binlog în MySQL), iar replicile aplică jurnalul în aceeași ordine. De obicei replicarea e asincronă: primara confirmă scrierea fără să aștepte replicile.

Ce câștigi:

  • scalarea citirilor: aplicația trimite citirile la replici (rapoarte, pagini de produs), iar primara are mai multe resurse pentru scrieri;
  • disponibilitate: dacă primara pică, o replică poate fi promovată;
  • izolare: rapoartele grele rulează pe o replică dedicată, fără să încetinească aplicația;
  • backup-uri făcute de pe replică.

Ce nu rezolvă:

  • scrierile: fiecare replică trebuie să aplice toate scrierile, deci adăugarea de replici nu mărește capacitatea de scriere;
  • mărimea datelor: fiecare replică are toate datele;
  • consistența imediată: replicile pot fi în urmă cu milisecunde sau secunde (replication lag).

Variante: replicare sincronă (scrierea e confirmată după ce cel puțin o replică a primit-o; fără pierdere de date la failover, dar scrieri mai lente) sau semi-sincronă. Când scrierile depășesc o singură primară, următorul pas e partiționarea (sharding).

Ce urmărește intervievatorul: Verifică înțelegerea limitelor replicării. Greșeala tipică: „adaug replici ca să scalez scrierile”.

Eroarea, în practică:Baza primară la 100% din cauza citirilorReplica_IO_Running: No (replică fără date noi)

34 Junior

Un utilizator își schimbă numele în profil, dă refresh și vede numele vechi, apoi după câteva secunde pe cel nou. Ce s-a întâmplat și cum repari?

Răspuns scurt: E replication lag: scrierea a mers pe primară, dar citirea următoare a ajuns la o replică rămasă în urmă. Asiguri read-your-writes trimițând citirile utilizatorului la primară scurt timp după o scriere sau folosind doar replici ajunse la poziția scrierii.

Fenomenul încalcă garanția read-your-writes: utilizatorul se așteaptă să-și vadă propriile modificări imediat, chiar dacă alții le pot vedea cu întârziere.

Cauza: aplicația scrie pe primară și citește de pe replici, iar replicarea asincronă are o întârziere care crește sub încărcare, la tranzacții mari sau la probleme de rețea.

Soluții, de la simplu la elaborat:

  • Citire de pe primară după scriere: după ce utilizatorul modifică ceva, marchezi sesiunea (de exemplu un cookie cu momentul scrierii) și, timp de câteva secunde, citirile lui merg la primară.
  • Citiri critice mereu pe primară: pagina „Profilul meu” sau „Comenzile mele” citesc de pe primară, iar listele publice de pe replici.
  • Citire condiționată de poziție: după scriere reții poziția din jurnal (LSN în PostgreSQL, GTID în MySQL) și citești de pe o replică doar dacă a aplicat cel puțin acea poziție; altfel mergi la primară.
  • Răspuns din scriere: interfața afișează datele trimise în răspunsul la scriere, fără o nouă citire.

Monitorizezi lag-ul replicilor și scoți din rotație replicile care rămân mult în urmă. Problema e înrudită cu monotonic reads: utilizatorul nu trebuie să vadă date noi, apoi iar vechi, ceea ce se întâmplă când două citiri succesive ajung la replici cu lag diferit; o rezolvi legând utilizatorul de aceeași replică.

Ce urmărește intervievatorul: Intervievatorul verifică dacă recunoști simptomul replicării asincrone. Mulți candidați ghicesc „problema de cache” fără să ia în calcul replicile.

Eroarea, în practică:Replication lag: modificarea nu apare după salvare

35 Junior

Ce este sharding-ul și de ce e o decizie pe care încerci s-o amâni cât poți?

Răspuns scurt: Sharding înseamnă împărțirea datelor unui tabel pe mai multe baze independente, după o cheie (de exemplu client_id), ca scrierile și datele să se distribuie. E amânat pentru că aduce complexitate mare: interogări și tranzacții între shard-uri, rebalansare, operare și backup pentru N baze.

Fiecare shard conține o parte din rânduri, iar aplicația (sau un strat de rutare) știe pe ce shard e o cheie. Spre deosebire de replicare, unde fiecare nod are toate datele, aici fiecare nod are doar o parte, deci și scrierile se împart.

Ce rezolvă:

  • capacitatea de scriere peste limita unei singure primare;
  • volumul de date peste ce încape sau se poate opera rezonabil pe o singură mașină;
  • izolarea: un shard cu probleme afectează doar o parte din utilizatori.

De ce îl amâni:

  • interogările care nu au cheia de sharding trebuie trimise la toate shard-urile și combinate;
  • join-urile și tranzacțiile între shard-uri devin grele sau imposibile;
  • constrângerile globale (unicitatea unui email peste toate shard-urile) cer mecanisme separate;
  • rebalansarea când un shard crește prea mult e o operație delicată;
  • operarea: migrări de schemă, backup, monitorizare pentru fiecare shard.

Ordinea uzuală înainte de sharding: interogări și indexuri bune, scalare verticală, cache, replici de citire, arhivarea datelor vechi, separarea pe servicii (fiecare cu baza lui). Abia când scrierile sau volumul nu mai încap, partiționezi. Când o faci, alegi cheia cu grijă, pentru că schimbarea ei ulterior înseamnă mutarea tuturor datelor.

Ce urmărește intervievatorul: Verifică maturitatea: știi că sharding-ul are un cost mare și când merită. Candidații îl propun des pentru câteva mii de cereri pe secundă.

Eroarea, în practică:Baza primară saturată de scrieriSharding fără cheie: scatter-gather

36 Junior

Cum alegi cheia de sharding pentru tabela de comenzi a unui magazin? Ce este o partiție fierbinte?

Răspuns scurt: O cheie bună distribuie uniform datele și traficul și apare în majoritatea interogărilor, de exemplu client_id. O partiție fierbinte apare când cheia concentrează traficul pe un shard: data comenzii (toate scrierile de azi pe același shard) sau un client uriaș.

Criteriile unei chei de sharding:

  • Cardinalitate mare: multe valori distincte, ca datele să se poată împărți fin. tara cu 5 valori nu ajunge.
  • Distribuție uniformă a datelor și a traficului, nu doar a numărului de rânduri.
  • Prezența în interogări: dacă majoritatea interogărilor filtrează după cheie, fiecare atinge un singur shard. „Comenzile clientului X” sunt frecvente, deci client_id e un candidat bun.
  • Localitatea: datele care se citesc sau se modifică împreună (comanda și liniile ei) stau pe același shard dacă au aceeași cheie.

Exemple de chei proaste:

  • data comenzii: toate scrierile de azi merg pe ultimul shard, iar celelalte stau. E partiția fierbinte clasică pentru chei care cresc în timp.
  • id auto-incrementat cu împărțire pe intervale: aceeași problemă, scrierile noi lovesc mereu ultimul interval.
  • magazinul, pe o platformă cu un magazin foarte mare și mii de magazine mici: shard-ul lui e supraîncărcat.

Remedii:

  • hash pe cheie în loc de intervale, ca valorile consecutive să se împrăștie;
  • cheie compusă (de exemplu magazin_id + client_id) pentru clienții foarte mari;
  • shard dedicat pentru un tenant uriaș.

Spune și compromisul: cu client_id, raportul „vânzările de ieri pe tot magazinul” atinge toate shard-urile, deci rapoartele se fac într-un depozit de date separat, alimentat din shard-uri.

Ce urmărește intervievatorul: Intervievatorul verifică dacă te gândești la tiparul de acces, nu doar la distribuția datelor. Greșeala tipică: cheie după dată sau după un câmp cu puține valori.

Eroarea, în practică:ProvisionedThroughputExceeded (hot partition)Sharding fără cheie: scatter-gather

37 Junior

Unde păstrezi pozele și videoclipurile încărcate de utilizatori și unde păstrezi informațiile despre ele? Cum ajunge fișierul acolo?

Răspuns scurt: Fișierele merg într-un object storage (S3 sau echivalent), iar metadatele (autor, dată, mărime, cheia obiectului) într-o bază de date. Ideal, clientul încarcă fișierul direct în object storage cu un URL presemnat generat de server, iar serverul doar înregistrează metadatele.

Bazele de date nu sunt făcute pentru blob-uri mari: cresc backup-urile, încetinesc replicarea, consumă memoria pentru cache-ul paginilor. Un object storage e gândit exact pentru asta: capacitate practic nelimitată, durabilitate mare prin copii multiple, cost mic pe GB, acces prin HTTP și integrare cu un CDN.

Fluxul cu URL presemnat:

1. client -> API:            POST /upload  {nume, tip, mărime}
2. API:                      verifică utilizatorul și limitele,
                             generează cheia "poze/2026/11/abc123.jpg"
                             și un URL presemnat valabil câteva minute
3. client -> object storage: PUT pe URL-ul presemnat (fișierul)
4. client -> API:            POST /upload/abc123/gata
5. API -> bază:              salvează metadatele, starea "încărcat"
6. API -> coadă:             job de procesare (miniaturi, scanare)

Avantaje:

  • fișierele mari nu trec prin serverele de aplicație, deci acestea nu consumă bandă și memorie;
  • object storage-ul scalează singur la volum;
  • citirea se face prin CDN, cu URL-uri publice sau tot presemnate pentru conținut privat.

Detalii de menționat: limita de mărime și tipul de fișier se verifică în politica URL-ului, upload-urile neterminate se curăță periodic, iar fișierele mari folosesc upload în mai multe bucăți (multipart), reluabil dacă se întrerupe conexiunea.

Ce urmărește intervievatorul: Verifică dacă știi tiparul standard pentru fișiere. Greșeala tipică: fișierele salvate în baza de date sau pe discul serverului de aplicație.

Eroarea, în practică:Fișiere încărcate dispar (disc local)413 Request Entity Too Large

38 Mid

Ce problemă are distribuirea cheilor cu hash(cheie) % N când adaugi un nod și cum o rezolvă consistent hashing? Scrie o implementare simplă.

Răspuns scurt: Cu modulo, schimbarea lui N mută aproape toate cheile pe alt nod, ceea ce golește un cache sau declanșează o migrare uriașă. Cu consistent hashing, nodurile și cheile stau pe un inel, iar adăugarea unui nod mută doar aproximativ 1/N din chei.

Cu hash(k) % 4, trecerea la 5 noduri schimbă nodul pentru aproximativ 80% din chei. Pentru un cache distribuit asta înseamnă miss-uri masive dintr-odată; pentru o bază, mutarea majorității datelor.

În consistent hashing, fiecare nod are mai multe puncte pe un inel (noduri virtuale), iar o cheie merge la primul punct de după hash-ul ei. Un nod nou ia doar cheile dintre punctele lui și predecesori.

PYTHON
import bisect, hashlib

def h(s):
    return int(hashlib.md5(s.encode()).hexdigest(), 16)

class Inel:
    def __init__(self, noduri, virtuale=100):
        self.puncte = []                    # lista sortată de (hash, nod)
        for n in noduri:
            self.adauga(n, virtuale)

    def adauga(self, nod, virtuale=100):
        for i in range(virtuale):
            bisect.insort(self.puncte, (h(f"{nod}#{i}"), nod))

    def nod_pentru(self, cheie):
        i = bisect.bisect(self.puncte, (h(cheie), ""))
        return self.puncte[i % len(self.puncte)][1]

inel = Inel(["cache-a", "cache-b", "cache-c"])
print(inel.nod_pentru("produs:42"))

Nodurile virtuale sunt importante: cu un singur punct pe nod, intervalele sunt inegale și un nod poate primi mult mai multe chei. Cu sute de puncte pe nod, distribuția devine uniformă, iar la căderea unui nod cheile lui se împart între mai multe noduri, nu doar vecinului. Ponderile se obțin dând mai multe puncte nodurilor mai puternice.

Consistent hashing apare în cache-uri distribuite, în baze ca Cassandra și DynamoDB și în load balancere care vor afinitate stabilă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi de ce redistribuirea contează la scară. Candidații știu des numele tehnicii, dar nu pot explica nodurile virtuale.

39 Mid

Cum generezi ID-uri unice într-un sistem distribuit? Compară auto-increment, UUID și un generator de tip Snowflake.

Răspuns scurt: Auto-increment e simplu, dar depinde de o singură bază. UUID-ul aleator se generează oriunde, fără coordonare, dar e lung și se indexează prost. Snowflake combină timpul, id-ul mașinii și un contor într-un număr de 64 de biți, unic și aproximativ ordonat în timp.

Auto-increment (BIGSERIAL, AUTO_INCREMENT):

  • plus: scurt, ordonat, ușor de citit;
  • minus: generarea depinde de o singură bază, devine punct de coordonare la sharding; ID-urile consecutive dezvăluie volumul (câte comenzi ai) și se pot ghici.

UUID v4 (128 de biți aleatori):

  • plus: generat oriunde, fără coordonare, probabilitate de coliziune neglijabilă;
  • minus: lung (36 de caractere ca text), iar valorile aleatoare inserate într-un index B-tree îl fragmentează și scad performanța scrierilor. UUID v7 (cu timpul la început) rezolvă parțial ordonarea.

Snowflake (popularizat de Twitter), 64 de biți:

1 bit semn | 41 biți milisecunde de la o epocă proprie | 10 biți id mașină | 12 biți secvență
  • 41 de biți de milisecunde acoperă aproximativ 69 de ani;
  • 10 biți permit 1.024 de generatoare;
  • 12 biți permit 4.096 de ID-uri pe milisecundă pe generator.

Plusuri: încape într-un BIGINT, e aproximativ ordonat în timp (indexuri fericite, sortare după creare), nu cere coordonare la fiecare ID. Minusuri: fiecare generator are nevoie de un id unic de mașină (alocat la pornire, de exemplu prin ZooKeeper sau din configurație) și depinde de ceas: dacă ceasul sare înapoi, generatorul trebuie să aștepte sau să refuze, altfel poate repeta ID-uri.

Alternativă simplă: alocarea de intervale. Un serviciu central dă fiecărui server câte 1.000 de ID-uri odată, iar serverul le consumă local.

Ce urmărește intervievatorul: Verifică dacă știi compromisurile dintre coordonare, mărime și ordonare. Greșeala frecventă: ignorarea problemei ceasului la Snowflake.

Eroarea, în practică:Id-uri duplicate între shard-uri

40 Mid

Ce tipuri de baze NoSQL cunoști și pentru ce problemă e potrivit fiecare?

Răspuns scurt: Cheie-valoare (Redis, DynamoDB) pentru acces rapid după cheie; documente (MongoDB) pentru obiecte cu structură variabilă; wide-column (Cassandra) pentru volume mari de scrieri cu acces după cheie de partiție; grafuri (Neo4j) pentru relații adânci; serii de timp pentru metrici.

„NoSQL” acoperă modele foarte diferite, fiecare optimizat pentru alt tipar de acces:

  • Cheie-valoare: un dicționar distribuit. Operațiile sunt get/put după cheie, extrem de rapide. Potrivit pentru sesiuni, cache, coșuri de cumpărături, linkuri scurte. Exemple: Redis (în memorie), DynamoDB (gestionat, persistent).
  • Documente: valoarea e un document JSON cu câmpuri interogabile și indexabile. Potrivit pentru cataloage de produse cu atribute variabile, profiluri, conținut. Exemple: MongoDB, Couchbase.
  • Wide-column: date organizate pe cheie de partiție și cheie de sortare; scrieri foarte rapide, scalare orizontală pe multe noduri. Potrivit pentru mesaje de chat (partiție = conversația, sortare = timpul), evenimente, istorice. Exemple: Cassandra, ScyllaDB, HBase.
  • Grafuri: noduri și muchii ca cetățeni de prim rang; interogări de tipul „prietenii prietenilor care au cumpărat X”. Potrivit pentru rețele sociale, recomandări, detecție de fraudă. Exemplu: Neo4j.
  • Serii de timp: optimizate pentru puncte (timp, valoare) și agregări pe intervale. Potrivit pentru metrici, senzori. Exemple: InfluxDB, TimescaleDB (extensie Postgres).
  • Motoare de căutare (Elasticsearch, OpenSearch): index inversat pentru text liber și filtre.

Principiul comun al bazelor NoSQL distribuite este că modelezi datele după interogări: decizi întâi ce citiri ai, apoi structura. Dacă tiparele de acces nu sunt cunoscute sau se schimbă des, flexibilitatea SQL valorează mai mult.

Ce urmărește intervievatorul: Verifică dacă vezi NoSQL ca pe o familie de unelte cu roluri diferite. Candidații tratează des „NoSQL” ca pe un singur lucru, sinonim cu MongoDB.

41 Mid

Baza primară pică. Cum funcționează failover-ul automat și ce poate merge prost?

Răspuns scurt: Monitorizarea detectează căderea primarei, cea mai actualizată replică e promovată, iar aplicația e redirecționată spre ea. Riscuri: pierderea scrierilor nereplicate (la replicare asincronă), split brain dacă vechea primară revine și failover-uri false declanșate de o detecție greșită.

Pașii unui failover automat (Patroni pentru PostgreSQL, Orchestrator pentru MySQL, sau serviciul gestionat al furnizorului de cloud):

  • Detecția: mai mulți observatori verifică primara. E nevoie de un acord (de exemplu prin etcd sau Consul), ca o problemă de rețea a unui singur observator să nu declanșeze failover.
  • Alegerea: se alege replica cu cel mai mult din jurnal aplicat.
  • Promovarea: replica devine primară și acceptă scrieri.
  • Redirecționarea: aplicația află noua adresă printr-un DNS actualizat, o adresă IP virtuală sau un proxy (PgBouncer, HAProxy).
  • Reconfigurarea: celelalte replici urmăresc noua primară.

Ce poate merge prost:

  • Pierderea datelor: cu replicare asincronă, scrierile confirmate de vechea primară, dar nereplicate, se pierd. Replicarea sincronă spre cel puțin o replică elimină riscul, cu cost de latență.
  • Split brain: vechea primară nu era moartă, ci izolată. Dacă revine și acceptă scrieri, ai două primare cu date divergente. Previi cu fencing: vechea primară e oprită forțat sau i se retrage accesul înainte de promovare.
  • Failover-uri false: un timeout prea agresiv mută primara la fiecare pauză scurtă, iar fiecare mutare înseamnă erori pentru aplicație.
  • Aplicația: conexiunile vechi trebuie închise și refăcute; tranzacțiile în curs eșuează și trebuie reîncercate sigur.

Testează failover-ul periodic: un mecanism care n-a rulat niciodată în producție nu poate fi considerat sigur.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că failover-ul e o operație riscantă, nu un buton magic. Mulți candidați spun doar „replica preia”.

Eroarea, în practică:Split brain: două primare simultanBaza primară a căzut, fără failover

42 Senior

Ai 4 shard-uri, iar datele cresc. Cum treci la 16 shard-uri fără să oprești aplicația?

Răspuns scurt: Folosești shard-uri logice mai multe decât serverele și muți partiții întregi pe rând: copiezi datele, aplici diferențele din jurnal până ajungi la zi, comuți scurt scrierile, verifici, apoi schimbi rutarea. Fiecare pas e treptat și reversibil.

Cea mai bună pregătire e făcută la design: shard-uri logice mult mai multe decât cele fizice (de exemplu 1.024 de partiții logice pe 4 servere). Atunci „trecerea la 16” înseamnă doar mutarea unor partiții logice întregi pe servere noi, fără să schimbi funcția de hash a cheilor.

Mutarea unei partiții, pas cu pas:

  • Copia inițială: copiezi datele partiției pe serverul nou dintr-un snapshot.
  • Recuperarea diferenței: aplici modificările apărute între timp, din jurnalul bazei (CDC), până când serverul nou e la câteva secunde în urmă.
  • Comutarea: oprești scrierile pentru acea partiție o fracțiune de secundă (sau trimiți scrierile în ambele locuri o vreme), aștepți ca diferența să ajungă la zero și schimbi tabela de rutare (în serviciul de configurare sau în proxy-ul de sharding).
  • Verificarea: compari numărul de rânduri și sume de control; ții datele vechi o perioadă pentru revenire.
  • Curățenia: ștergi partiția de pe serverul vechi.

Ce mai discuți:

  • rutarea trebuie să fie centralizată și versionată, ca toate instanțele aplicației să știe aceeași hartă;
  • limitezi viteza copierii, ca să nu afecteze traficul de producție;
  • muți câte o partiție, urmărind metricile, nu toate odată;
  • uneltele existente (Vitess pentru MySQL, Citus pentru Postgres, bazele distribuite care fac asta automat) reduc mult riscul față de o soluție proprie.

Ce urmărește intervievatorul: Verifică experiența cu operațiile pe date vii. Greșeala tipică: „opresc aplicația, mut datele, schimb modulo-ul”.

Eroarea, în practică:Shard-uri dezechilibrate (cheie după dată)

43 Senior

Datele sunt împărțite pe shard-uri după client_id. Cum faci o operație care atinge doi clienți de pe shard-uri diferite, de exemplu un transfer de bani?

Răspuns scurt: Încerci întâi să eviți problema prin modelare. Dacă nu se poate, folosești un saga cu pași locali și compensări (debitare, apoi creditare, cu anulare la eșec), sau o tranzacție distribuită (two-phase commit), mai sigură, dar mai lentă și sensibilă la căderea coordonatorului.

Într-o singură bază, transferul e o tranzacție ACID. Când cele două conturi sunt pe shard-uri diferite, nu mai există o tranzacție locală care să le cuprindă pe amândouă.

Opțiuni:

  • Modelarea ca să nu ai nevoie: datele modificate împreună stau pe același shard. Pentru transferuri între clienți oarecare nu e posibil, dar pentru comanda și liniile ei, da.
  • Two-phase commit (2PC): un coordonator cere fiecărui shard să se pregătească (blochează și garantează că poate face commit), apoi le cere tuturor commit. E atomic, dar ține blocări pe durata rundei și, dacă coordonatorul pică între faze, participanții rămân blocați până la recuperare. Unele baze distribuite îl implementează intern cu consens, ceea ce îl face mai robust.
  • Saga: un șir de tranzacții locale, fiecare cu o compensare. Debitezi contul A (local), publici un eveniment, creditezi contul B (local). Dacă creditarea eșuează definitiv, rulezi compensarea: recreditezi contul A. Între pași, sistemul e temporar inconsistent (banii sunt „în tranzit”), ceea ce trebuie modelat explicit, de exemplu cu o înregistrare de transfer cu stare.
  • Registru unic: transferurile se scriu ca înregistrări într-un singur jurnal (ledger) partiționat după transfer, iar soldurile se calculează din el.

Pentru saga ai nevoie de pași idempotenți și de un mecanism sigur de publicare a evenimentelor (outbox), altfel un eveniment pierdut lasă banii blocați în tranzit.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi limitele tranzacțiilor într-un sistem partiționat. Candidații propun des un 2PC fără să menționeze blocarea sau compensările.

CAP, consistență și cvorum

44 Junior

Explică teorema CAP pe înțeles. De ce formularea „alegi 2 din 3” este o simplificare?

Răspuns scurt: Când rețeaua se rupe între noduri, un sistem distribuit alege între a răspunde mereu (disponibilitate) și a răspunde doar cu date actualizate (consistență). Simplificarea: partițiile nu sunt opționale, deci alegerea reală apare doar în timpul lor, între C și A.

Cele trei litere:

  • C (consistency): orice citire vede ultima scriere confirmată, ca și cum ar exista o singură copie a datelor.
  • A (availability): orice nod funcțional răspunde la orice cerere.
  • P (partition tolerance): sistemul continuă să funcționeze când mesajele dintre noduri se pierd.

Într-un sistem distribuit real, rețeaua se va rupe la un moment dat, deci P nu e o opțiune la care poți renunța. Întrebarea devine: ce face sistemul în timpul unei partiții?

  • CP: nodurile care nu pot confirma că au datele actuale refuză cererile (sau o parte din ele). Exemplu: o bază de solduri bancare, unde e mai bine să refuzi o operație decât să permiți cheltuirea de două ori a acelorași bani.
  • AP: toate nodurile răspund, chiar cu date posibil vechi, iar după refacerea rețelei datele se reconciliază. Exemplu: numărul de like-uri sau un coș de cumpărături.

Alte nuanțe utile:

  • în lipsa partițiilor, poți avea și C și A; compromisul de zi cu zi e între consistență și latență (vezi PACELC);
  • alegerea se face pe funcționalitate, nu pe tot sistemul: același produs poate fi CP la plăți și AP la recomandări;
  • „C” din CAP (linearizabilitate) nu e același lucru cu „C” din ACID (respectarea constrângerilor).

Ce urmărește intervievatorul: Verifică dacă înțelegi CAP corect, nu ca pe un meniu. Greșeala tipică: „alegem CA”, ceea ce nu are sens într-un sistem distribuit.

Eroarea, în practică:Cannot achieve consistency level ALL

45 Junior

Ce înseamnă consistența eventuală? Dă un exemplu în care e acceptabilă și unul în care nu.

Răspuns scurt: Dacă nu mai apar scrieri, toate copiile ajung în final la aceeași valoare, dar între timp citirile pot fi vechi. E acceptabilă pentru vizualizări sau un feed, nu pentru stocul la plasarea comenzii sau soldul unui cont.

Într-un sistem eventual consistent, o scriere e confirmată după ce a ajuns pe unul sau pe câteva noduri, iar restul o primesc asincron. Avantajele sunt latența mică și disponibilitatea: scrierile și citirile merg chiar dacă unele noduri sunt lente sau inaccesibile. Prețul: o perioadă (de obicei milisecunde, uneori mai mult) în care noduri diferite dau răspunsuri diferite.

Exemple acceptabile:

  • numărul de like-uri sau de vizualizări arată 1.203 în loc de 1.205;
  • o postare nouă apare în feed-ul prietenilor după câteva secunde;
  • un DNS actualizat se propagă în câteva minute;
  • un produs nou apare în rezultatele căutării după un minut.

Exemple inacceptabile:

  • verificarea stocului la ultimul produs: doi clienți văd „1 în stoc” și cumpără amândoi;
  • soldul contului la o retragere;
  • unicitatea unui nume de utilizator sau a unui loc la un concert;
  • schimbarea parolei sau revocarea unui acces (fereastra de inconsistență e o problemă de securitate).

În design, separi datele după toleranță: partea critică merge într-o bază cu consistență puternică (o primară SQL, tranzacții, constrângeri), iar partea tolerantă poate folosi cache-uri, replici și baze distribuite eventual consistente. La interviu spune explicit care date sunt în ce categorie.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să legi modelul de consistență de cerințele produsului. Greșeala tipică: aceeași consistență pentru toate datele.

Eroarea, în practică:Citiri vechi cu consistență eventuală

46 Junior

Ce este split brain într-un cluster și cum îl previi?

Răspuns scurt: O ruptură de rețea împarte clusterul, iar ambele părți se cred active și acceptă scrieri, deci datele diverg. Îl previi cu cvorum (doar majoritatea poate fi activă), un număr impar de noduri sau un arbitru și fencing pentru vechea primară.

Exemplu: două servere de bază, A primară și B replică, cu failover automat. Legătura dintre ele se rupe, dar ambele sunt pornite și accesibile pentru aplicații. B nu mai vede A, se promovează primară. Acum A și B primesc scrieri în paralel: comanda 1001 pe A e alta decât comanda 1001 pe B.

Mecanisme de prevenire:

  • Cvorum: o decizie (alegerea primarei) cere acordul majorității nodurilor. Cu 3 noduri, partea cu 2 poate continua, iar nodul izolat știe că e în minoritate și se oprește din scrieri.
  • Număr impar de voturi: cu 2 noduri nu există majoritate la o ruptură; adaugi un al treilea nod sau un arbitru (witness) care doar votează.
  • Fencing: înainte ca noua primară să înceapă, vechea e izolată forțat: i se taie accesul la stocare, e oprită prin API-ul infrastructurii (STONITH, „shoot the other node in the head”) sau scrierile ei sunt respinse pe baza unui token de generație.
  • Lease-uri: primara deține un drept cu termen limitat și trebuie să-l reînnoiască prin cvorum; dacă nu reușește, se retrage singură înainte să expire.

Sisteme ca etcd, ZooKeeper sau Consul implementează consens (Raft, ZAB) și sunt folosite tocmai ca sursă de adevăr pentru „cine e lider”. La interviu, menționarea cvorumului și a fencing-ului arată că ai înțeles de ce failover-ul automat e periculos fără ele.

Ce urmărește intervievatorul: Verifică dacă știi riscul principal al failover-ului automat. Mulți candidați propun două noduri cu failover automat, fără arbitru.

Eroarea, în practică:Split brain: două primare simultan

47 Junior

Ce garanții de consistență se așteaptă un utilizator obișnuit de la o aplicație, chiar dacă sistemul e eventual consistent? Cum le obții?

Răspuns scurt: Să-și vadă propriile modificări (read-your-writes), să nu vadă datele mergând înapoi (monotonic reads) și să vadă efectele în ordinea lor. Le obții rutând citirile utilizatorului la un nod actualizat, legând sesiunea de o replică sau folosind versiuni.

Între consistența puternică și cea eventuală există garanții „de sesiune”, mai ieftine decât consistența globală, dar care elimină comportamentele care deranjează oamenii:

  • Read-your-writes: după ce îmi schimb poza de profil, o văd imediat, chiar dacă prietenii mei o văd peste câteva secunde. Soluție: după o scriere, citirile acelui utilizator merg la primară sau la un nod despre care știi că a primit scrierea (după versiune sau poziția din jurnal).
  • Monotonic reads: dacă am văzut 10 comentarii, la refresh nu trebuie să văd 8. Apare când citiri succesive ajung la replici cu întârzieri diferite. Soluție: sesiunea utilizatorului e legată de aceeași replică, sau clientul trimite ultima versiune văzută și nodul care nu e la zi refuză sau așteaptă.
  • Consistent prefix / ordine cauzală: nu vezi răspunsul la o întrebare înainte de întrebare. Soluție: evenimentele legate stau în aceeași partiție (de exemplu toată conversația) sau au metadate de cauzalitate.
  • Monotonic writes: scrierile aceluiași utilizator se aplică în ordinea în care le-a făcut.

Practic, multe probleme raportate ca „bug-uri ciudate” (comentariul care dispare și reapare, setarea salvată care revine) sunt încălcări ale acestor garanții. La interviu, când alegi replici sau o bază eventual consistentă, menționează cum asiguri măcar read-your-writes.

Ce urmărește intervievatorul: Intervievatorul verifică dacă vezi consistența din perspectiva utilizatorului, nu doar ca CAP abstract.

Eroarea, în practică:Replication lag: modificarea nu apare după salvareCitiri vechi cu consistență eventuală

48 Mid

Într-o bază distribuită cu replicare de 3 (N = 3), ce înseamnă să scrii cu W = 2 și să citești cu R = 2? De ce W + R > N îți dă citiri actualizate?

Răspuns scurt: Scrierea e confirmată după 2 replici din 3, iar citirea întreabă 2 replici și ia valoarea cea mai nouă. Dacă W + R > N, orice set de citire se suprapune cu orice set de scriere, deci citirea atinge mereu o replică actualizată.

Parametrii cvorumului, folosiți de baze de tip Dynamo (Cassandra, ScyllaDB, Riak):

  • N: câte copii are fiecare cheie;
  • W: câte replici trebuie să confirme o scriere;
  • R: câte replici răspund la o citire.

Cu N = 3, W = 2, R = 2: scrierea ajunge sigur pe 2 replici, iar citirea consultă 2 replici. Două submulțimi de câte 2 dintr-o mulțime de 3 au mereu cel puțin un element comun, deci una dintre replicile citite are valoarea nouă. Coordonatorul alege versiunea cea mai recentă (după timestamp sau versiune) și, de obicei, repară replica rămasă în urmă (read repair).

Variante și compromisuri:

  • W = 1, R = 1: foarte rapid și disponibil, dar citirile pot fi vechi (consistență eventuală).
  • W = 3, R = 1: citiri rapide și actuale, dar orice replică căzută blochează scrierile.
  • W = 2, R = 2 (cvorum): tolerează căderea unei replici atât la scriere, cât și la citire.

În Cassandra acestea sunt nivelurile de consistență ONE, QUORUM, ALL, alese per interogare.

Limitări de menționat: cvorumul nu oferă tranzacții și nici linearizabilitate deplină în toate cazurile (scrieri concurente, ceasuri neperfecte, „sloppy quorum” cu hinted handoff, unde scrierea ajunge temporar pe alte noduri decât replicile oficiale). Pentru operații de tip „compară și schimbă” ai nevoie de consens (de exemplu tranzacțiile ușoare Paxos din Cassandra).

Ce urmărește intervievatorul: Verifică dacă înțelegi matematica simplă din spatele cvorumului și compromisul latență/disponibilitate. Candidații recită des „W + R > N” fără să explice suprapunerea.

Eroarea, în practică:Cannot achieve consistency level ALLCannot achieve consistency level QUORUM

49 Mid

Două noduri acceptă scrieri pentru aceeași cheie în timpul unei partiții de rețea. Cum rezolvi conflictul după ce rețeaua revine?

Răspuns scurt: Fie alegi automat un câștigător (last-write-wins după timestamp, simplu, dar pierde scrieri), fie păstrezi ambele versiuni și le combini (vector clocks care detectează conflictul, apoi aplicația sau utilizatorul decide), fie folosești structuri care se combină singure fără conflict (CRDT), de exemplu contoare și mulțimi.

Strategiile principale:

  • Last-write-wins (LWW): fiecare scriere are un timestamp, iar cea mai nouă câștigă. E simplu și folosit pe scară largă, dar pierde tacit una dintre scrieri, iar ceasurile serverelor nu sunt perfect sincronizate, deci „cea mai nouă” poate fi de fapt cea mai veche. Acceptabil pentru date unde ultima valoare chiar e cea relevantă (ultima locație a unui șofer).
  • Vector clocks / version vectors: fiecare versiune păstrează câte un contor pe nod. Compararea lor spune dacă o versiune o include pe cealaltă (atunci păstrezi pe cea nouă) sau dacă sunt concurente (conflict real). Conflictele sunt păstrate ca „frați” și rezolvate de aplicație, de exemplu prin unirea a două coșuri de cumpărături.
  • CRDT (conflict-free replicated data types): structuri gândite să se combine determinist în orice ordine. Un contor G-Counter ține câte un contor pe nod și suma lor; un OR-Set permite adăugări și ștergeri concurente. Potrivite pentru like-uri, colaborare în timp real, liste de favorite.
  • Logica de business: pentru unele date regula e specifică (la stoc, scazi ambele vânzări și tratezi stocul negativ ca o comandă de reaprovizionare sau anulare).

Cel mai simplu mod de a evita conflictele este ca fiecare înregistrare să aibă un singur nod proprietar care acceptă scrieri. La interviu, când alegi multi-master, spune explicit ce strategie de conflict folosești și ce date pot fi pierdute.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că multi-master înseamnă conflicte și cum se tratează. Greșeala tipică: LWW ales fără să menționezi pierderea scrierilor.

Eroarea, în practică:Citiri vechi cu consistență eventuală

50 Mid

Ce spune PACELC și de ce e mai util decât CAP în discuțiile de zi cu zi?

Răspuns scurt: PACELC spune: dacă există o partiție (P), alegi între disponibilitate (A) și consistență (C); altfel (E, else), chiar când totul merge, alegi între latență (L) și consistență (C). Compromisul latență–consistență apare la fiecare cerere, nu doar în rarele momente de partiție.

CAP vorbește doar despre ce se întâmplă în timpul unei partiții de rețea, un eveniment relativ rar. În restul timpului, un sistem distribuit tot trebuie să decidă: aștept confirmarea mai multor replici (consistent, dar mai lent) sau răspund imediat de pe o singură replică (rapid, dar posibil vechi)?

PACELC clasifică sistemele pe ambele axe:

  • PA/EL: în partiție alege disponibilitatea, altfel latența. Exemple tipice: Cassandra și DynamoDB în configurațiile implicite, cu consistență eventuală.
  • PC/EC: alege consistența în ambele situații, plătind în disponibilitate și latență. Exemple: bazele distribuite cu consens, ca Spanner sau CockroachDB.
  • PA/EC sau PC/EL: combinații mai rare sau configurabile.

De ce e util în practică:

  • explică de ce o replicare sincronă între regiuni adaugă zeci de milisecunde la fiecare scriere, chiar fără nicio defecțiune;
  • îți dă vocabular pentru a discuta configurarea per interogare: în Cassandra, ONE pentru latență, QUORUM pentru consistență;
  • mută discuția spre întrebarea concretă a produsului: „cât de vechi poate fi răspunsul, ca să economisim latență?”.

La interviu, când propui o bază, poți spune: „pentru feed accept PA/EL, pentru plăți vreau PC/EC și accept latența”.

Ce urmărește intervievatorul: Verifică dacă înțelegi că alegerea de consistență are cost permanent de latență. Candidații care știu doar CAP o tratează ca pe o problemă rară.

51 Senior

Cum ai implementa un lock distribuit, de exemplu ca un job să ruleze pe un singur server? De ce ai nevoie de fencing tokens?

Răspuns scurt: Iei lock-ul cu expirare într-un sistem comun: Redis (SET NX PX) sau, mai sigur, etcd/ZooKeeper cu lease-uri. Un proces oprit temporar poate crede că încă are lock-ul; un fencing token crescător, verificat de resursă, respinge scrierile lui.

Varianta simplă cu Redis:

SET lock:raport-zilnic <id-unic-proces> NX PX 30000

NX setează doar dacă cheia nu există, PX dă expirarea, ca un proces mort să nu țină lock-ul la nesfârșit. Eliberarea trebuie să verifice că lock-ul e încă al tău (compară valoarea și șterge atomic, cu un script Lua), altfel poți șterge lock-ul altui proces.

Problema fundamentală: expirarea. Scenariul:

1. procesul A obține lock-ul (expiră în 30 s)
2. A intră într-o pauză GC de 40 s
3. lock-ul expiră, procesul B îl obține și începe să scrie
4. A își revine, crede că are lock-ul și scrie și el

Nicio verificare făcută de A înainte de pasul 4 nu e suficientă, pentru că pauza poate apărea oricând. Soluția este fencing token: serviciul de lock dă la fiecare achiziție un număr crescător (A primește 33, B primește 34). Resursa protejată (baza, stocarea) ține minte cel mai mare token văzut și respinge scrierile cu token mai mic. Scrierea lui A cu 33 vine după cea a lui B cu 34, deci e respinsă.

Pentru corectitudine (nu doar eficiență) folosești un sistem cu consens (etcd, ZooKeeper, Consul), care oferă lease-uri și revizii crescătoare ce pot servi ca token. Un lock într-un singur Redis e acceptabil când o dublă execuție doar consumă resurse în plus, nu strică date. Ideal, operația protejată este și idempotentă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi de ce lock-urile distribuite sunt subtile. Greșeala tipică: un SETNX fără expirare sau fără nicio protecție la deținătorii întârziați.

Eroarea, în practică:Split brain: două primare simultan

Cozi de mesaje, pub/sub și procesare asincronă

Exersează capitolul cu exerciții reale: Curs System Design online →
52 Junior

De ce ai pune o coadă de mesaje între serverul web și procesarea unei comenzi (email de confirmare, factură, notificare depozit)?

Răspuns scurt: Ca utilizatorul să primească răspunsul imediat după salvarea comenzii, iar munca lentă sau nesigură să se facă în fundal. Coada absoarbe vârfurile, decuplează serviciile, permite reîncercări și scalarea separată a workerilor.

Fără coadă, cererea POST /comenzi ar salva comanda, ar genera PDF-ul facturii, ar trimite emailul și ar anunța depozitul, totul înainte de răspuns. Dacă serverul de email răspunde greu, utilizatorul așteaptă; dacă pică, comanda eșuează deși a fost salvată.

Cu coadă:

client -> API: salvează comanda în bază, publică "comanda_creata" în coadă, răspunde 201
coadă  -> workeri: email, factură, notificare depozit (fiecare în ritmul lui)

Beneficii:

  • latență mică pentru utilizator: răspunsul nu mai depinde de serviciile lente;
  • absorbirea vârfurilor: la Black Friday, mesajele se adună în coadă, iar workerii le procesează în ritmul lor, fără să cadă;
  • izolarea defectelor: dacă serviciul de email e căzut, mesajele așteaptă și se procesează după revenire;
  • reîncercări automate la erori temporare;
  • scalare independentă: adaugi workeri pentru facturi fără să atingi API-ul.

Costuri: sistemul devine eventual consistent (emailul vine după câteva secunde), ai o componentă în plus de operat și monitorizat, iar workerii trebuie să fie idempotenți, pentru că un mesaj poate fi livrat de mai multe ori. Și nu tot se mută în coadă: verificarea stocului și plata, de care depinde răspunsul, rămân de obicei sincrone.

Ce urmărește intervievatorul: Verifică dacă știi motivele concrete pentru procesarea asincronă. Greșeala tipică: totul pus în coadă, inclusiv ce trebuie confirmat utilizatorului imediat.

Eroarea, în practică:Mesaje în coadă fără consumatoriComanda durează secunde: email trimis sincron

53 Junior

Care este diferența dintre o coadă point-to-point și un sistem pub/sub? Când îl alegi pe fiecare?

Răspuns scurt: Într-o coadă, fiecare mesaj e procesat de un singur consumator dintre cei disponibili: împarți munca. În pub/sub, fiecare abonat primește o copie a fiecărui mesaj: anunți un eveniment mai multor servicii interesate.

Coada (point-to-point): producătorii pun joburi, iar consumatorii concurează pentru ele. Cu 10 workeri, fiecare mesaj e preluat de exact unul. Potrivit pentru împărțirea muncii: redimensionarea pozelor, trimiterea emailurilor, generarea rapoartelor. Exemple: Amazon SQS, cozile RabbitMQ, joburile în Redis.

Pub/Sub: producătorul publică un eveniment pe un topic, iar fiecare abonat (serviciu) îl primește. Evenimentul comanda_creata ajunge la serviciul de email, la cel de facturare, la depozit și la analitică, fiecare independent. Producătorul nu știe câți abonați există, deci poți adăuga un serviciu nou fără să-l modifici. Exemple: Amazon SNS, Google Pub/Sub, exchange-urile fanout din RabbitMQ.

Combinația frecventă: pub/sub între servicii, iar în interiorul fiecărui serviciu o coadă împărțită între instanțele lui. Kafka le unește natural: un topic e citit de mai multe grupuri de consumatori (fiecare grup primește tot, ca la pub/sub), iar în interiorul unui grup partițiile se împart între instanțe (ca la o coadă).

Ce mai diferă între sisteme:

  • păstrarea: o coadă clasică șterge mesajul după confirmare; Kafka păstrează jurnalul o perioadă configurată, deci un consumator nou poate reciti istoricul;
  • ordinea: garantată doar în anumite condiții (o partiție, o coadă FIFO).

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi corect tiparul de mesagerie. Candidații confundă des „mai mulți consumatori” cu „fiecare primește tot”.

Eroarea, în practică:Doar un serviciu primește evenimentul

54 Junior

Ce garanții de livrare au sistemele de mesaje: at-most-once, at-least-once, exactly-once? Pe care o folosești de obicei?

Răspuns scurt: At-most-once: mesajul poate fi pierdut, dar nu e procesat de două ori. At-least-once: nu se pierde, dar poate fi procesat de mai multe ori. Exactly-once: o dată și numai o dată, greu de obținut cap-coadă. În practică folosești at-least-once cu consumatori idempotenți.

Diferența vine din momentul în care consumatorul confirmă mesajul (ack):

  • At-most-once: confirmi înainte de procesare. Dacă procesul pică în timpul procesării, mesajul e deja confirmat și se pierde. Potrivit pentru date unde pierderea e acceptabilă: metrici aproximative, loguri de debug.
  • At-least-once: confirmi după procesare. Dacă procesul pică după procesare, dar înainte de confirmare, mesajul revine și e procesat din nou. Nu pierzi nimic, dar ai duplicate. E modul implicit în majoritatea sistemelor (SQS, RabbitMQ cu ack manual, Kafka cu commit după procesare).
  • Exactly-once: efectul apare o singură dată. Unele sisteme o oferă în interiorul lor (de exemplu tranzacțiile Kafka, pentru citire din și scriere în Kafka), dar când procesarea atinge lumea exterioară (o bază, un email, o plată), garanția trebuie construită în aplicație.

De ce at-least-once + idempotență e alegerea standard: pierderea unui mesaj (o comandă care nu ajunge la depozit) e de obicei mai gravă decât un duplicat, iar duplicatele se pot neutraliza. Consumatorul idempotent recunoaște mesajul deja procesat după un id unic (o tabelă cu id-urile procesate, o constrângere de unicitate, o actualizare condiționată) și nu repetă efectul.

Pentru emailuri sau SMS-uri, unde nu poți „anula” un duplicat trimis, reții înainte de trimitere că mesajul e în curs și accepți că, în cazuri foarte rare, poate pleca de două ori.

Ce urmărește intervievatorul: Verifică dacă știi că duplicatele sunt normale într-un sistem cu cozi. Greșeala tipică: presupunerea că broker-ul garantează exactly-once cap-coadă.

Eroarea, în practică:Mesaj procesat de două ori (duplicate delivery)Mesaje pierdute: ack înainte de procesare

55 Junior

Ce este un dead letter queue (DLQ) și când ajunge un mesaj acolo?

Răspuns scurt: DLQ este o coadă separată în care sunt mutate mesajele care nu au putut fi procesate după un număr maxim de încercări (sau au expirat). Așa, un mesaj stricat nu blochează și nu încarcă la nesfârșit coada principală, iar echipa îl poate analiza și reprocesa.

Fără DLQ, un mesaj care eșuează mereu, de exemplu un JSON invalid sau o comandă care referă un produs șters (un „poison message”), se întoarce în coadă și e reîncercat la nesfârșit. Consumă resurse, umple logurile cu aceeași eroare și, într-o coadă ordonată, poate bloca mesajele din spatele lui.

Cum funcționează de obicei:

  • coada principală are un prag, de exemplu 5 livrări (maxReceiveCount în SQS, sau numărul de reîncercări configurat în consumator);
  • între încercări se așteaptă tot mai mult (backoff), ca erorile temporare să aibă timp să treacă;
  • după ultimul eșec, mesajul e mutat în DLQ, împreună cu motivul, dacă sistemul îl păstrează.

Ce faci cu DLQ-ul:

  • alertă când primește mesaje: fiecare mesaj acolo e o comandă, o plată sau un email care n-a fost procesat;
  • analiză: e un bug în cod, date invalide, o dependență căzută?
  • reprocesare (redrive) după reparare, mutând mesajele înapoi în coada principală, ceea ce cere consumatori idempotenți;
  • retenție: o perioadă clară, după care mesajele vechi sunt arhivate.

Distincția importantă: erorile temporare (timeout, serviciu indisponibil) merită reîncercate; erorile permanente (validare) ar trebui să meargă direct în DLQ, fără să irosească încercările.

Ce urmărește intervievatorul: Intervievatorul verifică dacă te gândești la mesajele care nu se pot procesa. Candidații uită des că un DLQ fără alertă e doar un loc unde se pierd date în tăcere.

Eroarea, în practică:Poison message: mesaj care eșuează mereu

56 Junior

Coada de comenzi crește continuu: au intrat 2.000 de mesaje pe secundă, iar workerii procesează 1.500. Cum observi asta și ce faci?

Răspuns scurt: Observi prin metricile cozii: numărul de mesaje în așteptare (backlog, consumer lag) și vechimea celui mai vechi mesaj, cu alerte. Reacționezi adăugând workeri sau mărind paralelismul, optimizând procesarea și, dacă nu ajunge, limitând sau amânând munca neesențială.

Cu 2.000 de mesaje pe secundă la intrare și 1.500 procesate, backlog-ul crește cu 500 pe secundă, adică 1,8 milioane pe oră. Coada nu se golește singură, iar întârzierea dintre plasarea comenzii și procesarea ei crește tot timpul.

Ce măsori:

  • adâncimea cozii / consumer lag (în Kafka, diferența dintre ultimul offset scris și cel procesat de grup);
  • vechimea celui mai vechi mesaj, care spune direct cât de întârziată e procesarea și e mai ușor de legat de o cerință („comenzile se procesează în cel mult 2 minute”);
  • rata de intrare și cea de procesare, ca să vezi tendința.

Ce faci:

  • scalezi workerii: autoscalare după backlog sau vechime, nu după CPU. Atenție la limita de paralelism: în Kafka, numărul de consumatori activi dintr-un grup nu poate depăși numărul de partiții;
  • cauți gâtul de sticlă din aval: dacă workerii așteaptă după baza de date sau după un API extern, mai mulți workeri doar mută problema;
  • optimizezi: procesare în loturi, mai puține apeluri pe mesaj;
  • prioritizezi: cozi separate pentru munca urgentă și cea care poate aștepta;
  • backpressure: dacă backlog-ul depășește o limită sigură, încetinești sau respingi producătorii pentru munca neesențială.

Dimensionarea corectă pornește de la vârf: capacitatea workerilor trebuie să depășească rata de intrare de la vârf, cu marjă, ca backlog-ul acumulat să se și golească.

Ce urmărește intervievatorul: Verifică dacă știi să operezi o coadă în producție. Greșeala tipică: monitorizarea doar a CPU-ului workerilor, fără metricile cozii.

Eroarea, în practică:Coada crește continuu (consumer lag)

57 Mid

Se spune des că exactly-once delivery este un mit. Ce înseamnă asta și cum obții totuși efectul „o singură dată” când procesezi mesaje?

Răspuns scurt: Pe o rețea nesigură, confirmarea se poate pierde și mesajul e retrimis, deci livrarea exact o dată nu se poate garanta. Obții efectul cu livrare at-least-once și consumatori idempotenți, care deduplică atomic, în aceeași tranzacție cu efectul.

Problema celor doi generali, în varianta practică: workerul procesează mesajul, apoi trimite confirmarea. Dacă pică între cele două, broker-ul nu știe că mesajul a fost procesat și îl retrimite. Dacă ar confirma înainte, ar putea pierde mesajul. Nu există o ordine care să le evite pe amândouă fără ajutorul consumatorului.

Soluția: efect idempotent, adică procesarea repetată a aceluiași mesaj produce același rezultat. Tehnici:

  • Tabelă de deduplicare în aceeași tranzacție cu efectul:
SQL
BEGIN;
INSERT INTO mesaje_procesate (mesaj_id) VALUES ('evt-8812');  -- cheie primară
UPDATE stoc SET cantitate = cantitate - 1 WHERE produs_id = 7;
COMMIT;

Dacă mesajul revine, INSERT eșuează pe cheia primară, tranzacția se anulează și workerul doar confirmă mesajul.

  • Operații idempotente prin natura lor: SET status = 'expediat' în loc de „incrementează”, UPSERT după un id stabil.
  • Actualizări condiționate: UPDATE ... WHERE versiune = 4.
  • Chei de idempotență trimise mai departe către API-urile externe care le acceptă (procesatorii de plăți au de obicei un astfel de antet).

Ce numește Kafka „exactly-once semantics” acoperă citirea și scrierea în Kafka în aceeași tranzacție; când efectul e într-o bază sau într-un serviciu extern, ai nevoie tot de tehnicile de mai sus. La interviu, formularea corectă este „at-least-once delivery cu procesare idempotentă”.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi limita fundamentală și soluția practică. Candidații promit des „exactly-once” doar pentru că broker-ul are o opțiune cu acest nume.

Eroarea, în practică:Mesaj procesat de două ori (duplicate delivery)SQS: visibility timeout prea scurt

58 Mid

Serviciul salvează comanda în baza de date și apoi publică un eveniment în Kafka. Uneori comanda există, dar evenimentul lipsește. De ce și cum rezolvă pattern-ul outbox problema?

Răspuns scurt: Sunt două scrieri în sisteme diferite, fără tranzacție comună (dual write): dacă procesul pică între ele, rămâi cu una singură. În outbox, evenimentul intră într-o tabelă din aceeași bază și tranzacție, iar un proces separat îl publică în Kafka.

Scenariul cu dual write:

1. INSERT comanda în bază   -> commit reușit
2. publish "comanda_creata" -> procesul e oprit de un deploy chiar aici

Comanda există, dar depozitul și emailul nu află niciodată de ea. Inversarea ordinii nu ajută: atunci poți publica un eveniment pentru o comandă al cărei commit a eșuat.

Outbox:

SQL
BEGIN;
INSERT INTO comenzi (id, client_id, total) VALUES (9001, 42, 350);
INSERT INTO outbox (id, tip, payload)
VALUES ('evt-9001', 'comanda_creata', '{"comanda_id": 9001}');
COMMIT;

Ambele scrieri sunt în aceeași tranzacție locală, deci apar amândouă sau niciuna. Un relay separat publică mesajele din outbox:

  • prin polling: citește rândurile nepublicate, le publică, le marchează ca publicate;
  • prin CDC: citește jurnalul bazei (de exemplu cu Debezium) și transformă inserările din outbox în mesaje.

Relay-ul poate publica un mesaj de două ori (pică după publicare, înainte de marcare), deci consumatorii trebuie să fie idempotenți, cu deduplicare după id-ul evenimentului. Ordinea se păstrează publicând în ordinea din tabelă, pe partiții după agregat (de exemplu comanda).

Pattern-ul invers, inbox, protejează consumatorul: mesajul primit e scris într-o tabelă de deduplicare în aceeași tranzacție cu efectul lui. Outbox-ul este baza fiabilă pentru saga și pentru orice arhitectură bazată pe evenimente.

Ce urmărește intervievatorul: Verifică dacă recunoști problema scrierilor duble și soluția standard. Candidații propun des un retry la publicare, care nu acoperă căderea procesului.

59 Mid

Cum păstrezi ordinea mesajelor (de exemplu creat, plătit, expediat pentru aceeași comandă) când ai mai mulți consumatori în paralel?

Răspuns scurt: Garantezi ordinea doar acolo unde contează: per cheie. Trimiți toate mesajele aceleiași comenzi în aceeași partiție (cheia mesajului = id-ul comenzii), iar fiecare partiție e procesată de un singur consumator, în ordine. Ordinea globală între comenzi diferite nu e necesară și ar elimina paralelismul.

Ordinea globală pe tot sistemul înseamnă un singur consumator, adică fără scalare. Aproape niciodată nu ai nevoie de ea: contează ca evenimentele aceleiași comenzi să fie procesate în ordine, nu ca o comandă de la 10:00 să fie procesată înaintea uneia de la 10:01.

Cum se face:

  • Kafka: producătorul trimite mesajul cu cheia comanda_id. Mesajele cu aceeași cheie ajung în aceeași partiție, iar o partiție e citită de un singur consumator din grup, în ordine. Paralelismul vine din numărul de partiții.
  • SQS FIFO: câmpul MessageGroupId = id-ul comenzii; ordinea e păstrată în cadrul grupului.
  • RabbitMQ: cozi separate sau consistent hashing exchange, cu un consumator pe coadă.

Capcanele:

  • reîncercările: dacă mesajul 1 eșuează și e mutat la sfârșit sau într-o coadă de retry, mesajul 2 poate fi procesat înaintea lui. Într-o partiție ordonată, un mesaj blocat oprește toată partiția, deci ai nevoie de o strategie pentru mesajele care eșuează mereu;
  • producătorii multipli pentru aceeași cheie pot trimite în altă ordine decât cea a evenimentelor reale;
  • schimbarea numărului de partiții mută cheile pe alte partiții și poate strica ordinea temporar.

Complementar, consumatorul poate fi tolerant: fiecare eveniment are o versiune sau un număr de secvență, iar evenimentele vechi sosite după cele noi sunt ignorate (expediat nu se întoarce la plătit).

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că ordinea se garantează per cheie. Greșeala tipică: un singur consumator pentru tot sistemul, „ca să fie în ordine”.

Eroarea, în practică:Mesaje procesate în altă ordine

60 Senior

Ce este backpressure și cum îl implementezi într-un pipeline în care producătorii sunt mai rapizi decât consumatorii?

Răspuns scurt: O componentă supraîncărcată semnalează în amonte să încetinească, în loc să accepte tot și să cadă. Îl implementezi cu buffere și cozi limitate, limite de concurență, răspunsuri 429 sau 503 cu Retry-After și consumatori care trag munca în ritmul lor.

Fără backpressure, diferența dintre producție și consum se acumulează undeva: în memorie (până la OutOfMemory), în cozi nelimitate (cu latență care crește la infinit) sau în conexiuni deschise (până la epuizarea resurselor). Sistemul cade nu la vârf, ci la câteva minute după.

Mecanisme, de la interior spre exterior:

  • Buffere limitate: o coadă internă cu capacitate fixă. Când e plină, producătorul se blochează, primește o eroare sau mesajul e aruncat după o regulă explicită.
  • Model pull: consumatorii cer munca atunci când au capacitate (Kafka, SQS, fluxurile reactive cu request(n)), în loc ca producătorul să împingă oricât.
  • Limite de concurență: un serviciu acceptă cel mult N cereri în paralel; restul așteaptă puțin sau sunt respinse rapid. Limitele adaptive (de tipul celor inspirate de controlul congestiei TCP) ajustează N după latență.
  • Respingere explicită la margine: API-ul răspunde 429 Too Many Requests sau 503 Service Unavailable cu Retry-After, iar clienții reîncearcă cu backoff și jitter.
  • Propagarea: dacă baza e lentă, serviciul din fața ei își reduce concurența, iar gateway-ul începe să respingă. Semnalul urcă până la sursă.

Ce trebuie decis de business: ce se întâmplă cu munca refuzată. Pentru metrici poți eșantiona; pentru comenzi, preferi să le accepți într-o coadă durabilă și să le procesezi mai lent; pentru cererile interactive, o eroare rapidă e mai bună decât un timeout după 30 de secunde.

Ce urmărește intervievatorul: Verifică dacă știi să protejezi un sistem de propria lui încărcare. Candidații propun des cozi nelimitate, care doar amână căderea.

Eroarea, în practică:429 de la API-ul unui furnizor externCoada crește continuu (consumer lag)

61 Senior

O comandă trebuie să rezerve stocul, să încaseze plata și să programeze livrarea, fiecare în alt serviciu cu baza lui. Cum asiguri că nu rămâi cu plata încasată și fără stoc? Explică pattern-ul saga.

Răspuns scurt: Saga împarte operația în pași locali, fiecare cu o acțiune de compensare. Dacă un pas eșuează, rulezi compensările pașilor deja făcuți în ordine inversă: eliberezi stocul, returnezi plata. Pașii sunt coordonați fie de un orchestrator central, fie prin evenimente (coregrafie).

Fără tranzacție distribuită, nu poți face cele trei modificări atomic. Saga acceptă inconsistența temporară, dar garantează că sistemul ajunge fie la final, fie la o stare compensată.

Pașii și compensările:

1. Stoc:   rezervă produsele        | compensare: eliberează rezervarea
2. Plăți:  încasează suma           | compensare: rambursează
3. Livrare: programează curierul    | (ultimul pas; dacă eșuează, compensezi 2 și 1)

Două stiluri:

  • Orchestrare: un serviciu (sau un motor de workflow ca Temporal) ține starea comenzii, cheamă pe rând pașii și decide compensările. Fluxul e vizibil într-un singur loc, ușor de urmărit și de modificat.
  • Coregrafie: fiecare serviciu reacționează la evenimente (stoc_rezervat declanșează plata, plata_esuata declanșează eliberarea stocului). Mai decuplat, dar fluxul e împrăștiat și greu de înțeles când crește.

Detalii care arată experiență:

  • ordinea pașilor contează: pune primii pașii ușor de compensat (o rezervare se anulează ușor) și ultimii pe cei greu de compensat (un email nu se poate „retrage”);
  • fiecare pas și fiecare compensare sunt idempotente și reîncercabile, pentru că mesajele se pot repeta;
  • compensarea nu e un rollback: rambursarea apare în extras, deci e o acțiune de business vizibilă;
  • starea saga se persistă (și se publică prin outbox), ca o cădere a orchestratorului să nu o lase la jumătate;
  • utilizatorul vede stări intermediare („comandă în procesare”), nu un răspuns sincron final.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să gestionezi consistența între microservicii. Greșeala tipică este presupunerea că o tranzacție poate cuprinde mai multe servicii.

API-uri și microservicii

62 Junior

Ce este un API gateway și ce responsabilități îi dai? Ce nu ar trebui să facă?

Răspuns scurt: Punctul unic de intrare spre servicii: rutează, verifică autentificarea, aplică limite de trafic, termină TLS, colectează metrici și loguri. Nu conține logică de business, altfel devine un monolit ascuns de care depind toate echipele.

Într-o arhitectură cu mai multe servicii, clienții nu vor să știe că /produse e în serviciul de catalog și /comenzi în alt serviciu, pe alte adrese. Gateway-ul le oferă o singură adresă și se ocupă de preocupările comune:

  • rutarea după cale, metodă, antet sau versiune;
  • autentificarea: validează token-ul (JWT, OAuth) și transmite mai departe identitatea, ca serviciile să nu repete verificarea;
  • rate limiting și cote per client sau per cheie de API;
  • terminarea TLS, compresia, CORS;
  • observabilitate: id de corelare pe fiecare cerere, loguri de acces, metrici;
  • uneori agregare simplă sau transformări de protocol (REST spre gRPC).

Ce nu pune în gateway:

  • logică de business (calculul prețului, reguli de comandă) care ar trebui să stea în serviciul responsabil;
  • transformări complexe specifice unei echipe, care fac din fiecare schimbare o modificare a gateway-ului comun.

Gateway-ul e pe drumul tuturor cererilor, deci trebuie să fie redundant (mai multe instanțe), rapid și monitorizat atent. Exemple: Kong, Envoy, Nginx, AWS API Gateway, Spring Cloud Gateway. Când clienți diferiți (web, mobil) au nevoi foarte diferite, se pune câte un Backend for Frontend în spatele gateway-ului, nu se încarcă gateway-ul cu logica fiecăruia.

Ce urmărește intervievatorul: Verifică dacă știi rolul gateway-ului și limita lui. Candidații îl transformă des într-un loc pentru orice logică „comună”.

Eroarea, în practică:API gateway supraîncărcat la vârfAPI fără autentificare la gateway

63 Junior

Utilizatorii trebuie să vadă notificări noi fără să dea refresh. Compară polling, long polling, Server-Sent Events și WebSocket.

Răspuns scurt: Polling: clientul întreabă periodic, simplu, dar irosește cereri și are întârziere. Long polling: serverul ține cererea deschisă până apare ceva. SSE: o conexiune HTTP deschisă prin care serverul trimite evenimente într-un singur sens. WebSocket: conexiune bidirecțională persistentă, potrivită pentru chat și jocuri.

Polling scurt: clientul trimite GET /notificari?dupa=123 la fiecare 10 secunde. Simplu și compatibil cu orice infrastructură, dar majoritatea răspunsurilor sunt goale, iar întârzierea medie e jumătate din interval. Bun pentru actualizări rare.

Long polling: serverul nu răspunde imediat; ține cererea până apare o notificare sau expiră un timeout (de exemplu 30 de secunde), apoi clientul deschide imediat alta. Latență mică, funcționează prin proxy-uri obișnuite, dar fiecare client ține o conexiune ocupată și fiecare mesaj costă o cerere nouă.

Server-Sent Events (SSE): clientul deschide o conexiune HTTP (EventSource în browser), iar serverul trimite evenimente text pe ea, oricând. Reconectarea automată și id-ul ultimului eveniment sunt incluse în standard. Doar server spre client, ceea ce e suficient pentru notificări, scoruri live, progresul unui job.

WebSocket: după un handshake HTTP, conexiunea devine un canal bidirecțional, cu mesaje în ambele sensuri. Potrivit pentru chat, colaborare în timp real, jocuri. Mai complex: conexiuni de lungă durată pe servere (limite de conexiuni deschise), load balancere care trebuie să le suporte, reconectare și reluarea mesajelor pierdute implementate de tine.

Consecința comună pentru SSE și WebSocket: serverul care ține conexiunea trebuie să afle de evenimente generate în altă parte, deci ai nevoie de un pub/sub intern (Redis Pub/Sub, Kafka) prin care orice server poate livra mesajul clientului conectat la el.

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi mecanismul după cerință. Greșeala tipică: WebSocket peste tot, inclusiv pentru actualizări rare și unidirecționale.

64 Junior

Pornești un produs nou cu o echipă de 5 oameni. Monolit sau microservicii? Cum argumentezi la interviu?

Răspuns scurt: De obicei un monolit modular: o aplicație, o bază, module bine separate în cod. Microserviciile aduc deploy independent și scalare separată, dar costă infrastructură, observabilitate și apeluri prin rețea. Extragi un serviciu când ai un motiv concret.

Argumentele pentru monolit la început:

  • viteză: o singură aplicație de construit, testat și pus în producție;
  • tranzacții simple: o comandă și stocul ei se modifică într-o singură tranzacție, fără saga;
  • refactorizare ușoară: granițele dintre module se pot muta cât timp domeniul încă se clarifică;
  • operare simplă: un singur set de loguri, metrici și alerte, fără rețea între componente.

Ce aduc microserviciile și când merită:

  • deploy independent: echipe separate pot livra fără să se coordoneze, util când ai multe echipe pe același produs;
  • scalare diferențiată: procesarea video are nevoie de alte resurse decât API-ul de catalog;
  • izolarea defectelor și a tehnologiilor: un serviciu poate fi scris altfel sau poate cădea fără să oprească tot.

Costurile microserviciilor: apeluri prin rețea (latență, eșecuri parțiale), consistență între baze, observabilitate distribuită, versionarea contractelor, mai multă infrastructură.

Răspunsul matur: monolit modular, cu granițe clare între module (fiecare cu tabelele lui, comunicare prin interfețe, nu prin acces direct la datele altuia). Când o parte are nevoi diferite de scalare sau o echipă separată, o extragi ca serviciu. Granițele bine trasate fac extragerea mult mai ușoară.

Ce urmărește intervievatorul: Verifică judecata tehnică, nu entuziasmul pentru tehnologii. Candidații aleg des microservicii pentru orice, fără să vorbească despre costuri.

65 Junior

Într-o arhitectură cu microservicii, cum află serviciul de comenzi adresa serviciului de plăți, dacă instanțele apar și dispar dinamic?

Răspuns scurt: Prin service discovery: instanțele se înregistrează într-un registru (Consul, Eureka, etcd sau registrul Kubernetes) și sunt scoase la căderea health check-ului. Apelantul folosește un nume stabil, rezolvat fie de un load balancer sau de DNS-ul intern (server-side), fie de o bibliotecă din client (client-side).

Adresele IP fixe în configurație nu funcționează când instanțele pornesc și se opresc prin autoscalare sau deploy. Ai nevoie de o sursă de adevăr actualizată.

Componentele:

  • Registrul de servicii: ține lista instanțelor sănătoase pentru fiecare serviciu. Instanța se înregistrează la pornire (sau o înregistrează platforma) și e scoasă când nu mai trece health check-ul ori nu mai trimite semnale.
  • Descoperirea server-side: apelantul trimite cererea la un nume stabil (plati.intern) sau la un load balancer intern, care alege o instanță. În Kubernetes, un Service are un nume DNS stabil (plati.default.svc.cluster.local) și o adresă virtuală, iar platforma distribuie cererile pe pod-urile gata.
  • Descoperirea client-side: clientul citește lista din registru și alege singur instanța (bibliotecile Netflix, gRPC cu load balancing în client). Elimină un salt în rețea, dar fiecare limbaj are nevoie de bibliotecă.
  • Service mesh (Istio, Linkerd): un proxy lângă fiecare instanță (sidecar) face descoperirea, echilibrarea, reîncercările și TLS-ul mutual, fără cod în aplicație.

Detalii utile: DNS-ul are cache, deci clienții trebuie să respecte TTL-uri mici; o instanță nouă intră în rotație doar după ce trece verificarea de „gata” (readiness); la oprire, instanța e scoasă din registru înainte să se închidă, ca cererile în curs să se termine.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi cum se găsesc serviciile într-un mediu dinamic. Candidații pun des adrese hardcodate sau uită de health checks.

66 Mid

Proiectează API-ul unui URL shortener: endpoint-uri, coduri de status, erori. Ce cod HTTP folosești la redirecționare și de ce?

Răspuns scurt: POST /api/linkuri creează un link (201 cu codul scurt), GET /{cod} redirecționează, GET /api/linkuri/{cod} dă detaliile, DELETE îl dezactivează. La redirecționare alegi 302 dacă vrei să numeri fiecare click și să poți schimba destinația, sau 301 dacă vrei ca browserele să păstreze redirecționarea în cache.

Un API minimal:

POST   /api/linkuri          {"url": "https://...", "alias": "oferta", "expira": "2026-12-31"}
       201 Created           {"cod": "oferta", "scurt": "https://scurt.ro/oferta"}
       400 Bad Request       URL invalid sau alias cu caractere nepermise
       409 Conflict          aliasul e deja folosit
       429 Too Many Requests prea multe linkuri create de același client

GET    /{cod}                302 Found + Location: https://destinatie
       404 Not Found         cod inexistent
       410 Gone              link expirat sau dezactivat

GET    /api/linkuri/{cod}    200 OK cu destinația, data creării, numărul de click-uri
DELETE /api/linkuri/{cod}    204 No Content (doar proprietarul; altfel 403)

Alegerea dintre 301 și 302:

  • 301 Moved Permanently: browserul (și uneori proxy-urile) păstrează redirecționarea. La al doilea click nu mai ajunge la tine: încărcare mai mică, dar pierzi statisticile și nu mai poți schimba destinația pentru cei care au redirecționarea în cache.
  • 302 Found (sau 307): fiecare click trece prin serviciu, deci îl poți număra, poți aplica expirarea și poți schimba destinația.

Alte decizii de menționat: crearea de linkuri cere autentificare sau limite stricte (altfel serviciul devine unealtă de spam), destinațiile se verifică pe liste de domenii periculoase, iar redirecționarea, endpoint-ul cu cel mai mult trafic, trebuie să fie simplă și servită din cache.

Ce urmărește intervievatorul: Verifică dacă știi să proiectezi un API concret, cu erorile lui, și dacă vezi impactul codului de status asupra arhitecturii.

67 Mid

Aplicația mobilă, site-ul și un partener extern folosesc același API, dar fiecare are nevoie de alte date și alt format. Ce este pattern-ul Backend for Frontend și când îl folosești?

Răspuns scurt: BFF înseamnă câte un strat de backend dedicat fiecărui tip de client, care agregă și adaptează datele din serviciile comune exact pentru ecranele acelui client. Îl folosești când clienții au nevoi foarte diferite, iar un API generic forțează fie multe apeluri, fie răspunsuri umflate.

Cu un singur API generic, apar două probleme. Aplicația mobilă are nevoie, pentru ecranul principal, de date din 5 servicii, deci face 5 apeluri pe o rețea mobilă lentă. Site-ul are nevoie de câmpuri pe care mobilul nu le folosește, deci răspunsurile cresc pentru toți. Orice schimbare cerută de un client riscă să-i strice pe ceilalți.

Cu BFF:

aplicație mobilă -> BFF mobil   \
site web         -> BFF web      -> servicii: catalog, coș, recomandări, utilizatori
parteneri        -> API public  /
  • BFF-ul mobil expune GET /ecran-principal, care cheamă în paralel serviciile, combină rezultatele și întoarce exact câmpurile afișate, eventual comprimate.
  • E de obicei întreținut de echipa clientului respectiv, deci poate evolua în ritmul aplicației.
  • API-ul public pentru parteneri rămâne stabil, versionat și documentat, fără să fie influențat de schimbările din ecranele interne.

Riscuri:

  • duplicarea logicii între BFF-uri; regula este ca BFF-ul să conțină doar agregare și adaptare, nu reguli de business;
  • încă o componentă pe drumul cererii, cu propria latență și disponibilitate;
  • prea multe BFF-uri pentru diferențe mici.

Alternativa des comparată este GraphQL, unde clientul cere exact câmpurile dorite dintr-un singur endpoint; ea rezolvă problema câmpurilor, dar mută complexitatea în server (costul interogărilor, cache-ul).

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să adaptezi arhitectura la clienți diferiți fără să strici API-ul comun.

68 Mid

O cerere a utilizatorului trece sincron prin 6 microservicii, unul după altul. Ce probleme apar și cum le reduci?

Răspuns scurt: Latențele se adună, disponibilitățile se înmulțesc (6 servicii de 99,9% dau aproximativ 99,4%), iar un serviciu lent blochează fire și conexiuni în toate serviciile din amonte. Reduci lanțul (apeluri în paralel, date replicate local, evenimente asincrone) și protejezi fiecare apel cu timeout-uri dintr-un buget comun.

Problemele unui lanț lung:

  • Latența cumulată: 6 servicii a câte 30 ms înseamnă cel puțin 180 ms, plus rețea, iar percentilele mari se adună și mai rău.
  • Disponibilitatea în serie: dacă fiecare are 99,9%, lanțul are aproximativ 0,999^6 ≈ 99,4%, adică de câteva ori mai mult timp de nefuncționare decât fiecare serviciu.
  • Defecte în cascadă: dacă ultimul serviciu devine lent, fiecare serviciu din amonte ține cereri deschise, își umple pool-urile de fire și conexiuni și devine lent la rândul lui.
  • Depanare grea: fără tracing distribuit, nu știi unde s-au pierdut cele 2 secunde.

Cum reduci problema:

  • scurtezi lanțul: dacă serviciul A cheamă B doar ca să afle numele produsului, A poate păstra o copie locală, actualizată prin evenimente;
  • paralelizezi apelurile independente în loc să le înșiri;
  • asincron pentru ce nu e necesar în răspuns (notificări, statistici);
  • buget de timp (deadline): cererea are un termen total (de exemplu 800 ms), transmis mai departe; fiecare serviciu știe cât timp mai are și renunță dacă nu mai are rost;
  • degradare elegantă: dacă recomandările nu răspund, pagina se afișează fără ele;
  • bulkhead-uri: pool-uri separate de conexiuni pentru fiecare dependență, ca una lentă să nu le blocheze pe celelalte.

La interviu, un desen cu lanțuri sincrone lungi e un semnal că granițele dintre servicii trebuie regândite.

Ce urmărește intervievatorul: Verifică dacă înțelegi costul cumulat al apelurilor sincrone. Candidații desenează des lanțuri lungi fără să calculeze latența și disponibilitatea.

Eroarea, în practică:504 Gateway Timeoutupstream timed out while reading response header

69 Senior

Cum ai împărți un monolit mare în microservicii? După ce criterii alegi granițele și în ce ordine extragi serviciile?

Răspuns scurt: Granițele urmează domeniul de business și proprietatea datelor (bounded contexts), nu straturile tehnice. Extragi treptat, cu pattern-ul strangler fig: un proxy trimite o parte din trafic la serviciul nou, începi cu o zonă cu valoare mare și dependențe puține, iar fiecare serviciu primește propria bază.

Criterii pentru granițe:

  • Domeniul: catalog, coș, comenzi, plăți, livrare, utilizatori sunt contexte diferite, cu limbaj și reguli proprii. Un serviciu „de bază de date” sau „de validare” e o graniță tehnică proastă.
  • Proprietatea datelor: fiecare serviciu deține tabelele lui; nimeni altcineva nu scrie direct în ele. Dacă două părți modifică mereu aceleași date în aceeași tranzacție, probabil sunt același serviciu.
  • Ritmul schimbărilor și echipele: părțile care se schimbă des și au o echipă dedicată câștigă cel mai mult din deploy independent.
  • Nevoile de scalare: o componentă cu profil diferit (procesare media) e un candidat natural.

Ordinea și tehnica:

  • pornești cu o zonă cu dependențe puține și beneficiu clar, nu cu nucleul cel mai încâlcit;
  • strangler fig: un proxy sau gateway în fața monolitului trimite rutele migrate la serviciul nou; restul merg tot la monolit;
  • întâi separi codul în module în monolit, apoi datele (tabelele modulului devin private), apoi le muți fizic;
  • în perioada de tranziție, datele se sincronizează prin evenimente sau CDC, iar comparația dintre vechi și nou (rulare în umbră) dă încredere;
  • infrastructura comună (CI/CD, observabilitate, logare, tracing) trebuie să existe înainte de al doilea serviciu.

Semne că granițele sunt greșite: fiecare funcționalitate atinge mai multe servicii, apar apeluri sincrone circulare, deploy-urile trebuie coordonate. Atunci ai obținut un „monolit distribuit”, mai rău decât cel inițial.

Ce urmărește intervievatorul: Intervievatorul verifică experiența de arhitectură pe termen lung. Greșeala tipică: împărțirea după straturi tehnice sau o rescriere completă dintr-odată.

Disponibilitate, observabilitate și securitate

70 Junior

Cât timp de nefuncționare pe an înseamnă 99%, 99,9%, 99,99% și 99,999% disponibilitate?

Răspuns scurt: Aproximativ: 99% înseamnă 3,65 zile pe an, 99,9% înseamnă 8,76 ore, 99,99% aproximativ 52,6 minute, iar 99,999% aproximativ 5,26 minute. Fiecare „9” în plus reduce timpul permis de 10 ori și crește mult costul.

Calculul pornește de la un an de 365 de zile, adică 8.760 de ore:

99%      -> 1% × 8.760 h      = 87,6 h ≈ 3,65 zile pe an  (≈ 7,2 h pe lună)
99,9%    -> 0,1% × 8.760 h    = 8,76 h pe an              (≈ 43,8 min pe lună)
99,99%   -> 0,01% × 525.600 min ≈ 52,6 min pe an          (≈ 4,4 min pe lună)
99,999%  -> ≈ 5,26 min pe an                              (≈ 26 s pe lună)

Ce înseamnă pentru design:

  • 99,9% se poate atinge cu redundanță simplă (mai multe instanțe, bază cu failover), dar un deploy prost sau o migrare care durează o oră consumă bugetul pe un trimestru.
  • 99,99% cere failover automat (o intervenție manuală durează de obicei mai mult de câteva minute), deploy-uri fără oprire, mai multe zone de disponibilitate.
  • 99,999% cere redundanță în mai multe regiuni, automatizare completă și un proces de operare matur; e scump și rar justificat.

Două observații importante: disponibilitatea percepută de utilizator e a întregului lanț (inclusiv DNS, CDN, servicii externe), iar mentenanța planificată contează și ea, dacă nu e exclusă explicit din acord. La interviu, când primești o cerință de disponibilitate, transform-o în minute pe lună și explică ce mecanisme o fac posibilă.

Ce urmărește intervievatorul: Verifică dacă poți transforma procentele în timp concret. Candidații spun des „five nines” fără să știe ce înseamnă în minute.

Eroarea, în practică:Disponibilitate sub SLA

71 Junior

Ce este un punct unic de eșec (SPOF) și cum îl găsești într-o diagramă de arhitectură?

Răspuns scurt: O componentă a cărei cădere oprește sistemul sau o funcție importantă. Îl găsești întrebând, pentru fiecare componentă, „dacă pică asta, mai merg cererile?”: o singură instanță, o bază fără rezervă, un load balancer unic, un furnizor extern fără alternativă.

Metoda practică: urmărești drumul fiecărui tip de cerere (citire, scriere, upload, plată) prin diagramă și, la fiecare componentă, presupui că a dispărut.

SPOF-uri frecvente:

  • un singur server de aplicație;
  • baza de date primară fără replică de rezervă și fără failover;
  • un singur load balancer sau gateway;
  • un cache de care aplicația depinde obligatoriu (de exemplu sesiunile sunt doar acolo);
  • o coadă cu un singur broker;
  • un job cron care rulează doar pe o anumită mașină;
  • o singură zonă de disponibilitate sau o singură regiune;
  • dependențe externe: un singur furnizor de plăți, de email, de DNS;
  • certificate, chei sau domenii care expiră, gestionate manual.

Cum le elimini:

  • redundanță: cel puțin două instanțe, în zone diferite, cu health checks și failover automat;
  • degradare: dacă recomandările pică, pagina merge fără ele; componenta rămâne singulară, dar nu mai e critică;
  • alternative: un al doilea furnizor de email sau SMS.

Atenție la redundanța falsă: două servere care depind de același disc, de aceeași sursă de alimentare sau de același fișier de configurare au tot un SPOF comun. Iar redundanța trebuie să aibă și capacitate: dacă un server pică și celălalt nu poate duce singur tot traficul, ai evitat SPOF-ul doar pe hârtie.

Ce urmărește intervievatorul: Intervievatorul verifică dacă îți analizezi critic propriul design. Greșeala tipică: identificarea SPOF-ului doar la servere, nu și la bază, DNS sau servicii externe.

Eroarea, în practică:Rate limiter-ul a devenit punct unic de eșecBrokerul de mesaje unic a căzut

72 Junior

Care este diferența dintre SLI, SLO și SLA? Dă un exemplu pentru un API de comenzi.

Răspuns scurt: SLI este metrica măsurată (procentul de cereri reușite sub 300 ms). SLO este ținta internă pentru ea (99,9% pe 30 de zile). SLA este angajamentul contractual față de clienți, de obicei mai relaxat decât SLO-ul, cu penalizări dacă e încălcat.

  • SLI (Service Level Indicator): ce măsori efectiv. Pentru API-ul de comenzi: „procentul de cereri POST /comenzi care au primit un răspuns non-5xx în sub 500 ms”, măsurat la load balancer.
  • SLO (Service Level Objective): ținta pentru SLI pe o perioadă: „99,9% din cereri, pe o fereastră glisantă de 30 de zile”. E o decizie internă a echipei, împreună cu produsul.
  • SLA (Service Level Agreement): promisiunea scrisă către clienți, cu consecințe: „99,5% disponibilitate lunară, altfel credit de 10% din abonament”. E intenționat mai relaxat decât SLO-ul, ca echipa să aibă timp să reacționeze înainte de a încălca contractul.

Din SLO decurge bugetul de erori: la 99,9%, 0,1% din cereri pot eșua într-o lună. Dacă bugetul e aproape consumat, echipa amână lansările riscante și se ocupă de stabilitate; dacă e intact, își poate permite să livreze mai repede.

Sfaturi practice:

  • măsoară SLI-ul cât mai aproape de utilizator (la intrare, nu doar în aplicație), altfel o cădere a load balancer-ului nu se vede;
  • alege puține SLO-uri, pentru ce contează utilizatorilor: disponibilitate, latență, uneori corectitudine sau prospețimea datelor;
  • 100% nu e o țintă realistă: fiecare dependență are propriile căderi, iar costul tinde la infinit.

Ce urmărește intervievatorul: Verifică dacă folosești corect vocabularul de fiabilitate. Candidații confundă des SLA cu SLO sau nu știu ce e bugetul de erori.

Eroarea, în practică:Disponibilitate sub SLAMonitorizare fără alerte

73 Junior

Cum calculezi disponibilitatea a două componente legate în serie și a două componente redundante în paralel?

Răspuns scurt: În serie, cererea are nevoie de ambele, deci disponibilitățile se înmulțesc: 99,9% × 99,9% ≈ 99,8%. În paralel, sistemul cade doar dacă pică ambele: 1 − (1 − 0,999)² = 99,9999%, presupunând căderi independente și failover instantaneu.

Serie (aplicația depinde de server și de bază):

A = A1 × A2
  = 0,999 × 0,999 ≈ 0,998  -> 99,8%

Fiecare componentă în plus pe drumul cererii scade disponibilitatea totală. Un lanț de 5 componente de 99,9% are aproximativ 99,5%.

Paralel (două instanțe identice în spatele unui load balancer cu health checks):

A = 1 - (1 - A1) × (1 - A2)
  = 1 - 0,001 × 0,001 = 0,999999  -> 99,9999%

Combinat: un load balancer de 99,99%, două servere în paralel de 99,5% fiecare și o bază de 99,9%:

servere: 1 - 0,005² = 0,999975
total:   0,9999 × 0,999975 × 0,999 ≈ 0,99887  -> ≈ 99,89%

Concluzia: baza de date, singura componentă fără redundanță, domină rezultatul. Ca să urci, îi dai bazei replică de rezervă.

Limitele calculului, pe care le menționezi la interviu:

  • presupune căderi independente; în realitate, un deploy prost sau o zonă căzută lovește toate instanțele deodată;
  • presupune că failover-ul e instantaneu și reușește mereu;
  • ignoră capacitatea: dacă o instanță rămasă nu poate duce traficul, cererile se pierd chiar dacă „e disponibilă”.

Calculul e util ca ordin de mărime și pentru a găsi componenta care limitează sistemul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să cuantifici efectul redundanței. Greșeala tipică: adunarea procentelor sau ignorarea faptului că serie înseamnă înmulțire.

Eroarea, în practică:Disponibilitate sub SLA

74 Junior

Ce algoritmi de rate limiting cunoști și cum se comportă fiecare la o rafală de cereri?

Răspuns scurt: Fixed window numără cererile pe ferestre fixe (simplu, dar permite dublul limitei la granița ferestrelor). Sliding window netezește granița. Token bucket permite rafale până la capacitatea găleții și apoi o rată medie. Leaky bucket procesează cererile la o rată constantă, netezind complet rafalele.

  • Fixed window counter: un contor pe minut („cel mult 100 de cereri între 10:00:00 și 10:00:59”). Simplu și ieftin (un INCR cu expirare în Redis). Problema: 100 de cereri la 10:00:59 și alte 100 la 10:01:00 înseamnă 200 în două secunde.
  • Sliding window log: păstrezi momentul fiecărei cereri și numeri câte sunt în ultimele 60 de secunde. Exact, dar memoria crește cu numărul de cereri.
  • Sliding window counter: aproximare care combină contorul ferestrei curente cu o parte din cel al ferestrei anterioare, ponderată după cât din ea se suprapune. Precis suficient și ieftin.
  • Token bucket: o găleată cu capacitate C se reumple cu R jetoane pe secundă; fiecare cerere consumă un jeton. Permite rafale scurte (până la C), apoi limitează la R în medie. Potrivit pentru API-uri, unde clienții legitimi au rafale naturale.
  • Leaky bucket: cererile intră într-o coadă care se golește la rată constantă. Ieșirea e perfect netedă, potrivită pentru protejarea unui sistem care nu tolerează vârfuri (un furnizor extern cu limită strictă), dar adaugă latență.
PYTHON
def permite(bucket, acum, capacitate=20, rata=5):
    bucket.jetoane = min(capacitate, bucket.jetoane + (acum - bucket.ultima) * rata)
    bucket.ultima = acum
    if bucket.jetoane >= 1:
        bucket.jetoane -= 1
        return True
    return False

Cererile respinse primesc 429 Too Many Requests, ideal cu antetul Retry-After.

Ce urmărește intervievatorul: Verifică dacă știi diferențele de comportament dintre algoritmi. Candidații cunosc des doar fereastra fixă și nu-i văd problema de la graniță.

Eroarea, în practică:429 Too Many RequestsRobot care supraîncarcă serverele

75 Mid

Ce monitorizezi pentru un serviciu web în producție? Care sunt cei trei piloni ai observabilității și ce alerte pui?

Răspuns scurt: Metrici, loguri și trasee distribuite (traces). Pentru serviciul web urmărești semnalele de aur: latența, traficul, erorile și saturarea. Alertele se pun pe simptome văzute de utilizator (rata de erori, latența p99, consumul bugetului de erori), nu pe fiecare cauză posibilă.

Metrici: serii numerice agregate, ieftine de stocat și de interogat, bune pentru dashboard-uri și alerte. Exemple: cereri pe secundă, procentul de 5xx, histograma latenței, CPU, memoria, conexiunile din pool, adâncimea cozii.

Loguri: evenimente detaliate, de preferat structurate (JSON), cu un id de corelare al cererii. Bune pentru a afla ce s-a întâmplat exact cu o cerere.

Trasee distribuite: o cerere primește un trace id propagat prin toate serviciile, iar fiecare serviciu raportează segmentul lui (span). Arată unde s-a pierdut timpul într-un lanț de servicii. Standardul comun este OpenTelemetry.

Cele patru semnale de aur (din cartea SRE de la Google):

  • latența (pe percentile, separat pentru cererile reușite și eșuate);
  • traficul (cereri pe secundă);
  • erorile (rata de 5xx, dar și răspunsurile greșite);
  • saturarea (cât de aproape e de limită: CPU, memorie, pool de conexiuni, cozi).

Alerte bune:

  • pe simptome: „rata de erori peste 1% timp de 5 minute”, „p99 peste 1 s”, „bugetul de erori se consumă de 10 ori mai repede decât normal”;
  • pe saturare iminentă: discul la 85%, certificatul care expiră în 14 zile;
  • fiecare alertă are un responsabil și o acțiune; o alertă care nu cere acțiune devine zgomot și ajunge ignorată.

Cauzele (CPU-ul unui nod, o eroare izolată) se urmăresc în dashboard-uri, fără să trezească pe nimeni noaptea.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să operezi ce proiectezi. Greșeala tipică: alerte pe CPU pentru fiecare mașină, fără alerte pe ce simte utilizatorul.

Eroarea, în practică:Fără monitorizare: aflăm de la cliențiMonitorizare fără alerte

76 Mid

Sistemul primește de trei ori mai mult trafic decât poate duce. Ce este load shedding și cum decizi ce cereri arunci?

Răspuns scurt: Respingi intenționat și rapid o parte din cereri, ca restul să fie servite bine, în loc ca toate să devină lente și să expire. Păstrezi plățile, checkout-ul și utilizatorii logați; respingi întâi traficul de fundal, roboții și funcțiile neesențiale.

Fără protecție, un sistem supraîncărcat intră într-o spirală: cozile cresc, latența crește, clienții dau timeout și reîncearcă, ceea ce adaugă și mai mult trafic. La final nicio cerere nu mai e servită în timp util, deși serverul lucrează la capacitate maximă. Este mai bine să servești corect 30% din cereri decât greșit pe toate.

Cum funcționează:

  • detecția supraîncărcării: concurența în curs peste o limită, latența cozii interne, CPU-ul sau timpul petrecut de cerere în așteptare;
  • respingerea rapidă: 503 Service Unavailable sau 429 cu Retry-After, înainte de a consuma resurse (fără interogări în bază, fără apeluri în aval);
  • respingerea cererilor deja expirate: dacă clientul a renunțat (deadline-ul a trecut), nu mai are rost să procesezi cererea.

Criterii de prioritate:

  • critice: plata, finalizarea comenzii, autentificarea;
  • importante: navigarea utilizatorilor logați;
  • amânabile: recomandări, statistici, preîncărcări, sincronizări de fundal;
  • de aruncat primele: roboți, crawlere, clienți care depășesc cota.

Prioritatea vine dintr-un antet setat la gateway sau din ruta cererii. Pe lângă respingere, poți degrada: pagina fără recomandări, rezultate din cache mai vechi, imagini de calitate mai mică. Clienții trebuie să reîncerce cu backoff și jitter, altfel respingerile generează noi valuri.

Ce urmărește intervievatorul: Verifică dacă știi să protejezi sistemul la suprasarcină în mod controlat. Candidații se bazează des doar pe autoscalare, care nu reacționează în câteva secunde.

Eroarea, în practică:503 Service UnavailableCădere în cascadă (cascading failure)

77 Mid

Cum pui în producție o versiune nouă fără ca utilizatorii să observe? Compară rolling, blue-green și canary.

Răspuns scurt: Rolling înlocuiește instanțele pe rând; blue-green pornește un mediu nou și mută tot traficul odată, cu revenire rapidă; canary trimite întâi un procent mic din trafic și crește treptat. Toate cer compatibilitate între versiuni, mai ales la schema bazei.

Rolling update: din 10 instanțe, scoți una sau două din load balancer, le actualizezi, aștepți să treacă health check-ul, continui cu următoarele. Nu cere capacitate dublă, dar o vreme rulează ambele versiuni, iar revenirea înseamnă un alt rolling.

Blue-green: mediul „albastru” servește traficul; pornești „verde” cu versiunea nouă, îl testezi, apoi muți traficul (din load balancer sau DNS). Revenirea înseamnă mutarea traficului înapoi, în câteva secunde. Costă capacitate dublă pe durata schimbării.

Canary: 1–5% din trafic merge la versiunea nouă. Compari automat rata de erori și latența cu versiunea veche; dacă sunt bune, crești la 25%, 50%, 100%; dacă nu, oprești. O problemă afectează doar o mică parte din utilizatori.

Condiții comune pentru zero downtime:

  • oprire grațioasă: instanța se scoate din load balancer, termină cererile în curs, apoi se oprește;
  • verificarea „gata” (readiness) înainte să primească trafic;
  • compatibilitatea versiunilor: vechea și noua versiune rulează simultan, deci API-urile și mesajele trebuie să fie compatibile în ambele sensuri;
  • migrările bazei în doi pași (expand/contract): întâi adaugi coloana nouă (compatibil cu codul vechi), livrezi codul care o folosește, apoi, într-o versiune ulterioară, ștergi ce nu mai e folosit.

Feature flags completează strategia: codul nou ajunge în producție dezactivat și e pornit separat de deploy.

Ce urmărește intervievatorul: Intervievatorul verifică experiența de livrare în producție. Greșeala tipică: uitarea migrărilor de schemă, care sunt de obicei partea riscantă.

Eroarea, în practică:Site-ul cade la fiecare deploy

78 Mid

Ce măsuri de securitate de bază incluzi într-un design de sistem, chiar dacă intervievatorul nu le cere explicit?

Răspuns scurt: HTTPS peste tot (TLS la intrare și, ideal, între servicii), autentificare și autorizare centralizate, secrete într-un manager de secrete, criptarea datelor sensibile la stocare, principiul privilegiului minim, rețele private pentru baze și servicii interne, rate limiting, validarea intrărilor și audit.

O listă scurtă pe care o poți parcurge la final, legând fiecare punct de o componentă din diagramă:

  • Transportul: TLS terminat la load balancer sau gateway; pentru date sensibile, TLS și între servicii (mTLS într-un service mesh). Fără HTTP în clar pentru autentificare sau date personale.
  • Identitatea: autentificarea la gateway (OAuth 2.0 / OpenID Connect, token-uri cu durată scurtă), autorizarea în fiecare serviciu, pe resursă („poate acest utilizator să vadă comanda 9001?”), nu doar „e logat”.
  • Rețeaua: bazele, cache-urile și cozile stau în subrețele private, accesibile doar de la serviciile care au nevoie. Doar load balancer-ul e public.
  • Secretele: parolele bazelor și cheile de API în AWS Secrets Manager, Vault sau echivalent, rotite periodic; niciodată în cod sau în imagini.
  • Datele: criptare la stocare pentru baze, backup-uri și object storage; minimizarea datelor personale (GDPR); URL-uri presemnate cu termen scurt pentru fișiere private.
  • Privilegiul minim: fiecare serviciu are propriul rol, cu acces doar la resursele lui.
  • Protecția la abuz: rate limiting, protecție DDoS la CDN, validarea și limitarea mărimii intrărilor.
  • Auditul: loguri pentru acțiunile sensibile (schimbări de permisiuni, plăți, exporturi), păstrate separat și protejate la modificare.

La interviu nu ai timp să detaliezi totul, dar două minute dedicate securității la final arată că ai un model complet al sistemului.

Ce urmărește intervievatorul: Verifică dacă tratezi securitatea ca parte a designului, nu ca pe un adaos. Candidații o omit des complet sau o reduc la „folosim HTTPS”.

Eroarea, în practică:Not secure (site servit prin HTTP)Date necriptate la stocare

79 Senior

Ce sunt RPO și RTO și cum influențează alegerea strategiei de backup și de recuperare în caz de dezastru?

Răspuns scurt: RPO spune câte date ai voie să pierzi (în timp), RTO cât poate dura revenirea. Un RPO de o zi se acoperă cu backup zilnic, unul de secunde cere replicare continuă, iar un RTO de minute cere mediu de rezervă și failover automatizat.

Cele două obiective vin de la business și determină costul:

  • RPO = 0: nicio scriere confirmată nu se pierde. Cere replicare sincronă (cel puțin într-o altă zonă), cu latență mai mare la scriere.
  • RPO de secunde sau minute: replicare asincronă într-o altă regiune, plus arhivarea continuă a jurnalului bazei (point-in-time recovery).
  • RPO de ore: snapshot-uri periodice.
  • RTO de minute: mediu de rezervă activ sau „cald” (warm standby), infrastructura descrisă ca cod, failover automatizat sau cu un singur pas manual, DNS cu TTL mic.
  • RTO de ore: „pilot light”, adică doar datele replicate și infrastructura minimă pornită, restul pornit la nevoie.
  • RTO de zile: restaurare din backup pe infrastructură nouă.

Ce diferențiază un plan real de unul pe hârtie:

  • backup-urile se testează prin restaurare, periodic și automat; un backup nerestaurat niciodată e doar o speranță;
  • backup-urile sunt izolate: alt cont, altă regiune, imutabile pentru o perioadă, ca un atac ransomware sau o ștergere accidentală să nu le atingă și pe ele;
  • replicarea nu e backup: un DELETE greșit se replică imediat, de aceea ai nevoie și de puncte de restaurare în timp;
  • exerciții periodice de recuperare (game days), cu cronometrarea RTO-ului real;
  • ordinea de pornire a serviciilor și dependențele (DNS, secrete, chei) sunt documentate.

Obiectivele diferă pe sisteme: plățile pot avea RPO aproape zero, iar statisticile pot fi refăcute din surse.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să legi cerința de business de mecanismul tehnic. Greșeala tipică: „avem replici, deci nu avem nevoie de backup”.

Eroarea, în practică:Backup netestat: restaurarea eșuează

80 Senior

Platforma ta servește mai mulți clienți (multi-tenant) pe aceleași servere. Un client începe să trimită de 50 de ori mai mult trafic și îi încetinește pe toți. Cum previi asta prin design?

Răspuns scurt: Izolezi resursele per client: cote și rate limiting per tenant, cozi și pool-uri de concurență separate (bulkhead), prioritizare corectă (fair queuing), iar clienții foarte mari primesc resurse dedicate (shard sau celulă proprie). Măsori consumul per tenant ca să vezi imediat cine generează încărcarea.

Problema „vecinului zgomotos” apare când resursele comune (CPU, conexiunile la bază, cozile, cache-ul) sunt consumate fără limită de un singur client.

Mecanisme, de la margine spre interior:

  • Cote și rate limiting per tenant la gateway, cu limite pe plan de abonament; depășirea primește 429, nu afectează pe alții.
  • Concurență limitată per tenant: chiar dacă respectă rata, un client cu cereri foarte scumpe (rapoarte uriașe) poate ține ocupate serverele. Limitezi numărul de cereri simultane per client.
  • Fair queuing: cozile de lucru sunt împărțite pe tenanți, iar workerii iau pe rând din fiecare, ca un client cu un milion de joburi să nu blocheze un client cu zece.
  • Bulkhead-uri: pool-uri de conexiuni și workeri separate pentru clienții mari sau pentru tipurile de muncă grea.
  • Celule (cell-based architecture): platforma e împărțită în celule independente, fiecare cu propriile servere și baze, iar fiecare tenant aparține unei celule. Un incident afectează doar o celulă. Clienții foarte mari pot primi o celulă dedicată.
  • Limitarea interogărilor: timeout-uri pe interogări, limite de rezultate, paginare obligatorie.

Observabilitatea per tenant e obligatorie: metricile de consum etichetate cu id-ul clientului îți arată în câteva minute cine a schimbat comportamentul. Discuția include și partea de produs: limitele se comunică în documentație și se leagă de planurile comerciale.

Ce urmărește intervievatorul: Verifică experiența cu platforme partajate. Candidații propun des doar „scalăm mai mult”, ceea ce îl lasă pe client să consume și capacitatea nouă.

Design de sisteme clasice

Exersează capitolul cu exerciții reale: Curs System Design online →
81 Junior

Desenează arhitectura unui blog cu 1.000 de cititori pe zi. Apoi spune ce schimbi, pas cu pas, când ajunge la 1 milion de cititori pe zi.

Răspuns scurt: La 1.000 de cititori ajunge un server cu aplicația și baza, plus backup. Spre 1 milion adaugi pe rând: CDN, cache pentru articole, baza pe server separat cu replică, mai multe servere în spatele unui load balancer și monitorizare.

Versiunea 1 (1.000 de cititori pe zi, deci câteva cereri pe minut):

client -> server (aplicație + bază de date)  + backup zilnic în alt loc

Orice altceva e risipă. Contează backup-ul testat și HTTPS-ul.

Pașii spre 1 milion de cititori pe zi (în jur de 12 cereri pe secundă în medie la o pagină pe vizită, cu vârfuri de câteva ori mai mari când un articol devine popular):

  • CDN pentru imagini, CSS și JS, apoi chiar pentru paginile articolelor (aceleași pentru toți cititorii nelogați), cu TTL scurt. Pentru un blog, acesta e cel mai mare câștig: majoritatea cererilor nu mai ajung la server.
  • Baza de date pe un server separat, ca aplicația și baza să nu concureze pentru memorie, cu backup automat.
  • Cache (Redis) pentru articolele populare și listele de pe prima pagină.
  • Două sau mai multe servere de aplicație în spatele unui load balancer, pentru disponibilitate și deploy fără oprire; serverele devin stateless (sesiunile autorilor în Redis, imaginile în object storage).
  • Replică de rezervă pentru bază, cu failover.
  • Monitorizare și alerte: latență, erori, încărcarea bazei.

Ideea importantă pentru interviu: fiecare pas e motivat de o problemă măsurată (latență, încărcare, SPOF), nu adăugat din reflex. Un blog e dominat de citiri, deci investiția merge în cache și CDN, nu în sharding sau microservicii.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să crești un sistem treptat și justificat. Greșeala tipică: arhitectura de la scara mare desenată direct pentru primii 1.000 de utilizatori.

82 Junior

Cum generezi codul scurt într-un URL shortener? Scrie conversia unui număr în base62 și spune ce alternative există.

Răspuns scurt: Iei un ID numeric unic (din bază sau dintr-un generator distribuit) și îl scrii în base62 (cifre, litere mici și mari). Cu 7 caractere ai 62^7 ≈ 3,5 trilioane de coduri. Alternativa e un hash al URL-ului trunchiat, care cere tratarea coliziunilor.

Conversia unui ID în base62:

PYTHON
ALFABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

def base62(n):
    if n == 0:
        return ALFABET[0]
    cod = []
    while n > 0:
        n, rest = divmod(n, 62)
        cod.append(ALFABET[rest])
    return "".join(reversed(cod))

print(base62(125))           # 21
print(base62(3_500_000_000)) # 3ORDSU

Spațiul de coduri: 62^6 ≈ 56,8 miliarde, 62^7 ≈ 3,52 trilioane, suficient pentru orice estimare realistă.

Variante:

  • ID secvențial + base62: fără coliziuni, coduri scurte. Dezavantaj: codurile sunt previzibile (un atacator poate enumera linkurile). Remediu: amesteci ID-ul cu o permutare inversabilă înainte de codare sau pornești de la un generator de tip Snowflake.
  • Hash al URL-ului (MD5, SHA-256), din care păstrezi primele 7 caractere în base62: același URL dă același cod (deduplicare gratuită), dar trebuie să verifici coliziunile în bază și, la coliziune, să adaugi un sufix și să reîncerci.
  • Cod aleator: generezi 7 caractere aleatoare și le inserezi cu o constrângere de unicitate; la conflict reîncerci. Simplu, nepredictibil, cu verificare la fiecare inserare.
  • Coduri pregenerate: un serviciu generează în avans coduri unice și le distribuie serverelor în loturi.

Aliasurile personalizate („/oferta”) folosesc același spațiu, deci au nevoie de aceeași constrângere de unicitate.

Ce urmărește intervievatorul: Verifică dacă poți scrie cod simplu și dacă știi compromisurile dintre metode. Candidații uită des de coliziuni la varianta cu hash.

83 Junior

Proiectează un serviciu de tip Pastebin: utilizatorii salvează texte și primesc un link de partajare. Ce componente desenezi și unde ții textele?

Răspuns scurt: Un API stateless în spatele unui load balancer, o bază pentru metadate (cod, autor, dată, expirare, vizibilitate), un object storage pentru conținutul textelor, un cache și un CDN pentru textele populare, plus un job care șterge textele expirate.

Cerințele de clarificat: mărimea maximă a unui text (de exemplu 1 MB), expirarea, texte private sau publice, raportul citiri/scrieri (mult mai multe citiri).

Componentele:

client -> CDN -> load balancer -> API (stateless, mai multe instanțe)
API -> bază de date: paste(cod, autor_id, creat_la, expira_la, vizibilitate, cheie_obiect)
API -> object storage: conținutul textului, cheia = codul
API -> cache: textele cerute des
job programat: șterge textele expirate din bază și din object storage

De ce separi conținutul de metadate:

  • textele pot avea până la câțiva MB; în object storage sunt ieftine și nu încarcă baza;
  • baza rămâne mică și rapidă, ușor de replicat și de interogat („textele mele”, „expiră azi”).

Pentru texte mici (câțiva KB), păstrarea lor direct în bază e o simplificare acceptabilă; spune pragul.

Fluxuri:

  • creare: generezi codul (ca la URL shortener), scrii obiectul, apoi rândul de metadate; întorci linkul;
  • citire: cauți metadatele (cache, apoi bază), verifici expirarea și vizibilitatea, citești conținutul (cache sau object storage). Textele publice și populare pot fi servite direct din CDN.

Detalii de calitate: limitarea creărilor per IP (spam), detectarea conținutului abuziv, TTL-ul cache-ului legat de expirarea textului, ca un text expirat să nu mai fie servit.

Ce urmărește intervievatorul: Intervievatorul verifică dacă separi corect datele mari de metadate. Greșeala tipică: totul într-o singură tabelă cu o coloană text uriașă.

84 Junior

Un videoclip devine viral și primește mii de vizualizări pe secundă. Cum numeri vizualizările fără să blochezi un singur rând din baza de date?

Răspuns scurt: Nu faci un UPDATE pe același rând la fiecare vizualizare. Incrementezi un contor în memorie (Redis INCR), eventual împărțit pe mai multe chei, sau publici evenimentele într-o coadă și le agregi în loturi, iar baza primește periodic suma acumulată.

UPDATE videoclipuri SET vizualizari = vizualizari + 1 WHERE id = 7 la fiecare vizualizare înseamnă mii de scrieri pe secundă pe același rând. Fiecare scriere ia un lock pe rând, deci se execută una după alta: baza devine gâtul de sticlă, iar celelalte interogări pe acel tabel suferă.

Variante mai bune:

  • Contor în Redis: INCR vizualizari:7 e atomic și foarte rapid. Un job copiază periodic (de exemplu la fiecare minut) valoarea în bază. Pierzi cel mult ultimele secunde dacă Redis pică fără persistență, ceea ce e acceptabil pentru un contor de vizualizări.
  • Contor împărțit: pentru o cheie extrem de fierbinte, folosești vizualizari:7:0 … vizualizari:7:15 pe noduri diferite, incrementezi una aleatoare și aduni la citire.
  • Evenimente agregate: fiecare vizualizare e un eveniment în Kafka; un consumator le adună în memorie pe intervale de câteva secunde și scrie o singură actualizare (+ 4.231). Poți păstra și evenimentele brute pentru analize și pentru eliminarea vizualizărilor false.
  • Agregare în aplicație: fiecare server ține contoare locale și le trimite periodic.

Afișarea poate fi aproximativă și ușor întârziată („1,2 milioane de vizualizări”). Dacă numărul are efecte financiare (plata creatorilor), păstrezi evenimentele brute deduplicate și calculezi exact într-un proces separat.

Ce urmărește intervievatorul: Verifică dacă recunoști problema rândului fierbinte și știi tehnicile de agregare. Candidații propun des un simplu UPDATE sau un lock.

Eroarea, în practică:Hot key în Redis

85 Junior

Proiectează un clasament în timp real pentru un joc mobil cu milioane de jucători: top 100 și poziția fiecărui jucător.

Răspuns scurt: Folosești o structură ordonată în memorie, de exemplu un sorted set în Redis: ZADD la fiecare scor nou, ZREVRANGE pentru top 100, ZREVRANK pentru poziția unui jucător, toate în timp logaritmic. Baza de date rămâne sursa durabilă a scorurilor.

O interogare SQL ORDER BY scor DESC peste milioane de rânduri, la fiecare deschidere a ecranului, e scumpă, iar „pe ce loc sunt?” cere numărarea tuturor jucătorilor cu scor mai mare. Un sorted set ține elementele ordonate după scor (intern, o skip list), cu operații în O(log N):

ZADD clasament:sezon5 1520 jucator:42     # setează scorul
ZINCRBY clasament:sezon5 30 jucator:42    # adaugă puncte
ZREVRANGE clasament:sezon5 0 99 WITHSCORES   # top 100
ZREVRANK clasament:sezon5 jucator:42      # poziția (de la 0)
ZREVRANGE clasament:sezon5 140 160        # vecinii unui jucător de pe locul 150

Arhitectura:

  • serverul de joc validează scorul (anti-trișare) și îl scrie în bază, apoi în sorted set;
  • citirile clasamentului vin doar din Redis;
  • Redis are replică și persistență; dacă se pierde, clasamentul se reconstruiește din bază;
  • clasamente separate pe perioade (saptamana:45) cu expirare, și pe regiuni sau prieteni.

La scară foarte mare (sute de milioane de jucători), un singur sorted set poate deveni prea mare pentru un nod. Atunci împarți pe intervale de scor, iar poziția globală se calculează adunând numărul de jucători din intervalele superioare. Pentru jucătorii de la coada clasamentului, o poziție aproximativă („top 40%”) e suficientă și mult mai ieftină.

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi structura de date potrivită. Greșeala tipică: sortarea în bază la fiecare cerere.

Eroarea, în practică:Hot key în Redis

86 Junior

Proiectează un sistem de notificări care trimite email, SMS și push pentru evenimente ca „comanda a fost expediată”.

Răspuns scurt: Serviciile publică evenimente; serviciul de notificări le transformă după preferințele utilizatorului și șabloane în mesaje, pe care le pune în cozi separate pe canal (email, SMS, push). Workeri dedicați trimit prin furnizori externi, cu reîncercări, limite de rată, deduplicare și jurnal de livrare.

Fluxul:

serviciul de comenzi -> eveniment "comanda_expediata" (pub/sub)
serviciul de notificări:
   - citește preferințele utilizatorului (ce canale, ore de liniște, dezabonări)
   - alege șablonul și limba, completează datele
   - pune câte un mesaj în coada fiecărui canal
coadă email -> workeri email -> furnizor email
coadă SMS   -> workeri SMS   -> furnizor SMS
coadă push  -> workeri push  -> APNs / FCM
jurnal de livrare: trimis, eșuat, deschis

De ce cozi separate pe canal: furnizorii au limite și viteze diferite. Dacă furnizorul de SMS e lent sau căzut, emailurile și push-urile pleacă normal.

Detalii importante:

  • deduplicare: fiecare notificare are un id derivat din eveniment și canal, ca reîncercările să nu trimită de două ori;
  • reîncercări cu backoff la erori temporare și DLQ pentru cele permanente (număr invalid, token de push expirat, care se șterge din profil);
  • limitele furnizorului: rata de trimitere pe secundă, respectată de workeri;
  • prioritate: codurile de autentificare au coadă proprie și prioritară, newsletterele merg separat;
  • preferințele și legislația: dezabonare, ore de liniște, acordul pentru marketing;
  • furnizor de rezervă pentru canalele critice.

Statisticile din jurnal (livrat, deschis) se folosesc pentru depanare și pentru reclamațiile de tipul „n-am primit codul”.

Ce urmărește intervievatorul: Verifică dacă izolezi canalele și tratezi realitatea furnizorilor externi. Candidații desenează des un singur worker care trimite sincron toate tipurile de mesaje.

Eroarea, în practică:Doar un serviciu primește evenimentul

87 Mid

Proiectează un rate limiter pentru un API public, care rulează pe 20 de servere: fiecare cheie de API are voie la 100 de cereri pe minut.

Răspuns scurt: Contoarele comune tuturor serverelor stau într-un store rapid, ca Redis, partiționat după cheia de API. Verificarea e atomică (INCR sau script Lua), la gateway. Răspunzi cu 429 și antete despre limită și decizi explicit ce faci dacă pică Redis.

Dacă fiecare server ar număra local, un client ar putea face de 20 de ori mai multe cereri, distribuite de load balancer. Ai nevoie de stare comună.

Design:

client -> load balancer -> gateway (rate limiter) -> serviciile API
                              |
                              v
                         Redis cluster (cheie: rl:<api_key>:<fereastra>)

Algoritmul pe Redis, ca script atomic (aici sliding window aproximat sau token bucket). Variant simplă cu fereastră fixă:

INCR rl:abc123:202611041530
EXPIRE rl:abc123:202611041530 120      (doar la prima incrementare)
-> dacă valoarea > 100: respinge

Răspunsurile includ antetele X-RateLimit-Limit, X-RateLimit-Remaining și, la respingere, 429 Too Many Requests cu Retry-After.

Decizii de discutat:

  • latența: un apel la Redis pe fiecare cerere adaugă sub o milisecundă în același centru de date; pentru volume uriașe, serverele pot rezerva local „pachete” de jetoane și se sincronizează rar, cu o mică imprecizie;
  • atomicitatea: citește-verifică-scrie în doi pași permite depășiri la cereri concurente, de aceea folosești INCR sau Lua;
  • eșecul store-ului: fail-open (permite traficul, riști abuzul) sau fail-closed (respinge, riști o cădere totală); pentru majoritatea API-urilor se alege fail-open cu limite locale de urgență;
  • limite pe mai multe niveluri: pe cheie, pe IP, pe endpoint scump, global;
  • configurația: limitele pe plan de abonament stau într-un serviciu de configurare, citite în cache.

Ce urmărește intervievatorul: Intervievatorul verifică dacă gândești limitarea ca problemă distribuită, cu stare comună și compromisuri la eșec.

Eroarea, în practică:429 Too Many RequestsRobot care supraîncarcă serverele

88 Mid

Proiectează un chat 1-la-1: cum ajunge mesajul de la Ana la Mihai când sunt conectați prin WebSocket la servere diferite? Ce se întâmplă dacă Mihai e offline?

Răspuns scurt: Mesajul se salvează întâi în bază, apoi se află din registrul de prezență serverul lui Mihai și i se trimite printr-un pub/sub intern. Dacă Mihai e offline, primește o notificare push, iar la reconectare cere mesajele de după ultimul id primit.

Componentele:

Ana --WebSocket--> server chat A
server A -> baza de mesaje (partiție = conversația, sortare = id/timp)
server A -> registru de prezență (Redis): "mihai" -> server chat C
server A -> pub/sub intern, canalul serverului C
server C --WebSocket--> Mihai

Pașii trimiterii:

  • clientul Anei trimite mesajul cu un id generat de client, folosit pentru deduplicare dacă reîncearcă;
  • serverul A îl salvează (o bază wide-column ca Cassandra se potrivește bine: scrieri multe, citiri pe conversație ordonate în timp) și confirmă Anei „trimis”;
  • caută serverul lui Mihai în registrul de prezență și publică mesajul pe canalul acelui server;
  • serverul C îl trimite pe conexiunea lui Mihai; clientul confirmă, iar starea devine „livrat”.

Cazul offline:

  • registrul nu are o conexiune activă (sau conexiunea a căzut între timp);
  • mesajul rămâne în bază; se trimite o notificare push prin APNs/FCM;
  • la reconectare, clientul trimite ultimul id primit pe fiecare conversație și primește tot ce a urmat.

Detalii: ordinea e garantată per conversație (id crescător per conversație sau Snowflake), conexiunile WebSocket au nevoie de heartbeat ca să detecteze rapid deconectările, iar la căderea unui server de chat clienții se reconectează la altul și își actualizează prezența. Load balancer-ul trebuie să suporte conexiuni de lungă durată.

Ce urmărește intervievatorul: Verifică dacă știi problema rutării mesajelor între servere cu conexiuni persistente și tratarea clientului offline.

89 Mid

Proiectează feed-ul unei rețele sociale. Compară fan-out la scriere cu fan-out la citire și spune ce faci cu conturile care au milioane de urmăritori.

Răspuns scurt: Fan-out la scriere copiază postarea în feed-ul precalculat al fiecărui urmăritor: citiri foarte rapide. Fan-out la citire construiește feed-ul la deschidere. Soluția uzuală e hibridă: la scriere pentru conturile obișnuite, la citire pentru conturile foarte populare.

Fan-out la scriere (push):

postare nouă -> coadă -> workeri: pentru fiecare urmăritor,
                adaugă id-ul postării în feed:<urmaritor> (listă limitată, de exemplu ultimele 800)
deschidere feed -> citește feed:<utilizator> din cache, încarcă postările după id

Plus: citirea, de departe operația cea mai frecventă, e foarte ieftină. Minus: o postare a unui cont cu 10 milioane de urmăritori înseamnă 10 milioane de scrieri; multe sunt pentru utilizatori care nici nu intră în aplicație.

Fan-out la citire (pull): la deschidere, iei postările recente ale fiecărui cont urmărit și le combini. Plus: scrierea e ieftină, nimic nu e calculat degeaba. Minus: un utilizator care urmărește 1.000 de conturi declanșează multe citiri la fiecare deschidere; latența e mai mare.

Hibridul:

  • conturile obișnuite: fan-out la scriere;
  • conturile cu foarte mulți urmăritori („celebrități”): postările lor nu se copiază, ci se adaugă la citire, din cache-ul postărilor lor recente;
  • utilizatorii inactivi nu primesc fan-out; feed-ul lor se reconstruiește la revenire.

Alte piese: un serviciu de clasare (feed-ul nu e doar cronologic), paginare cu cursor peste lista precalculată, cache-ul postărilor și al profilurilor, iar ștergerea unei postări se aplică la afișare (postările șterse sunt filtrate), nu prin eliminarea din milioane de liste.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi compromisul clasic al feed-urilor și cazul conturilor foarte populare.

90 Mid

Proiectează autocompletarea căutării (typeahead) pentru un magazin: la fiecare literă tastată vrei primele 10 sugestii în sub 100 ms.

Răspuns scurt: Precalculezi pentru fiecare prefix top 10 termeni populari, într-un trie sau într-un map prefix -> listă, ținut în memorie și servit prin cache. Popularitatea se calculează offline din loguri, iar clientul trimite cereri doar după o scurtă pauză în tastare.

Calculul top 10 la fiecare literă, prin parcurgerea tuturor termenilor, e prea lent. Ideea e să muți munca în afara drumului cererii.

Construcția (offline, de exemplu la fiecare oră sau zi):

  • agregi logurile de căutare: termen -> număr de căutări în ultima perioadă (cu ponderi mai mari pentru zilele recente);
  • construiești un trie în care fiecare nod (prefix) stochează direct top 10 termeni sub el;
  • sau, mai simplu, un map prefix -> [top 10] pentru prefixele de până la, să zicem, 15 caractere.

Servirea:

client (debounce ~150 ms) -> CDN / cache -> serviciu typeahead (structura în memorie)
GET /sugestii?q=tel -> ["telefon", "telefon samsung", "televizor", ...]
  • răspunsurile pentru prefixele scurte sunt identice pentru toți, deci se pot păstra în CDN și în browser;
  • serviciul ține structura în memorie și e replicat; o versiune nouă se încarcă alături de cea veche și se comută atomic.

Detalii de calitate:

  • filtrarea termenilor nepotriviți și a celor fără rezultate;
  • tendințele bruște (un produs nou lansat) cer o actualizare mai frecventă, de exemplu un flux separat care ajustează scorurile între reconstrucții;
  • personalizarea (istoricul utilizatorului) se combină în client sau într-un strat separat, peste lista generală;
  • toleranța la greșeli de tastare se face cu un motor de căutare (Elasticsearch are sugestii fuzzy), cu cost mai mare.

Ce urmărește intervievatorul: Verifică dacă știi să precalculezi pentru latență mică. Greșeala tipică: o interogare LIKE 'tel%' în baza principală la fiecare tastă.

Eroarea, în practică:LIKE '%text%' încarcă baza la 100%

91 Mid

Ce se întâmplă, pas cu pas, după ce un utilizator apasă „Upload” pe un videoclip, până când alții îl pot viziona pe telefon și pe calculator?

Răspuns scurt: Fișierul se încarcă direct în object storage (multipart, URL presemnat), apoi workeri asincroni îl verifică, îl transcodează în mai multe rezoluții, îl segmentează pentru streaming adaptiv (HLS/DASH) și fac miniaturi. Segmentele sunt servite prin CDN.

Pașii:

  • Inițierea: clientul cere upload-ul; API-ul creează înregistrarea videoclipului (stare „se încarcă”) și dă URL-uri presemnate pentru un upload multipart: fișierul e trimis în bucăți, reluabil dacă se întrerupe conexiunea.
  • Finalizarea: object storage-ul anunță încărcarea (eveniment), iar API-ul marchează starea „în procesare” și pune un job în coadă.
  • Procesarea (workeri, de obicei pe mașini dedicate):
  • verificarea fișierului și a conținutului;
  • transcodarea în mai multe rezoluții și rate de biți (de exemplu 240p până la 1080p), în codecuri suportate larg;
  • segmentarea în bucăți de câteva secunde plus un fișier manifest (HLS sau DASH), ca playerul să poată schimba calitatea după viteza rețelei;
  • miniaturi și eventual subtitrări automate. Un videoclip lung se poate împărți în fragmente transcodate în paralel, pentru viteză.
  • Publicarea: segmentele și manifestul ajung în object storage, metadatele trec în starea „disponibil”, utilizatorul primește o notificare.
  • Vizionarea: playerul descarcă manifestul, apoi segmentele, prin CDN. Majoritatea traficului e servit din CDN; originea vede doar miss-urile.

Ce mai discuți: jobul de transcodare e reîncercabil și idempotent (procesarea aceluiași fișier de două ori dă același rezultat), costul de stocare pentru variantele multiple, ștergerea originalului sau mutarea lui într-o clasă de stocare mai ieftină și limitele de mărime pe upload.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi fluxul complet al conținutului media. Greșeala tipică: videoclipul trimis prin serverul de aplicație și servit întreg, într-o singură rezoluție.

Eroarea, în practică:413 Request Entity Too Large

92 Mid

Proiectează rezervarea locurilor la un concert: mii de oameni încearcă în același timp să cumpere aceleași locuri. Cum eviți să vinzi un loc de două ori?

Răspuns scurt: Rezervarea locului e atomică în bază: un UPDATE condiționat pe starea locului (sau SELECT ... FOR UPDATE), cu o rezervare temporară care expiră dacă plata nu se finalizează. Vârful îl absorbi cu o coadă de așteptare virtuală.

Corectitudinea vine din bază, nu din aplicație. Varianta cu actualizare condiționată:

SQL
UPDATE locuri
SET stare = 'rezervat', rezervat_de = 1234, expira_la = now() + interval '10 minutes'
WHERE eveniment_id = 77 AND loc = 'A12'
  AND (stare = 'liber' OR (stare = 'rezervat' AND expira_la < now()));

Dacă rândul a fost actualizat (1 rând afectat), locul e al tău pentru 10 minute; dacă nu (0 rânduri), altcineva l-a luat. Două cereri simultane nu pot câștiga amândouă, pentru că baza blochează rândul la actualizare. Pentru mai multe locuri deodată, le actualizezi în aceeași tranzacție, într-o ordine fixă, ca să eviți deadlock-urile.

Fluxul complet:

  • coadă virtuală: la deschiderea vânzărilor, utilizatorii primesc un loc într-o coadă de așteptare și intră în pagina de cumpărare în ritmul pe care sistemul îl poate duce;
  • harta locurilor se citește din cache, cu întârziere de câteva secunde (poate arăta un loc liber deja luat; rezervarea atomică decide);
  • rezervarea temporară blochează locul cât timp utilizatorul plătește;
  • plata cu cheie de idempotență; la confirmare, locul devine „vândut” într-o tranzacție care verifică că rezervarea e încă a lui;
  • expirarea: un job eliberează rezervările expirate (sau condiția din UPDATE le consideră libere).

De ce nu cache sau o bază eventual consistentă pentru rezervare: acolo două noduri pot accepta aceeași rezervare. Partea critică rămâne pe o bază cu consistență puternică.

Ce urmărește intervievatorul: Verifică dacă știi să garantezi unicitatea sub concurență. Greșeala tipică: verificarea „e liber?” urmată de o scriere separată, fără atomicitate.

Eroarea, în practică:ERROR: deadlock detectedLoc vândut de două ori (lost update)

93 Senior

Proiectează un web crawler care descarcă miliarde de pagini. Care sunt componentele principale și cum eviți să supraîncarci un site?

Răspuns scurt: Frontiera de URL-uri (cozi prioritizate), workeri de descărcare, cache DNS, parsare, deduplicare de URL-uri și de conținut, stocare. Politețea vine din cozi pe host, cu un singur worker și o pauză între cereri pe host, plus respectarea robots.txt.

Fluxul:

URL-uri inițiale -> frontieră -> workeri descărcare -> parsare
                     ^                                   |
                     |-- filtru „văzut deja” <-- linkuri extrase
conținut -> deduplicare -> stocare (object storage) -> indexare

Componentele, pe rând:

  • Frontiera: decide ce se descarcă și când. Are două niveluri: cozi de prioritate (pagini importante, pagini care se schimbă des) și cozi pe host, fiecare host fiind servit de un singur worker la un moment dat, cu o pauză configurată între cereri. Așa nu trimiți sute de cereri pe secundă unui site mic.
  • robots.txt: descărcat și păstrat în cache per domeniu, verificat înaintea fiecărui URL, inclusiv Crawl-delay acolo unde e folosit.
  • DNS: rezolvarea poate deveni gâtul de sticlă; folosești un cache DNS propriu.
  • Deduplicarea URL-urilor: normalizezi URL-urile (fără fragmente, parametri ordonați) și verifici apartenența într-un Bloom filter sau într-un store distribuit; la miliarde de URL-uri, un Bloom filter ocupă puțină memorie, cu o mică rată de fals pozitive (unele pagini noi sunt sărite).
  • Deduplicarea conținutului: hash al conținutului pentru pagini identice și tehnici ca SimHash pentru pagini aproape identice.
  • Capcanele: calendare infinite, URL-uri generate fără sfârșit; limitezi adâncimea și numărul de pagini pe domeniu.
  • Scalarea: frontiera e partiționată după host (hash pe domeniu), deci fiecare worker deține un set de domenii și politețea rămâne locală.

Recrawl-ul se programează după cât de des se schimbă fiecare pagină, iar progresul se salvează periodic, ca o cădere să nu reia totul de la zero.

Ce urmărește intervievatorul: Intervievatorul verifică dacă vezi atât scara (deduplicare, partiționare), cât și responsabilitatea față de site-urile vizitate.

94 Senior

Proiectează partea de „găsește șoferii disponibili din apropiere” pentru o aplicație de ride-sharing. Șoferii își trimit locația la fiecare câteva secunde.

Răspuns scurt: Împarți harta în celule (geohash, S2, H3) și ții în memorie șoferii disponibili din fiecare celulă; actualizările doar suprascriu poziția. Căutarea citește celula clientului și vecinele, apoi ordonează după distanță sau timpul estimat de sosire.

Volumul de scrieri e problema principală: dacă 500.000 de șoferi trimit locația la fiecare 4 secunde, ai 125.000 de actualizări pe secundă. Dar doar ultima poziție contează, deci nu păstrezi istoricul în baza principală.

Indexarea spațială:

  • Geohash: transformă (latitudine, longitudine) într-un șir; prefixele comune înseamnă zone apropiate. Cu o precizie de 6 caractere, celulele au aproximativ 1,2 × 0,6 km.
  • Quadtree: împarte recursiv zonele dense în celule mai mici; potrivit pentru densitate inegală (centrul orașului vs periferie).
  • S2 / H3: sisteme de celule ierarhice folosite în industrie, cu vecinătăți bine definite.

Arhitectura:

șofer -> gateway (WebSocket/HTTP) -> serviciu de locație
   -> store în memorie: celulă -> {șoferi disponibili}, șofer -> (poziție, timp)
client: „vreau o mașină” -> serviciu de potrivire
   -> citește celula clientului + vecinii, filtrează după stare și vechimea poziției
   -> ordonează după ETA (serviciu de rute), oferă cursa primului șofer

Redis are comenzi geospațiale (GEOADD, GEOSEARCH) care folosesc geohash intern, o variantă rapidă pentru un oraș. La scară mare, partiționezi după regiune sau oraș, pentru că potrivirile sunt locale.

Alte decizii: pozițiile mai vechi de câteva zeci de secunde sunt ignorate, oferta către un șofer e exclusivă și expiră (ca doi clienți să nu primească același șofer, actualizare atomică a stării), iar istoricul traseelor pentru facturare și analiză merge asincron într-un store separat.

Ce urmărește intervievatorul: Verifică dacă știi indexarea spațială și dacă tratezi corect volumul mare de scrieri efemere.

95 Senior

Proiectează un key-value store distribuit, de tipul DynamoDB sau Cassandra: get(key) și put(key, value), scalabil și disponibil. Ce piese principale are?

Răspuns scurt: Partiționare cu consistent hashing și noduri virtuale, replicare pe N noduri succesive din inel, cvorumuri configurabile (W, R), versiuni pentru conflicte, detectarea căderilor prin gossip, hinted handoff și reparare anti-entropie (Merkle trees), iar pe fiecare nod un motor de stocare optimizat pentru scrieri (LSM-tree).

Piesele, legate de cerințe:

  • Partiționarea: consistent hashing cu noduri virtuale, ca datele și încărcarea să se împartă uniform și adăugarea unui nod să mute doar o parte din chei.
  • Replicarea: fiecare cheie e copiată pe N noduri (de exemplu următoarele 3 noduri fizice distincte din inel, ideal în zone diferite).
  • Consistența configurabilă: scrierea confirmată după W replici, citirea după R; cu W + R > N obții citiri actualizate în cazurile obișnuite, cu W = R = 1 latență minimă.
  • Versiunile și conflictele: fiecare valoare are o versiune (timestamp pentru last-write-wins sau vector clocks pentru detectarea scrierilor concurente).
  • Coordonatorul: orice nod poate primi cererea și o trimite replicilor (fără un master unic, deci fără SPOF).
  • Detectarea căderilor: protocol gossip, în care nodurile își transmit periodic starea; un nod suspectat nu mai primește cereri.
  • Hinted handoff: dacă o replică e temporar căzută, alt nod păstrează scrierea cu un „bilet” și o predă când replica revine.
  • Anti-entropie: replicile își compară periodic datele prin Merkle trees (hash-uri pe intervale de chei) și sincronizează doar diferențele; plus read repair la citiri.
  • Stocarea locală: LSM-tree: scrierile merg întâi într-un jurnal (commit log) și într-o structură în memorie (memtable), descărcată periodic în fișiere sortate (SSTable), compactate în fundal; Bloom filters evită citirile inutile de pe disc.

Discuția de compromisuri: sistemul e AP în configurația implicită, iar ștergerile au nevoie de marcaje (tombstones) păstrate o vreme, ca o replică întârziată să nu „învie” datele șterse.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți asambla conceptele (hashing, cvorum, conflicte, recuperare) într-un sistem coerent.

Situații și comportament la interviu

96 Junior

Primești la interviu o problemă de system design pe care n-ai mai văzut-o niciodată. Cum îți organizezi cele 45 de minute?

Răspuns scurt: Urmezi o structură fixă: cerințe și presupuneri (5–8 min), estimări (3–5 min), API și modelul de date (5 min), arhitectura de ansamblu (10 min), aprofundarea a 1–2 componente alese împreună cu intervievatorul (10–15 min), apoi problemele și compromisurile (5 min).

O structură care te scoate din blocaj, indiferent de problemă:

  • Cerințe (5–8 minute): funcțiile principale, ce lași deoparte, utilizatori și trafic, cerințele nefuncționale (latență, disponibilitate, consistență). Scrie-le pe tablă.
  • Estimări (3–5 minute): cereri pe secundă la vârf, raportul citiri/scrieri, stocare, bandă. Doar cât îți trebuie pentru decizii, cu cifre rotunjite.
  • API și date (5 minute): 3–5 endpoint-uri principale și entitățile cu câmpurile importante. Aici se vede dacă ai înțeles problema.
  • Arhitectura de ansamblu (10 minute): drumul unei cereri de citire și al uneia de scriere, de la client la stocare. Simplu, complet, fără detalii premature.
  • Aprofundare (10–15 minute): întrebi „ce parte ați vrea să detaliem?” sau propui tu partea cea mai grea (generarea codurilor, fan-out-ul, consistența rezervărilor).
  • Încheiere (5 minute): SPOF-uri, ce se întâmplă la de 10 ori mai mult trafic, monitorizare, ce ai face diferit cu mai mult timp.

Comportamentul contează la fel de mult ca structura:

  • gândește cu voce tare, ca intervievatorul să-ți urmărească raționamentul și să te poată ajuta;
  • justifică fiecare componentă cu o cerință sau o cifră;
  • numește compromisurile („aleg asta și plătesc cu...”);
  • dacă nu știi ceva, spune ce știi și cum ai afla, nu inventa.

Problema nouă e de obicei o combinație de piese cunoscute: cache, coadă, partiționare, CDN. Structura te ajută să le găsești.

Ce urmărește intervievatorul: Verifică dacă ai un proces repetabil și dacă știi să conduci discuția. Greșeala tipică este să te pierzi în detaliile unei componente înainte de a avea imaginea întreagă.

97 Junior

Un coleg junior te întreabă de ce aplicația a devenit lentă după ce numărul de utilizatori s-a dublat. Cum îi explici și ce verificați împreună, în ordine?

Răspuns scurt: Îi explici că latența crește brusc când o componentă se apropie de limită. Verificați în ordine: ce cereri sunt lente, unde se pierde timpul (trasee), ce resursă e saturată (CPU, conexiuni la bază, interogări lente), apoi remediați acea resursă.

Modelul de răspuns structurat:

Explicația (pe înțeles): sistemul e un lanț de componente, fiecare cu o capacitate. Cât timp sunt departe de limită, dublarea traficului abia se simte. Aproape de limită, cererile încep să aștepte la coadă, iar timpul de așteptare crește mult mai repede decât traficul. De aceea „s-a dublat traficul” poate însemna de zece ori mai lent, iar problema e de obicei o singură componentă: gâtul de sticlă.

Verificarea, în ordine:

  • Care cereri sunt lente? Metricile pe endpoint (latența p95/p99, nu media) arată dacă sunt toate sau doar câteva.
  • Unde se pierde timpul? Un trace al unei cereri lente arată segmentele: aplicație, bază, cache, serviciu extern.
  • Ce resursă e saturată? CPU-ul serverelor, pool-ul de conexiuni la bază (cereri care așteaptă o conexiune), interogările lente (logul de interogări lente, EXPLAIN), rata de hit a cache-ului, memoria și pauzele GC.
  • Ce s-a schimbat? Pe lângă trafic, un deploy recent sau o interogare nouă fără index pot fi cauza reală.

Remedierea, după gâtul de sticlă găsit: index pentru interogarea lentă, cache pentru citirile repetate, mai multe instanțe dacă serverele sunt la limită, replici de citire pentru bază, procesare asincronă pentru munca grea.

Lecția pentru coleg: întâi măsori, apoi schimbi. Adăugarea de servere „la ghici” nu ajută dacă baza de date e problema și poate chiar înrăutăți situația, prin mai multe conexiuni.

Ce urmărește intervievatorul: Intervievatorul verifică metoda de depanare și capacitatea de a explica. Greșeala tipică: soluția propusă înainte de a identifica gâtul de sticlă.

Eroarea, în practică:CPU 100%: scalarea verticală a ajuns la limită

98 Junior

Ai prezentat designul, iar intervievatorul întreabă „Și dacă pică baza de date?”. Cum răspunzi fără să te blochezi?

Răspuns scurt: Tratezi întrebarea ca pe o invitație de a discuta fiabilitatea: spui ce se întâmplă acum în designul tău (impactul), cum detectezi căderea, ce mecanism o tratează (replică de rezervă, failover, backup) și ce compromisuri are, apoi actualizezi diagrama.

Întrebările de tipul „și dacă pică X?” nu sunt capcane, ci modul obișnuit în care intervievatorul aprofundează. Un răspuns structurat:

  • Impactul actual: „Acum baza e o singură instanță, deci e un punct unic de eșec: scrierile se opresc, iar citirile merg doar cât timp sunt în cache.” Recunoașterea onestă a problemei e un plus, nu un minus.
  • Detecția: health checks și monitorizare pe bază, alertă la eroare.
  • Mecanismul: replică de rezervă sincronă sau asincronă, failover automat cu un sistem de consens (sau serviciul gestionat al furnizorului), aplicația care se reconectează la noua primară.
  • Compromisurile: replicarea sincronă nu pierde date, dar încetinește scrierile; cea asincronă e rapidă, dar poate pierde ultimele scrieri la failover. Alegi după cerințe.
  • Degradarea: în timpul failover-ului, ce vede utilizatorul? Citirile din cache merg, scrierile primesc un mesaj prietenos sau intră într-o coadă și se aplică după revenire.
  • Recuperarea de dezastru: backup-uri cu restaurare testată, pentru cazul în care se pierd toate copiile.

Apoi actualizezi diagrama: adaugi replica și marchezi failover-ul. Dacă nu știi un detaliu, de exemplu cum funcționează intern failover-ul unei anumite baze, spune ce garanție îți trebuie și cum ai verifica-o.

Același tipar merge pentru orice componentă: cache, coadă, regiune, serviciu extern.

Ce urmărește intervievatorul: Verifică reacția sub presiune și dacă te gândești singur la defecte. Candidații se blochează des sau apără designul în loc să-l îmbunătățească.

Eroarea, în practică:Baza primară a căzut, fără failoverSingle point of failure (SPOF)

99 Mid

Este vârf de trafic, iar utilizatorii primesc 504 Gateway Timeout de la load balancer. Cum investighezi, pas cu pas?

Răspuns scurt: 504 înseamnă că load balancer-ul n-a primit răspuns de la server la timp. Întâi limitezi impactul (rollback, scalare, load shedding), apoi cauți unde stau cererile: servere saturate, pool de conexiuni epuizat, interogări lente, o dependență externă lentă.

1. Stabilizare, înainte de cauza exactă:

  • a fost un deploy recent? Dacă da, rollback;
  • serverele sunt la limită? Scalezi, dacă gâtul de sticlă nu e în aval;
  • activezi load shedding sau dezactivezi funcțiile neesențiale (recomandări, rapoarte).

2. Localizare:

  • metricile load balancer-ului: 504 la toate țintele sau doar la unele? O singură instanță problematică se scoate din rotație.
  • metricile aplicației: latența pe endpoint, fire sau conexiuni ocupate, cozile interne. Dacă serverele au CPU mic, dar cererile durează mult, ele așteaptă ceva.
  • trasee: unde stă o cerere lentă? Des, în așteptarea unei conexiuni din pool sau a unui apel extern.
  • baza de date: conexiuni active, interogări lente sau blocate, lock-uri, încărcarea replicilor.
  • dependențele externe: un furnizor lent ține firele ocupate și blochează tot serverul.

3. Cauze frecvente și remedii:

  • pool de conexiuni epuizat de interogări lente: index, optimizare, timeout pe interogare;
  • dependență lentă fără timeout: timeout scurt, circuit breaker, apel asincron;
  • cache stampede după expirarea unei chei populare: protecție la reîncărcare;
  • timeout-uri incoerente: aplicația așteaptă 60 s, iar load balancer-ul renunță la 30 s, deci serverul muncește degeaba. Timeout-urile scad din exterior spre interior.

4. După incident: analiză fără vinovați, alertă pe rata de 5xx și pe saturarea pool-urilor, test de încărcare pentru scenariul respectiv.

Ce urmărește intervievatorul: Intervievatorul verifică metoda de lucru într-un incident real. Greșeala tipică: repornirea serverelor la întâmplare fără să cauți unde stau cererile.

Eroarea, în practică:502 Bad Gateway504 Gateway Timeout

100 Mid

Echipa vrea să introducă Kafka și să împartă aplicația în 8 microservicii, deși produsul are câteva sute de utilizatori. Cum argumentezi și ce propui?

Răspuns scurt: Întrebi ce problemă concretă rezolvă, compari costul (operare, depanare, consistență, viteză de livrare) cu beneficiul la scara actuală și propui pași mici: monolit modular, o coadă gestionată simplă și criterii clare pentru extragerea unui serviciu.

Un răspuns structurat, pe care îl poți folosi și în discuția cu echipa:

Înțelege motivația: ce problemă vor să rezolve? Deploy-uri care se blochează reciproc, o componentă care încetinește restul, nevoia de procesare asincronă, dorința de a învăța o tehnologie? Fiecare are altă soluție.

Pune costurile pe masă, concret:

  • un cluster Kafka trebuie operat, monitorizat, actualizat (sau plătit ca serviciu gestionat);
  • 8 servicii înseamnă 8 pipeline-uri, configurații, alerte, versiuni de API;
  • consistența între servicii cere saga și outbox, depanarea cere tracing distribuit;
  • o echipă mică va petrece mult timp pe infrastructură în loc de funcționalități pentru utilizatori.

Propune o alternativă care păstrează beneficiile:

  • monolit modular, cu granițe clare între module (fiecare cu tabelele lui), ca o extragere viitoare să fie simplă;
  • pentru munca asincronă, o coadă gestionată (SQS, Cloud Tasks) sau un sistem de joburi pe baza existentă, până când volumul cere mai mult;
  • un serviciu separat doar acolo unde există un motiv clar (procesarea video, cu resurse diferite).

Definește criterii de revenire la decizie: numărul de echipe, frecvența conflictelor la deploy, volumul de evenimente, nevoile de scalare diferite. Documentează decizia într-un ADR (architecture decision record).

Tonul contează: arăți că ai ascultat, folosești cifre și riscuri, nu preferințe, și lași ușa deschisă pentru momentul potrivit.

Ce urmărește intervievatorul: Verifică judecata și comunicarea tehnică. Candidații fie acceptă orice tehnologie nouă, fie o resping fără argumente și fără alternativă.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de System Design, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață System Design scriind cod, nu doar citind

Curs System Design: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 10 lecții sunt gratuite.