Sollicitatievragen voor software engineers met antwoorden (2026): coderen, fundamenten, systeemontwerp en gedrag

Sollicitatiegesprekken voor software engineers volgen bij de meeste bedrijven een vast patroon: een telefoontje van een recruiter, een of twee programmeerrondes, een ronde systeemontwerp voor medior en senior rollen, en een gedragsronde. Hieronder staan 20 sollicitatievragen voor software engineers met antwoorden, gegroepeerd per ronde. Elk codevoorbeeld is getest tegen een brute-force versie op duizenden willekeurige invoeren voordat we het publiceerden.

Wat elke ronde test

Sollicitatiegesprekken voor net afgestudeerden gaan vooral over programmeren en gedrag. Bij senior gesprekken komt er meer systeemontwerp bij, en verwachten ze diepere antwoorden over eerdere projecten. Voor het telefoontje met de recruiter, zie onze telefonische screening-vragen.

Programmeervragen

Doe in elke programmeerronde drie dingen: zeg je aanpak hardop voordat je typt, benoem de tijds- en geheugencomplexiteit, en test aan het eind met een klein voorbeeld. Onze Big O-spiekbriefje behandelt het complexiteitsdeel.

1. Two sum: geef de indices van twee getallen die optellen tot een doel

Sla elk getal en zijn index op in een hashmap. Controleer bij elk nieuw getal of het complement al in de map zit.

def two_sum(nums, target):
    seen = {}
    for i, x in enumerate(nums):
        if target - x in seen:
            return [seen[target - x], i]
        seen[x] = i
    return []

print(two_sum([2, 7, 11, 15], 9))  # [0, 1]

O(n) tijd en O(n) geheugen. De brute-force versie controleert elk paar in O(n²), en interviewers willen meestal dat je die eerst noemt en daarna verbetert.

2. Geldige haakjes: controleer of elk haakje in de juiste volgorde is gesloten

Zet openingshaakjes op een stapel. Bij een sluithaakje moet het bovenste item op de stapel het bijbehorende openingshaakje zijn.

def is_valid(s):
    pairs = {")": "(", "]": "[", "}": "{"}
    stack = []
    for ch in s:
        if ch in pairs:
            if not stack or stack.pop() != pairs[ch]:
                return False
        else:
            stack.append(ch)
    return not stack

print(is_valid("([]{})"), is_valid("(]"))  # True False

O(n) tijd en O(n) geheugen. De laatste regel is belangrijk: een string als "((" laat items op de stapel achter en is niet geldig.

3. Samenvoegen van overlappende intervallen

Sorteer op starttijd, en breid dan het laatste samengevoegde interval uit of begin een nieuw interval.

def merge_intervals(intervals):
    merged = []
    for start, end in sorted(intervals):
        if merged and start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])
    return merged

print(merge_intervals([[1, 3], [2, 6], [8, 10], [15, 18]]))
# [[1, 6], [8, 10], [15, 18]]

O(n log n) tijd door het sorteren. Vraag of intervallen die elkaar raken, zoals [1, 2] en [2, 3], moeten worden samengevoegd. Deze versie voegt ze samen.

4. Keer een gelinkte lijst om

Loop één keer door de lijst en laat elk knooppunt naar het vorige knooppunt wijzen.

class ListNode:
    def __init__(self, val, next=None):
        self.val = val
        self.next = next

def reverse_list(head):
    prev = None
    while head:
        head.next, prev, head = prev, head, head.next
    return prev

O(n) tijd en O(1) extra geheugen. Als de meervoudige toewijzing de interviewer te slim lijkt, schrijf het dan als drie regels met een tijdelijke variabele. Duidelijk gaat boven kort.

5. Geef de k meest voorkomende elementen terug

Tel met een hashmap, en pak daarna de k grootste aantallen met een heap.

from collections import Counter
import heapq

def top_k_frequent(nums, k):
    counts = Counter(nums)
    return [x for x, _ in heapq.nlargest(k, counts.items(), key=lambda p: p[1])]

print(top_k_frequent([1, 1, 1, 2, 2, 3], 2))  # [1, 2]

O(n log k) tijd. Een vervolgvraag is bucket sort op frequentie, dat geeft O(n).

6. Ontwerp een LRU-cache met O(1) get en put

Je hebt snel opzoeken nodig en snel herordenen op basis van recent gebruik. Een hashmap plus een dubbel gelinkte lijst doet beide. In Python is OrderedDict precies die combinatie.

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.data = OrderedDict()

    def get(self, key):
        if key not in self.data:
            return -1
        self.data.move_to_end(key)
        return self.data[key]

    def put(self, key, value):
        if key in self.data:
            self.data.move_to_end(key)
        self.data[key] = value
        if len(self.data) > self.capacity:
            self.data.popitem(last=False)

