DmitriiIamanko

Java Backend Developer

Backend for banking, document management and retail. For three years I built the internal service portal of a top-5 Russian bank, used by ~30,000 employees: Java 21, Spring Boot 3, Camunda 7, PostgreSQL, Kafka. I owned incident recovery and BPMN tooling end to end, from analysis to production support, including frontend work in Vue.js.

Experience: 6+ years of commercial Java development
Last role: Java Developer at IT_One, until Oct 2026
Format: Remote, full-time; experienced in remote work
Time zone: Tbilisi, UTC+4
Contract: B2B (Georgian IE) or EOR
English: C1 (EF SET 67/100)

Core stack

Java 8–21
Spring Boot 3
Apache Kafka
Camunda 7
PostgreSQL
Vue.js 3 / 2

Telegram @iamankod iamankodmitrii@gmail.com LinkedIn PDF на русском

Stack

Technologies from the resume by group. The core stack is highlighted.

Backend

Java 8–21
Spring Boot 3
Spring Security
Spring Data JPA
Hibernate
Apache Kafka
REST, OpenAPI
JUnit, Mockito

Spring Boot Test
MapStruct
ShedLock

BPM and automation

Camunda 7
Groovy
Dify, LLM
Python

BPMN
JUEL
bpmn-js

Data

PostgreSQL
Redis
Liquibase
XML, XSD, JAXB

Build and infrastructure

Docker
Portainer
TeamCity
GitLab CI
Nexus
Maven
Git

Grafana

Frontend

Vue.js 3 / 2
JavaScript

Vuex
Element UI

Architecture: microservices, monolith decomposition, event-driven architecture (Kafka), GoF design patterns, scheduled jobs and distributed locks (ShedLock)

Process and tools: Scrum Jira Confluence Claude Code

Currently learning:Camunda 8 / Zeebe, Kubernetes and Helm, AWS, Kotlin

Case studies

Four pieces of work: what was needed, what I did and what came of it.

Cases for Java Backend come first. Change role

IT_One, project for a major bank for Java Backend

Event-driven notifications and integrations

Task: Connect the portal to external systems and keep employees informed about their requests.
What I did: A Kafka notification producer and a consumer service that delivers messages through the corporate messenger API
Unified read receipts across Redis, workflow tasks and requests: an atomic Lua script, idempotent PostgreSQL writes
A courier service API: cost calculation, documents, tracking, scheduled status updates
Admin search over several million requests rewritten from JPA / Criteria API to dynamic native SQL: filtering and pagination in a CTE before the joins, pg_trgm GIN indexes
REST integrations with the Idea Platform low-code system
Result: Request search went from ~1–2 s to ~200–300 ms. Notifications run on Kafka events and reach employees in the corporate messenger; the portal exchanges data with the courier service and Idea Platform.

Kafka
REST
Redis
PostgreSQL

A Kafka producer publishes notification events; a consumer service delivers them through the corporate messenger API.

IT_One, project for a major bank for Java Backend

Process recovery after failures

Task: Camunda processes have to survive failures of external systems, and admins need to see what happened and how to fix it.
What I did: Extended the incident handler: failures that match configurable error patterns go to a retry queue in PostgreSQL
A ShedLock-guarded scheduler retries the step via ProcessInstanceModification: up to 3 attempts with a fixed delay, loop protection, queue-overflow alerts
An incident action log, moving an instance to any step, and an error-to-fix knowledge base that sends the matching instruction to the HR system
Result: An estimated 25–30% of the 100–500 daily Camunda incidents now resolve without an admin.

Camunda 7
ShedLock
PostgreSQL
Spring Boot

How the retry works

On top, a request moving through the portal; below, the mechanism I built. The scheduler retries a known error and the request goes on. An error that matches no pattern is not retried and goes to an admin. If retries keep failing, the limit stops them.

Astelit for Java Backend

From a monolith to services

Task: Move notifications, data sync with external systems and Telegram bots out of the monolith.
What I did: Designed REST APIs between services during the team’s monolith-to-microservices split
Built a 1C integration service solo from scratch: per-table schedulers, batch loading via the 1C API, integrity checks
Set up CI/CD from scratch: build and tests, Nexus, Docker, docker-compose, Portainer
Result: Notifications, data sync and bots run as separate services, and build and delivery are automated.

Spring Boot
REST
Docker
CI/CD

