Дмитро

Dmytro Gordeev
Java Developer
Phone: [open contact info](look above in the "contact info" section) | Email: [open contact info](look above in the "contact info" section) | Telegram: https://t.me/guudducko
Kyiv / Remote
GitHub: github.com/kuum-oss | Portfolio: kuum-oss.github.io/kuum-oss_web

ABOUT ME
Java developer with hands-on experience building complete systems: from desktop apps with a web layer to distributed Spring
Boot services with performance and fault-tolerance testing. Independently designed, containerized in Docker, and load-tested
backend services (Gatling, JMH, Chaos Engineering). Interested in fintech, ready to close stack gaps quickly and grow within a
product team.

TECHNICAL SKILLS
• Java 25, Kotlin — OOP, concurrency, Coroutines
• Spring Boot (Core, MVC, Data JPA, Security, REST APIs) — embedded Tomcat; Maven — multi-module builds (Vault,
fou, sol, someone_V2)
• PostgreSQL, MySQL — schema design, SQL queries
• Redis — caching, fallback logic on cache failure
• Resilience4j — Circuit Breaker, fault-tolerant architectures
• Docker, Docker Compose — service containerization
• Performance testing: Gatling (smoke/load/stress/soak/spike), JMH, Chaos Engineering
• JUnit 5, Mockito, Testcontainers — unit and integration testing with real databases in containers
• JaCoCo — test coverage analysis
• Spring Security Crypto (BCrypt) — password hashing; Caffeine — in-memory caching
• Monitoring: Prometheus, Grafana, OpenTelemetry (basic)
• Git, REST APIs; design patterns — MVC, Repository, Strategy, Observer, State Machine, Gateway (applied across
projects); TDD — Testcontainers-first integration tests, 0 mocks where possible; Linux — Docker/CI environment (GitHub
Actions, Ubuntu runners)
• Authentication & Authorization — user/admin roles, user registration, ban system, access control
• Understanding of non-blocking programming with Kotlin Coroutines and the Actor Model
• kotlinx.serialization (JSON), kotlinx-datetime — data serialization and date/time handling in Kotlin projects
• CI/CD: GitHub Actions; static code analysis with SonarCloud and ArchUnit
• RabbitMQ, Spring AMQP — event-driven architecture, durable queues, Dead Letter Queues (DLQ); AWS SDK v2,
LocalStack (S3), Flyway, Awaitility; OkHttp — HTTP client, retry/backoff, rate-limit handling

EDUCATION & EXPERIENCE
• КНЕУ (Kyiv National Economic University) — Junior Bachelor, Computer Science (specialty 121)
• Systems Engineering — specialized secondary education
• Online courses: CS50 (Harvard), Oxford courses — algorithms, CS fundamentals
• Informal practical experience: building modules for startups, debugging legacy systems, load testing closed systems on a
freelance basis (full-cycle delivery)

WORK EXPERIENCE
Backend Developer e-commerce startup, marketplace for local sellers · ~2,5 years · NDA
• Owned and delivered backend modules end-to-end: product catalog with search and filtering, cart with session management,
and payment provider integration — from design to deployment.
• Worked in a cross-functional team of 5 engineers using Jira, Telegram, and weekly syncs. Participated in sprint planning,
estimation, and retrospectives — lightweight Scrum without ceremony.
• Resolved production bugs under real deadlines; adapted to mid-sprint requirement changes; received systematic code
reviews from senior developers — built discipline around clean, maintainable code.
• Code is under NDA; public portfolio was built independently to demonstrate the same engineering level.

PROJECTS
orbit — distributed IoT fleet monitoring platform pet-project · github.com/kuum-oss/orbit
• Infrastructure: Terraform + LocalStack (S3, SQS/DLQ, SNS), mTLS self-signed CA between all services, Docker
Compose; 75 infra integration tests.
• Ingest service: WebFlux reactive pipeline + gRPC bidirectional streaming (Protobuf) for telemetry ingestion from IoT
devices into Kafka anomaly pipeline.
• Orchestration: Camunda BPMN engine with delegates for anomaly evaluation, technician assignment, ticket lifecycle, and
retry escalation — triggered by Kafka consumer.
sol — load testing framework for a Spring Boot Service pet- project· kuum-oss.github.io/kuum-oss_web/sol.html
• Developed a Spring Boot target application with PostgreSQL and Redis integration.

• Implemented fault tolerance using Resilience4j Circuit Breaker and cache fallback logic.
• Built a comprehensive Gatling test suite (smoke, load, stress, soak, spike) and benchmarked application performance with
JMH.
• Conducted Chaos Engineering experiments and configured Prometheus and Grafana monitoring using Docker Compose.
fou — notification microservice for E-commerce pet- project, event-driven · kuum-oss.github.io/kuum-oss_web/fou.html
• Event-driven architecture: Order events via RabbitMQ (durable queues, DLQ, exponential backoff) → consumer pipeline
→ PostgreSQL + AWS S3
• Graceful degradation: when S3 is unavailable, notifications are stored with the PENDING_UPLOAD status, and
@Scheduled retries recover them without order loss.
• Consumer-level idempotency: duplicate RabbitMQ messages are silently skipped; TransactionTemplate: S3 upload is
performed outside the transaction (the database connection is not held during slow uploads).
• JWT, Spring Security, and ownership checks; RFC 7807 Problem Details for error responses; Flyway schema versioning.
• Integration testing with Testcontainers: 5 tests using real containers (PostgreSQL, RabbitMQ, LocalStack), 0 mocks.
someone_V2 (Smart Organizer) pet- project, full-stack · kuum-oss.github.io/kuum-oss_web/someone.html
• Full-stack application: desktop client (Java Swing, FlatLaf) + web server (Javalin, FreeMarker) packaged into a single fat
JAR.
• REST API : 10+ endpoints (GET/POST) for catalog management, in-browser EPUB reading, point-based purchases,
reservations, and an admin panel
• Authentication & Authorization (JWT, Spring Security, role-based access control).
• MySQL connection pooling with commons-dbcp2) with self-healing reconnection after connection loss.
• Password hashing with Spring Security Crypto (BCrypt); Caffeine for in-memory caching.
• Integrated an external REST API (Google Books) and implemented document processing with Apache Tika
• Testing: JUnit 5, Mockito, Testcontainers (MySQL, H2), and ArchUnit with code coverage measured by JaCoCo.
• CI/CD: GitHub Actions, static code analysis with SonarCloud; deployment with Docker Compose.
Kot — trading engine (concurrency study project) pet- project, Kotlin · kuum-oss.github.io/kuum-oss_web/kot.html
• Implemented Event Sourcing and CQRS architectural patterns from scratch in pure Kotlin.
• Implemented concurrent processing using Kotlin Coroutines and data serialization with kotlinx.serialization.
• Unit testing with JUnit 5 (kotlin-test-junit5).
Vault — fintech microservices platform pet-project, in development · github.com/kuum-oss/Vault
• Multi-module Spring Boot 3 / Java 25 system: API Gateway, auth, accounts, transfers, reports — 8 services behind a
Spring Cloud Gateway with JWT/JWE validation and identity header propagation downstream.
• Auth service: JWS inside JWE (Nimbus JOSE), BCrypt, TOTP 2FA (Google Authenticator); ephemeral RSA key pair on
dev profile.
• Transfer state machine (DRAFT → INITIATED → PROCESSING → SETTLED/FAILED/REVERSED) with Apache
Kafka KRaft producer/consumer pipeline between transfers and accounts services.
• Schema versioning with Liquibase; transactional outbox schema defined; Spring Cloud Config Server + Eureka service
discovery; all infra (Kafka, PostgreSQL, Redis, Zipkin) in Docker Compose.

LANGUAGES
• Ukrainian — native
• English — B2

Age — 18 (no deferment required)