Kompletny Przewodnik - Rozmowa Full-Stack Developer 2026

Full-Stack Developer to jedna z najbardziej poszukiwanych ról w IT. Łączysz światy frontendu i backendu, budujesz aplikacje od A do Z. Ale rozmowa rekrutacyjna na Full-Stack jest wyzwaniem - musisz wykazać się wiedzą z obu stron, plus umiejętnością ich integracji.

Ten przewodnik to Twoja mapa przygotowania. Od JavaScript przez React i Node.js, po bazy danych, API design i podstawy DevOps. Każda sekcja zawiera linki do szczegółowych artykułów z konkretnymi pytaniami.

---

Co sprawdzają na rozmowie Full-Stack Developer

Full-Stack to nie "trochę frontendu + trochę backendu". To umiejętność myślenia end-to-end - jak dane płyną od użytkownika przez API do bazy i z powrotem.

Struktura oceny

Obszar	Waga	Co sprawdzają
JavaScript/TypeScript	20-25%	Fundamenty, async, ES6+, typy
Frontend Framework	15-20%	React/Angular/Vue, state management
Backend & API	20-25%	Node.js, REST, autentykacja
Bazy danych	15-20%	SQL, NoSQL, ORM, modelowanie
DevOps basics	10-15%	Docker, CI/CD, deployment
System Design	5-10%	Architektura, integracja warstw

T-shaped professional

Rekruterzy rozumieją, że Full-Stack to spektrum:

Frontend-leaning Full-Stack:
████████████████░░░░ Frontend (80%)
████████░░░░░░░░░░░░ Backend (40%)

Backend-leaning Full-Stack:
████████░░░░░░░░░░░░ Frontend (40%)
████████████████░░░░ Backend (80%)

Balanced Full-Stack:
████████████░░░░░░░░ Frontend (60%)
████████████░░░░░░░░ Backend (60%)

Nie musisz być ekspertem od wszystkiego. Ważne, żebyś mógł pracować na całym stosie i rozumiał jak warstwy współpracują.

---

JavaScript i TypeScript - Fundament Full-Stack

JavaScript to jedyny język działający zarówno w przeglądarce jak i na serwerze (Node.js). Dla Full-Stack Developera znajomość JS jest absolutnie kluczowa.

JavaScript - co musisz wiedzieć

Fundamenty:

• Closures, hoisting, scope (let/const/var)
• this keyword - jak działa w różnych kontekstach
• Prototypy i dziedziczenie prototypowe
• Event loop - jak działa asynchroniczność

// Klasyczne pytanie: co wypisze ten kod?
console.log('1');
setTimeout(() => console.log('2'), 0);
Promise.resolve().then(() => console.log('3'));
console.log('4');

// Odpowiedź: 1, 4, 3, 2
// Synchroniczne → Microtasks (Promise) → Macrotasks (setTimeout)

Async/await i Promises:

// Typowe zadanie: pobierz dane sekwencyjnie vs równolegle
// Sekwencyjnie (wolne)
const user = await fetchUser(id);
const posts = await fetchPosts(user.id);
const comments = await fetchComments(posts[0].id);

// Równolegle (szybkie)
const [users, products, orders] = await Promise.all([
  fetchUsers(),
  fetchProducts(),
  fetchOrders()
]);

ES6+ features:

• Destructuring, spread operator, rest parameters
• Arrow functions i ich this
• Modules (import/export)
• Optional chaining (?.) i nullish coalescing (??)

👉 Szczegółowe pytania: Najtrudniejsze Pytania JavaScript

TypeScript - must-have w 2026

TypeScript to standard w profesjonalnym developmencie. Full-Stack Developer musi go znać.

// Typowe pytanie: co jest źle z tym kodem?
interface User {
  id: number;
  name: string;
  email?: string;
}

function sendEmail(user: User) {
  // Błąd: email może być undefined!
  sendTo(user.email.toLowerCase());
}

// Poprawnie:
function sendEmail(user: User) {
  if (user.email) {
    sendTo(user.email.toLowerCase());
  }
}
// Lub z non-null assertion (jeśli jesteś pewien):
sendTo(user.email!.toLowerCase());

Kluczowe tematy:

• Typy podstawowe vs złożone
• Interface vs Type
• Generics
• Utility types (Partial, Pick, Omit, Record)
• Type guards i narrowing

👉 Szczegółowe pytania: TypeScript dla Początkujących

---

Frontend - React, Angular lub Vue

Większość ofert Full-Stack wymaga znajomości jednego z głównych frameworków. React dominuje, ale Angular i Vue też są popularne.

