Senior Full-Stack Developer | Java & Angular | 9+ Years Experience

Building Scalable Full-Stack Systems for Complex Enterprise Environments

Experience across Fintech, SaaS, and enterprise: Angular frontends, Java backends, APIs, microservices architectures, and mission-critical systems handling high transaction volumes.

9+ Years in Full-Stack Development

5 Industry Sectors

100% Project Delivery Rate

Contact View Case Studies

Context

Enterprise Technical Complexity

⚠️

Legacy systems slowing down product development and limiting market opportunities

⚠️

Inconsistent or poorly documented APIs becoming a bottleneck for teams

⚠️

Monoliths that are hard to scale, deploy, and maintain as user bases grow

⚠️

Critical initiatives that benefit from experienced senior engineering contribution

My experience centers on these kinds of challenges: robust, scalable full-stack applications — from modern Angular frontends to high-performance Java backends — in environments where performance, security, and long-term maintainability matter.

Areas of Experience

Expertise in Full-Stack & Enterprise Systems

Technical focus on scalable architecture, clean code, cloud-native platforms, and long-term maintainability.

🏗️

Microservices Architecture (Java & Spring)

Design and delivery of scalable, domain-driven microservices using Java and Spring Boot. Strong focus on service boundaries, ownership, resilience, and long-term evolution of distributed systems.

Clear service ownership and domain boundaries
Reduced cross-team dependencies
Improved system resilience and fault isolation
Architecture designed for long-term scalability

Experience in: Large-scale backend platforms, domain-driven systems, microservices transformations

🔗

API Strategy & Backend Engineering

Design of robust, secure, and versioned REST APIs as core platform contracts. Emphasis on API governance, backward compatibility, and clean, well-documented interfaces to support fast product evolution and partner integrations.

Consistent API standards across teams
Strong frontend, mobile, and partner integrations
Reduced breaking changes and regressions
Improved developer productivity and onboarding

Experience in: API-first products, SaaS platforms, enterprise backend ecosystems

🔄

Legacy System Modernization (Java Enterprise)

Modernization of legacy Java and enterprise platforms using safe, incremental strategies: modularization, strangler patterns, refactoring, and progressive architectural evolution with minimal business disruption.

Controlled reduction of technical debt
Improved maintainability and code ownership
Faster onboarding and knowledge transfer
Extended lifespan of mission-critical systems

Experience in: Banking, Insurance, Telecom, large enterprise systems

⚡

Performance, Scalability & Reliability

Systematic performance analysis and optimization across backend services and Angular frontends. Focus on throughput, latency, database efficiency, and system stability under real-world production load.

Lower API latency and faster response times
Improved frontend rendering and UX performance
Higher system stability under peak load
Support for increased traffic and transaction volumes

Experience in: High-traffic platforms, performance-sensitive and business-critical applications

🔐

Security, Authentication & Platform Protection

Design and implementation of secure authentication and authorization for distributed systems, following industry standards and defense-in-depth principles to protect users, data, and business workflows.

OAuth2, JWT, and role-based access control
Secure service-to-service communication
Protection of sensitive business and user data
Reduced attack surface and security risks

Experience in: Fintech, SaaS, regulated environments, sensitive data platforms

🧩

Full-Stack Feature Ownership (Java + Angular)

End-to-end ownership of complex business features, from backend domain logic to Angular UI integration, ensuring clean architecture, maintainable code, and high-quality user experience.

Faster delivery of business-critical features
Reduced coordination and handoff overhead
Strong consistency between backend and frontend
High confidence in production releases

Experience in: Product teams requiring senior full-stack ownership on critical features

☁️

Cloud, DevOps & Platform Engineering

Design and operation of cloud-ready backend platforms with strong DevOps practices. Focus on automated delivery, containerization, and infrastructure that supports fast, reliable, and repeatable deployments across environments.

Automated CI/CD pipelines for faster releases
Containerized applications with Docker and Kubernetes
Cloud-native deployment strategies (Azure, AWS)
Reduced deployment risk and improved release confidence
Improved environment consistency across dev, test, and production

Experience in: Cloud platforms, scalable backend systems, teams adopting DevOps and platform engineering practices

🧪

Quality Engineering, Testing & Observability

Strong quality culture built around automated testing, code quality, and system observability. Focus on preventing regressions, improving confidence in releases, and ensuring long-term maintainability of complex systems.

Test-driven development (TDD) and behavior-driven development (BDD)
High unit and integration test coverage
Continuous code quality analysis (SonarQube)
Early detection of regressions and quality issues
Improved production confidence and reduced incidents

Experience in: Business-critical systems, long-lived platforms, teams focused on engineering excellence

🤖

Soft Skills & AI-assisted Projects

Leveraging AI tools to enhance creativity, productivity, and personal initiatives. Demonstrates problem-solving, project ownership, and ability to integrate modern AI workflows into real-world projects.

Initiative and independent project management
Creative application of AI for content and coding tasks
Structured thinking and problem-solving skills
Effective communication and collaboration, even with AI-assisted outputs
Curiosity and adaptability to new technologies

Experience in: personal projects, AI-assisted development, coding and creative workflows, productivity optimization

Proven Track Record

Selected Case Studies

A few highlights from 9+ years and dozens of projects — Senior contributions in enterprise teams with real impact on complex, business-critical systems

Telecommunications

Enterprise API Management Platform — Java API Management Expert

Key focus: API orchestration, Kong gateway extensions, and secure, observable platform evolution at scale.

Context

I joined a team responsible for designing and operating a centralized API management platform for a major telecommunications group. The platform aimed to standardize service consumption across internal teams and external partners, while supporting large-scale application migrations and continuous product evolution driven by new business requirements.

Multiple upstream and downstream APIs were migrated in parallel, requiring continuous adaptation of backend services to new API contracts, endpoints, and security models. This involved refactoring existing codebases to support new API versions, ensure backward compatibility, and maintain high availability, performance, and service continuity.

Key challenges included defining a scalable target architecture, coordinating multi-API migrations, and delivering robust orchestration, advanced security, and enterprise-grade observability with minimal service disruption.

My Role

As a Java API Management expert within the platform team, I:

Designed and developed scalable backend microservices supporting the centralized API management platform.
Actively contributed to large-scale application and API migrations, ensuring backward compatibility and service continuity.
Designed and implemented core API orchestration and provisioning workflows.
Designed and implemented custom Lua plugins for Kong API Gateway to extend platform capabilities.
Designed and optimized authentication and authorization pipelines based on OAuth2, JWT, and API Keys, aligned with enterprise security and compliance requirements.
Performed performance analysis and optimization to improve response times, memory usage, and overall API throughput.
Established automated testing strategies integration and performance/load testing using JMeter, and Serenity.
Designed event-driven inter-service communication to improve scalability, resilience, and system decoupling.
Improved platform observability through Elasticsearch and Kibana, enabling faster root-cause analysis and improved operational stability.
Promoted code quality and maintainability through Clean Code practices, refactoring, and code reviews.

Impact & Results

Supported large-scale migrations to a modern centralized API gateway, ensuring continuity for internal and external consumers.
Improved platform security consistency by standardizing OAuth2, JWT, and API Key authentication across new and migrated APIs.
Increased platform reliability and scalability under high traffic through targeted backend and gateway optimizations.
Strengthened monitoring and troubleshooting capabilities via deep ELK stack integration and improved logging practices.
Improved maintainability and long-term platform evolution through systematic refactoring and quality-driven development practices.

Java 8/11 Lua Spring Core Spring Boot Spring Rest Spring Integration Spring Security Spring WebFlux Spring Test Kong API Gateway Apache Kafka Hibernate JUnit Mockito JMeter Serenity GitLab CI Jenkins Git Docker Kubernetes ElasticSearch Kibana Maven Gradle SonarQube Cassandra PostgreSQL OAuth2 JWT TDD BDD Clean Code Architecture Hexagonale Microservices Event-Driven Scrum

Cybersecurity

Email Security & Password Manager Platform — Full-Stack Contributor

Key focus: High-throughput email security, enterprise-grade encryption, and cloud-native, highly reliable platforms.

Context

I joined a cybersecurity company where the team was continuously enhancing an email protection platform processing millions of messages per day, while simultaneously developing a new enterprise password manager product. Both products required strong security guarantees, strict performance constraints, and reliable cloud-native deployments.

The challenge was to evolve critical, high-volume processing systems while introducing new security-sensitive features, without compromising availability, latency, or data protection requirements.

My Role

As a full-stack developer within a distributed team, I:

Analyzed functional requirements and contributed to effort estimation and technical planning.
Applied BDD scenarios to define and validate user behaviors, aligning stakeholders on acceptance criteria and automated test coverage.
Systematically applied TDD to ensure reliable, maintainable, and requirements-compliant implementations.
Contributed to the development and evolution of the high-volume email protection platform.
Designed and implemented advanced threat detection features while maintaining strict performance constraints.
Optimized performance and reliability of critical message-processing flows.
Contributed to the development of an enterprise web and browser-extension password manager.
Designed and implemented encryption mechanisms and PIN-based authentication flows for secure credential management.
Developed and operated cloud-native services on Microsoft Azure using Docker and Kubernetes.
Contributed to internal tooling to support build, deployment, and operational workflows.
Applied Clean Code and Clean Architecture principles to improve code quality, maintainability, and long-term evolution.

Impact & Results

Improved threat detection accuracy while preserving platform throughput and latency constraints.
Delivered secure encryption and authentication mechanisms for enterprise password management.
Increased reliability and stability of high-volume processing pipelines under heavy load.
Enabled scalable, cloud-native deployments with high availability on Azure.
Improved overall code quality, maintainability, and automated test coverage across both products.

Java 8-17-21 TypeScript HTML5 CSS3 Spring Core Spring Boot Spring Rest Spring Integration Spring Security Spring WebFlux Spring Test Spring Kafka Angular 12-18 Quarkus Micronaut Hibernate JOOQ R2DBC JUnit Mockito JBehave Jasmine Microsoft Azure AWS Jenkins GitLab Git Docker Kubernetes ElasticSearch Kibana Maven Kafka RabbitMQ SonarQube Vault TDD BDD DDD Clean Code Architecture Hexagonale Microservices Event-Driven Scrum ShapeUp

Aviation

Full-Stack Platform Development — Java/Angular Contributor

Key focus: Large-scale Angular modernization, full-stack feature delivery, and systematic reduction of technical debt in business-critical systems.

Context

I joined a distributed team at a global airline to modernize and evolve multiple business-critical applications while maintaining full service continuity. The platform was impacted by significant technical debt, outdated Angular versions, and the need to deliver new features in parallel with modernization efforts.

The challenge was to upgrade core frontend technologies, improve overall code quality, and reduce long-term maintenance risks without disrupting production systems.

My Role

As a full-stack developer, I:

Translated functional requirements into clear user stories with detailed BDD acceptance criteria, ensuring strong alignment between business, QA, and development teams.
Delivered end-to-end feature development and complex bug fixes across the full stack, with a strong focus on Java backend services and Angular frontend components.
Applied TDD practices to drive backend and frontend design, improving testability, reliability, and long-term maintainability.
Led multi-version Angular migrations while coordinating backend compatibility to ensure seamless end-to-end upgrades with zero service disruption.
Designed and implemented backend improvements in Java (Spring-based services), enhancing service robustness, error handling, and business logic clarity.
Refactored complex backend and frontend legacy components to reduce technical debt and improve code readability and maintainability.
Optimized backend performance (request handling, database access, and service interactions) to improve response times and system stability.
Strengthened frontend architecture and state management to improve scalability and long-term evolution of the Angular codebase.
Implemented comprehensive automated testing strategies across backend and frontend to improve regression detection and delivery confidence.
Improved build stability and quality monitoring using Bamboo and SonarQube, helping identify regressions and quality issues earlier in the lifecycle.
Actively contributed to technical design discussions, effort estimation, and sprint backlog refinement to improve delivery predictability.
Supported cross-team collaboration through code reviews, knowledge sharing, and promotion of best practices across multiple applications.

Impact & Results

Delivered successful multi-version Angular upgrades with zero service interruption.
Significantly reduced technical debt through structured refactoring initiatives.
Improved frontend and backend maintainability and overall code quality.
Increased automated test coverage and confidence in production deployments.
Established consistent frontend development standards across teams.

Java 8 TypeScript HTML5 CSS3 Spring Core Spring Boot Spring Rest Spring Integration Spring Batch Spring Security Spring Test Spring Kafka Angular 9-13 Hibernate JUnit Mockito Jasmine JBehave Microsoft Azure AWS Bamboo Git Docker Kubernetes ElasticSearch Kibana Kafka RabbitMQ SonarQube Maven TDD BDD DDD Clean Code Architecture Hexagonale Microservices Event-Driven Scrum SAFe Kanban

Banking

Enterprise API Consumer & Security SDK — Backend Engineer / Technical Owner

Key focus: Standardized, secure API consumption through automated client generation and centralized JWT-based security.

Context

I joined a large banking group initiative to standardize how internal teams and external partners securely consumed APIs across the organization. Historically, API consumers were implemented manually, leading to inconsistent authentication handling, duplicated logic, integration errors, and increased security risks.

The organization needed a platform to automatically generate secure API clients from OpenAPI specifications, enforce standardized JWT-based authentication, and embed enterprise security, logging, and error-handling practices — while accelerating onboarding for teams and partners.

My Role

As a backend engineer and technical owner of the initiative, I:

Designed and implemented a platform to automatically generate secure Java API clients from OpenAPI (Swagger) specifications.
Built a shared Security SDK to centralize JWT-based authentication, token lifecycle management, and secure request handling.
Designed standardized authentication interceptors to transparently attach and refresh JWT tokens for outbound API calls.
Developed custom code generation templates to embed enterprise security, logging, and error-handling best practices into generated clients.
Implemented validation mechanisms to enforce secure configuration at generation time and prevent insecure setups.
Integrated automated client generation into build workflows to streamline packaging and distribution of secure clients.
Applied strict TDD practices to validate authentication flows, token handling, and generation logic.
Supported migration from manually implemented API consumers to standardized, generated clients.
Collaborated closely with security and architecture teams to ensure compliance with enterprise security policies and audit requirements.

Impact & Results

Established a standardized, automated approach for secure API client generation across the organization.
Significantly reduced authentication- and integration-related errors.
Improved security consistency by enforcing JWT-based authentication across all generated clients.
Accelerated onboarding of internal teams and partners by reducing manual client implementation effort.
Reduced duplicated integration code and long-term maintenance costs.
Improved auditability and traceability of API consumption through standardized security and logging.

Java Spring Boot Spring Security JWT Token-Based Authentication OpenAPI / Swagger Client Code Generation Custom Generation Templates Security SDK TDD CI/CD Integration

Financial Services

Legacy Core System Modernization — Backend Contributor

Key focus: Progressive monolith decomposition, domain-driven architecture, and event-driven microservices modernization.

Context

I joined an enterprise modernization initiative centered around a legacy monolithic core system that had become difficult to scale, slow to deploy, and increasingly risky to change due to tight coupling between business domains and shared database schemas.

The organization needed to modernize the architecture to support faster feature delivery, improved scalability, and better team autonomy, while maintaining business continuity and minimizing migration risk.

My Role

As a backend contributor within a distributed modernization team, I:

Contributed to defining domain boundaries using Domain-Driven Design (DDD) to decompose the monolith into well-scoped business capabilities.
Participated in the design of the target microservices architecture, including service responsibilities, API contracts, and communication patterns.
Implemented Spring Boot–based microservices to extract core business capabilities while maintaining backward compatibility.
Contributed to the gradual replacement of monolithic functionality with independently deployable services.
Helped design API gateway routing strategies to progressively shift traffic from the monolith to new microservices.
Contributed to database decoupling efforts, including clarification of data ownership and extraction of service-specific schemas.
Implemented event-driven communication using Apache Kafka to reduce coupling and enable asynchronous integration.
Refactored shared business logic into dedicated services and libraries to improve separation of concerns.
Supported migration testing strategies (parallel runs, contract testing, regression validation) to ensure functional parity during transition.

Impact & Results

Enabled gradual migration from a legacy monolith to a modular microservices architecture with minimal business disruption.
Reduced deployment risk by enabling independent releases of extracted services.
Improved scalability by isolating high-load business capabilities into dedicated, horizontally scalable services.
Increased team autonomy through clearer ownership of business domains.
Improved system resilience by reducing blast radius and isolating failures to individual services.
Established a sustainable, low-risk modernization path while continuing to deliver new business features.

Java Spring Boot Spring Cloud Spring Data REST APIs Apache Kafka DDD Microservices CI/CD GitLab CI SQL Databases Refactoring Clean Architecture

Background & Experience

9+ Years of Full-Stack & Enterprise Expertise

Proven experience delivering scalable, maintainable, and secure software solutions across enterprise systems, cloud-native platforms, and full-stack development. Skilled in architecture, modern Java ecosystems, frontend technologies, and AI-assisted projects.

Industry Sectors

✓ Banking and Financial Services
✓ Telecommunications
✓ Cybersecurity
✓ Aviation and Tourism
✓ Insurance
✓ Government and Public Sector

Environment & Scale

✓ Large-scale enterprise platforms
✓ Distributed and remote teams
✓ Regulated and high-security contexts
✓ Mission-critical, high-transaction systems
✓ Cloud-native and containerized deployments

Soft Skills & AI-assisted Projects

✓ Initiative and independent project ownership
✓ Creative application of AI in personal and professional projects
✓ Structured problem-solving and analytical thinking
✓ Collaboration and cross-team communication
✓ Curiosity and adaptability to emerging technologies

Technology Stack

Enterprise-grade technologies for scalable, secure, and maintainable applications. Focused on long-term reliability, clean architecture, performance, and modern full-stack development.

Backend Engineering (Core Expertise)

Java 8–25 Spring Boot Spring Core Spring Rest Spring Data Spring Security Spring Batch Spring Integration Spring Cloud Quarkus Micronaut Hibernate JOOQ R2DBC Reactive Programming

Frontend Engineering

Angular 2–18 TypeScript RxJS Angular Material HTML5 CSS3 Responsive Design React (legacy & maintenance) jQuery (legacy systems)

API Design & Integration

REST API Design OpenAPI / Swagger API Versioning Kong API Gateway API Security & Governance GraphQL (integration) Webhooks Service-to-Service Communication

Event-Driven & Messaging

Apache Kafka Kafka Streams AMQP RabbitMQ Event-Driven Architecture Asynchronous Processing

Databases & Persistence

PostgreSQL MySQL Oracle SQL Server MongoDB MariaDB Data Modeling Query Optimization

Security & Identity

OAuth2 JWT SSO Spring Security API Authentication & Authorization Token-Based Security Secure API Design

Testing & Code Quality

JUnit Mockito TDD BDD JBehave SonarQube Clean Code Refactoring

Architecture & Design

Microservices Architecture Modular Monolith Hexagonal Architecture Domain-Driven Design (DDD) Monolith Modernization Event-Driven Architecture Scalable System Design

Cloud & Delivery Environments

AWS (application-level) Microsoft Azure (application-level) Docker (usage & troubleshooting) Kubernetes (working in K8s environments) CI/CD Pipelines (GitLab, Jenkins, Bamboo)

Tools & Ecosystem

IntelliJ IDEA Visual Studio Code Postman ElasticSearch Kibana Maven Gradle Lombok Git SVN

How I Work

Quality Standards & Engineering Practices

Principles applied for long-term maintainability and reliability.

Test-Driven Development

Tests before code. TDD ensures features work as expected and prevents regressions. Codebases are backed by comprehensive test suites from day one.

Clean Architecture

Systems designed with clear separation of concerns. Business logic isolated from infrastructure. Codebases stay adaptable to changing requirements and technology choices.

Domain-Driven Design

Software modeled around the business domain. Shared language between developers and stakeholders, reducing miscommunication and aligning the system with real business processes.

Continuous Integration

Every change automatically tested, analyzed, and validated. Code quality measured continuously with tools like SonarQube. Problems caught early, not in production.

Documentation as Code

APIs documented with OpenAPI specifications. Architecture decisions recorded. Knowledge captured in the codebase, not lost when team members change.

Collaborative Approach

Code reviews, pair programming, and knowledge transfer. Focus on strengthening team capability and collective ownership.

Questions

Frequently Asked Questions

What types of projects have you worked on?

Complex enterprise applications involving Java backend systems, Angular frontends, API management, and distributed architectures. Environments where performance, scalability, security, and long-term maintainability are critical. Experience includes platform modernization, API strategy, and strengthening existing systems.

Do you build projects from scratch?

Yes. Experience on greenfield projects, from initial technical design to production-ready implementation. That includes defining architecture, setting up backend and frontend foundations, API design, security models, and development best practices.

A significant part of my experience also involves joining existing platforms to modernize, refactor, and scale complex systems. This dual experience supports designing new systems with real-world constraints in mind.

What kind of environments have you worked in?

Experience as a senior technical contributor within engineering teams. That includes close collaboration with developers, architects, and product stakeholders, and adapting to changing priorities.

Background includes supporting long-term initiatives, critical project phases, and specific technical challenges such as platform modernization, API strategy, and performance and scalability improvements.

How do you approach code quality and maintainability?

Systematic application of Clean Code principles, TDD/BDD practices, and proven architectural patterns. Focus on code that is easy to understand, test, and evolve. Goal: reduce technical debt over time and keep the platform maintainable as teams and business needs grow.

Do you work fully remotely?

Strong experience in fully remote and distributed team environments. Effective collaboration across time zones and within remote agile teams. Comfortable with on-site sessions when required for key project activities.

How do you integrate with existing teams?

As a senior member of the team, I participate in technical discussions, code reviews, and architectural decisions. Focus on strengthening existing practices while respecting the team's processes and delivery constraints. Objective: raise the overall technical level and deliver reliable, scalable systems.

How do you ensure long-term knowledge sharing?

Key architectural decisions are documented; best practices are shared and collaboration with other developers is a priority. Collective code ownership and knowledge sharing keep the team autonomous and confident in maintaining and evolving the platform.

How can I get in touch?

Use the contact form below for professional inquiries and general questions. If you’d like to receive my CV, say so in your message and I’ll send it to you. Messages are reviewed and responded to as capacity allows.

Contact

Get in Touch

Professional inquiries and general questions. Use the form below to get in touch. If you need my CV, mention it in your message and I’ll send it to you.