Índice completo del banco de preguntas

Fichero generado por scripts/generar-indice.mjs. No lo edites a mano: ejecuta npm run indice.

494 preguntas en 11 áreas · 209 marcadas como [CASO] (análisis de problemas).

¿No sabes por dónde empezar? Los cursos enseñan lo necesario para responderlas.

Área	Preguntas	[CASO]
☕ Java Senior + Microservicios	62	17
🟦 TypeScript Senior + Microservicios	48	26
🐹 Golang Senior + Microservicios	55	18
☁️ AWS	47	16
☁️ Azure	30	12
☁️ GCP	31	12
🧩 Microfrontends	30	12
🔐 Seguridad y Vulnerabilidades	42	13
🔄 Versionamiento de APIs	40	16
📨 Mensajería y Event-Driven (Kafka · RabbitMQ · Colas)	59	17
🧠 Casos de Estudio Transversales	50	50
Total	494	209

---

☕ Java Senior + Microservicios

Carpeta: java-microservicios/ · 62 preguntas

Java Core Avanzado — Preguntas de Entrevista Senior

01-java-core-avanzado.md · 15 preguntas

1. ¿Cómo funciona G1 GC internamente y qué parámetros clave usarías para hacer tuning? — _{JVM / Garbage Collection}
2. ¿Cuándo elegirías ZGC o Shenandoah en lugar de G1? ¿Qué sacrificas? — _{JVM / Garbage Collection}
3. Explica el Java Memory Model: ¿qué es happens-before y por qué importa? — _{Concurrencia / JMM}
4. volatile vs synchronized vs AtomicLong/VarHandle: ¿cuándo usar cada uno? — _{Concurrencia / JMM}
5. ¿Qué garantías especiales dan los campos final y qué es la publicación segura (safe publication)? — _{Concurrencia / JMM}
6. CompletableFuture: composición, manejo de errores y sus pitfalls principales — _Concurrencia
7. ForkJoinPool y work-stealing: ¿cómo funciona y qué problemas causa el commonPool? — _Concurrencia
8. Virtual threads (Project Loom): ¿cómo funcionan, cuándo usarlos y qué es el pinning? — _{Concurrencia / Loom}
9. Structured concurrency: ¿qué problema resuelve frente a ExecutorService y CompletableFuture? — _{Concurrencia / Loom}
10. HashMap por dentro: hashing, resize, treeification y por qué es peligroso en concurrencia — _Colecciones
11. ConcurrentHashMap: ¿cómo logra thread-safety sin un lock global y qué garantías da? — _{Colecciones / Concurrencia}
12. Records: ¿qué aportan realmente, qué limitaciones tienen y cuándo NO usarlos? — _{Lenguaje moderno}
13. Sealed classes + pattern matching: ¿cómo cambian el diseño de dominio en Java moderno? — _{Lenguaje moderno}
14. Streams paralelos: ¿cuándo ayudan, cuándo perjudican y cuáles son sus pitfalls? — _{Streams / Concurrencia}
15. Streams secuenciales: pitfalls avanzados que delatan a un desarrollador junior — _Streams

Spring y Microservicios — Preguntas de Entrevista Senior

02-spring-y-microservicios.md · 16 preguntas

1. ¿Cómo funciona la auto-configuración de Spring Boot por dentro? — _{Spring Boot internals}
2. @Transactional: propagación, rollback y los pitfalls del proxy — _{Spring / Transacciones}
3. ¿Cómo implementarías circuit breakers con Resilience4j y qué configuración importa de verdad? — _Resiliencia
4. Comunicación síncrona vs asíncrona entre microservicios: ¿cómo decides? — _Arquitectura
5. Kafka: consumer groups y rebalancing — ¿qué pasa exactamente y cómo lo controlas? — _Kafka
6. Kafka: ¿qué significa exactly-once realmente y cómo se consigue con Java? — _Kafka
7. Patrón Saga: orquestación vs coreografía para transacciones distribuidas — _Patrones
8. Patrón Outbox: ¿cómo publicas eventos de forma atómica con tu transacción de BD? — _{Patrones / Kafka}
9. Proxies en Spring (JDK vs CGLIB) y ciclo de vida de beans: ¿qué errores reales causan? — _{Spring internals}
10. Spring Cloud Config y configuración dinámica: ¿cómo refrescas configuración sin redeploy y qué riesgos tiene? — _{Spring Cloud}
11. Spring Cloud Gateway: ¿qué papel juega y cómo implementarías rate limiting y resiliencia en el borde? — _{Spring Cloud}
12. CQRS y Event Sourcing: ¿qué resuelven, cómo se implementan y cuándo son una mala idea? — _Patrones
13. Service discovery: ¿Eureka, DNS de Kubernetes o service mesh? ¿Client-side o server-side? — _{Infraestructura de microservicios}
14. Observabilidad en microservicios Java: Micrometer, OpenTelemetry y qué instrumentar — _{Observabilidad}
15. Testcontainers: ¿cómo testeas integración real (BD, Kafka) sin mocks y sin flakiness? — _Testing
16. Contract testing con Pact: ¿cómo evitas romper consumidores sin tests E2E? — _Testing

Casos y Problemas de Producción — Preguntas de Entrevista Senior

03-casos-y-problemas.md · 15 preguntas

1. Memory leak en producción: el heap crece hasta OOM cada 3 días [CASO] — _{JVM / Troubleshooting}
2. Latencia p99 alta en un servicio Spring Boot con p50 normal: ¿cómo lo investigas? [CASO] — _Performance
3. Thread pool exhaustion: Tomcat deja de responder pero la CPU está al 10% [CASO] — _{Concurrencia / Spring}
4. Deadlock en producción: dos funcionalidades se congelan a la vez de forma intermitente [CASO] — _Concurrencia
5. Consumer lag creciente en Kafka: el consumidor procesa pero cada vez va más atrás [CASO] — _Kafka
6. Mensajes duplicados: facturación cobró dos veces el mismo pedido [CASO] — _{Kafka / Patrones}
7. Transacción distribuida que deja datos inconsistentes: pedido pagado sin stock reservado [CASO] — _{Patrones / Datos distribuidos}
8. N+1 queries con JPA/Hibernate: un listado que hace 400 queries [CASO] — _{JPA / Performance}
9. OutOfMemoryError: Metaspace tras varios redeploys o en un servicio con mucha reflection [CASO] — _{JVM / Troubleshooting}
10. Un servicio degradado tumba en cascada a toda la plataforma: anatomía y defensa [CASO] — _{Resiliencia / Arquitectura}
11. Migrar un monolito a microservicios: ¿por dónde empiezas y cómo evitas el desastre? [CASO] — _{Arquitectura / Migración}
12. Full GC pauses de varios segundos: los health checks fallan y los pods se reinician [CASO] — _{JVM / GC}
13. HikariCP agotado: “Connection is not available, request timed out after 30000ms” [CASO] — _{Base de datos / Spring}
14. Pérdida de mensajes: un evento de pedido nunca llegó a facturación [CASO] — _Kafka
15. Hot partition en Kafka: una partición concentra el tráfico y un consumer va ahogado [CASO] — _Kafka

Quarkus, MicroProfile y Native Image — Preguntas de Entrevista Senior

04-quarkus-y-native.md · 16 preguntas

1. ¿Qué hace diferente a Quarkus de Spring Boot por dentro? Build-time processing — _{Quarkus internals}
2. ArC: el CDI de Quarkus — qué implementa, qué no, y el error del “bean eliminado” — _{Quarkus / CDI}
3. GraalVM Native Image: closed-world assumption — qué se rompe y cómo se registra — _{Native Image}
4. JVM vs native: ¿cuándo compensa de verdad compilar a native? — _{Native Image / Arquitectura}
5. Mutiny y el modelo reactivo de Quarkus: Uni, Multi, event loop y @Blocking — _{Reactivo / Mutiny}
6. RESTEasy Reactive: imperativo y reactivo en el mismo stack — ¿cómo decide el dispatch? — _{REST / Quarkus}
7. Panache: active record vs repository, límites y Panache reactive — _{Persistencia / Panache}
8. Configuración en Quarkus: MicroProfile Config, @ConfigMapping, perfiles y la trampa build-time — _{Configuración}
9. SmallRye Fault Tolerance: semántica exacta de @Retry, @Timeout, @CircuitBreaker, @Bulkhead y @Fallback — _{Resiliencia / MicroProfile}
10. Reactive Messaging con Kafka: channels, ack, commit strategies y concurrencia — _{Mensajería / Kafka}
11. Dev mode y Dev Services: live reload, testcontainers automáticos y continuous testing — _{Developer Experience}
12. Testing en Quarkus: @QuarkusTest, @QuarkusIntegrationTest, @InjectMock y test profiles — _Testing
13. Transacciones en Quarkus: Narayana, propagación y el choque bloqueante/reactivo — _{Transacciones}
14. MicroProfile REST Client: interfaces tipadas, fault tolerance y propagación de contexto — _{Integración / MicroProfile}
15. [CASO] En JVM funciona, el binario native peta en producción al deserializar un payload [CASO] — _{Native Image / Troubleshooting}
16. [CASO] Migrar 40 microservicios Spring Boot a Quarkus: ¿tiene sentido? Plan y criterios [CASO] — _{Arquitectura / Migración}