Notifications, data sync with external systems and bots moved into separate services with REST APIs between them.

IT_One, project for a major bank

A BPMN editor inside the portal

Task: Let analysts view and edit BPMN diagrams right in the portal instead of desktop Camunda Modeler.
What I did: Built it solo from scratch, from analysis to production: Spring Boot backend, bpmn-js frontend
bpmn-js Modeler with the Camunda properties panel, publishing to the engine with a mandatory comment
Role-based access, version and publication history
Result: The team’s ~10 analysts moved to it from desktop Camunda Modeler. Diagrams are edited and published in the portal, each with its version history and access rules.

Camunda 7
bpmn-js
Spring Boot
Vue 2

Every version of a diagram is kept and the published one is highlighted. Without the editor role, the palette and editing are off.

Also: LLM automation

1–2 days → ~2 hours
Process design with LLMs. Taken from a feasibility study to production. A Dify pipeline generates Camunda 7 BPMN from a service description, checks it with a static analyzer and an LLM audit, and prepares a review report; I designed the pipeline, prompts and analyzer, and tested it on 10 real processes. Generation takes about 10 minutes; the rest is refinement. A second pipeline moves form field specifications from Confluence into the portal’s XML forms.

Experience

In commercial development since August 2020, which makes 6 years and 3 months. Domains: banking, document management, retail.

IT_One

Java Developer

Nov 2023 – Oct 2026

Internal service portal of a top-5 Russian bank, used by all of its ~30,000 employees for leave, payroll and other approvals; up to ~2,000 new requests a day. On-prem, 3 instances behind an F5 load balancer. A team of 20+ people.

Owned incident recovery and BPMN tooling end to end, from analysis to production support, on the backend (Spring Boot) and the frontend (Vue 2).
Auto-recovery after external-system outages: an estimated 25–30% of 100–500 daily Camunda incidents now resolve without an admin.
Built the in-portal BPMN editor solo; the team’s ~10 analysts moved to it from desktop Camunda Modeler.
Rewrote the admin request search from JPA to native SQL with pg_trgm indexes: ~1–2 s → ~200–300 ms.
Wrote a Kafka notification producer and a consumer that delivers messages via the corporate messenger API; integrated a courier service and the HR system.
Took LLM-based BPMN generation (Dify) from a feasibility study to production: process design went from 1–2 days to ~2 hours.
Reviewed teammates’ code; fixed release-pipeline issues: security-scan findings, builds, dev → prod Nexus sync.

Java 21, Spring Boot 3.5, Camunda 7, PostgreSQL, Liquibase, Kafka, Redis, ShedLock, MapStruct, Docker, TeamCity, GitLab CI, Nexus, Grafana, Prometheus, Vue 2, bpmn-js, Dify

Astelit

Software Engineer (Java Backend)

Aug 2020 – Sep 2023

Custom software development, Rostov-on-Don. Three full-cycle projects in a 6-person team: an electronic document management system, a Telegram bot, a backend for a retail mobile app.

Development lead on the retail mobile app backend: requirements with the client, integration plan with their legacy system.
Built a 1C integration service solo from scratch: per-table schedulers, batch loading via the 1C API, integrity checks.
Designed REST APIs between services during the monolith-to-microservices split; wrote and extended a Kafka producer for push notifications.
Set up CI/CD from scratch: build and test pipelines, artifacts in Nexus, Docker, docker-compose, Portainer.
Built a Grafana analytics dashboard on complex SQL; introduced Redis to cache the app’s home-screen data.
Spring Security with LDAP, Vue 3 frontend; unit-tested all my code with JUnit and Mockito. Mentored the team’s junior developer.

Java 8–17, Spring Boot, Spring Security (LDAP), PostgreSQL, Liquibase, Kafka, Redis, Grafana, Docker, docker-compose, Portainer, Nexus, JUnit, Mockito, Vue 3

Education

2024
M.Sc. in Software Engineering, Web Technologies program
ITMO University, Saint Petersburg. Apostilled diploma.
2021
B.Sc. in Informatics and Computer Engineering
Donetsk National University

Languages

Russiannative
EnglishC1, EF SET 67/100

Contact

Open to a full-time remote role.

Format: Remote, full-time
Contract: B2B (ready to register as a Georgian individual entrepreneur) or EOR
Location: Tbilisi, UTC+4. Russian citizen.

Resume

PDF in English PDF на русском Save contact