Sommige interviewers vragen je de gelinkte lijst zelf te bouwen. Leg eerst de structuur uit: de map wijst naar lijstknooppunten, het meest recente knooppunt staat aan het ene uiteinde, en je verwijdert vanaf het andere uiteinde.

7. Kortste pad in een raster met muren

Breedte-eerst zoeken (BFS) vindt het kortste pad wanneer elke stap even veel kost.

from collections import deque

def shortest_path(grid):
    rows, cols = len(grid), len(grid[0])
    if grid[0][0] or grid[rows - 1][cols - 1]:
        return -1
    queue = deque([(0, 0, 0)])
    seen = {(0, 0)}
    while queue:
        r, c, steps = queue.popleft()
        if (r, c) == (rows - 1, cols - 1):
            return steps
        for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):
            nr, nc = r + dr, c + dc
            if 0 <= nr < rows and 0 <= nc < cols and not grid[nr][nc] and (nr, nc) not in seen:
                seen.add((nr, nc))
                queue.append((nr, nc, steps + 1))
    return -1

print(shortest_path([[0, 0, 0], [1, 1, 0], [0, 0, 0]]))  # 4

O(rijen × kolommen) tijd en geheugen. Markeer cellen als gezien wanneer je ze aan de wachtrij toevoegt, niet wanneer je ze eruit haalt, anders wordt dezelfde cel vele keren in de wachtrij gezet.

8. Vind de eerste foute versie

Versies 1 tot n zijn goed tot een bepaald punt en daarna fout. Binaire zoekactie vindt de eerste foute versie in O(log n) controles.

def first_bad_version(n, is_bad):
    lo, hi = 1, n
    while lo < hi:
        mid = (lo + hi) // 2
        if is_bad(mid):
            hi = mid
        else:
            lo = mid + 1
    return lo

Dit patroon geldt voor elke ja-of-nee-vraag die maar één keer omslaat, en dat komt vaak voor. Voor een lijst met opgaven die deze patronen behandelen, zie Blind 75.

Vragen over CS-fundamenten

9. Wat is het verschil tussen een proces en een thread?

Een proces is een draaiend programma met een eigen geheugenruimte. Threads draaien binnen een proces en delen het geheugen ervan. Threads zijn goedkoper om aan te maken en ertussen te wisselen, en ze kunnen data direct delen, maar juist dat delen is de reden dat je locks nodig hebt en dat race conditions ontstaan. Processen zijn geïsoleerd, dus een crash in het ene proces haalt de andere niet onderuit.

10. Wat is het verschil tussen TCP en UDP?

TCP zet een verbinding op en garandeert geordende, betrouwbare aflevering met hertransmissie en flow control. UDP stuurt onafhankelijke pakketjes zonder garantie op aflevering of volgorde, en met minder overhead. Gebruik TCP voor webpagina's, API's en bestandsoverdracht. UDP past bij live spraak, video en games, waar een te laat pakket toch niets meer waard is. Onze vragen over computernetwerken in sollicitatiegesprekken gaan verder.

11. Wat gebeurt er als je een URL in een browser typt en op Enter drukt?

De browser zet het domein via DNS om naar een IP-adres, opent een TCP-verbinding en doet bij HTTPS een TLS-handshake. Hij stuurt een HTTP-verzoek, en de server, vaak achter een load balancer, stuurt een antwoord terug. De browser verwerkt de HTML, vraagt de CSS, JavaScript en afbeeldingen op waarnaar wordt verwezen, en toont de pagina. Ga dieper in op het onderdeel dat de interviewer kiest.

12. Hoe werkt een hashtabel, en wat is de tijdcomplexiteit?

Een hashfunctie zet elke sleutel om naar een bucket in een array. Opzoeken, invoegen en verwijderen zijn gemiddeld O(1). Als twee sleutels in dezelfde bucket terechtkomen, lost de tabel de botsing op door te ketenen of door een andere plek te proberen, en hij vergroot zichzelf als hij te vol raakt. In het slechtste geval is het O(n), als veel sleutels botsen.

13. Wanneer kies je een SQL-database boven een NoSQL-database?

Kies SQL wanneer de data relationeel is, je joins en transacties nodig hebt en het schema redelijk stabiel is: bestellingen, betalingen, gebruikersaccounts. Kies een document- of key-value store wanneer de toegangspatronen eenvoudig zijn, de datastructuur varieert, of je schrijfbewerkingen over veel machines wilt schalen. Veel systemen gebruiken beide. Het antwoord dat interviewers willen is de afweging, niet een winnaar. Onze REST API-sollicitatievragen behandelen de API-laag die er meestal bovenop zit.

Vragen over systeemontwerp

14. Ontwerp een URL-verkorter

