Konrad Koza
Java Developer
JavaScript
Bash
Kotlin
Node JS
TypeScript
Java
Data Layer & Database: 6/10
Security & Auth: 6/10
API Design: 5/10
Active 2 days ago
+48 (570) 511202 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Backend Java developer (senior-level, approx) specializing in secure REST API development and transactional service modules. The strongest proven skill is building robust Spring Boot backend services with multi-datasource transaction boundaries and integration tests, as shown by AdminDataSourceConfiguration, FlywayConfiguration and Testcontainers-based tests. There is limited public evidence of large-scale distributed systems design, advanced caching or explicit production performance tuning strategies.
Technical skills
JavaScript
Bash
Kotlin• Senior
Node JS• Middle
TypeScript• Senior • 3y+
Java• Senior • 3y+
Kotlin
Mockito
Node JS
Axios
Java
HikariCP
Spring Boot
Spring Framework
Testcontainers
Spring Data JPA
Spring Security
MapStruct
Databases
PostgreSQL
Frontend
ESLint
i18next
Prettier
React Hook Form
Recharts
Redux
Redux Toolkit
shadcn/ui
Tailwind CSS
Vite
Zod
Radix UI
PostCSS
React Router
Material UI
React.js
Angular
DevOps
ArgoCD
Nginx
Kubernetes
Docker Compose
Docker• 3y+
Git• 3y+
OpenShift
Rest API
TeamCity
QA
Vitest
Rest-Assured
AI/ML
Copilot
Timeline
Fullstack Java Developer
•
Middle
Commerzbank Digital Technology Centre
•
Full-Time
Implemented backend functionality with Spring Boot and Java, including integrations with existing services via SOAP clients. Designed REST APIs for frontend requirements and supported a React + TypeScript user interface. Prepared and executed deployments to an OpenShift environment using Docker and TeamCity, while maintaining unit test coverage and technical documentation.
Java
Spring Boot
React.js
TypeScript
Rest API
Docker
TeamCity
OpenShift
Fullstack Java Developer Intern
•
Junior
Commerzbank Digital Technology Centre
•
Internship
Developed and re-engineered Java-based software modules and implemented new features using Spring Boot and Java. Built frontend capabilities with React and TypeScript and created REST APIs to match modern UI needs. Wrote unit tests to support code quality and documented implementation and deployment steps for the team.
Javasince 2024
Spring Bootsince 2024
React.jssince 2024
TypeScriptsince 2024
Rest APIsince 2024
Senior Backend Developer
Confidence: High API Engineer
Backend Java developer (senior-level, approx) specializing in secure REST API development and transactional service modules. The strongest proven skill is building robust Spring Boot backend services with multi-datasource transaction boundaries and integration tests, as shown by AdminDataSourceConfiguration, FlywayConfiguration and Testcontainers-based tests. There is limited public evidence of large-scale distributed systems design, advanced caching or explicit production performance tuning strategies.
API Design
5/10
How well APIs are designed
API design is consistent and pragmatic with role-based access, validation, pagination and optimistic-locking via ETag, but lacks explicit API versioning and advanced idempotency strategies.
Data Layer & Database
6/10
Working with databases
Data layer shows deliberate design: multiple datasources and transaction managers, Flyway, Hikari datasource configuration, repository patterns and integration tests using Testcontainers; good evidence of schema and migration awareness.
Evidence
konradkoza/nutrixplorer/src/main/java/pl/lodz/p/it/nutrixplorer/configuration/AdminDataSourceConfiguration.java
konradkoza/nutrixplorer/src/main/java/pl/lodz/p/it/nutrixplorer/configuration/FlywayConfiguration.java
konradkoza/nutrixplorer/src/test/java/pl/lodz/p/it/nutrixplorer/integration/AbstractContainerTests.java
Scalability & Performance
3/10
Handling load and speed
Some operational concerns are addressed (Hikari, scheduled tasks), but there is little evidence of explicit caching strategies, queue-based decoupling, rate limiting or measured performance tuning.
System Architecture
5/10
Overall system structure
Service and module boundaries are deliberate with separate mok/mow modules, logging aspect, configuration classes and transaction-scoped services, indicating considered architecture for maintainability and separation of concerns.
Evidence
konradkoza/nutrixplorer/src/main/java/pl/lodz/p/it/nutrixplorer/configuration/ServiceLoggingAspect.java
konradkoza/nutrixplorer/src/main/java/pl/lodz/p/it/nutrixplorer/mok/services/AuthenticationService.java
konradkoza/nutrixplorer/src/main/java/pl/lodz/p/it/nutrixplorer/mow/services/BasketService.java
Security & Auth
6/10
Protecting data and access
Strong authentication and authorization practices are present: JWT handling, KeyReader, Spring Security configuration, password encoding and role checks; input validation and custom error codes add to boundary security.
Reliability & Observability
5/10
Stability and monitoring
Reliability and observability practices are present: structured logging aspects, global exception handling, transaction listeners and integration tests with Testcontainers, but advanced resilience patterns (backoff, circuit breakers, distributed tracing) are not visible.
Verified artifacts
Expertise
Java• Senior
Databases & Vector Storage• Middle
Microservices & API Architecture• Middle
Industries
Food & Beverages• Middle
Technologies
Kotlin• Senior
PostgreSQL
Docker Compose
Mockito
Recommendations
- Lead development of Spring Boot REST services that require strong authn/authz, transactional integrity and optimistic concurrency control (ETag workflows).
- Implement or extend integration test suites and CI with Testcontainers and Flyway migration testing for reliable deployments.
- Build APIs that need careful data-layer design and multi-datasource transactions, such as modular monoliths migrating to services.
- Implement resilience features (retry with backoff, circuit breakers, tracing) and measured performance optimizations where SLAs require them.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior QA Engineer
Confidence: Medium SDET
Senior backend SDET specializing in integration testing and transactional Java/Spring services. The strongest proven skill is API integration testing and test infrastructure, demonstrated by Testcontainers+DBRider integration tests and RestAssured flows in AbstractContainerTests.java and UsersTests.java. Public code shows little evidence of CI-driven test orchestration, performance/load testing, or end-to-end UI flake engineering.
Test Automation Frameworks
7/10
Building automated tests
Own test infrastructure and automation: integration test base using Testcontainers, DBRider dataset seeding and RestAssured plus unit testing with Mockito show deliberate test-infra design and fixture usage.
Test Coverage & Strategy
6/10
What and how to test
Test coverage and strategy include negative-path checks (forbidden, blocked login, activation flow), optimistic-lock/ETag handling and input validation; however there is limited evidence of property-based tests, mutation testing or explicit risk-based tagging.
API & Integration Testing
8/10
Testing how parts work together
Strong API and integration testing: Testcontainers-backed integration tests exercise real endpoints, DBRider dataset seeding and token/activation flows are validated end-to-end, demonstrating contract and error-path checks beyond simple 'assert 200' tests.
Performance & Load Testing
Testing speed under load
Not evidenced in public code
Bug Reporting & Analysis
Finding and describing bugs
Not evidenced in public code
CI Test Integration
Running tests automatically
Not evidenced in public code
Expertise
SDET & Test Engineering• Middle
Unit & Component Testing• Middle
Industries
Food & Beverages• Middle
Technologies
Java• Senior • 3y+
Rest API
Spring Framework
Spring Boot
Spring Data JPA
Spring Security
HikariCP
Vitest
MapStruct
Testcontainers
Recommendations
- Develop and own backend microservices and APIs (Java/Spring) with strong transactional guarantees, security and optimistic-lock handling.
- Lead API/integration test engineering and test infrastructure (Testcontainers, DBRider, RestAssured, unit+mock suites) to raise confidence in service-to-service contracts.
- Implement contract and schema validation expansions and CI test orchestration (selective pipelines, artifact capture, quarantining flaky tests) to bridge current gaps.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium App Engineer
Frontend app engineer (mid-level) focused on building React SPAs with practical server-state patterns and routing that improve robustness. The strongest proven skill is server-state design and API integration, demonstrated by RTK Query services with tag invalidation and explicit ETag If-Match handling in basketService.ts and userService.ts. There is limited evidence of advanced accessibility, formal performance measurement, or complex cross-cutting architecture patterns such as state machines, optimistic rollback, or thorough test coverage.
UI Component Architecture
3/10
How interface parts are built
Component boundaries and composition show practical SPA structure and use of lazy-loading and hooks, but there is limited evidence of a bespoke design system or advanced component architecture authored by the developer.
Responsive & Cross-browser
3/10
Works on all screens and browsers
Responsive work uses Tailwind and CSS with some attention to prefers-reduced-motion; no advanced cross-browser feature-detection or RTL evidence was found.
Performance Optimization
4/10
Speed of the interface
Practical performance practices are present such as code-splitting and RTK Query server-state caching; there is no measured before/after telemetry or bundle analysis in the code.
Accessibility & Semantics
2/10
Usable for everyone
Minimal explicit accessibility work is visible; there is a prefers-reduced-motion media query but no ARIA on custom widgets or keyboard/focus management patterns authored here.
Evidence
State Management & Data Flow
4/10
Managing data in the app
Solid server-state discipline is demonstrated with RTK Query endpoints, tag-based invalidation and explicit ETag If-Match handling; request cancellation, optimistic rollback or state machines are not present.
UX & Visual Polish
4/10
Look and feel quality
Visual polish and UX helpers are present via Tailwind theming, color/index utilities, and nutritional domain mappings, but there are few advanced UX patterns like skeletons, undo flows or staged loading across the codebase.
Expertise
React• Middle
HTML & CSS• Middle
Frontend Architecture & Build Tools• Middle
Industries
Food & Beverages• Middle
Media & Entertainment• Middle
Technologies
JavaScript
TypeScript• Senior • 3y+
Node JS• Middle
Redux
Tailwind CSS
ArgoCD
Kubernetes
Nginx
React.js
Vite
Radix UI
Axios
Material UI
PostCSS
ESLint
Prettier
Zod
shadcn/ui
Recharts
i18next
React Hook Form
Redux Toolkit
React Router
Recommendations
- Develop single-page applications with moderate-to-complex REST APIs where server-state caching and concurrency (ETag/If-Match) matter, such as admin dashboards or product management UIs.
- Build and maintain frontend features that require robust API integration and role-based routing, including guarded routes and lazy-loaded pages.
- Work on UX-focused feature implementation and component refactors that convert utility functions into a small design system and add accessibility and testing coverage.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: