As a Backend Developer, Slap yourself if you cannot clearly explain at least 10 of the following:
TCP congestion control algorithms
TLS 1.3 handshake internals
HTTP/2 multiplexing & HPACK
HTTP/3 QUIC packet loss recovery
Connection pooling pitfalls
Zero-downtime deployment strategies
Database transaction isolation levels (serializable vs snapshot)
B-tree vs LSM-tree index internals
Query planner & cost-based optimization
Deadlock detection & prevention
ACID vs BASE trade-offs
Two-phase commit vs Saga pattern
Distributed locking (Redlock pitfalls)
CAP theorem in practice
CRDTs & conflict-free replicated data types
Eventual consistency anti-patterns
Kafka partition rebalancing & exactly-once semantics
RabbitMQ dead-letter queues & message ordering
gRPC streaming flow control
GraphQL resolver batching & N 1 problem
OAuth2 token introspection vs JWT validation
Rate limiting algorithms (token bucket vs leaky bucket)
Circuit breaker bulkhead patterns
Observability: OpenTelemetry tracing propagation
Prometheus metric cardinality explosion
Log aggregation with sampling
Memory-mapped files vs traditional I/O
Garbage collection tuning (G1 vs ZGC)
Thread pools vs virtual threads (Project Loom)
Actor model vs shared-memory concurrency
Message-driven architecture (Akka / Orleans)
CQRS Event Sourcing projections
Outbox pattern for reliable events
Sharding strategies & hot partition avoidance
Read replicas lag monitoring
Database connection pool exhaustion
Prepared statement caching
Index bloat & vacuum strategies
Kubernetes pod disruption budgets
Service mesh traffic shifting
Serverless cold-start mitigation
API gateway throttling & caching layers
Background job queues (Celery / BullMQ) retry semantics
Distributed cache invalidation (cache-aside vs write-through)
Eventual consistency in cache
Idempotency keys in API design
Optimistic locking with version vectors
Paxos / Raft consensus internals
Byzantine fault tolerance basics
Chaos engineering principles
Database failover & split-brain prevention
Microservices observability (distributed tracing)
API contract testing (Pact / Spring Cloud Contract)
Backward-compatible schema evolution
Protobuf vs JSON performance trade-offs
Binary protocol parsing
Zero-copy networking (sendfile)
epoll / kqueue internals
Syscall overhead & context switching
Memory barriers & CPU cache coherence
Lock-free data structures
Bloom filters & HyperLogLog in practice
Consistent hashing for load balancing
Virtual memory & page faults impact
Container runtime security (seccomp, AppArmor)
Sidecar pattern limitations
Service discovery (Consul vs DNS)
Blue-green vs canary deployments
Feature flags with rollout strategies
Data pipeline backpressure handling
Exactly-once processing guarantees
Idempotent consumers in event streams
And if you only know 10 — kindly return the “Senior Backend Developer” title. 😄
As a Frontend Developer,
Slap yourself if you cannot clearly explain at least 10 of the following:
Pointer events
ARIA live regions internals
Accessibility tree
Idempotent UI actions
Deterministic rendering
Priority inversion in async code
Speculative prerendering
Largest Contentful Paint (LCP)
Cumulative Layout Shift (CLS)
Interaction to Next Paint (INP)
First Input Delay (FID)
Long tasks API
PerformanceObserver API
Garbage collection timing
Detached DOM nodes
Browser memory leak detection
Streaming fetch response handling
AbortController
Backpressure in streams API
WebRTC
CRDT basics for collaboration
Offline conflict resolution
Optimistic UI rollback strategy
Event sourcing in frontend
Finite state modeling
Micro-frontend orchestration
Edge rendering
Server components
Selective hydration
Suspense boundaries
Render waterfalls
Scheduler priorities
Tearing in concurrent UI
Race conditions in UI state
Prototype pollution
DOM clobbering
Trusted Types
Content Security Policy (CSP)
CSRF vs XSS mitigation
SameSite cookie modes
CORS preflight
Preload vs Prefetch vs Preconnect
Priority hints
HTTP/3 and QUIC
ETag vs Cache-Control
Stale-while-revalidate
Cache invalidation strategies
Service Worker lifecycle traps
IndexedDB
MutationObserver cost
ResizeObserver loop limits
IntersectionObserver internals
Subpixel rendering
CSS containment
GPU acceleration in CSS
Paint vs composite vs layout
Browser compositing layers
WebAssembly integration
OffscreenCanvas
Transferable objects
SharedArrayBuffer
Web Workers vs Service Workers
Web Components interoperability
Custom Elements lifecycle
Shadow DOM
Module federation
Dynamic import chunking
Code splitting strategies
Tree shaking internals
Render blocking resources
Critical rendering path
Layout thrashing
Task starvation
Event loop (macro vs microtasks)
Stale closure problem
Memoization pitfalls
Referential equality
Immutable data patterns
Structural sharing
Virtual DOM diffing complexity
Fiber architecture
Reconciliation algorithm
Time slicing
Concurrent rendering
Streaming SSR
Islands architecture
Partial hydration
Hydration
And if you only know 10 — kindly return the "Senior Frontend Developer" title. 😄