---

🟦 TypeScript Senior + Microservicios

Carpeta: typescript-microservicios/ · 48 preguntas

TypeScript Avanzado — Preguntas de Entrevista Senior

01-typescript-avanzado.md · 16 preguntas

1. ¿Qué son los conditional types y cómo funciona infer? — _{Type System}
2. Distributividad de conditional types: ¿por qué Exclude funciona y cuándo hay que desactivarla? [CASO] — _{Type System}
3. Mapped types: key remapping con as y modificadores +/- — _{Type System}
4. Template literal types: rutas y eventos tipados [CASO] — _{Type System}
5. Varianza: covarianza, contravarianza, strictFunctionTypes y bivarianza de métodos — _{Type System}
6. Type narrowing: type guards con is, discriminated unions, asserts y exhaustividad con never [CASO] — _{Type System}
7. Branded types: tipado nominal sobre un sistema estructural — _{Type System / Diseño de dominio}
8. satisfies vs anotación de tipo vs as: ¿cuándo usar cada uno? — _{Type System}
9. Generics avanzados: constraints, defaults, inferencia parcial y sobre-genericidad — _{Type System / Diseño de API}
10. Structural typing: excess property checks y compatibilidad accidental [CASO] — _{Type System}
11. unknown vs any vs never: fronteras de API y manejo de errores — _{Type System / Robustez}
12. Declaration merging y module augmentation: extender Express Request y tipos globales [CASO] — _{Módulos / Interop}
13. tsconfig estricto para servicios Node modernos: qué flags activar y por qué — _{Tooling / Configuración}
14. Monorepos TypeScript: project references, builds incrementales y Turborepo/Nx [CASO] — _{Tooling / Arquitectura}
15. Decoradores: legacy (experimentalDecorators) vs estándar TC39 — y por qué NestJS sigue en legacy — _{Lenguaje / Frameworks}
16. Validación runtime con Zod: los tipos se borran, las fronteras no se defienden solas [CASO] — _{Robustez / Fronteras del sistema}

Node.js y Microservicios — Preguntas de Entrevista Senior

02-node-y-microservicios.md · 16 preguntas

1. Explica las fases del event loop de Node.js y qué se ejecuta en cada una — _{Runtime de Node.js}
2. [CASO] Un servicio deja de responder a health checks aunque el proceso sigue vivo: sospechas de starvation de microtasks. ¿Qué está pasando y cómo lo diagnosticas? [CASO] — _{Runtime de Node.js}
3. Worker threads vs cluster vs child_process: ¿cuándo usarías cada uno? — _{Runtime de Node.js}
4. Streams y backpressure: ¿cómo procesarías un archivo de 10 GB de pedidos sin tumbar el servicio? — _{Runtime de Node.js}
5. Inyección de dependencias en NestJS: providers, scopes y su coste — _NestJS
6. Guards, interceptors, pipes y exception filters en NestJS: orden de ejecución y casos de uso — _NestJS
7. REST vs gRPC entre microservicios con TypeScript: ¿cuándo eliges cada uno? — _{Comunicación entre servicios}
8. Kafka vs RabbitMQ vs BullMQ: ¿cómo eliges la tecnología de mensajería? — _Mensajería
9. Patrón Saga: coreografía vs orquestación en un flujo de pedidos y pagos — _{Patrones de microservicios}
10. Patrón Outbox e idempotencia: ¿cómo consigues “exactly-once efectivo” entre base de datos y broker? — _{Patrones de microservicios}
11. [CASO] Al desplegar en Kubernetes se pierden peticiones y quedan jobs a medias: diseña el graceful shutdown [CASO] — _{Operación / Kubernetes}
12. Manejo de errores async en Node: unhandled rejections, captureRejections y por qué no “tragar” errores — _{Runtime de Node.js}
13. Observabilidad con OpenTelemetry en Node: trazas distribuidas, propagación de contexto y correlación — _{Observabilidad}
14. Estrategia de testing en microservicios: unit, integración con Testcontainers y contract testing — _Testing
15. [CASO] La latencia p99 de tu API se dispara con ciertos payloads: ¿cómo detectas y evitas el bloqueo del event loop? [CASO] — _Performance
16. Manejo de JSON grande en Node: streaming parsers, NDJSON y alternativas binarias — _{Performance / Datos}

Casos y Problemas Reales — Entrevista Senior

03-casos-y-problemas.md · 16 preguntas

1. Memory leak: el heap crece hasta OOM [CASO] — _{Node.js internals / Observabilidad}
2. Event loop bloqueado: p99 disparado por código CPU-bound [CASO] — _{Performance / Event loop}
3. OOM procesando archivos grandes: readFile vs streams [CASO] — _{Streams / Backpressure}
4. Unhandled promise rejection tumbando pods en cascada [CASO] — _{Async / Resiliencia}
5. Fuga de conexiones a Postgres: pool agotado [CASO] — _{Bases de datos / Recursos}
6. Cola con lag creciente: consumidores que no dan abasto [CASO] — _{Mensajería / Kafka / BullMQ}
7. Race condition: doble descuento de stock en operaciones concurrentes [CASO] — _{Concurrencia / Consistencia de datos}
8. Hot reload de configuración sin reiniciar el servicio [CASO] — _{Configuración / Operabilidad}
9. Migración JS→TS incremental en un servicio grande [CASO] — _{TypeScript / Deuda técnica}
10. Timeout en cascada entre servicios: A→B→C [CASO] — _{Sistemas distribuidos / Resiliencia}
11. DNS y keep-alive con axios/undici en alta concurrencia [CASO] — _{Redes / HTTP clients}
12. Degradación por GC: pausas largas y sawtooth agresivo [CASO] — _{Node.js internals / Memoria}
13. Pérdida de eventos: mensajes que “desaparecen” [CASO] — _{Mensajería / Consistencia}
14. Duplicación de jobs/mensajes: el mismo evento procesado dos veces [CASO] — _{Mensajería / Idempotencia}
15. Hot path degradado: CPU throttling en Kubernetes distorsionando latencias [CASO] — _{Kubernetes / Runtime}
16. Graceful shutdown roto: 502s en cada deploy [CASO] — _{Kubernetes / Ciclo de vida}

---

🐹 Golang Senior + Microservicios

Carpeta: golang-microservicios/ · 55 preguntas

Go Core Avanzado — Preguntas de Entrevista Senior

01-go-core-avanzado.md · 21 preguntas

1. Explica el modelo GMP del scheduler de Go — _{Runtime / Scheduler}
2. ¿Por qué las goroutines son más baratas que los threads del OS? — _{Runtime / Concurrencia}
3. Channels buffered vs unbuffered: semántica y cuándo usar cada uno — _{Concurrencia / Channels}
4. select: semántica, patrones y trampas — _{Concurrencia / Channels}
5. Patrones de concurrencia: pipeline, fan-out y fan-in — _{Concurrencia / Patrones}
6. El paquete sync: Mutex, RWMutex, WaitGroup, Once — usos y trampas — _{Concurrencia / Sincronización}
7. errgroup: qué aporta sobre WaitGroup y cómo usarlo bien — _{Concurrencia / Sincronización}
8. sync/atomic vs Mutex: cuándo y por qué — _{Concurrencia / Sincronización}
9. context.Context: cancelación, deadlines y valores — reglas de uso — _{Context / Diseño de APIs}
10. Escape analysis, stack vs heap, y cómo reducir allocaciones — _{Memoria / Performance}
11. El GC de Go: cómo funciona, GOGC y GOMEMLIMIT — _{Memoria / GC}
12. Slices internals: capacidad, aliasing, append y sus gotchas — _{Estructuras de datos}
13. Maps internals: buckets, iteración aleatoria y concurrencia — _{Estructuras de datos}
14. Interfaces internals: iface/eface y el gotcha del “typed nil” — _{Tipos / Interfaces}
15. Generics en Go: type parameters, constraints y cuándo usarlos — _{Tipos / Generics}
16. Error handling idiomático: wrapping, errors.Is/As, sentinel vs typed errors — _{Errores / Diseño de APIs}
17. defer: semántica precisa y sus gotchas — _{Lenguaje / Control de flujo}
18. for range, closures y goroutines: el bug clásico de captura de variables — _{Lenguaje / Concurrencia}
19. Stack growth, sync.Pool y presión de GC en hot paths — _{Memoria / Performance}
20. [CASO] Un servicio funciona en tests pero -race en CI reporta una data race en un map de caché. Analiza [CASO] — _{Concurrencia / Debugging}
21. [CASO] Necesitas procesar 10M de registros llamando a una API externa con límite de 100 concurrentes. Diseña la solución [CASO] — _{Concurrencia / Diseño}

Microservicios en Go — Preguntas de Entrevista Senior

02-microservicios-en-go.md · 18 preguntas

1. Diseño de un servidor HTTP de producción con net/http: timeouts y configuración — _{HTTP / Servicios}
2. Middleware en Go: patrón, orden y ejemplos reales — _{HTTP / Servicios}
3. gRPC en Go: unary vs streaming, deadlines y manejo de errores — _gRPC
4. Interceptors de gRPC: para qué y cómo implementarlos — _gRPC
5. Graceful shutdown completo de un microservicio en Go — _{Ciclo de vida / Operación}
6. Worker pools y control de concurrencia en servicios — _{Concurrencia aplicada}
7. Rate limiting en Go: algoritmos e implementación — _Resiliencia
8. Circuit breakers: por qué, cómo funcionan y su implementación en Go — _Resiliencia
9. Kafka en Go: consumer groups, rebalancing y elección de librería — _{Mensajería / Kafka}
10. Patrón Outbox e idempotencia: publicar eventos sin perder ni duplicar — _{Mensajería / Consistencia}
11. Patrón Saga: transacciones distribuidas sin 2PC — _{Patrones distribuidos}
12. Estructura de proyecto en Go: internal/, hexagonal y organización de paquetes — _{Arquitectura / Proyecto}
13. Inyección de dependencias en Go: manual, wire, fx — criterio — _{Arquitectura / Proyecto}
14. Observabilidad en Go: OpenTelemetry, métricas y pprof en producción — _{Observabilidad}
15. Testing en microservicios Go: table-driven, testcontainers, mocks y race detector — _Testing
16. Timeouts, retries y hedging entre servicios: presupuesto de latencia end-to-end — _{Resiliencia / Comunicación}
17. Versionado y evolución de APIs y eventos en microservicios Go — _{Contratos / Evolución}
18. Configuración y secretos en microservicios Go — _{Operación / Configuración}

Casos y Problemas de Producción — Go y Microservicios

03-casos-y-problemas.md · 16 preguntas

1. [CASO] Goroutine leak en producción: la memoria y el número de goroutines crecen sin parar [CASO] — _{Concurrencia / Debugging}
2. [CASO] La memoria RSS crece y el pod es OOM-killed, pero el heap de pprof se ve pequeño [CASO] — _{Memoria / GC}
3. [CASO] Deadlock: el servicio se congela por completo bajo carga y no responde ni el health check [CASO] — _{Concurrencia / Debugging}
4. [CASO] El race detector señala una race en producción… que “nunca ha dado problemas”. Convence al equipo y arréglala [CASO] — _{Concurrencia / Debugging}
5. [CASO] p99 degradado con p50 normal: ¿GC o contención? Diagnostica y arregla [CASO] — _{Performance / Latencia}
6. [CASO] El servidor HTTP agota file descriptors: “too many open files” [CASO] — _{HTTP / Recursos}
7. [CASO] Contexto cancelado que no se propaga: el caller recibe timeout pero el trabajo sigue ejecutándose (trabajo huérfano) [CASO] — _{Context / Consistencia}
8. [CASO] Datos corruptos intermitentes: dos features pisan los mismos bytes por aliasing de slices [CASO] — _{Slices / Memoria}
9. [CASO] Un panic en una goroutine tumba todo el proceso cada pocas horas [CASO] — _{Errores / Runtime}
10. [CASO] Consumer de Kafka con lag creciente: los mensajes se acumulan más rápido de lo que se procesan [CASO] — _{Kafka / Throughput}
11. [CASO] Timeouts en cascada entre servicios gRPC: un incidente pequeño se convierte en outage general [CASO] — _{gRPC / Resiliencia}
12. [CASO] Connection pool de database/sql agotado: requests esperando conexión y timeouts en la capa de datos [CASO] — _{Base de datos / Recursos}
13. [CASO] Procesar un archivo de 20GB tumba el servicio por memoria: diseño de streaming [CASO] — _{I/O / Memoria}
14. [CASO] Migración de un servicio Java/Node a Go: qué evaluar, cómo ejecutarla y qué trampas esperan [CASO] — _{Arquitectura / Migración}
15. [CASO] El servicio consume 100% CPU con tráfico normal: busy loop, serialización o algo peor [CASO] — _{Performance / CPU}
16. [CASO] Tras un deploy, errores 502/connection reset intermitentes solo durante los rollouts [CASO] — _{Ciclo de vida / Kubernetes}

---

☁️ AWS

Carpeta: cloud/aws/ · 47 preguntas

Fundamentos y Arquitectura en AWS — Entrevistas Senior

01-fundamentos-y-arquitectura.md · 18 preguntas

1. Diseño de una VPC: subnets públicas/privadas, NAT e Internet Gateway — _Networking
2. VPC Endpoints: Gateway vs Interface, y cuándo usarlos — _Networking
3. VPC Peering vs Transit Gateway: conectividad entre VPCs — _Networking
4. IAM avanzado: evaluación de policies, roles y STS — _Seguridad
5. Permission boundaries, SCPs y acceso cross-account — _Seguridad
6. ECS vs EKS vs Lambda vs Fargate: criterios de elección de cómputo — _Cómputo
7. ALB vs NLB vs API Gateway: exposición de servicios — _{Networking / Integración}
8. RDS vs Aurora: cuándo pagar la prima de Aurora — _{Bases de datos}
9. DynamoDB: modelado single-table y particiones calientes — _{Bases de datos}
10. SQS vs SNS vs EventBridge: mensajería y eventos — _Integración
11. Kinesis Data Streams vs MSK (Kafka): streaming de datos — _{Integración / Streaming}
12. Step Functions: orquestación de workflows — _{Integración / Orquestación}
13. ElastiCache: Redis vs Memcached y patrones de caching — _{Bases de datos / Performance}
14. S3: consistencia, clases de almacenamiento y performance — _{Almacenamiento}
15. Multi-AZ vs multi-región: alta disponibilidad real — _{Arquitectura / Resiliencia}
16. Disaster Recovery: RTO/RPO y las cuatro estrategias — _{Arquitectura / Resiliencia}
17. Well-Architected Framework: los seis pilares aplicados — _{Arquitectura / Gobernanza}
18. Control de costos en AWS: de la visibilidad a la optimización — _FinOps

Microservicios en AWS — Entrevistas Senior

02-microservicios-en-aws.md · 13 preguntas

1. Arquitectura de referencia de microservicios en AWS — _Arquitectura
2. Service discovery con Cloud Map y alternativas — _{Networking / Integración}
3. Service mesh en AWS: App Mesh vs VPC Lattice — _{Networking / Arquitectura}
4. API Gateway + Lambda vs contenedores para APIs — _{Cómputo / Arquitectura}
5. Colas y DLQs: retries, backoff y poison messages — _{Integración / Resiliencia}
6. Exactly-once vs at-least-once en SQS y Kinesis — _{Integración / Consistencia}
7. El patrón Saga con Step Functions — _{Arquitectura / Consistencia}
8. El patrón Outbox con DynamoDB Streams (y CDC en general) — _{Arquitectura / Consistencia}
9. Secrets Manager vs Parameter Store: gestión de secretos y configuración — _{Seguridad / Configuración}
10. CI/CD en AWS: blue/green y canary con CodeDeploy — _{DevOps / Despliegue}
11. Observabilidad: CloudWatch, X-Ray y ADOT — _{Observabilidad}
12. Lambda internals: cold starts, concurrencia y provisioned concurrency — _{Cómputo / Performance}
13. Versionado de APIs y contratos entre microservicios — _{Arquitectura / Integración}

Casos y Problemas en AWS — Entrevistas Senior

03-casos-y-problemas.md · 16 preguntas

1. Lambda con cold starts inaceptables en una API de pagos [CASO] — _{Cómputo / Performance}
2. DynamoDB con throttling por hot partition en un multi-tenant [CASO] — _{Bases de datos}
3. La factura de AWS se triplicó este mes: análisis [CASO] — _FinOps
4. Pods de EKS en CrashLoopBackOff tras un deploy [CASO] — _{Contenedores / EKS}
5. Latencia intermitente entre servicios en distintas AZ [CASO] — _{Networking / Performance}
6. Mensajes de SQS que “reaparecen” y se procesan varias veces [CASO] — _Integración
7. La DLQ se está llenando: triage y reproceso [CASO] — _{Integración / Operación}
8. RDS PostgreSQL con CPU al 100%: análisis con Performance Insights [CASO] — _{Bases de datos}
9. API Gateway devolviendo 429 y 504: throttling y timeouts [CASO] — _{Integración / Performance}
10. Caída de una AZ: comportamiento del sistema y diseño de resiliencia [CASO] — _{Arquitectura / Resiliencia}
11. Fuga de credenciales IAM: respuesta al incidente [CASO] — _Seguridad
12. S3 lento en listados masivos y cargas con millones de objetos [CASO] — _{Almacenamiento / Performance}
13. Kinesis con shards saturados y consumidores con lag creciente [CASO] — _{Streaming / Performance}
14. Migración a AWS: lift-and-shift vs re-architect [CASO] — _{Arquitectura / Estrategia}
15. ECS tasks que mueren por memoria (OOM) de forma intermitente [CASO] — _{Contenedores / ECS}
16. NAT Gateway con costos disparados: análisis y rediseño [CASO] — _{Networking / FinOps}

---

☁️ Azure

Carpeta: cloud/azure/ · 30 preguntas

Azure — Fundamentos y Arquitectura (Perfil Senior Backend/Microservicios)

01-fundamentos-y-arquitectura.md · 12 preguntas

1. ¿Cómo organizas suscripciones, Management Groups y Resource Groups en una organización grande? — _{Gobernanza y organización}
2. Diseño de redes: VNets, subnets, NSGs, Private Endpoints y peering — _Redes
3. Identidad: Entra ID, Service Principals, Managed Identities y RBAC — _{Identidad y seguridad}
4. Cómputo: ¿cuándo elegir AKS, Container Apps, App Service o Functions? — _{Cómputo y arquitectura}
5. Azure SQL vs Cosmos DB: consistencia, particionado y RUs — _Datos
6. Mensajería: Service Bus vs Event Grid vs Event Hubs — _{Mensajería e integración}
7. API Management: rol en una arquitectura de microservicios — _{Integración y APIs}
8. Front Door vs Application Gateway vs Load Balancer vs Traffic Manager — _{Redes y entrega}
9. Key Vault: gestión de secretos, claves y certificados — _Seguridad
10. Almacenamiento: Blob Storage, tiers y ciclo de vida — _{Datos y almacenamiento}
11. Multi-región y Disaster Recovery: cómo se diseña — _{Resiliencia y DR}
12. Well-Architected Framework aplicado a un diseño en Azure — _{Arquitectura y buenas prácticas}

Azure — Microservicios y Casos Prácticos (Perfil Senior Backend/Microservicios)

02-microservicios-y-casos.md · 18 preguntas

1. Arquitectura de referencia de microservicios en Azure (AKS + Service Bus + APIM) — _{Arquitectura de microservicios}
2. Durable Functions para implementar Sagas — _{Patrones distribuidos}
3. Dapr sobre Container Apps: qué aporta a microservicios — _{Plataformas y runtime}
4. Observabilidad con Application Insights: distributed tracing y sampling — _{Observabilidad}
5. Despliegues blue/green y canary en AKS — _{Entrega continua}
6. Idempotencia, outbox y exactly-once práctico en mensajería Azure — _{Patrones distribuidos}
7. [CASO] Cosmos DB devuelve 429: RU exhaustion y hot partition [CASO] — _Datos
8. [CASO] La DLQ de Service Bus crece sin parar [CASO] — _Mensajería
9. [CASO] App Service con memory leak y reinicios continuos [CASO] — _{Cómputo / rendimiento}
10. [CASO] AKS: pods evicted y nodos bajo presión [CASO] — _{Kubernetes / operación}
11. [CASO] Latencia alta entre servicios en AKS: DNS, conntrack y kube-proxy [CASO] — _{Kubernetes / redes}
12. [CASO] Azure Functions con cold starts y timeouts [CASO] — _Serverless
13. [CASO] El costo de Cosmos DB y Log Analytics se disparó [CASO] — _{FinOps / costos}
14. [CASO] Throttling de Entra ID en la autenticación entre servicios [CASO] — _Identidad
15. [CASO] Pérdida de mensajes en Event Hubs por mal checkpointing [CASO] — _Streaming
16. [CASO] Incidente por expiración de secretos/certificados en Key Vault [CASO] — _{Seguridad / operación}
17. [CASO] Migración de on-premise a Azure: evaluación y estrategia [CASO] — _{Migración / arquitectura}
18. [CASO] Degradación tras un failover de región [CASO] — _{Resiliencia / DR}

---

☁️ GCP

Carpeta: cloud/gcp/ · 31 preguntas

Fundamentos y Arquitectura en GCP — Entrevistas Senior

01-fundamentos-y-arquitectura.md · 13 preguntas

1. Explica la jerarquía de recursos de GCP (Organización, Folders, Projects) y por qué importa en una empresa grande — _{Fundamentos / Gobernanza}
2. IAM en GCP: roles, service accounts y mejores prácticas de mínimo privilegio — _{Seguridad / IAM}
3. ¿Qué es Workload Identity Federation y por qué elimina las claves de service account? — _{Seguridad / IAM}
4. VPC en GCP: Shared VPC vs VPC Peering vs Private Service Connect — _Redes
5. GKE vs Cloud Run vs Cloud Functions vs App Engine: ¿cuándo eliges cada uno? — _{Cómputo / Arquitectura}
6. GKE Autopilot vs Standard: trade-offs reales en producción — _{Cómputo / Kubernetes}
7. Cloud SQL vs Spanner vs Firestore vs Bigtable: criterios de elección, consistencia y particionado — _{Datos / Bases de datos}
8. Pub/Sub en profundidad: at-least-once, ordering keys, exactly-once y dead letter queues — _{Mensajería / Integración}
9. BigQuery: arquitectura, particionado/clustering y control de costos — _{Datos / Analítica}
10. Cloud Load Balancing global: anatomía del External Application Load Balancer — _{Redes / Tráfico}
11. Memorystore (Redis) en arquitecturas de microservicios: patrones, límites y alta disponibilidad — _{Datos / Caching}
12. Diseño multi-región y Disaster Recovery en GCP: RTO/RPO y qué servicio da qué — _{Arquitectura / Resiliencia}
13. Anthos / GKE Enterprise y service mesh: ¿cuándo justifica su complejidad? — _{Plataforma / Service Mesh}

Microservicios en GCP y Casos de Producción — Entrevistas Senior

02-microservicios-y-casos.md · 18 preguntas