Verduidelijk eerst de eisen: hoeveel nieuwe links per dag, hoeveel keer ze worden geopend, of links verlopen, en of eigen aliassen zijn toegestaan. Behandel daarna de API (aanmaken en doorverwijzen), hoe je korte codes genereert (een teller gecodeerd in base 62, of een willekeurige code met een controle op uniciteit), de opslag (een key-value store van code naar URL), en een cache voor populaire links, omdat lezen veel vaker voorkomt dan schrijven. Sluit af met analytics en misbruikpreventie als de tijd het toelaat. We lopen het hele ontwerp door in onze gids voor systeemontwerp.

15. Ontwerp een rate limiter

Begin met waar hij draait (bij de API-gateway, per gebruiker of per API-sleutel) en wat er gebeurt als een client boven de limiet komt (HTTP 429 met een wachttijd). Een token bucket is de gebruikelijke keuze: elke client heeft een emmer die met een vaste snelheid wordt aangevuld en een maximaal aantal tokens bevat, en elk verzoek gebruikt er één. Zo sta je korte pieken toe en handhaaf je toch een gemiddelde snelheid. Bij meerdere servers houd je de tellers bij in een gedeelde opslag zoals Redis, zodat elke server dezelfde telling ziet. Voor meer oefening, zie onze systeemontwerp-sollicitatievragen.

Gedragsvragen

Gebruik voor elk verhaal een duidelijke structuur: de situatie, wat je hebt gedaan, en het resultaat, met cijfers waar je die hebt.

16. Vertel eens iets over jezelf

Geef een versie van twee minuten over je loopbaan die eindigt met waarom je deze rol wilt. Noem een of twee projecten met concrete resultaten. Onze gids over vertel eens over jezelf bevat voorbeelden.

17. Vertel over een lastige bug die je hebt opgelost

Voorbeeldantwoord: "Onze checkout-service begon een paar keer per dag zonder patroon te time-outen. Ik heb request-ID's aan de logs toegevoegd en ontdekte dat elke time-out kwam van één databasequery, die alleen draaide wanneer een winkelwagen meer dan 50 artikelen had. Op de join-kolom ontbrak een index. Ik heb de index toegevoegd, de trage query ging van ongeveer 4 seconden naar minder dan 50 milliseconden, en ik heb een melding ingesteld op de latentie van die query, zodat we het de volgende keer eerder zien."

18. Vertel over een meningsverschil met een teamgenoot

Voorbeeldantwoord: "Een teamgenoot wilde onze meldingsservice herschrijven in een nieuw framework, en ik vond het risico te hoog vlak voor een lancering. In plaats van in de vergadering te discussiëren, stelde ik voor dat we allebei de kosten en het risico opschreven. We kwamen overeen de twee ergste problemen in de huidige code op te lossen voor de lancering en de herschrijving voor het volgende kwartaal te plannen. De lancering ging op tijd live, en twee maanden later hebben we de herschrijving gedaan met een goed testplan."

19. Vertel over een project dat is mislukt

Kies een echte mislukking waarvan je een deel verantwoordelijk was. Leg uit wat er misging, wat je anders zou doen, en wat je daarna hebt veranderd. Interviewers letten op eerlijkheid en leervermogen, niet op een perfect track record.

20. Waarom wil je hier werken?

Koppel iets specifieks aan het product of het engineeringwerk van het bedrijf aan je eigen ervaring. "Ik gebruik jullie API al twee jaar en ik wil graag aan de platformkant werken" is sterker dan "jullie zijn een geweldig bedrijf."

Vragen om aan de interviewer te stellen

• Hoe ziet een gewone week eruit voor iemand in dit team?
• Hoe wordt het werk gepland, en wie bepaalt de prioriteiten?
• Hoe verlopen code review en deployment hier?
• Hoe ziet succes eruit in de eerste zes maanden?
• Wat is het moeilijkste technische probleem waar het team aan werkt?

Zie vragen die je aan het eind van een sollicitatiegesprek stelt voor meer.

Hoe je je voorbereidt

1. Kies één taal en gebruik die voor elke oefenopgave. Python is de meest gekozen keuze omdat de code kort is. Onze Python-sollicitatievragen behandelen de taal zelf.
2. Oefen per patroon, niet per aantal: hashmaps, twee wijzers, schuivend venster, binaire zoekactie, BFS en DFS, heaps en dynamisch programmeren.
3. Los opgaven hardop op met een timer. Een correcte stille oplossing scoort lager dan een heldere uitgesproken oplossing.
4. Oefen in de editor die je zult gebruiken. Veel bedrijven gebruiken CoderPad, dat een gratis sandbox heeft.
5. Bereid vijf verhalen uit je werk voor die je kunt aanpassen aan de meeste gedragsvragen.
6. Doe voor medior en senior rollen minstens een paar volledige oefensessies systeemontwerp met iemand die vervolgvragen stelt.