React - najpopularniejszy wybór

Hooks - fundament React:

function UserProfile({ userId }) {
  const [user, setUser] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetchUser(userId)
      .then(setUser)
      .finally(() => setLoading(false));
  }, [userId]); // Dependency array!

  // Memoizacja dla optymalizacji
  const formattedName = useMemo(
    () => formatName(user?.name),
    [user?.name]
  );

  if (loading) return <Spinner />;
  return <div>{formattedName}</div>;
}

State management:

• useState/useReducer dla lokalnego stanu
• Context API dla globalnego stanu (proste przypadki)
• Redux/Zustand dla złożonych aplikacji

Kluczowe pytania:

• Kiedy useEffect vs useLayoutEffect?
• Jak unikać zbędnych rerenderów?
• Virtual DOM - jak działa?
• React 19 - co nowego?

👉 Szczegółowe pytania: Najtrudniejsze Pytania React

Angular - enterprise alternative

Jeśli aplikujesz do korporacji, Angular może być wymagany:

@Component({
  selector: 'app-user-list',
  template: `
    <div *ngFor="let user of users$ | async">
      {{ user.name }}
    </div>
  `
})
export class UserListComponent {
  users$ = this.http.get<User[]>('/api/users');

  constructor(private http: HttpClient) {}
}

Kluczowe tematy:

• Dependency Injection
• RxJS i Observables
• Signals (Angular 17+)
• Change Detection

👉 Więcej o Angular: Kompletny Przewodnik - Rozmowa Frontend Developer

---

Backend - Node.js i Express/NestJS

Dla Full-Stack z JavaScript, Node.js to naturalny wybór backendu. Ten sam język na froncie i backendzie.

Node.js fundamentals

Event loop w Node.js:

// Node.js jest single-threaded ale non-blocking
const fs = require('fs');

// Blokujące (źle dla performance)
const data = fs.readFileSync('file.txt');

// Non-blocking (dobrze)
fs.readFile('file.txt', (err, data) => {
  console.log(data);
});
console.log('To wykona się przed odczytem pliku!');

Kluczowe pytania:

• Jak działa Event Loop w Node.js?
• Czym różni się od Event Loop w przeglądarce?
• Jak obsłużyć CPU-intensive tasks? (Worker Threads)
• Streams - kiedy używać?

Express.js - minimalistyczny framework

const express = require('express');
const app = express();

// Middleware
app.use(express.json());
app.use(cors());

// Routes
app.get('/api/users', async (req, res) => {
  try {
    const users = await User.findAll();
    res.json(users);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Error handling middleware
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Something broke!' });
});

👉 Szczegółowe pytania: Express.js Pytania Rekrutacyjne

NestJS - enterprise Node.js

NestJS to Angular dla backendu - TypeScript, dekoratory, DI:

@Controller('users')
export class UsersController {
  constructor(private usersService: UsersService) {}

  @Get()
  findAll(): Promise<User[]> {
    return this.usersService.findAll();
  }

  @Post()
  @UseGuards(AuthGuard)
  create(@Body() createUserDto: CreateUserDto): Promise<User> {
    return this.usersService.create(createUserDto);
  }
}

👉 Szczegółowe pytania: NestJS Pytania Rekrutacyjne

👉 Kompletny przewodnik Node.js: Kompletny Przewodnik - Rozmowa Node.js Backend

---

REST API Design

Full-Stack Developer musi umieć projektować i implementować API. To most między frontendem a backendem.

Podstawy REST

GET    /api/users          → Lista użytkowników
GET    /api/users/123      → Konkretny użytkownik
POST   /api/users          → Utwórz użytkownika
PUT    /api/users/123      → Zastąp użytkownika
PATCH  /api/users/123      → Częściowa aktualizacja
DELETE /api/users/123      → Usuń użytkownika

Typowe pytania rekrutacyjne

PUT vs PATCH:

// PUT - zastępuje cały zasób
PUT /users/123
{ "name": "John", "email": "john@example.com", "role": "admin" }

// PATCH - aktualizuje tylko podane pola
PATCH /users/123
{ "email": "newemail@example.com" }

Statusy HTTP:

200 OK           // Sukces
201 Created      // Zasób utworzony
204 No Content   // Sukces bez body (DELETE)
400 Bad Request  // Błąd walidacji
401 Unauthorized // Brak autentykacji
403 Forbidden    // Brak uprawnień
404 Not Found    // Zasób nie istnieje
409 Conflict     // Konflikt (np. duplikat)
500 Server Error // Błąd serwera

Paginacja:

GET /api/users?page=2&limit=20

// Response
{
  "data": [...],
  "meta": {
    "total": 150,
    "page": 2,
    "limit": 20,
    "totalPages": 8
  }
}

👉 Szczegółowe pytania: REST API - Pytania Rekrutacyjne

---

Bazy danych - SQL i NoSQL

Full-Stack Developer musi rozumieć oba światy: relacyjne (SQL) i dokumentowe (NoSQL).

SQL - relacyjne bazy danych

-- Klasyczne pytanie: znajdź użytkowników z więcej niż 5 zamówieniami
SELECT u.name, COUNT(o.id) as order_count
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
GROUP BY u.id, u.name
HAVING COUNT(o.id) > 5
ORDER BY order_count DESC;

Kluczowe tematy:

• JOINs (INNER, LEFT, RIGHT, FULL)
• GROUP BY i agregacje
• Subqueries
• Indeksy i optymalizacja
• Transakcje (ACID)

👉 Szczegółowe pytania: SQL Pytania Rekrutacyjne

MongoDB - dokumentowa baza danych

// Znajdź aktywnych użytkowników z zamówieniami > $100
db.users.aggregate([
  { $match: { status: 'active' } },
  {
    $lookup: {
      from: 'orders',
      localField: '_id',
      foreignField: 'userId',
      as: 'orders'
    }
  },
  { $unwind: '$orders' },
  { $match: { 'orders.total': { $gt: 100 } } },
  {
    $group: {
      _id: '$_id',
      name: { $first: '$name' },
      totalSpent: { $sum: '$orders.total' }
    }
  }
]);

Kiedy SQL vs NoSQL:

Kryterium	SQL	NoSQL (MongoDB)
Schemat	Sztywny	Elastyczny
Relacje	Silne (JOIN)	Słabe (embed/reference)
Transakcje	ACID	Eventually consistent*
Skalowanie	Vertical	Horizontal
Use case	Finanse, ERP	Content, Real-time

*MongoDB 4.0+ wspiera multi-document ACID transactions

👉 Szczegółowe pytania: MongoDB Pytania Rekrutacyjne

ORM - Prisma, Sequelize, TypeORM

// Prisma - nowoczesny ORM
const usersWithPosts = await prisma.user.findMany({
  where: { active: true },
  include: {
    posts: {
      where: { published: true },
      orderBy: { createdAt: 'desc' },
      take: 5
    }
  }
});

---

Autentykacja i autoryzacja

Każda aplikacja Full-Stack wymaga obsługi użytkowników. Musisz znać podstawy security.

JWT (JSON Web Tokens)

// Generowanie tokena
const jwt = require('jsonwebtoken');

const token = jwt.sign(
  { userId: user.id, role: user.role },
  process.env.JWT_SECRET,
  { expiresIn: '1h' }
);

// Weryfikacja w middleware
function authMiddleware(req, res, next) {
  const token = req.headers.authorization?.split(' ')[1];

  if (!token) {
    return res.status(401).json({ error: 'No token provided' });
  }

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    return res.status(401).json({ error: 'Invalid token' });
  }
}

Flow autentykacji

1. User: POST /auth/login { email, password }
2. Server: Validate credentials
3. Server: Generate JWT token
4. Server: Return { token, user }
5. Client: Store token (localStorage/cookie)
6. Client: Add "Authorization: Bearer <token>" to requests
7. Server: Verify token in middleware

Typowe pytania

• Gdzie przechowywać token? localStorage vs httpOnly cookie
• Access token vs Refresh token - po co dwa tokeny?
• JWT vs Session - kiedy co stosować?
• OAuth 2.0 - flow autoryzacji z Google/GitHub

---

DevOps basics dla Full-Stack

Full-Stack Developer powinien umieć zdeployować swoją aplikację. Podstawy DevOps są kluczowe.

Docker

# Multi-stage build dla Node.js
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 3000
CMD ["node", "dist/main.js"]

Docker Compose dla local development:

version: '3.8'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/myapp
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: myapp
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

👉 Szczegółowe pytania: Docker Pytania Rekrutacyjne

CI/CD basics

# GitHub Actions - prosty pipeline
name: CI/CD

on:
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm ci
      - run: npm test
      - run: npm run build

  deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to production
        run: |
          # Deploy script here

---

System Design dla Full-Stack

Na rozmowach senior Full-Stack pytają o projektowanie systemów. Musisz umieć myśleć end-to-end.

Typowe zadanie: Zaprojektuj aplikację e-commerce

┌─────────────────────────────────────────────────────────────┐
│                        FRONTEND                              │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │   React     │  │   Next.js   │  │    CDN      │         │
│  │   SPA       │  │    SSR      │  │   Assets    │         │
│  └──────┬──────┘  └──────┬──────┘  └─────────────┘         │
└─────────┼────────────────┼──────────────────────────────────┘
          │                │
          ▼                ▼
┌─────────────────────────────────────────────────────────────┐
│                      API GATEWAY                             │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  Rate Limiting │ Auth │ Routing │ Load Balancing   │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘
          │
          ▼
┌─────────────────────────────────────────────────────────────┐
│                       BACKEND                                │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │  User    │  │  Product │  │  Order   │  │  Payment │   │
│  │ Service  │  │ Service  │  │ Service  │  │ Service  │   │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘   │
└───────┼─────────────┼─────────────┼─────────────┼──────────┘
        │             │             │             │
        ▼             ▼             ▼             ▼
┌─────────────────────────────────────────────────────────────┐
│                      DATA LAYER                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │ PostgreSQL│  │  Redis   │  │ MongoDB  │  │   S3     │   │
│  │  (Users)  │  │ (Cache)  │  │ (Products)│ │ (Files)  │   │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘   │
└─────────────────────────────────────────────────────────────┘

Pytania, które padają

1. Jak obsłużysz 10x więcej użytkowników?

   • Horizontal scaling (więcej serwerów)
   • Caching (Redis)
   • CDN dla static assets
   • Database read replicas

2. Jak zapewnisz availability?

   • Load balancer
   • Health checks
   • Graceful degradation
   • Circuit breaker

3. Jak obsłużysz płatności?

   • Idempotency keys
   • Saga pattern dla distributed transactions
   • Eventual consistency

👉 Szczegółowe wzorce: Wzorce i Architektura Backend

---

Projekt portfolio - Full-Stack App

Najlepsza przygotowanie to zbudowanie własnego projektu. Oto co powinien zawierać:

Minimalny Full-Stack projekt

my-fullstack-app/
├── frontend/
│   ├── src/
│   │   ├── components/
│   │   ├── pages/
│   │   ├── hooks/
│   │   ├── services/     # API calls
│   │   └── App.tsx
│   └── package.json
│
├── backend/
│   ├── src/
│   │   ├── controllers/
│   │   ├── services/
│   │   ├── models/
│   │   ├── middleware/
│   │   └── app.ts
│   └── package.json
│
├── docker-compose.yml
└── README.md

Checklist do portfolio

• Frontend: React/Next.js z TypeScript
• Backend: Node.js (Express lub NestJS)
• Baza danych: PostgreSQL lub MongoDB
• Autentykacja: JWT z refresh tokens
• API: REST z walidacją
• Docker: docker-compose dla local dev
• Testy: Unit + Integration tests
• CI/CD: GitHub Actions pipeline
• README: Setup instructions, API docs

---

Plan przygotowania - 4 tygodnie

Tydzień 1: JavaScript i Frontend

• JavaScript fundamentals (closures, async/await, Event Loop)
• TypeScript basics
• React hooks (useState, useEffect, useMemo, useCallback)
• State management basics

Tydzień 2: Backend i API

• Node.js fundamentals
• Express.js routing, middleware
• REST API design
• Autentykacja (JWT)

Tydzień 3: Bazy danych i ORM

• SQL queries (JOIN, GROUP BY, agregacje)
• MongoDB basics
• ORM (Prisma lub Sequelize)
• Modelowanie danych

Tydzień 4: DevOps i praktyka

• Docker i docker-compose
• CI/CD basics
• System Design fundamentals
• Mock interviews, portfolio review

---

Zobacz też

Frontend

• Kompletny Przewodnik - Rozmowa Frontend Developer - głębokie zanurzenie w frontend
• Najtrudniejsze Pytania JavaScript - zaawansowany JS
• Najtrudniejsze Pytania React - React deep dive
• TypeScript dla Początkujących - podstawy TS

Backend

• Kompletny Przewodnik - Rozmowa Node.js Backend - Node.js ecosystem
• Express.js Pytania Rekrutacyjne - Express framework
• NestJS Pytania Rekrutacyjne - NestJS framework
• REST API - Pytania Rekrutacyjne - API design

Bazy danych

• SQL Pytania Rekrutacyjne - relacyjne bazy
• MongoDB Pytania Rekrutacyjne - NoSQL

DevOps

• Docker Pytania Rekrutacyjne - konteneryzacja
• Wzorce i Architektura Backend - architektura

---

Ostatnia aktualizacja: Styczeń 2026