1. Arquitectura de referencia de microservicios en GCP: GKE/Cloud Run + Pub/Sub — _{Arquitectura de microservicios}
2. Cloud Run internals: concurrencia por instancia, cold starts y CPU throttling fuera de request — _{Cómputo / Serverless}
3. Sagas y patrón Outbox con Pub/Sub: consistencia entre microservicios sin 2PC — _{Patrones distribuidos}
4. Observabilidad de microservicios con OpenTelemetry en GCP — _{Observabilidad}
5. Despliegues canary con Cloud Deploy: pipeline de entrega progresiva en GCP — _{CI/CD / Entrega}
6. Resiliencia entre microservicios: timeouts, retries, circuit breakers y load shedding en GCP — _{Arquitectura / Resiliencia}
7. [CASO] El backlog de una suscripción de Pub/Sub crece sin parar y los mensajes se reentregan varias veces [CASO] — _{Mensajería / Operación}
8. [CASO] Cloud Run con latencia p99 alta: diagnóstico de cold starts y contención [CASO] — _{Serverless / Rendimiento}
9. [CASO] GKE: pods OOMKilled intermitentes y el autoscaler de nodos tarda en absorber picos [CASO] — _{Kubernetes / Operación}
10. [CASO] Cloud SQL (Postgres) agota las conexiones: FATAL: remaining connection slots are reserved [CASO] — _{Bases de datos / Operación}
11. [CASO] La factura de BigQuery se triplica en un mes: queries sin particionar y dashboards descontrolados [CASO] — _{Datos / FinOps}
12. [CASO] Spanner con latencias de escritura degradadas: hotspotting por claves secuenciales [CASO] — _{Bases de datos distribuidas}
13. [CASO] Firestore con errores ABORTED y latencia: contención en documentos calientes [CASO] — _{Bases de datos NoSQL}
14. [CASO] Se ha filtrado una clave JSON de service account en un repositorio público: respuesta al incidente [CASO] — _{Seguridad / Respuesta a incidentes}
15. [CASO] Latencia elevada entre servicios desplegados en regiones distintas [CASO] — _{Redes / Rendimiento}
16. [CASO] Errores 429 RESOURCE_EXHAUSTED en producción: cuotas de GCP alcanzadas [CASO] — _{Operación / Cuotas}
17. [CASO] Migración de AWS a GCP de una plataforma de microservicios: estrategia y mapeo de servicios [CASO] — _{Arquitectura / Migración}
18. [CASO] Incidente: Cloud Run devuelve errores porque alcanzó su límite de instancias [CASO] — _{Serverless / Operación}

---

🧩 Microfrontends

Carpeta: microfrontends/ · 30 preguntas

Microfrontends — Fundamentos y Arquitectura

01-fundamentos-y-arquitectura.md · 18 preguntas

1. ¿Qué son los microfrontends y cuándo NO deberías usarlos? — _Fundamentos
2. Patrones de composición: build-time, server-side, edge-side y client-side — _Fundamentos
3. Module Federation en webpack 5: ¿cómo funciona y cómo se configura? — _{Module Federation}
4. shared, singleton y la negociación de versiones: ¿cómo evitas dos Reacts en la página? — _{Module Federation}
5. Remotes dinámicos: cargar microfrontends cuya URL no se conoce en build — _{Module Federation}
6. Module Federation 2.0 y Rspack: ¿qué cambia respecto a MF clásico? — _{Module Federation}
7. single-spa: arquitectura, ciclo de vida y cuándo elegirlo sobre Module Federation — _{Frameworks de orquestación}
8. Import maps nativos y web components como base de microfrontends sin lock-in de bundler — _{Estándares web}
9. iframes para microfrontends: ¿cuándo son la respuesta correcta? — _Composición
10. Routing en una arquitectura shell/container: ¿quién es dueño de la URL? — _Arquitectura
11. Comunicación entre microfrontends: custom events, pub/sub y por qué minimizarla — _Arquitectura
12. Diseño de contratos entre equipos: ¿qué es exactamente “el contrato” de un MFE? — _{Organización y arquitectura}
13. Design system compartido: versionado de la librería UI entre equipos autónomos — _{Design system}
14. Autenticación y sesión compartida entre microfrontends — _Seguridad
15. Aislamiento de CSS entre microfrontends: shadow DOM, CSS modules, prefijos — _Estilos
16. Deployment independiente: versionado de remotes, manifests y estrategias de release — _Delivery
17. Estrategias de testing en microfrontends: E2E cross-MFE y contract testing — _Testing
18. Performance en microfrontends: duplicación, waterfall de carga y prefetch — _Performance

Microfrontends — Casos y Problemas

02-casos-y-problemas.md · 12 preguntas

1. Dos MFEs cargan versiones incompatibles de React y la app crashea [CASO] — _{Module Federation}
2. Un deploy de un remote rompió producción para todos los equipos [CASO] — _{Delivery / Gobernanza}
3. El bundle total de la aplicación es gigante por dependencias duplicadas [CASO] — _Performance
4. Migración incremental de un monolito Angular a microfrontends con React (strangler fig) [CASO] — _{Migración / Arquitectura}
5. Los estilos de un MFE pisan a otro en producción [CASO] — _Estilos
6. Memory leak al montar y desmontar MFEs repetidamente [CASO] — _{Runtime / Ciclo de vida}
7. Estado de autenticación desincronizado entre MFEs [CASO] — _{Seguridad / Estado}
8. Latencia de carga inicial alta por waterfall de remotes [CASO] — _Performance
9. Un equipo necesita releases independientes pero el design system introduce breaking changes [CASO] — _{Design system / Gobernanza}
10. SSR con microfrontends: Next.js multi-zone y sus límites [CASO] — _{SSR / Arquitectura}
11. ¿Monorepo con módulos o microfrontends reales? Análisis organizacional y ley de Conway [CASO] — _{Arquitectura / Organización}
12. Observabilidad y error tracking por equipo: ¿de quién es este error en producción? [CASO] — _{Observabilidad}

---

🔐 Seguridad y Vulnerabilidades

Carpeta: seguridad-vulnerabilidades/ · 42 preguntas

OWASP Top 10 y Vulnerabilidades Comunes

01-owasp-y-vulnerabilidades.md · 18 preguntas

1. ¿Qué es Broken Access Control (A01) y por qué encabeza el OWASP Top 10? — _{OWASP Top 10}
2. ¿Qué son los fallos criptográficos (A02) y cómo se evitan en un backend? — _{OWASP Top 10}
3. Explica las inyecciones (SQL, NoSQL, command) y cómo prevenirlas de forma sistemática — _{OWASP Top 10}
4. ¿Qué es Insecure Design (A04) y en qué se diferencia de un bug de implementación? — _{OWASP Top 10}
5. ¿Qué es Security Misconfiguration (A05) y cómo se gestiona a escala? — _{OWASP Top 10}
6. Componentes vulnerables y ataques de supply chain (A06): ¿cómo gestionas el riesgo de terceros? — _{OWASP Top 10 / Supply chain}
7. Fallos de identificación y autenticación (A07): errores comunes y diseño robusto de login — _{OWASP Top 10 / Autenticación}
8. Fallos de integridad de software y datos (A08): CI/CD, actualizaciones y deserialización — _{OWASP Top 10 / Integridad}
9. Logging y monitoring insuficiente (A09): ¿qué registrar, qué no, y cómo detectar ataques? — _{OWASP Top 10 / Detección}
10. Server-Side Request Forgery (SSRF, A10): riesgo en la nube y defensas — _{OWASP Top 10 / SSRF}
11. XSS y Content Security Policy: modelo de amenaza y defensa en capas — _{Web / XSS}
12. CSRF y SameSite: ¿sigue siendo relevante y cómo se defiende hoy? — _{Web / CSRF}
13. Deserialización insegura en Java y Node: ¿por qué es tan peligrosa y cómo se evita? — _{Deserialización}
14. JWT: errores comunes (alg none, secretos débiles, audience/issuer, revocación) y uso correcto — _{Autenticación / JWT}
15. OAuth2 y OIDC: flujos correctos, PKCE y errores comunes de implementación — _{Autenticación / OAuth2-OIDC}
16. Secrets management: ciclo de vida, rotación y detección de secretos en repositorios — _{Gestión de secretos}
17. Dependencias vulnerables: SCA, priorización con CVSS/EPSS y respuesta a un CVE crítico [CASO] — _{Supply chain / Gestión de vulnerabilidades}
18. Seguridad en contenedores y Kubernetes: imágenes, least privilege, network policies y pod security — _{Contenedores / Kubernetes}

Seguridad en Microservicios

02-seguridad-en-microservicios.md · 12 preguntas

