Guía integral de formación y preparación para entrevistas
Java Backend Developer · Microservices Developer · Software Engineer
Niveles objetivo: Junior · Mid-Level · Senior
Enfoque: desarrollo backend empresarial con Java, Spring Boot, Quarkus, bases de datos, seguridad, arquitectura distribuida y operación en producción.
Presentación
Esta guía reúne los conocimientos técnicos que aparecen con frecuencia en procesos de selección para posiciones de desarrollo backend con Java. Está diseñada para acompañar una preparación progresiva: comienza con los fundamentos del lenguaje y llega hasta el diseño, construcción, despliegue y operación de sistemas distribuidos.
El temario no debe interpretarse como una lista de tecnologías que hay que memorizar. Cada bloque representa un conjunto de competencias que un desarrollador debe poder comprender, implementar, probar, diagnosticar y explicar. En los niveles iniciales se espera construir funcionalidades correctas; en niveles intermedios, resolver problemas con autonomía; y en niveles senior, tomar decisiones técnicas considerando impacto, riesgos, costos y necesidades del negocio.
Cómo está organizado
- Fundamentos: lenguaje Java, orientación a objetos, colecciones, excepciones, JVM y concurrencia.
- Backend empresarial: SQL, persistencia, Spring, Quarkus, APIs y seguridad.
- Sistemas distribuidos: microservicios, mensajería, consistencia, resiliencia y programación reactiva.
- Entrega y operación: testing, Docker, Kubernetes, CI/CD, cloud y observabilidad.
- Dominio profesional: arquitectura, rendimiento, diseño de sistemas, entrevistas y proyectos de portafolio.
Qué significa dominar un tema
Considera un tema aprendido cuando puedas cumplir estas cuatro condiciones:
- Explicarlo: describir qué es, qué problema resuelve y cómo funciona.
- Implementarlo: desarrollar un ejemplo sin depender de copiar un tutorial.
- Validarlo: escribir pruebas y reconocer sus casos límite y fallos posibles.
- Justificarlo: comparar alternativas y explicar por qué elegirías una solución en un escenario concreto.
Diferencia entre los niveles
| Nivel | Competencia esperada | Evidencia práctica |
|---|---|---|
| Junior | Comprende los fundamentos y desarrolla funcionalidades acotadas siguiendo estándares del equipo. | APIs CRUD, consultas SQL, validaciones, pruebas unitarias y uso correcto de Git. |
| Mid-Level | Diseña e implementa componentes completos con autonomía y resuelve problemas de integración. | Servicios seguros, transacciones, pruebas de integración, mensajería y despliegues automatizados. |
| Senior | Define soluciones sostenibles, anticipa riesgos y guía decisiones técnicas y al equipo. | Diseño de sistemas, resiliencia distribuida, rendimiento, observabilidad, seguridad y liderazgo técnico. |
Importante: los títulos Junior, Mid-Level y Senior no tienen una definición universal. Las empresas los asocian a años de experiencia, autonomía, complejidad del trabajo y capacidad de asumir responsabilidades. Usa esta clasificación como referencia de competencias, no como garantía de contratación.
1. Java: fundamentos del lenguaje
1.1 Plataforma y entorno
- Historia y evolución de Java.
- JDK, JRE y JVM: diferencias y responsabilidades.
- Compilación:
.java→ bytecode.class→ ejecución en JVM. - Classpath y module path.
- Variables de entorno
JAVA_HOMEyPATH. - JShell,
javac,java,jary herramientas del JDK. - Versiones LTS: Java 8, 11, 17, 21 y 25; compatibilidad y migraciones.
- Convenciones de nombres, estructura de paquetes y documentación Javadoc.
1.2 Sintaxis y tipos
- Variables, constantes y alcance.
- Tipos primitivos y tipos referencia.
- Casting, promoción numérica y overflow.
- Operadores, precedencia y expresiones.
- Condicionales,
switchmoderno y expresionesswitch. - Bucles
for,while,do-while,breakycontinue. - Arrays multidimensionales.
String, inmutabilidad, String Pool,StringBuilderyStringBuffer.var, cuándo usarlo y cuándo evitarlo.- Enums y constantes.
1.3 Programación orientada a objetos
- Clases, objetos, atributos, métodos y constructores.
- Encapsulamiento y modificadores de acceso.
- Herencia, composición y delegación.
- Polimorfismo y despacho dinámico.
- Abstracción, clases abstractas e interfaces.
- Sobrecarga y sobrescritura.
this,super,static,finalyabstract.- Clases anidadas, internas y anónimas.
- Records y clases inmutables.
- Sealed classes e interfaces.
equals(),hashCode()ytoString().- Contrato de igualdad y uso correcto en colecciones.
- Copia defensiva y diseño de objetos.
1.4 Excepciones
- Jerarquía
Throwable,ErroryException. - Checked vs. unchecked exceptions.
try,catch,finally, multi-catch y try-with-resources.- Crear excepciones de dominio.
- Propagación y traducción de excepciones.
- No usar excepciones como flujo normal.
- Preservar causas y contexto sin filtrar información sensible.
1.5 Genéricos y colecciones
- Generic classes, methods y interfaces.
- Type erasure.
- Wildcards:
?,? extends T,? super T. - PECS: Producer Extends, Consumer Super.
List,Set,Queue,DequeyMap.ArrayListvs.LinkedList.HashMap,LinkedHashMap,TreeMapyConcurrentHashMap.HashSet,TreeSetyLinkedHashSet.- Complejidad temporal de operaciones.
- Iterators, fail-fast y
ConcurrentModificationException. - Comparable vs. Comparator.
- Inmutabilidad y colecciones no modificables.
1.6 Java moderno y programación funcional
- Lambdas y functional interfaces.
Predicate,Function,Consumer,Supplier,UnaryOperator.- Method references.
- Stream API:
filter,map,flatMap,reduce,collect. - Collectors, grouping, partitioning y joining.
- Streams paralelos: ventajas, riesgos y cuándo no usarlos.
Optional: uso correcto y anti-patrones.- Date and Time API:
LocalDate,Instant,ZonedDateTime,Duration. - Pattern matching y evolución del lenguaje.
- Text blocks.
- Switch expressions.
- Virtual threads (Java 21): concepto, casos de uso y límites.
1.7 Entrada/salida y utilidades
- I/O clásico y NIO.2.
- Archivos, paths, streams y buffers.
- Serialización: riesgos de Java Serialization y alternativas.
- HTTP Client de Java.
- Properties y configuración.
- Logging con SLF4J y Logback.
- Internacionalización y formatos.
- Expresiones regulares.
2. JVM, memoria y concurrencia
2.1 JVM y memoria
- Stack, heap, metaspace y memoria nativa.
- Frames, referencias y ciclo de vida de objetos.
- Garbage Collection: conceptos, generaciones y pausas.
- G1 GC, ZGC y Shenandoah: panorama y criterios de elección.
- Memory leaks en Java: referencias estáticas, listeners, caches y recursos.
- OutOfMemoryError y StackOverflowError.
- Heap dump, thread dump y análisis básico.
- JIT compiler, warm-up y optimización.
- JMX, Java Flight Recorder y Java Mission Control.
2.2 Concurrencia
- Procesos vs. hilos.
Thread,RunnableyCallable.- Estados de un hilo.
- Race conditions, deadlocks, starvation y livelocks.
synchronized, locks y monitores.volatile, atomicidad y visibilidad.- Java Memory Model y happens-before.
AtomicInteger, atomics y CAS.ReentrantLock,ReadWriteLock,Semaphore,CountDownLatch,CyclicBarrier.- ExecutorService, thread pools y colas.
CompletableFuture, composición y manejo de errores.- Concurrent collections.
- Structured Concurrency: conceptos y evolución según versión.
- Virtual threads: blocking I/O, pinning y dimensionamiento.
- Cómo diagnosticar bloqueos y saturación.
3. Diseño de software y buenas prácticas
3.1 Principios
- SOLID: SRP, OCP, LSP, ISP y DIP.
- DRY, KISS, YAGNI y separación de responsabilidades.
- Alta cohesión y bajo acoplamiento.
- Programar contra interfaces.
- Composición sobre herencia.
- Inmutabilidad.
- Fail fast.
- Principio de menor privilegio.
- Diseño orientado a dominio (DDD) como herramienta, no como dogma.
3.2 Patrones de diseño
- Creacionales: Singleton, Factory Method, Abstract Factory, Builder y Prototype.
- Estructurales: Adapter, Facade, Decorator, Proxy, Composite y Bridge.
- Comportamiento: Strategy, Observer, Template Method, Command, State, Chain of Responsibility y Iterator.
- Dependency Injection.
- Repository, Unit of Work y Specification.
- Cuándo aplicar un patrón y cuándo evitar complejidad innecesaria.
3.3 Clean Code y mantenibilidad
- Nombres expresivos y funciones pequeñas.
- Diseño de clases y límites de responsabilidad.
- Manejo de errores consistente.
- Comentarios útiles vs. comentarios redundantes.
- Refactoring seguro.
- Code smells y deuda técnica.
- Convenciones, formatter, linter y análisis estático.
- Revisiones de código y pull requests.
- Documentación técnica y ADR (Architecture Decision Records).
4. Herramientas del ecosistema Java
- Maven: lifecycle, scopes, plugins, profiles, dependency management, BOM y multi-module.
- Gradle: tasks, plugins, configurations, wrapper y Kotlin DSL.
- Gestión de dependencias y vulnerabilidades.
- Git: branching, merge, rebase, cherry-pick, tags, revert y resolución de conflictos.
- GitHub/GitLab: pull requests, pipelines, issues y releases.
- IDE: IntelliJ IDEA, Eclipse o VS Code; debugging y profiling.
- Terminal Linux: procesos, permisos, variables, grep, curl, netstat/ss y logs.
- SonarQube/SonarCloud.
- Checkstyle, SpotBugs, PMD y formatter.
- OpenAPI/Swagger, Postman e Insomnia.
5. SQL y bases de datos relacionales
5.1 Fundamentos
- Modelo relacional: tablas, filas, columnas y dominios.
- PK, FK, UNIQUE, CHECK y NOT NULL.
- Relaciones 1:1, 1:N y N:M.
- Normalización: 1FN, 2FN, 3FN y BCNF.
- Desnormalización justificada.
- Integridad referencial.
- Tipos de datos, precisión decimal, fechas y zonas horarias.
- Diseño de esquemas y convenciones.
5.2 SQL
- DDL, DML, DQL y DCL.
CREATE,ALTER,DROP,INSERT,UPDATE,DELETE.SELECT, filtros, ordenamiento y paginación.- JOIN: INNER, LEFT, RIGHT, FULL y CROSS.
- Subconsultas y CTE.
- Funciones agregadas,
GROUP BYyHAVING. - CASE, COALESCE, NULL y lógica ternaria.
- UNION vs. UNION ALL.
- Window functions:
ROW_NUMBER,RANK,LAG,LEADy agregaciones por ventana. - Vistas y vistas materializadas.
- Stored procedures, funciones y triggers: ventajas y costes.
- Transacciones y control de permisos.
5.3 Transacciones y concurrencia
- ACID.
- BEGIN, COMMIT y ROLLBACK.
- Dirty read, non-repeatable read, phantom read y lost update.
- Niveles de aislamiento.
- Bloqueos optimistas y pesimistas.
- Deadlocks y estrategias para reducirlos.
- MVCC.
- Idempotencia de operaciones de escritura.
5.4 Modelado y rendimiento
- Índices B-tree, compuestos, únicos y parciales (según motor).
- Selectividad y orden de columnas en índices.
- Índices que no se aprovechan.
EXPLAINy planes de ejecución.- Full table scan vs. index scan.
- Estadísticas y mantenimiento.
- N+1 queries.
- Connection pooling.
- Particionamiento y replicación: conceptos.
- Backups, restore y recuperación.
- Migraciones con Flyway o Liquibase.
5.5 Motores que conviene conocer
- PostgreSQL: tipos, JSONB, índices, explain analyze y extensiones.
- Oracle: SQL, secuencias, PL/SQL básico, planes y herramientas.
- MySQL/MariaDB: InnoDB, índices y transacciones.
- SQL Server: T-SQL, planes y herramientas.
- Diferencias entre motores y portabilidad SQL.
6. Bases de datos NoSQL y almacenamiento
- Cuándo elegir SQL o NoSQL.
- CAP theorem y consistencia eventual.
- MongoDB: documentos, colecciones, BSON, índices y agregaciones.
- Modelado embebido vs. referencias en MongoDB.
- Redis: strings, hashes, sets, sorted sets, TTL y pub/sub.
- Cache-aside, write-through y write-behind.
- Cassandra/DynamoDB: conceptos de particionado y acceso por patrones.
- Elasticsearch/OpenSearch: indexación y búsqueda.
- Object storage: S3-compatible, archivos y metadatos.
- Consistencia, expiración, invalidación y cache stampede.
- No usar NoSQL solo por moda: justificar el patrón de acceso.
7. JDBC, JPA e Hibernate
7.1 JDBC
- Driver, Connection, Statement y PreparedStatement.
- ResultSet.
- SQL injection y consultas parametrizadas.
- Transacciones JDBC.
- Batch processing.
- Connection pooling: HikariCP.
- Cierre de recursos y try-with-resources.
7.2 JPA y Hibernate
- ORM y especificación JPA/Jakarta Persistence.
- Entity, EntityManager y Persistence Context.
- Estados de entidad: transient, managed, detached y removed.
@Entity,@Id, generación de IDs y columnas.- Relaciones OneToOne, OneToMany, ManyToOne y ManyToMany.
- Owning side y
mappedBy. - Cascade y orphanRemoval.
- Fetch LAZY vs. EAGER.
- N+1, JOIN FETCH, EntityGraph y batch fetching.
- JPQL, Criteria API y native queries.
- DTO projections.
- Dirty checking y flush.
- Optimistic locking con
@Version. - Pessimistic locking.
- Auditoría y callbacks.
- Herencia en JPA.
- Paginación y ordenamiento.
- Límites de transacciones y lazy loading.
- Open Session in View: qué hace y por qué puede ser problemático.
- Evitar exponer entidades directamente en APIs.
8. Spring Framework
8.1 Core
- IoC y Dependency Injection.
- ApplicationContext y BeanFactory.
- Beans y ciclo de vida.
@Component,@Service,@Repositoryy@Controller.@Configurationy@Bean.- Inyección por constructor vs. campo.
- Scopes de beans.
- Autowiring, qualifiers y profiles.
- AOP, proxies, pointcuts y advice.
- Eventos de aplicación.
- Properties y configuración externa.
8.2 Spring Boot
- Auto-configuration y starters.
- Estructura de un proyecto.
application.propertiesy YAML.- Profiles y configuración por entorno.
- Configuration Properties.
- Actuator y health checks.
- Logging y niveles.
- Empaquetado JAR y ejecución.
- Embedded server.
- Custom auto-configuration: conceptos.
- Migración entre versiones de Spring Boot y Spring Framework.
- Gestión de dependencias con BOM.
8.3 Spring MVC y REST
- DispatcherServlet y flujo de una petición.
@RestController, mappings y parámetros.- Request/Response DTOs.
- Serialización JSON con Jackson.
- Validación con Jakarta Validation.
@Valid,@Validatedy validaciones personalizadas.- Manejo global con
@ControllerAdvice. - Códigos HTTP y semántica REST.
- Paginación, filtros y ordenamiento.
- Versionado de APIs.
- HATEOAS: nociones.
- CORS.
- Subida y descarga de archivos.
- OpenAPI y Swagger UI.
- Idempotencia y diseño de endpoints.
- ETags y conditional requests.
- Límites de tamaño, timeout y rate limiting.
8.4 Spring Data
- Spring Data JPA y repositories.
- Derived queries y
@Query. - Specifications y Criteria.
- Projections.
- Paginación.
- Auditing.
- Spring Data JDBC: diferencias.
- Spring Data MongoDB y Redis.
- Custom repository implementations.
8.5 Transacciones en Spring
@Transactional.- Propagation: REQUIRED, REQUIRES_NEW, SUPPORTS, NOT_SUPPORTED, MANDATORY, NEVER y NESTED.
- Isolation levels.
- Read-only transactions.
- Rollback rules.
- Proxy-based AOP y llamadas internas (self-invocation).
- Límites transaccionales entre capas.
- Por qué una transacción local no resuelve atomicidad entre microservicios.
8.6 Spring avanzado
- Spring Cache.
- Spring Scheduling y tareas programadas.
- Spring Integration: panorama.
- Spring Batch: jobs, steps, chunk processing y restartability.
- Spring Cloud: componentes y casos de uso.
- Spring Modulith: modularidad en monolitos.
- Spring REST Docs.
- Configuración y secretos externos.
9. Quarkus
9.1 Fundamentos
- Qué es Quarkus y su enfoque cloud-native.
- Quarkus vs. Spring Boot: diferencias y trade-offs.
- Build-time augmentation.
- CDI y Arc.
- Inyección de dependencias.
- Configuración con
application.properties. - Dev mode y Dev UI.
- Extensions y gestión de dependencias.
- Maven/Gradle y estructura del proyecto.
9.2 Desarrollo de APIs
- Quarkus REST (antes RESTEasy Reactive) y Jakarta REST.
- JAX-RS: recursos, paths, parámetros y respuestas.
- JSON-B/Jackson.
- Bean Validation.
- Exception mappers.
- OpenAPI y Swagger UI.
- REST Client Reactive.
- Filtros e interceptores.
- Multipart y manejo de archivos.
9.3 Persistencia y transacciones
- Hibernate ORM con Panache.
- Active Record vs. Repository pattern.
- Hibernate Reactive y Panache Reactive.
- JDBC y Agroal connection pool.
- Datasources.
- Flyway/Liquibase.
- JTA/Narayana y transacciones.
- MongoDB with Panache.
- Redis y caché.
9.4 Seguridad y operación
- Quarkus Security.
- OIDC y OAuth 2.0.
- JWT.
- Roles y autorización.
- Health, metrics y OpenTelemetry.
- Fault Tolerance.
- REST Client.
- Kafka y Reactive Messaging.
- Native executable con GraalVM/Mandrel.
- JVM mode vs. native mode: memoria, arranque, build y compatibilidad.
- Containerización y Kubernetes.
- Pruebas con
@QuarkusTesty Dev Services.
10. Seguridad de aplicaciones Java
10.1 Fundamentos
- CIA: confidencialidad, integridad y disponibilidad.
- Autenticación vs. autorización.
- Identidad, roles, permisos y políticas.
- Principio de mínimo privilegio.
- Defensa en profundidad.
- Gestión de secretos y rotación.
- TLS/HTTPS y certificados.
- Hashing vs. cifrado vs. encoding.
10.2 Spring Security
- SecurityFilterChain y filtros.
- Authentication, Authorization y SecurityContext.
- UserDetailsService y PasswordEncoder.
- BCrypt/Argon2.
- Autenticación basada en sesión.
- CSRF y CORS.
- Method Security:
@PreAuthorize,@PostAuthorize. - Security headers.
- Manejo de 401 y 403.
- Gestión de usuarios, roles y authorities.
- Test de endpoints protegidos.
10.3 OAuth 2.0, OpenID Connect y JWT
- OAuth 2.0: roles y flujo de autorización.
- Authorization Code + PKCE.
- Client Credentials.
- OpenID Connect y diferencia con OAuth.
- Access token, refresh token e ID token.
- JWT: header, payload y signature.
- Claims, issuer, audience, expiry y scopes.
- Firma simétrica vs. asimétrica.
- JWK/JWKS y rotación de claves.
- Validación de issuer, audience, firma y expiración.
- Revocación, rotación y almacenamiento seguro de refresh tokens.
- Por qué no guardar secretos en el payload.
- SSO.
- Keycloak: realms, clients, users, roles, scopes, mappers y service accounts.
- Integración de Spring Boot y Quarkus con Keycloak.
10.4 OWASP y seguridad práctica
- OWASP Top 10.
- SQL injection.
- XSS y CSRF.
- SSRF.
- Broken Access Control e IDOR/BOLA.
- Insecure Deserialization.
- Path traversal.
- Mass assignment.
- Secret leakage.
- Rate limiting y brute-force protection.
- Validación de entrada y salida.
- Dependencias vulnerables: OWASP Dependency-Check y scanners.
- SAST, DAST y análisis de contenedores.
- Logs sin contraseñas, tokens ni datos sensibles.
- Seguridad de APIs y límites de confianza.
11. APIs, integración y comunicación
- REST y restricciones REST.
- HTTP/1.1, HTTP/2 y nociones de HTTP/3.
- Métodos, headers, status codes y content negotiation.
- JSON, XML, Avro y Protocol Buffers.
- OpenAPI y contratos.
- SOAP y WSDL: fundamentos para sistemas empresariales.
- gRPC: contratos, streaming y cuándo conviene.
- WebSockets y Server-Sent Events.
- Webhooks.
- API Gateway y BFF.
- Rate limiting, throttling y quotas.
- Retries, timeouts y circuit breakers.
- Correlation ID y trace context.
- Compatibilidad hacia atrás y evolución de contratos.
- Consumer-driven contract testing.
- Pact: conceptos.
12. Arquitectura de software
12.1 Estilos arquitectónicos
- Monolito tradicional.
- Monolito modular.
- Arquitectura en capas.
- Hexagonal (Ports and Adapters).
- Clean Architecture.
- Onion Architecture.
- Microkernel y plugin architecture.
- Microservicios.
- Event-driven architecture.
- Serverless: fundamentos.
- Elegir arquitectura según tamaño, dominio, equipo y operación.
12.2 DDD
- Domain, subdomain y bounded context.
- Ubiquitous Language.
- Entity, Value Object y Aggregate.
- Aggregate Root e invariantes.
- Repository y Domain Service.
- Application Service y Domain Service.
- Domain Events.
- Context Mapping.
- Anti-Corruption Layer.
- Strategic vs. tactical DDD.
- Evitar modelos anémicos cuando el dominio requiere comportamiento.
12.3 Microservicios
- Principios y motivaciones.
- Límites de servicio y ownership de datos.
- Database per service.
- Comunicación síncrona vs. asíncrona.
- Service discovery.
- API Gateway.
- Configuración centralizada.
- Resiliencia y tolerancia a fallos.
- Distributed tracing.
- Logs y métricas centralizadas.
- Versionado y despliegue independiente.
- Backward compatibility.
- Idempotencia.
- Consistencia eventual.
- Saga choreography vs. orchestration.
- Outbox pattern e inbox pattern.
- CQRS y Event Sourcing: cuándo aplican y costes.
- Strangler pattern para migración.
- Anti-patterns: distributed monolith, shared database, chatty services y microservicios demasiado pequeños.
- Costes operativos y complejidad distribuida.
13. Spring Cloud y ecosistema de microservicios
- Spring Cloud Gateway.
- Service discovery con Eureka o alternativas.
- Config Server.
- OpenFeign y clientes HTTP.
- Load balancing.
- Resilience4j: circuit breaker, retry, rate limiter, bulkhead y time limiter.
- Spring Cloud Bus: panorama.
- Distributed tracing.
- Configuración de timeouts.
- Propagación de headers y contexto.
- Seguridad entre servicios.
- Kubernetes-native discovery vs. Eureka.
- Cuándo usar Spring Cloud y cuándo las capacidades de la plataforma.
14. Programación reactiva
- Imperativo vs. reactivo.
- Reactive Streams.
- Publisher, Subscriber, Subscription y Processor.
- Backpressure.
- Mono y Flux.
mapvs.flatMap.concatMap,flatMapSequentialyswitchMap.zip,merge,concatycombineLatest.onErrorReturn,onErrorResume,retryydoOnError.- Cold vs. hot publishers.
- Schedulers:
parallel,boundedElasticysingle. - Event loop y non-blocking I/O.
- WebFlux vs. Spring MVC.
- R2DBC vs. JDBC/JPA.
- Bloqueos accidentales y detección.
- Context propagation.
- Testing con StepVerifier.
- Cuándo la programación reactiva aporta valor y cuándo añade complejidad.
- Comparación con virtual threads.
15. Mensajería y sistemas event-driven
- Message broker vs. event streaming.
- Queue, topic, exchange, routing key y consumer group.
- RabbitMQ: exchanges direct, topic, fanout y headers; acknowledgements, DLQ, TTL y retry.
- Apache Kafka: brokers, topics, partitions, offsets, replication y consumer groups.
- Orden de mensajes y claves de partición.
- At-most-once, at-least-once y exactly-once (alcance real).
- Duplicados e idempotent consumers.
- Reintentos y dead-letter queues.
- Schema Registry y evolución de esquemas.
- Avro, Protobuf y JSON.
- Transactional outbox.
- CDC y Debezium: conceptos.
- Kafka Streams: fundamentos.
- Spring Kafka, Spring AMQP y Quarkus Reactive Messaging.
- Observabilidad de consumidores y lag.
16. Testing y calidad
16.1 Tipos de pruebas
- Pirámide de testing.
- Unitarias, integración, contrato, componente, end-to-end y aceptación.
- Test doubles: dummy, stub, fake, spy y mock.
- Arrange-Act-Assert.
- Cobertura: utilidad y límites.
16.2 Java y Spring
- JUnit 5.
- Mockito.
- AssertJ.
- Hamcrest.
- Spring Boot Test.
@WebMvcTest,@DataJpaTesty@SpringBootTest.- MockMvc y WebTestClient.
- Testcontainers.
- WireMock.
- REST Assured.
- StepVerifier para Reactor.
- Pruebas de seguridad.
- Pruebas de repositorios y transacciones.
- Pruebas con PostgreSQL/Oracle reales en contenedores cuando corresponda.
- Datos de prueba y limpieza.
- Evitar tests frágiles y mocks excesivos.
16.3 Calidad y automatización
- SonarQube: bugs, code smells, vulnerabilidades y quality gates.
- JaCoCo.
- Mutation testing: PIT.
- Análisis estático.
- Pruebas de carga: JMeter, Gatling o k6.
- Contract testing.
- Test de migraciones de base de datos.
- Definition of Done y criterios de aceptación.
17. Rendimiento y escalabilidad
- Latencia, throughput, concurrencia y capacidad.
- CPU-bound vs. I/O-bound.
- Profiling de CPU y memoria.
- JVM tuning y GC.
- Thread pools y colas.
- Connection pools.
- SQL tuning e índices.
- N+1 y batch operations.
- Caché local y distribuida.
- Cache invalidation.
- Paginación y streaming.
- Compresión y payload size.
- Load balancing.
- Horizontal vs. vertical scaling.
- Backpressure y control de carga.
- Rate limiting y bulkheads.
- Benchmarking correcto y pruebas representativas.
- Identificar cuellos de botella antes de optimizar.
18. Docker, Linux y despliegue
18.1 Docker
- Images, containers, layers y registries.
- Dockerfile y multi-stage builds.
- JVM container awareness.
- Usuario no-root.
- Health checks.
- Volumes y networks.
- Docker Compose.
- Secrets y variables de entorno.
- Límites de CPU y memoria.
- Logs y troubleshooting.
- Optimización de imágenes y caché de build.
- Escaneo de imágenes.
18.2 Linux y redes
- Procesos, señales y servicios.
- Permisos y usuarios.
- systemd.
- DNS, TCP/IP, puertos y sockets.
- HTTP, TLS y certificados.
- Reverse proxy con Nginx o Traefik.
- Firewall.
- Diagnóstico con
curl,ss,top,free,df,journalctly logs. - Gestión de certificados y renovación.
18.3 Kubernetes
- Cluster, control plane y nodes.
- Pod, Deployment, ReplicaSet y StatefulSet.
- Service: ClusterIP, NodePort y LoadBalancer.
- Ingress y Gateway API: panorama.
- ConfigMap y Secret.
- Requests, limits y QoS.
- Liveness, readiness y startup probes.
- Namespaces y RBAC.
- Persistent Volumes y Claims.
- HPA y autoscaling.
- Rolling updates y rollback.
- Jobs y CronJobs.
- Helm.
- Network Policies.
- Service discovery y DNS.
- Observabilidad y troubleshooting.
- Deployments blue-green y canary.
- Operar aplicaciones stateful y stateless.
19. CI/CD y DevOps
- CI vs. CD.
- Pipelines y stages.
- GitHub Actions, GitLab CI o Jenkins.
- Build, test, package, scan y deploy.
- Maven/Gradle en pipeline.
- Artefactos y versionado semántico.
- Docker build y push a registry.
- Despliegue por ambientes.
- Variables y secretos.
- Aprobaciones y gates.
- Rollback y estrategia de releases.
- Infraestructura como código: Terraform, conceptos.
- GitOps y Argo CD: panorama.
- Supply chain security y SBOM.
- Feature flags.
- Migraciones de base de datos durante despliegues.
20. Cloud y plataformas
- Conceptos IaaS, PaaS, SaaS y serverless.
- AWS: IAM, VPC, EC2, ECS, EKS, RDS, S3, ALB, CloudWatch, SQS y SNS.
- Azure: Entra ID, App Service, AKS, Azure Database, Blob Storage y Monitor.
- GCP: IAM, Compute Engine, GKE, Cloud SQL, Cloud Storage y Cloud Monitoring.
- Redes, subnets, security groups y balanceadores.
- Identidad y permisos.
- Secret managers.
- Managed databases y backups.
- Costos, tagging y presupuestos.
- Alta disponibilidad y disaster recovery.
- Multi-AZ y regiones.
- No es necesario dominar los tres clouds: elegir uno y conocer los conceptos transferibles.
21. Observabilidad y operación en producción
- Diferencia entre monitoring y observability.
- Logs, métricas y trazas.
- Logs estructurados JSON.
- Niveles de log y retención.
- Correlation ID y trace ID.
- SLIs, SLOs y SLAs.
- Error budget.
- RED y USE methods.
- Micrometer y Spring Boot Actuator.
- Prometheus y Grafana.
- OpenTelemetry.
- Jaeger, Tempo o Zipkin.
- ELK/EFK y OpenSearch.
- Alertas accionables.
- Dashboards.
- Health checks y readiness.
- Runbooks y gestión de incidentes.
- Postmortems sin culpabilización.
- Capacity planning y pruebas de resiliencia.
22. Seguridad operativa y arquitectura empresarial
- Gestión de secretos en Vault o secret managers cloud.
- TLS interno y mTLS.
- Rotación de certificados.
- RBAC y least privilege.
- Segmentación de red.
- Auditoría y trazabilidad.
- Protección de datos personales.
- Retención y borrado de datos.
- Cifrado en tránsito y reposo.
- Threat modeling.
- Secure SDLC.
- Gestión de vulnerabilidades y parches.
- Dependabot/Renovate.
- SBOM y firma de artefactos.
- Políticas de acceso a producción.
23. Arquitectura avanzada y temas Senior
- Atributos de calidad: disponibilidad, escalabilidad, seguridad, mantenibilidad y resiliencia.
- Quality Attribute Scenarios.
- Trade-off analysis.
- C4 Model: contexto, contenedores, componentes y código.
- Diagramas de secuencia y despliegue.
- ADRs y documentación de decisiones.
- Arquitectura evolutiva.
- Modularización y límites de dominio.
- Multi-tenancy.
- Alta disponibilidad y recuperación ante desastres.
- Replicación y consistencia distribuida.
- CAP y PACELC.
- Consensus: conceptos de Raft/Paxos.
- Distributed locks: riesgos y alternativas.
- Exactly-once como problema de diseño.
- Saga, Outbox, CQRS y Event Sourcing con sus costes.
- Bulkhead, circuit breaker, retry y timeout.
- Chaos engineering.
- Backward/forward compatibility.
- Zero-downtime deployments.
- Capacity planning y costo de infraestructura.
- Gobernanza técnica sin burocracia.
- Gestión de deuda técnica.
- Mentoring y feedback.
- Estándares de código y revisión.
- Comunicación de riesgos y decisiones a negocio.
24. Entrevistas técnicas: preguntas que debes poder responder
Java
- ¿Diferencia entre JDK, JRE y JVM?
- ¿Cómo funciona HashMap? ¿Qué ocurre ante colisiones?
- ¿Contrato entre equals y hashCode?
- ¿ArrayList vs. LinkedList?
- ¿HashMap vs. ConcurrentHashMap?
- ¿Interface vs. abstract class?
- ¿Checked vs. unchecked exception?
- ¿Qué es inmutabilidad?
- ¿map vs. flatMap en Streams y Reactor?
- ¿Qué es Optional y cuándo no usarlo?
- ¿Cómo funciona Garbage Collection?
- ¿Qué es una race condition?
- ¿Qué hace volatile?
- ¿Qué diferencia hay entre synchronized y Lock?
- ¿Qué son virtual threads?
Spring y Quarkus
- ¿Qué es IoC y DI?
- ¿Qué hace Spring Boot auto-configuration?
- ¿Diferencia entre @Component, @Service y @Repository?
- ¿Por qué preferir inyección por constructor?
- ¿Cómo funciona @Transactional?
- ¿Qué es la propagación REQUIRED vs. REQUIRES_NEW?
- ¿Qué problema resuelve Spring Security?
- ¿Qué diferencia hay entre Spring MVC y WebFlux?
- ¿Qué aporta Quarkus y qué es build-time augmentation?
- ¿Qué diferencia hay entre JVM mode y native mode?
- ¿Cómo probarías un endpoint protegido?
- ¿Cómo evitarías el problema N+1?
SQL y persistencia
- ¿Qué es un índice y cuándo puede perjudicar?
- ¿Qué es un plan de ejecución?
- ¿Qué significa ACID?
- ¿Qué diferencias hay entre los niveles de aislamiento?
- ¿Cómo detectarías un deadlock?
- ¿Qué es lazy loading?
- ¿Qué es dirty checking?
- ¿Cómo resolverías una actualización concurrente?
- ¿Cómo migrarías una tabla sin interrumpir el servicio?
Microservicios
- ¿Cuándo no usar microservicios?
- ¿Cómo manejarías una operación que afecta a dos servicios?
- ¿Qué es Saga?
- ¿Qué es Outbox?
- ¿Cómo evitarías duplicados en Kafka/RabbitMQ?
- ¿Qué ocurre si un servicio dependiente no responde?
- ¿Cómo implementarías retries sin generar una tormenta?
- ¿Qué es circuit breaker?
- ¿Cómo rastrearías una petición entre servicios?
- ¿Cómo versionarías contratos?
- ¿Cómo desplegarías sin downtime?
Seguridad
- ¿Autenticación vs. autorización?
- ¿OAuth 2.0 vs. OpenID Connect?
- ¿Qué contiene un JWT y qué no debe contener?
- ¿Cómo validas firma, issuer y audience?
- ¿Qué es PKCE?
- ¿Qué diferencia hay entre 401 y 403?
- ¿Cómo protegerías una API contra IDOR/BOLA?
- ¿Cómo guardar contraseñas?
- ¿Cómo gestionarías secretos en Kubernetes?
Operación y arquitectura
- ¿Cómo diagnosticarías un servicio lento?
- ¿Cómo investigarías un OutOfMemoryError?
- ¿Qué métricas mirarías primero?
- ¿Qué diferencia hay entre readiness y liveness?
- ¿Cómo dimensionarías un pool de conexiones?
- ¿Cómo harías rollback?
- ¿Cómo decidirías entre monolito modular y microservicios?
- ¿Cómo explicarías una decisión técnica a negocio?
25. Proyectos prácticos para construir un portafolio
Proyecto 1 --- Junior: API de gestión de tareas
- Java LTS + Spring Boot.
- CRUD de usuarios y tareas.
- PostgreSQL y Spring Data JPA.
- DTOs, validación y manejo global de errores.
- Paginación y filtros.
- JUnit, Mockito y pruebas de integración.
- Swagger/OpenAPI.
- Docker Compose.
- README con instrucciones y ejemplos HTTP.
Criterio de dominio: poder explicar cada endpoint, cada relación, el manejo de errores y las pruebas.
Proyecto 2 --- Junior/Mid: sistema de autenticación y autorización
- Spring Security.
- Registro e inicio de sesión.
- BCrypt o Argon2.
- JWT access token y refresh token.
- Roles y permisos.
- Endpoints públicos y protegidos.
- Pruebas de 401, 403 y acceso indebido.
- Keycloak como segunda implementación para comparar autenticación propia vs. Identity Provider.
Criterio de dominio: explicar OAuth 2.0, OIDC, JWT, expiración, refresh y riesgos de seguridad.
Proyecto 3 --- Mid: sistema de pagos o matrículas modular
- Spring Boot con arquitectura por capas o hexagonal.
- Módulos de estudiantes, matrículas, conceptos y pagos.
- PostgreSQL.
- Transacciones y reglas de negocio.
- Flyway.
- Auditoría.
- Idempotencia para registrar pagos.
- Reportes y exportación.
- Testcontainers.
- CI/CD.
Criterio de dominio: justificar límites transaccionales, modelo de datos, reglas de negocio y estrategia de pruebas.
Proyecto 4 --- Mid/Senior: plataforma de microservicios
- Servicios independientes: usuarios, catálogo, órdenes y pagos.
- API Gateway.
- Keycloak/OIDC.
- PostgreSQL por servicio.
- Comunicación REST y Kafka o RabbitMQ.
- Outbox pattern.
- Saga para el flujo de orden y pago.
- Resilience4j.
- Redis para caché cuando tenga sentido.
- OpenTelemetry, Prometheus y Grafana.
- Docker Compose y Kubernetes.
- Pruebas de integración y contrato.
- Pipeline CI/CD.
Criterio de dominio: demostrar fallos parciales, reintentos, duplicados, consistencia eventual y trazabilidad.
Proyecto 5 --- Comparativa Spring Boot vs. Quarkus
Implementa el mismo servicio en ambos frameworks: - CRUD y endpoint de consulta. - PostgreSQL y migraciones. - OIDC con Keycloak. - Health y métricas. - Tests. - Imagen Docker. - JVM mode y native mode en Quarkus. - Medir startup, memoria y throughput bajo condiciones equivalentes. - Documentar diferencias, ventajas, limitaciones y costos.
Criterio de dominio: comparar con mediciones reproducibles, no solo con afirmaciones de marketing.
Proyecto 6 --- Senior: sistema resiliente y observable
- Servicio con dependencias externas simuladas.
- Timeouts, retries con backoff y circuit breaker.
- Bulkhead y rate limiting.
- Colas y DLQ.
- Correlation IDs y trazas distribuidas.
- Dashboards y alertas.
- Pruebas de carga y fallos controlados.
- Runbook y postmortem de un incidente simulado.
Criterio de dominio: explicar cómo se detecta, limita, diagnostica y recupera un fallo.
26. Ruta de estudio sugerida
Una ruta de referencia de 24 semanas, ajustable según tu experiencia y horas disponibles:
Semanas Enfoque Resultado
1--3 Java, POO, colecciones, Resolver ejercicios y excepciones y Git explicar fundamentos
4--5 Java moderno, Streams, Código limpio y genéricos, JVM y comprensión de concurrencia ejecución
6--7 SQL, PostgreSQL, Diseñar y optimizar una modelado, índices y base relacional transacciones
8--9 JDBC, JPA/Hibernate y Persistencia correcta y migraciones sin N+1
10--12 Spring Core, Boot, MVC, API completa con REST y Data validación y documentación
13--14 Testing, seguridad, API protegida y JWT, OAuth2 y Keycloak testeada
15--16 Docker, Linux y CI/CD Aplicación desplegable
17--18 Microservicios, Servicios comunicados y Gateway, resiliencia y tolerantes a fallos configuración
19--20 Kafka/RabbitMQ, Saga y Flujo asíncrono Outbox consistente
21 Quarkus Segunda implementación y comparación
22 Observabilidad, Despliegue y operación Kubernetes y cloud
23--24 Arquitectura, Proyecto final y rendimiento y simulacros entrevistas
Distribución semanal recomendada
- 40% implementación práctica.
- 25% estudio de conceptos y documentación oficial.
- 20% ejercicios y preguntas de entrevista.
- 15% pruebas, refactoring y documentación.
27. Checklist de preparación por nivel
Junior
- Puedo explicar POO, SOLID básico y colecciones.
- Manejo excepciones, genéricos y Streams.
- Uso Git y Maven/Gradle.
- Escribo SQL con JOIN, agrupaciones y subconsultas.
- Diseño tablas con claves y restricciones.
- Creo APIs REST con Spring Boot.
- Uso DTOs, validación y manejo de errores.
- Implemento JPA sin relaciones incorrectas ni N+1 evidente.
- Escribo pruebas unitarias y de integración básicas.
- Uso Docker para levantar aplicación y base de datos.
- Puedo explicar un proyecto de principio a fin.
Mid-Level
- Diseño módulos y límites de responsabilidad.
- Manejo transacciones, concurrencia y locking.
- Implemento seguridad con OAuth2/OIDC y JWT.
- Integro servicios REST y mensajería.
- Manejo retries, timeouts y circuit breakers.
- Diseño consumidores idempotentes.
- Uso Testcontainers y pruebas de contrato.
- Configuro CI/CD y despliegues por ambiente.
- Diagnostico consultas lentas y problemas de memoria.
- Implemento logs, métricas y trazas.
- Puedo explicar trade-offs de una solución.
Senior
- Defino límites de dominio y arquitectura evolutiva.
- Evalúo monolito modular vs. microservicios con criterios de negocio.
- Diseño consistencia distribuida, Saga y Outbox.
- Defino resiliencia, SLOs y observabilidad.
- Planifico escalabilidad, capacidad y recuperación.
- Reviso riesgos de seguridad y supply chain.
- Diseño despliegues sin downtime y rollback.
- Lidero revisiones de código y decisiones técnicas.
- Mentoreo y comunico riesgos con claridad.
- Justifico decisiones con evidencia y mediciones.
28. Qué priorizar para postular
No todos los puestos exigen todo este temario. Para maximizar empleabilidad:
Prioridad alta para la mayoría de vacantes Java 1. Java 17/21, POO, colecciones, Streams y excepciones. 2. Spring Boot, Spring MVC, REST y Spring Data JPA. 3. SQL y PostgreSQL u Oracle. 4. Spring Security, JWT y OAuth2/OIDC. 5. JUnit, Mockito y pruebas de integración. 6. Git, Maven/Gradle y Docker. 7. Microservicios, HTTP, resiliencia y mensajería. 8. Linux, CI/CD y observabilidad básica.
Diferenciadores para Mid/Senior - Quarkus y compilación nativa. - WebFlux/Reactor y virtual threads. - Kafka, RabbitMQ, Outbox y Saga. - Kubernetes y cloud. - DDD, arquitectura hexagonal y diseño de sistemas. - Performance tuning, JVM, SQL y troubleshooting. - OpenTelemetry, SLOs y seguridad avanzada.
Consejo: revisa 10--15 ofertas reales del mercado al que postulas, registra tecnologías repetidas y ajusta el orden de estudio. No conviertas cada herramienta de una oferta en una obligación de dominarla antes de postular.
29. Recursos oficiales para estudiar
- Java: https://dev.java/learn/
- Documentación Java: https://docs.oracle.com/en/java/
- Spring Guides: https://spring.io/guides
- Spring Boot Reference: https://docs.spring.io/spring-boot/reference/
- Spring Security: https://docs.spring.io/spring-security/reference/
- Quarkus Guides: https://quarkus.io/guides/
- Jakarta EE: https://jakarta.ee/learn/
- PostgreSQL: https://www.postgresql.org/docs/
- Oracle Database: https://docs.oracle.com/en/database/
- Hibernate ORM: https://hibernate.org/orm/documentation/
- Testcontainers: https://testcontainers.com/guides/
- JUnit 5: https://junit.org/junit5/docs/current/user-guide/
- Mockito: https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html
- OWASP: https://owasp.org/www-project-top-ten/
- OAuth 2.0 / OIDC: https://openid.net/developers/
- Keycloak: https://www.keycloak.org/documentation
- Docker: https://docs.docker.com/
- Kubernetes: https://kubernetes.io/docs/home/
- Apache Kafka: https://kafka.apache.org/documentation/
- RabbitMQ: https://www.rabbitmq.com/docs
- OpenTelemetry: https://opentelemetry.io/docs/
- Prometheus: https://prometheus.io/docs/
- Grafana: https://grafana.com/docs/
- Git: https://git-scm.com/doc
- Maven: https://maven.apache.org/guides/
- Gradle: https://docs.gradle.org/
30. Método para estudiar cada tema
Para cada tema, sigue este ciclo:
- Comprender: define el concepto con tus propias palabras.
- Implementar: crea un ejemplo pequeño desde cero.
- Aplicar: intégralo en uno de los proyectos.
- Probar: demuestra el comportamiento esperado y los casos de error.
- Explicar: responde qué problema resuelve, cómo funciona y qué alternativas existen.
- Evaluar: identifica límites, riesgos y trade-offs.
No marques un tema como dominado solo por haber visto un tutorial. Márcalo cuando puedas implementarlo sin copiar, probarlo, depurarlo y explicarlo en una entrevista.
31. Glosario mínimo que debes manejar
- JVM: máquina virtual que ejecuta bytecode Java.
- JPA: especificación de persistencia objeto-relacional.
- Hibernate: implementación ORM de JPA/Jakarta Persistence.
- IoC/DI: inversión de control e inyección de dependencias.
- REST: estilo arquitectónico para sistemas distribuidos basado en recursos y semántica HTTP.
- JWT: formato de token con claims y firma; no implica cifrado por defecto.
- OAuth 2.0: marco de autorización delegada.
- OIDC: capa de identidad sobre OAuth 2.0.
- ACID: propiedades de transacciones.
- ORM: mapeo objeto-relacional.
- N+1: patrón de consultas que genera muchas consultas adicionales.
- Backpressure: mecanismo para que un consumidor controle el ritmo de emisión.
- Circuit breaker: patrón que corta temporalmente llamadas a una dependencia fallida.
- Saga: patrón para coordinar transacciones distribuidas mediante pasos y compensaciones.
- Outbox: patrón para persistir un cambio de negocio y el evento que debe publicarse de forma confiable.
- Idempotencia: repetir una operación produce el mismo efecto observable.
- Observabilidad: capacidad de inferir el estado interno de un sistema a partir de sus señales.
- SLO: objetivo medible de nivel de servicio.
- CI/CD: integración y entrega/despliegue continuos.
Meta final: tener al menos dos proyectos sólidos publicados, pruebas automatizadas, documentación clara, diagramas de arquitectura, instrucciones para ejecutar localmente y capacidad para explicar decisiones técnicas. Eso demuestra más que una lista extensa de tecnologías en el CV.
32. Cómo adaptar esta guía a una vacante real
Antes de empezar a estudiar para una oferta concreta, analiza la descripción del puesto y clasifica cada requisito:
| Clasificación | Significado | Qué hacer |
|---|---|---|
| Imprescindible | La oferta lo repite o lo exige explícitamente. | Debes poder explicarlo y demostrarlo con código. |
| Importante | Complementa el trabajo diario del puesto. | Aprende el flujo principal y practica su uso. |
| Deseable | Diferencia candidatos, pero no siempre es excluyente. | Estudia conceptos y casos de uso. |
| Específico de la empresa | Herramienta o plataforma propia de su entorno. | Aprende lo necesario para entender su función y demuestra capacidad de adaptación. |
No descartes una postulación porque no domines una tecnología secundaria. Si cumples los fundamentos del puesto y puedes demostrar experiencia transferible, postula y continúa aprendiendo.
Matriz sugerida para evaluar tu preparación
Califica cada competencia del 0 al 3:
- 0 — Sin conocimiento: todavía no puedes explicar el concepto.
- 1 — Básico: lo explicas, pero necesitas una guía para implementarlo.
- 2 — Competente: lo implementas y pruebas de manera autónoma.
- 3 — Sólido: puedes diagnosticar problemas, comparar alternativas y justificar decisiones.
Registra tus resultados y vuelve a evaluar cada bloque después de construir un proyecto. No uses el puntaje como una medida absoluta de tu valor profesional; sirve para detectar brechas de aprendizaje.
Plantilla para estudiar un concepto
Para cada tema, completa estas notas:
Tema:
Definición:
Problema que resuelve:
Cómo funciona:
Ejemplo práctico:
Errores frecuentes:
Riesgos o limitaciones:
Alternativas:
Preguntas que podrían hacerme en una entrevista:
Enlace a documentación oficial:
Estado: Pendiente / En práctica / Dominado
Preparación antes de una entrevista
- Revisa la descripción del puesto y selecciona los temas que realmente solicita.
- Prepara una presentación breve de tu experiencia y de los proyectos en los que participaste.
- Practica explicar la arquitectura de un proyecto: componentes, flujo de datos, persistencia, seguridad y despliegue.
- Repasa fundamentos de Java, SQL, Spring y HTTP; son frecuentes en entrevistas backend.
- Resuelve ejercicios de código y consultas SQL sin depender del IDE.
- Prepara ejemplos reales de errores que hayas investigado, decisiones que hayas tomado y mejoras que hayas implementado.
- Si desconoces una respuesta, explica cómo investigarías el problema en lugar de inventar una solución.
Cierre
El objetivo de esta guía es desarrollar criterio de ingeniería, no acumular nombres de frameworks. Un buen Java Developer entiende el lenguaje, diseña modelos de datos correctos, construye APIs seguras, prueba su código y sabe qué ocurre cuando el sistema falla en producción.
Para avanzar de nivel, combina estudio con práctica deliberada: construye proyectos completos, documenta las decisiones, automatiza las pruebas, despliega tus aplicaciones y aprende a diagnosticar problemas. La calidad de lo que puedes demostrar es más valiosa que la cantidad de tecnologías que puedes enumerar.