Fullstack Developer Interview & Technical Review Flashcards

Vocabulary flashcards covering technical concepts, interview strategy, Java, Spring Boot, Angular, REST, testing, Kotlin, and DevOps topics from the compeople Fullstack Developer interview preparation transcript.

compeople

Frankfurt-based IT consulting and software development company founded in 1999, specializing in Cloud, Automation, Data & AI, and Experience.

DVAG Salesforce Solution

A tailored solution developed by compeople for around 18,000 consultants at Deutsche Vermögensberatung (DVAG).

Agentic SDLC Blueprint & Agentic Business Canvas

Key AI initiatives active at compeople in 2026 focusing on AI integration within the software development lifecycle and business processes.

STAR Method

A structured technique used to answer behavioral interview questions by describing Situation, Task, Action, and Result (applied during system transition at B. Braun).

LLM Quality Assurance for Data Extraction

Methods to ensure reliable output from Large Language Models, including structured JSON Schema outputs, code-level validation, test datasets with target values, prompt versioning, and human review for critical values.

AI Development Risks & Mitigation

Risks include Prompt Injection, data leaks, insecure code, and hallucinations. Mitigation relies on automated tests, code reviews, restricted agent permissions, and human approval for critical steps.

Java == vs. equals()

The '==' operator compares object references (checking if both point to the exact same object in memory), whereas 'equals()' compares the actual logical content when overridden.

Java equals() and hashCode() Contract

Objects that are equal according to equals() must return identical hashCode() values; violating this breaks hash-based collections like HashMap and HashSet.

Java Record

Introduced in Java 16 as a compact, immutable data class that automatically generates private final fields, constructors, getters, equals(), hashCode(), and toString(). Ideal for DTOs.

Checked vs. Unchecked Exceptions

Checked exceptions subclass Exception (excluding RuntimeException) and must be handled or declared. Unchecked exceptions subclass RuntimeException. By default, @Transactional rolls back only on unchecked exceptions.

Java Optional Usage

Intended specifically as a return type to signal that a value can be missing. It should not be used for class fields or method parameters.

orElse() vs. orElseGet()

In Java Optional, orElse() evaluates its default argument immediately regardless of value presence, whereas orElseGet() accepts a Supplier that evaluates lazily only when empty.

List vs. Set vs. Map

List is an ordered collection allowing duplicates; Set prevents duplicate elements; Map stores key-value pairs with unique keys.

ArrayList vs. LinkedList

ArrayList provides fast O(1) indexed random access and is almost always preferred in practice, whereas LinkedList is rarely optimal for general usage.

Java Streams: map vs. flatMap

map transforms each element into a single element. flatMap transforms each element into a stream and flattens all resulting streams into a single stream.

Stream Intermediate vs. Terminal Operations

Intermediate operations (e.g., filter, map) are lazy and build a pipeline; terminal operations (e.g., collect, forEach, count) trigger execution of the stream pipeline.

Immutability

Object state that cannot be modified after creation, achieved via final fields, no setters, and defensive copies. Benefits include thread safety without synchronization and simpler testing.

Java Stack vs. Heap

Stack memory is thread-specific and stores local variables and active method calls. Heap memory is shared across all threads and holds instantiated objects cleaned by the Garbage Collector.

Race Condition

Occurs when multiple threads concurrently read/write shared mutable state, leading to nondeterministic behavior. Avoided using immutable objects, synchronized, Atomic classes, or ConcurrentHashMap.

Virtual Threads

Lightweight JVM-managed threads introduced in Java 21 for high-throughput blocking I/O tasks, enabled in Spring Boot 3.2+ via spring.threads.virtual.enabled=true.

Interface vs. Abstract Class

An Interface defines a contract supporting multiple inheritance and default methods without instance state. An Abstract Class shares instance state and common code but allows only single inheritance.

SOLID Principles

Five software design principles: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion (implemented via Spring Dependency Injection).

Spring Constructor Injection

The preferred Dependency Injection approach that allows final fields, clearly exposes required dependencies, and enables easy testing without invoking a Spring context.

Spring Bean Scopes

Defines bean lifecycle: singleton (default, one instance per container), prototype (new instance per request), request, and session. Singleton beans should remain stateless.