1. ¿Qué significa Zero Trust aplicado a la comunicación entre microservicios? — _{Arquitectura / Zero Trust}
2. mTLS y service mesh: ¿qué aportan y qué problemas no resuelven? — _{Comunicación segura / Service mesh}
3. Autenticación servicio-a-servicio: client credentials, workload identity y sus trade-offs — _{Autenticación M2M}
4. Propagación de la identidad del usuario entre servicios: JWT passthrough vs token exchange — _{Identidad distribuida}
5. API Gateway como punto de enforcement: qué centralizar y qué no — _{Arquitectura / Gateway}
6. Rate limiting y protección contra abuso en APIs distribuidas — _Anti-abuso
7. Validación de entrada en cada servicio: ¿por qué no basta validar en el borde? — _{Defensa en profundidad}
8. Cifrado en tránsito y en reposo en una plataforma de microservicios — _{Protección de datos}
9. Multi-tenancy: estrategias de aislamiento de datos y prevención de fugas entre tenants — _{Multi-tenancy / Aislamiento}
10. Auditoría y trazabilidad en sistemas distribuidos: diseño de un audit trail confiable — _{Auditoría / Observabilidad}
11. Seguridad en pipelines CI/CD: firmado de artefactos, SLSA y protección de la cadena de despliegue — _{CI/CD / Supply chain}
12. Gestión continua de vulnerabilidades en una plataforma de microservicios: escaneo y SLAs de remediación — _{Gestión de vulnerabilidades}

Casos e Incidentes de Seguridad

03-casos-e-incidentes.md · 12 preguntas

1. Encuentran una API key commiteada en el repositorio [CASO] — _{Respuesta a incidentes / Secretos}
2. Anuncian un CVE crítico en una librería usada en 40 servicios [CASO] — _{Respuesta a incidentes / Supply chain}
3. Detectas tráfico anómalo que sugiere una cuenta de servicio comprometida [CASO] — _{Respuesta a incidentes / Identidad M2M}
4. Un pentest reporta un IDOR en tu API [CASO] — _{Respuesta a incidentes / Broken Access Control}
5. Encuentran datos sensibles en los logs [CASO] — _{Respuesta a incidentes / Fuga de datos}
6. Un tercero reporta que tu endpoint permite SSRF hacia la metadata del cloud [CASO] — _{Respuesta a incidentes / SSRF}
7. Un token JWT robado está siendo usado en producción [CASO] — _{Respuesta a incidentes / JWT}
8. Ataque de credential stuffing en el login [CASO] — _{Respuesta a incidentes / Autenticación}
9. Una dependencia de npm resulta comprometida (supply chain) [CASO] — _{Respuesta a incidentes / Supply chain}
10. Datos de clientes expuestos por un bucket S3 mal configurado [CASO] — _{Respuesta a incidentes / Misconfiguration}
11. Certificado TLS expirado en producción [CASO] — _{Respuesta a incidentes / Disponibilidad}
12. Diseñar un programa de seguridad para un equipo que no tiene ninguno [CASO] — _{Estrategia / Programa de seguridad}

---

🔄 Versionamiento de APIs

Carpeta: versionamiento-apis/ · 40 preguntas

Versionamiento de APIs

01-versionamiento-de-apis.md · 16 preguntas

1. ¿Qué estrategias existen para versionar una API REST y cuáles son los trade-offs reales de cada una? — _{REST / Diseño de APIs}
2. ¿Qué es exactamente un breaking change en una API? Da una lista exhaustiva, incluyendo casos no obvios — _{Compatibilidad / Contratos}
3. Define backward compatibility y forward compatibility con precisión, desde la perspectiva productor/consumidor — _{Compatibilidad / Fundamentos}
4. Explica el patrón tolerant reader y la ley de Postel aplicada a APIs. ¿Cuáles son los riesgos de ser demasiado tolerante? — _{Compatibilidad / Patrones de integración}
5. ¿Cómo se versionan mensajes y servicios en gRPC/protobuf? Reglas de field numbers, reserved, y por qué proto3 hizo todo opcional — _{gRPC / Protobuf}
6. Versionado de schemas de eventos: modos de compatibilidad del Schema Registry (BACKWARD, FORWARD, FULL, TRANSITIVE) y quién migra primero — _{Eventos / Kafka / Schema Registry}
7. [CASO] Un equipo añade un campo a un evento Avro y los consumidores de otro equipo empiezan a fallar en producción. Diagnostica y propone la solución [CASO] — _{Eventos / Kafka / Schema Registry}
8. ¿Por qué GraphQL “no se versiona”? ¿Cómo se evoluciona un schema GraphQL y qué riesgos tiene ese modelo? — _GraphQL
9. ¿Cómo se aplica SemVer a APIs HTTP y a librerías internas? ¿Qué significa cada número y por qué 0.x es peligroso? — _{SemVer / Gestión de dependencias}
10. Contract-first con OpenAPI: ¿cómo se usa el contrato para generar código y detectar breaking changes automáticamente en CI? — _{API-first / OpenAPI / CI-CD}
11. ¿Cómo se depreca formalmente una versión de API? Headers Deprecation y Sunset, comunicación, métricas y brownouts — _{Ciclo de vida / Deprecación}
12. ¿Qué papel juega un API Gateway en el versionado? Routing por versión y transformaciones para mantener versiones viejas sin duplicar backend — _{API Gateway / Infraestructura}
13. Hypermedia/HATEOAS: ¿qué aporta realmente a la evolución de una API y por qué casi nadie lo usa? — _{REST / Hypermedia}
14. Idempotencia y versionado de comportamiento: ¿por qué cambiar la semántica de una operación es un breaking change aunque el esquema no cambie? — _{Semántica de operaciones / Diseño}
15. Versionado de SDKs cliente: relación entre versión del SDK y versión de la API, generación automática y el modelo de pinning de Stripe — _{SDKs / Developer Experience}
16. [CASO] Tras un release, un endpoint empieza a devolver 400 a un subconjunto de clientes que “no cambiaron nada”. El equipo solo endureció la validación de un campo. Analiza el incidente y define cómo prevenirlo [CASO] — _{Compatibilidad / Operación}

Versionamiento de Servicios y Datos

02-versionamiento-de-servicios-y-datos.md · 14 preguntas

1. Explica el patrón expand/contract (parallel change) para evolucionar una base de datos sin downtime — _{Bases de datos}
2. ¿Cómo estructuras migraciones de esquema con Flyway o Liquibase para despliegues sin downtime? — _{Bases de datos}
3. [CASO] Debes hacer backfill de 200M de filas y migrar la lectura a una tabla nueva sin ventana de mantenimiento. ¿Cómo secuencias dual write, backfill y dual read? [CASO] — _{Bases de datos}
4. ¿Cómo versionas mensajes en Kafka/RabbitMQ/SQS cuando conviven consumidores con distintas versiones? — _Mensajería
5. [CASO] Publicas eventos en un topic Kafka consumido por 8 equipos, algunos externos a tu organización, y necesitas un breaking change. ¿Qué haces? [CASO] — _Mensajería
6. ¿Por qué un rolling deployment exige compatibilidad N/N-1 y qué superficies de contrato afecta? — _Despliegue
7. [CASO] Vas a hacer un despliegue blue/green (y luego canary) de un servicio que incluye un cambio de esquema. ¿Cómo lo secuencias y qué NO se duplica? [CASO] — _Despliegue
8. ¿Cuándo usarías feature flags en lugar de (o además de) versionar, y qué deuda generan? — _{Estrategia de release}
9. ¿Cómo funcionan los consumer-driven contracts con Pact en CI y qué detectan que los tests E2E no? — _{Testing de contratos}
10. ¿Cómo versionas imágenes de contenedor y artefactos para que los despliegues sean reproducibles? — _{Artefactos y build}
11. Monorepo vs multirepo: ¿cómo cambia el versionado de servicios y librerías internas en cada modelo? — _{Organización de código}
12. [CASO] Tu plataforma interna debe retirar una API usada por 15 equipos. “Que todos migren el mismo sprint” ha fracasado dos veces. Diseña el proceso de coordinación del breaking change [CASO] — _{Organización y procesos}
13. ¿Cómo versionas configuración e infraestructura (Terraform, config de aplicación) y por qué el pinning importa? — _{Infraestructura y configuración}
14. En event sourcing los eventos almacenados son inmutables y viven para siempre. ¿Cómo evolucionas sus esquemas? — _{Event sourcing}

Casos y Problemas de Versionamiento

03-casos-y-problemas.md · 10 preguntas

