Backend developer focused on Java, Spring Boot, and clean architecture. Expanding into Python, NestJS, and React.

My approach centers on three pillars: performance, architecture, and security.

• Virtual Threads (Project Loom): Implemented using Spring Boot 3.x and Java 21+. Using the default virtual thread scheduler to maximize throughput without the complexity of reactive stacks.
• Persistence & Auditing: Entity lifecycle management through JpaAuditing for automated metadata. Database performance optimized via indexing and prevention of N+1 queries using EntityGraphs and Join Fetching.
• Caching Logic: Context-aware selection between Caffeine for local caching and Redis for distributed state. Reserved for Read-Heavy patterns where the hit rate justifies the consistency overhead.

• Modular Monoliths: Built upon Bounded Contexts for domain isolation. Internal communication through synchronous calls for immediate logic and asynchronous processing for long-running tasks.
• Microservices & WebClient: Non-blocking communication using WebClient for distributed environments, preventing blocking-I/O bottlenecks.
• CQRS Knowledge: Theoretical foundation from books and study. Understanding of Command Query Responsibility Segregation as a pattern for scaling read and write operations independently.

• OWASP Top 10 Alignment: Applying security principles to mitigate Injection through Jakarta Validation and Parameterized Queries, and Broken Access Control via granular RBAC.
• JWT Implementation: Signing with HS512. Efficiency optimized by pre-decoding the Base64 secret key through a Singleton pattern.
• State-Synchronized Authorization: Lightweight JWTs complemented by a cached /me endpoint for real-time permission updates, preventing stale role usage.
• Vulnerability Mitigation: Token transport enforced through HTTP-Only, Secure, and SameSite=Strict Cookies, protecting against XSS/CSRF. Global exception handling via @RestControllerAdvice to prevent sensitive data exposure.

I use AI agents as part of my development process — not as a shortcut, but as a way to enforce consistency and reduce cognitive load on repetitive tasks.

AI handles the patterns. I handle the decisions. My role is to define what needs to be built and why; AI helps me build it faster and with fewer mistakes. This separation keeps my focus on architecture and business logic while delegating boilerplate, test scaffolding, and documentation to specialized agents.

Before writing implementation code, I define the contract: API specs, test cases, and expected behavior. AI agents then generate the scaffolding from these specs — controllers, services, repositories, and tests — following the patterns I've established. This ensures consistency across modules and makes code reviews faster because the structure is predictable.

• Testing: Generating comprehensive test suites (unit, integration, E2E) from specs. AI catches edge cases I might miss and ensures coverage targets are met without writing repetitive test boilerplate.
• Security Analysis: Reviewing code against OWASP principles, identifying potential vulnerabilities, and suggesting mitigations before they reach production.
• Architecture Decisions: Exploring trade-offs between patterns, validating design choices against best practices, and ensuring consistency across bounded contexts.
• Documentation: Generating API docs, inline documentation, and changelog entries from code changes.

• Python [■■■□□]
  Leveraging solid Java foundations to transition into the Python ecosystem. Currently exploring Django for enterprise-grade backend development, with focus areas in AI/ML integration and data pipeline orchestration.

• NestJS [■□□□□]
  Extending backend expertise into the JavaScript/TypeScript ecosystem through NestJS. Focused on building scalable, maintainable APIs while applying enterprise architecture principles learned in the Java/Spring Boot ecosystem.

• React [■□□□□]
  Exploring frontend development to understand the full stack. Goal is to build complete applications with backend + frontend integration, not to become a frontend specialist.