Spring Stereotype Annotations

Specialized @Component annotations: @Service highlights service-layer logic, @Repository adds persistence exception translation, and @RestController combines @Controller and @ResponseBody.

Spring @Transactional

Creates a proxy that opens a transaction before method execution, commits on success, and triggers a rollback upon RuntimeException or Error (checked exceptions require rollbackFor).

Self-Invocation in Spring

Calling a method on 'this' inside the same bean bypasses the Spring proxy, rendering proxy-based annotations like @Transactional, @Cacheable, and @Async ineffective.

Propagation REQUIRED vs. REQUIRES_NEW

REQUIRED (default) joins an existing transaction or starts one if none exists. REQUIRES_NEW always suspends the outer transaction and initiates an independent new transaction.

@Transactional(readOnly = true)

An optimization hint allowing persistence providers like Hibernate to skip dirty-checking checks on read-only queries.

N+1 Query Problem

Performance issue where fetching 1 query for an entity list triggers N additional queries for lazy relationships. Solved using JOIN FETCH, @EntityGraph, or DTO projections.

LazyInitializationException

Exception thrown by Hibernate when code accesses a lazily-loaded relationship outside an active session or transaction boundary.

Spring @Cacheable

Caches method results based on parameter combinations (activated by @EnableCaching); removed via @CacheEvict. Runs via AOP proxy (subject to self-invocation limits).

Global REST Error Handling in Spring

Uses @RestControllerAdvice with @ExceptionHandler methods to return consistent error formats like RFC 9457 ProblemDetail (standard in Spring 6).

Spring DTO Validation

Uses Bean Validation annotations (@NotNull, @Size, @Email) on DTO fields and @Valid on Controller parameters, producing HTTP 400 Bad Request on failure.

Spring Test Annotations (@SpringBootTest vs @WebMvcTest vs @DataJpaTest)

@SpringBootTest loads the entire application context. @WebMvcTest isolates the web layer (mocking services via @MockitoBean / @MockBean). @DataJpaTest tests only JPA persistence with a test database.

Testcontainers

A testing library that provisions real database instances (e.g., PostgreSQL) inside Docker containers during integration test runs.

Spring Boot Actuator

Provides production-ready management endpoints (e.g., /actuator/health and metrics) used for application monitoring and health checks in Kubernetes or Azure.

PUT vs. PATCH vs. POST and Idempotency

PUT replaces resources entirely, PATCH partially modifies, and POST creates new resources. GET, PUT, and DELETE are idempotent (repeated requests yield identical server state); POST is non-idempotent.

Angular OnPush Change Detection

Optimization strategy that skips component subtree checks unless Input references change, events emit inside the component, an async pipe receives a value, or Signals change.

Angular Signals

Reactive state primitive introduced in Angular 16 using signal(), computed(), and effect(), enabling fine-grained DOM updates without full component-tree checks.

RxJS switchMap vs. mergeMap vs. concatMap

switchMap cancels prior inner subscriptions (ideal for search inputs); mergeMap handles subscriptions concurrently; concatMap executes inner observables sequentially.

Angular Standalone Components

Components created without NgModules that list their own dependencies directly in their imports array. Recommended since Angular 17 and default in Angular 19.

TypeScript any vs. unknown

any disables static type checking. unknown forces explicit type checks or assertions before invoking methods or accessing properties.

TypeScript interface vs. type

interface is open and extensible, ideal for defining object shapes; type supports union types, primitive aliases, and complex tuple combinations.

Test Pyramid

Testing strategy composed of a broad base of fast Unit Tests, a moderate layer of Integration Tests, and a thin top layer of End-to-End Tests.

Testing Library Core Principle

Tests should interact with software in the same way users do by selecting UI elements via role, label, or text rather than component internal implementation details.

Kotlin Operators: ?. , ?: , !!

?. (Safe Call) evaluates to null without throwing NPE; ?: (Elvis Operator) returns a fallback value when null; !! forces non-null conversion, raising a NullPointerException if null.

Spring Boot Dockerfile Best Practices

Use a slim JRE base image, implement multi-stage builds, execute as a non-root user, pass configs via environment variables, and configure health checks.