1. Renombrar un campo usado por 15 consumidores (expand/contract end-to-end) [CASO] — _{Evolución de contratos}
2. Un equipo rompió a 3 servicios en producción con un breaking change sin avisar [CASO] — _{Gestión de incidentes y prevención}
3. Migrar una columna VARCHAR a JSONB en una tabla de 500M filas sin downtime [CASO] — _{Migraciones de esquema de BD}
4. Deprecar /v1 con clientes móviles antiguos que no actualizan [CASO] — _{Deprecación y ciclo de vida}
5. Evolucionar un evento de Kafka con 8 consumidores en distintos equipos [CASO] — _{Evolución de eventos y esquemas}
6. Rollback de un deploy cuyo nuevo esquema ya escribió datos [CASO] — _{Despliegue y compatibilidad de datos}
7. Unificar dos APIs duplicadas que divergieron entre equipos [CASO] — _{Consolidación y arquitectura}
8. Un cliente externo se integró a un campo interno no documentado (ley de Hyrum) [CASO] — _{Contratos implícitos}
9. Versionar una librería interna compartida por 30 servicios [CASO] — _{Dependencias y librerías compartidas}
10. Diseñar el proceso de governance de APIs para 50 equipos [CASO] — _{Governance y plataforma}

---

📨 Mensajería y Event-Driven (Kafka · RabbitMQ · Colas)

Carpeta: mensajeria-eventos/ · 59 preguntas

Fundamentos de Mensajería y Arquitecturas Event-Driven — Preguntas de Entrevista Senior

01-fundamentos-de-mensajeria.md · 15 preguntas

1. ¿Por qué meterías una cola entre dos servicios? ¿Qué compras y qué pagas? — _Arquitectura
2. Semánticas de entrega: at-most-once, at-least-once, exactly-once. ¿Por qué exactly-once end-to-end es un mito? — _{Semánticas de entrega}
3. ¿Cómo haces un consumidor idempotente? Claves de idempotencia, tabla inbox, dedupe y TTL — _Fiabilidad
4. Patrón outbox transaccional: ¿por qué el dual write está prohibido y cómo lo implementa Debezium? — _{Patrones de integración}
5. Ordering: ¿qué garantiza realmente un broker y qué haces cuando el orden importa de verdad? — _{Ordering / Particionado}
6. Backpressure y colas: ley de Little, productor más rápido que el consumidor, límites y load shedding — _{Capacidad / Performance}
7. Dead letter queues: ¿cuándo envías un mensaje, qué metadatos guardas y cómo reprocesas? — _Fiabilidad
8. Event notification vs event-carried state transfer vs event sourcing: diferencias y cuándo usar cada uno — _{Patrones event-driven}
9. Event sourcing en serio: qué resuelve, qué complica y cuándo NO usarlo — _{Event Sourcing}
10. CQRS: ¿qué es de verdad, qué relación tiene con los eventos y cómo manejas la consistencia eventual en la UI? — _CQRS
11. Sagas: coreografía vs orquestación, compensaciones, timeouts y dónde vive el estado — _{Transacciones distribuidas}
12. Colas de comando vs topics de eventos: ¿qué diferencia semántica hay y quién es dueño del contrato? — _{Contratos / Diseño}
13. Schema evolution en eventos: compatibilidad backward/forward/full, schema registry y cómo migrar consumidores — _{Schema evolution}
14. Reintentos: backoff exponencial con jitter, retry topics, retry budget y cuándo NO reintentar — _Resiliencia
15. [CASO] Comunicación entre el servicio de pedidos y 6 servicios downstream [CASO] — _{Diseño de sistemas}

Apache Kafka — Preguntas de Entrevista Senior

02-kafka.md · 18 preguntas

1. Arquitectura de Kafka: brokers, topics, particiones, réplicas e ISR. ¿Por qué decimos que es un log distribuido y no una cola? — _Arquitectura
2. KRaft vs ZooKeeper: ¿qué cambió exactamente y por qué el proyecto migró? — _Arquitectura
3. El productor por dentro: batching, linger.ms, compresión, particionador sticky, acks e idempotencia (PID + secuencias) — _Productor
4. ¿Cuándo se puede perder un mensaje en Kafka? Enumera todas las vías — _Fiabilidad
5. Consumer groups y rebalancing: eager vs cooperative, static membership y los dos timeouts — _Consumidor
6. Gestión de offsets: auto-commit, commit manual, batch vs record, y qué pasa tras un crash — _Consumidor
7. Exactly-once en Kafka: transacciones, read_committed, transactional.id y zombie fencing. ¿Qué cubre y qué no? — _Fiabilidad
8. ¿Cómo eliges el número de particiones de un topic y qué cuesta cambiarlo después? — _Diseño
9. Retención vs compactación: delete, compact, tombstones y casos de uso de compacted topics — _{Almacenamiento}
10. Consumer lag: qué es exactamente, cómo se mide y cómo se ataca — _Operación
11. Kafka Streams: topología, state stores, RocksDB, changelogs, ventanas y EOS. ¿Cuándo Streams y cuándo un consumidor plano? — _{Procesamiento}
12. Schema Registry: formatos, modos de compatibilidad, subject naming strategies y cómo se despliega un cambio de esquema — _Ecosistema
13. Réplicas y durabilidad: replication.factor, min.insync.replicas, unclean election y rack awareness — el triángulo durabilidad/disponibilidad/latencia — _Fiabilidad
14. Kafka Connect: workers, source/sink, converters, DLQ y casos típicos (CDC, data lake) — _Ecosistema
15. Tuning de rendimiento: ¿por qué Kafka es rápido y dónde está normalmente el cuello de botella? — _Rendimiento
16. Multi-cluster y disaster recovery: MirrorMaker 2, Cluster Linking, active-passive vs active-active, offset translation y RPO/RTO — _{Operación / DR}
17. [CASO] El lag del consumer group de facturación crece sin parar desde ayer, pero el throughput de entrada no ha cambiado. Diagnostica [CASO] — _{Operación / Troubleshooting}
18. [CASO] Tras un failover de broker aparecieron miles de duplicados en downstream. ¿Por qué y cómo lo evitas? [CASO] — _{Fiabilidad / Troubleshooting}

RabbitMQ y Otros Brokers (SQS · SNS · NATS · Pulsar) — Preguntas de Entrevista Senior

03-rabbitmq-y-otros-brokers.md · 14 preguntas

1. Explica el modelo AMQP 0-9-1: exchanges, bindings, routing keys y colas. ¿Cómo modelarías un routing complejo? — _{RabbitMQ / AMQP}
2. Acks de consumidor y publisher confirms en RabbitMQ: ¿qué garantiza cada mecanismo y qué pierdes sin cada uno? — _{RabbitMQ / Fiabilidad}
3. Quorum queues vs classic mirrored queues: ¿por qué las mirrored están deprecadas y qué límites tienen las quorum? — _{RabbitMQ / Alta disponibilidad}
4. basic.qos / prefetch: ¿qué controla exactamente y cómo lo dimensionas? — _{RabbitMQ / Rendimiento}
5. TTL, dead-letter exchanges y colas de retraso: patrón de retry con backoff y sus trampas — _{RabbitMQ / Patrones}
6. Flow control en RabbitMQ: memory/disk alarms y credit flow. ¿Qué ve el productor cuando el broker se defiende? — _{RabbitMQ / Operación}
7. Clustering y particiones de red en RabbitMQ: pause_minority, ¿por qué no cruzar regiones, y qué papel juegan federation y shovel? — _{RabbitMQ / Distribución}
8. RabbitMQ Streams: ¿qué añaden frente a las colas clásicas y cuándo los elegirías frente a Kafka? — _{RabbitMQ / Streams}
9. Kafka vs RabbitMQ: criterio de elección de un senior — _{Arquitectura / Comparativa}
10. SQS y SNS: standard vs FIFO, visibility timeout, DLQs y el patrón fan-out. ¿Qué límites y costes hay que conocer? — _{AWS / Mensajería gestionada}
11. NATS y JetStream: ¿qué garantiza cada capa y dónde encajan frente a Kafka y RabbitMQ? — _NATS
12. Apache Pulsar: separación compute/storage, multi-tenancy y tipos de subscription. ¿Cuándo tendría sentido frente a Kafka? — _Pulsar
13. Producción: la memoria del nodo RabbitMQ sube hasta disparar la memory alarm y los publishers se quedan colgados. Las colas crecen. Diagnostica y resuelve. [CASO] — _{RabbitMQ / Operación}
14. Un patrón de retry con requeue=true y un mensaje envenenado tiene a 4 consumidores al 100% de CPU en bucle. ¿Qué pasó y cómo se arregla bien? [CASO] — _{RabbitMQ / Patrones de error}

Mensajería: Casos y Problemas de Producción — Preguntas de Entrevista Senior

04-casos-y-problemas.md · 12 preguntas

1. Rebalance storm: el consumer group entra en bucle de rebalanceos [CASO] — _{Kafka / Consumer groups}
2. Partición caliente: una de 24 concentra el 40% del tráfico [CASO] — _{Kafka / Particionado}
3. Duplicados masivos tras un incidente: cobros repetidos downstream [CASO] — _{Kafka / Idempotencia y offsets}
4. Mensajes fuera de orden tras escalar de 1 a 8 consumidores [CASO] — _{Kafka / Ordering}
5. El outbox se atasca: eventos que llegan horas tarde [CASO] — _{Outbox pattern / CDC}
6. DLQ desbordada un lunes: 200.000 mensajes y nadie sabe cuáles reprocesar [CASO] — _{Operación / Dead-letter queues}
7. Kafka “pierde” mensajes de auditoría: la conciliación mensual detecta huecos [CASO] — _{Kafka / Durabilidad}
8. RabbitMQ: la cola que crece hasta tirar el nodo cada Black Friday [CASO] — _{RabbitMQ / Capacidad y backpressure}
9. Schema roto en cascada: cinco consumidores muertos a la vez [CASO] — _{Contratos de eventos / Schema evolution}
10. Consumidor lento por dependencia: cada mensaje llama a una API con p99 de 3 s [CASO] — _{Consumidores / Throughput y dependencias}
11. Saga colgada: pedidos 6 horas en RESERVANDO_STOCK [CASO] — _{Sagas / Workflows distribuidos}
12. Migración de RabbitMQ a Kafka en caliente, sin parar producción [CASO] — _{Migraciones / Arquitectura de mensajería}

---

🧠 Casos de Estudio Transversales

Carpeta: casos-de-estudio/ · 50 preguntas

Casos de estudio: System Design (nivel senior)

01-system-design.md · 10 preguntas

1. Sistema de pagos idempotente multi-proveedor [CASO] — _{Pagos / Consistencia}
2. Rate limiter distribuido [CASO] — _{Infraestructura / Tráfico}
3. Sistema de notificaciones (push/email/SMS) a 50M usuarios [CASO] — _{Mensajería / Fan-out}
4. Carrito de compras con inventario en tiempo real (overselling) [CASO] — _{E-commerce / Concurrencia}
5. Plataforma de pedidos tipo delivery con tracking en tiempo real [CASO] — _{Marketplace / Tiempo real}
6. Autenticación y autorización para 100 microservicios [CASO] — _{Seguridad / Plataforma}
7. Feed de actividad [CASO] — _{Social / Lectura intensiva}
8. Sistema de reservas con alta concurrencia (asientos/citas) [CASO] — _{Reservas / Concurrencia}
9. API pública con tiers de rate limiting y facturación por uso [CASO] — _{Plataforma / Monetización}
10. Migración de un monolito de e-commerce a microservicios (strangler fig) [CASO] — _{Arquitectura evolutiva / Migración}

Casos de estudio: Incidentes en producción (nivel senior)

02-incidentes-en-produccion.md · 10 preguntas

1. El checkout cae cada día a las 12:00 exactas [CASO] — _{Diagnóstico sistemático}
2. La latencia p99 se degrada tras cada deploy, pero p50 está bien [CASO] — _{Performance / Deploys}
3. Un retry storm tumbó la plataforma completa [CASO] — _{Resiliencia / Fallos en cascada}
4. Datos inconsistentes entre el servicio de pedidos y el de inventario (saga rota) [CASO] — _{Consistencia distribuida}
5. La caché se cayó y la base de datos no aguantó [CASO] — _{Resiliencia / Caching}
6. El canary pasó todas las métricas pero rompió a un cliente enterprise [CASO] — _{Deploys / Observabilidad segmentada}
7. Duplicación de cobros a clientes [CASO] — _{Pagos / Idempotencia}
8. Funciona en staging pero degrada en producción [CASO] — _{Entornos / Metodología}
9. Una dependencia externa (pasarela de pagos) está lenta y arrastra todo el sistema [CASO] — _{Resiliencia / Aislamiento de fallos}
10. Pérdida de mensajes entre dos servicios detectada por conciliación [CASO] — _{Mensajería / Auditoría de datos}

Casos de estudio: Análisis de Nuevos Requerimientos (nivel senior)

03-nuevos-requerimientos.md · 10 preguntas

1. “Necesitamos que los usuarios puedan pagar en cuotas” [CASO] — _{Descubrimiento / Pagos}
2. “Es solo añadir un campo al formulario” [CASO] — _{Análisis de impacto / Contratos}
3. Feature nueva sobre un monolito legacy sin tests [CASO] — _{Legacy / Estrategia técnica}
4. “Para el viernes” [CASO] — _{Negociación / Deuda técnica}
5. Integración con un tercero mal documentado [CASO] — _{Integraciones / Riesgo}
6. “Quiero un dashboard en tiempo real” [CASO] — _{Producto / Datos}
7. Romper un contrato público con clientes externos activos [CASO] — _{APIs públicas / Versionado}
8. Multi-tenancy sobrevenida [CASO] — _{Arquitectura / B2B}
9. “Hazlo configurable”: el motor de reglas prematuro [CASO] — _{Diseño / Alcance}
10. Herencia de un requerimiento a medio hacer [CASO] — _{Continuidad / Arqueología}

Casos de estudio: Diagnóstico entre Entornos — QA, Staging y Producción (nivel senior)

04-diagnostico-multientorno.md · 10 preguntas

1. El bug que solo se reproduce en QA (nunca en local ni en prod) [CASO] — _{Entornos de QA}
2. Todo verde en staging, cae en producción a la primera hora pico [CASO] — _{Staging vs realidad}
3. Config drift: el hotfix manual de hace 6 meses [CASO] — _{Configuration drift}
4. “Funciona en mi máquina”: el contenedor pasa CI pero falla en el cluster [CASO] — _{Contenedores / Runtime}
5. Certificados y DNS: SSLHandshakeException solo en producción [CASO] — _{TLS / Redes}
6. La migración de BD que pasó en staging y revienta en producción [CASO] — _{Migraciones de BD}
7. Feature flags divergentes: el bug imposible de reproducir [CASO] — _{Feature flags}
8. Dependencias distintas por entorno: el mismo commit produce artefactos diferentes [CASO] — _{Builds reproducibles}
9. Datos de prueba vs datos reales: el buscador perfecto que enloquece en prod [CASO] — _{Datos de prueba}
10. Diseña la estrategia de entornos desde cero para 15 microservicios [CASO] — _{Diseño de entornos}

Casos de estudio: Versionado, Releases y Gestión del Cambio (nivel senior)

05-versionado-y-releases.md · 10 preguntas

1. Diseña la estrategia de branching para 10 equipos sobre 40 microservicios [CASO] — _{Branching / Delivery}
2. Hotfix urgente con main 30 commits por delante [CASO] — _{Hotfix / Incident response}
3. El rollback que no se puede hacer: la migración de BD ya corrió [CASO] — _{Migraciones / Rollback}
4. Release train vs continuous deployment para una plataforma B2B [CASO] — _{Release management / Cadencia}
5. Versionar microservicios: ¿semver de servicios sirve de algo? [CASO] — _{Versionado / Contratos}
6. Monorepo vs multirepo para 40 servicios y 10 equipos [CASO] — _{Repositorios / Tooling}
7. La librería compartida infernal: commons usada por 30 servicios [CASO] — _{Librerías internas / Dependencias}
8. Dos features de dos equipos deben salir juntas [CASO] — _{Coordinación / Acoplamiento de release}
9. Deprecar la v1 de una API pública con 200 integraciones activas [CASO] — _{API pública / Deprecation}
10. Auditoría: “¿qué versión exacta de qué corría en producción el 3 de marzo?” [CASO] — _{Trazabilidad / Compliance}

---

⬆ Volver al inicio