Projects

• Restructured feature modules by purpose (map, tickets, a new business module) as part of the module cleanup.
• Added error-state feedback — insufficient-coin and pin-change error snackbars, unfilled-profile-field indicators, and a tournament description screen.
• Added an instant-game close-confirmation dialog and a config refresh after coin collection.
• Migrated the CI/CD setup to a newer internal plugin/toolkit and fixed a Windows-only ktlint issue.

• Built the core UI components of the game loop (bottom bar, statistics, scan, and draw screens) and a module restructuring pass.
• Closed out a round of bug fixes across the already-shipped screens.
• Shipped to a large public audience — the app drew strong download volume shortly after release.

Clean Architecture, feature modules split into data/domain/ui/routing, MVI on top of a custom state-machine core, Conductor-based routing.

• Shipped the profile module to release, including a QR-code scanning flow.
• Built the geolocation and place-selection flow as a dedicated, reusable module.
• Added resource-locale selection and config-driven base-URL switching.
• Implemented a hash-cache layer (in-memory, later refactored into a repository) and the core flow-switching logic between the app's main sections.

• Forked the base template and set the initial architecture and code-generation conventions with the project's first commit.
• Built the ground-up foundation: base routing, base UI components, theming, and the network layer.
• Set up CI/CD — internal/release build tagging, daily builds.
• Led development for most of the project's active life — the largest single contributor by commit volume.
• Shipped a genuinely public, still-active app — later confirmed live on major app stores with a wide install base.

• Refined push-notification handling across the courier app.
• Carried the app through to production release — swapped in the production Firebase config and cleaned up the auth interceptor for the app-key header.

• Owned the courier profile screen and the order list/status flow — the two largest modules in the app by change volume.
• Shipped the order-search and status-display logic that went to production ahead of launch.

• Configured routing for the albums flow.
• Refactored business logic out of the UI layer into domain models, and extracted shared mediators between feature modules.
• Adapted the shared UI kit to the project's needs.

• Tech-led the project for roughly half a year — architecture calls, code review, and hands-on mentoring across the team.
• Shipped cross-cutting delete-from-preview logic for photo/video/audio/document files and a context menu with action categories.
• Fixed critical, cross-module bugs (a file-selection hang, multi-folder copy) touching 34 of the app's 46 feature modules.

• Built the money-operations details and history screens — the app's core day-to-day banking view.
• Shipped internal transfers alongside the SBP/phone and by-requisites transfer flows.

• Led the core payments team for about a year — the app's most heavily used, highest-stakes module.
• Shipped the key payment flows: SBP/phone transfers, legal-entity transfers by requisites (incl. tax payments), and scheduled payment templates.
• Drove architecture refactors of the money-operations and payment-templates modules.

• Built the registration and verification flow with its own routing.
• Hardened authentication (PIN, OTP, fingerprint) with real validation and error handling, not just stubs.
• Refined push notifications and updated the shared UI kit and screen styles.

• Wrote the project's first commit and shaped its initial module structure.
• Built a feature-toggle system with an admin debug panel, reused by the team afterward.
• Shipped the poker functionality end to end — variant list, tournament rules, blind selector.
• Won industry recognition — the app placed in the "Golden App" awards (Entertainment category) and won a Tagline Awards design honor.

• Added feature-toggle-gated mock data and currency mapping to the loans list.
• Handled identity-verification edge cases (e.g. an unrecognized-phone error state).
• Built the loan-repayment step flow — a progress indicator across repayment steps, plus the bottom navigation menu.

• Stood up several core lending features from scratch in the product's first year: loans list, loan origination, identity verification, and fingerprint login.
• Added an SSL/network-security backport so certificate pinning worked on older Android versions — a real requirement for a banking app.
• Returned years later in an infrastructure capacity — fixed CI runner and Gradle-cache issues and advised on build rules for the long-running, multi-market codebase.
• Formalized team process — wrote the fork/contribution wiki, commit-message conventions, and Android Studio project templates.

A shared starter-kit template forked per client engagement — theming, auth, and CI/CD infrastructure built once and reused, with each fork then diverging into its own client-specific feature set.

• Built the shared theming/design-system foundation (typography, color palette, base styles) reused across every project forked from the template.
• Built a reusable authentication template module — PIN/fingerprint and JWT-based login flows — for downstream apps to adopt directly.
• Set up the CI/CD release pipeline — automated changelog generation from git tags/commits, APK publishing, and crash-reporting integration — reused across every fork.
• Authored the team's engineering wiki and conventions — git flow, commit-message templates, and code style, plus the fork/onboarding steps for new client projects.

• Built the document-scanning feature end to end — camera capture, a native recognition pipeline, and UI for scan progress, results, and error states.
• Built the patient-registration flow — multi-section form navigation, custom date/dropdown selectors, and save/loading states.
• Wired the scanner into registration — recognized document data feeds directly into the registration form.

• Added a payment-success confetti animation to the receipt confirmation screen.
• Refactored the check-in result screen and its payment-status-dependent navigation.
• Handled geo-permission edge cases and deferred map initialization for the venue map.
• Optimized icon assets and shared color tokens as part of the white-label brand port.

• Shipped the post-payment "Thank You" redesign and a card-linking flow with contextual onboarding tooltips.
• Reworked table-reservation and check-splitting flows, and redesigned the venue map (pin clustering, geo-onboarding).
• Ported the whole UI theme to a second white-label brand without touching business logic.
• Delivered features as one of many contributors on a large, fast-moving team, rather than owning the core architecture.

• Added push-notification re-engagement prompts ("learn a new word" reminders).
• Built word-example display logic and fixed an auto-update bug in a later maintenance pass.

• Designed and built a language-learning app from scratch — word cards, categories, quizzes, progress tracking — largely solo.
• Shipped two full releases, including a complete architecture rewrite between them.
• Supported two localized flavors for two different audiences with separate assets and translations.

Bootstrapped the app from project inception — multi-flavor Gradle setup, MVP (Moxy) base controllers, DataBinding, RxJava2 — as the founding engineer and top contributor for the engagement's full ~19 months.

• Updated the root-detection security module to cover new threat patterns.
• Built account-list refresh logic for the balances screen.
• Built the accounts and cards modules — account list/detail, paginated transaction history, card list/detail/activation.
• Built payment features: own-account transfers, free-form payments with input validation, and payment templates.
• Refactored multi-language support into a standalone module, and fixed a set of memory leaks (integrating LeakCanary to catch more).
• Updated the real-time socket protocol powering the app's live-data channel.

• Founding engineer — set up the app's architecture from its first commit and remained its single largest contributor throughout.
• Built the UI-routing layer between screen controllers and the app's error/snackbar messaging.
• Shipped core banking features: quick balances, Digipass authentication, payment templates, language switching.
• Carried the app across three major release cycles (1.0 → 2.0 → 3.0), taking on a growing share of release-integration and branch-merge responsibility over the engagement.

Migrated a legacy MVP monolith toward modular boundaries (network/DB pulled into dedicated modules) while shipping features in parallel.

• Shipped a deposit-settings screen with a deposit-closing flow.
• Added region selection in the provider list and auto-detected the payment operator from user input.
• Built payment templates for recurring transactions.
• Shipped the branch/ATM map — pin clustering plus address and metro-station search.

• Ran a systematic modular decomposition of an inherited legacy app — pulled services into a dedicated network module, split out the local database, migrated the package after a corporate rebrand.
• Wrote the architecture-vision doc that guided the refactor.
• Fixed the bulk of the app's bugs and crashes, including payment-transaction crashes.
• Helped ship a top-ranked banking app — placed near the top of an independent mobile banking industry ranking, ahead of several major national banks.

• Built the "travel companion" matching flow (filters, a dedicated Travel screen/presenter) for finding fellow drivers.
• Worked the profile screen — gender, city, and avatar fields.
• Fixed push-notification bugs, including duplicate re-subscription and companion/offer alerts.
• Fixed database-migration and image-cropping bugs, added Wi-Fi-only content loading, and localized the app with a default RU locale.

• Stabilized a two-year-old legacy codebase through release, joining at its final push.
• Shipped Facebook-based registration, push notifications, and profile/filter logic fixes.

• Wired up the task graph — ktlintCheck/ktlintFormat, per-module Detekt with platform-specific rule merging, a git-hooks setup task, and aggregate pipelineCheck/prePushCheck tasks.
• Replaced hardcoded dependency coordinates with lazy version-catalog lookups.
• Built an extensible dependency-slot system (DSL closures) so consumers can override any tool's version without forking the plugin.

• Designed and built the plugin from scratch — centralizes detekt + ktlint config across every KODE Android repo instead of copy-pasted per-project setup.
• Solved Gradle configuration-cache compatibility with a dedicated round of provider-based fixes.
• Reused the Build Publish Plugin's core infrastructure instead of duplicating it.

• Added Showkase previews for the existing component gallery.
• Added a Gradle-wrapper validation workflow alongside the release/pre-merge CI pipeline.

• Migrated Maven Central publishing off deprecated Sonatype OSSRH onto the current vanniktech plugin.
• Updated the toolchain (Kotlin, AGP, Compose, Material3) and added release/pre-merge CI workflows.

• Built a pattern optimizer — auto-atomicization, dead-branch elimination, and alternation factoring.
• Added capture inference — generates typed Kotlin data classes from named regex groups.
• Added a `permute()` syntax for order-independent matching, plus a regex-diff tool, ASCII railroad diagrams, and a performance-benchmark command.

• Ported a Rust regex-DSL compiler to Kotlin Multiplatform from scratch — lexer, parser, AST, and compiler, no WASM bridge to the original.
• Extended it well past the original: a decompiler/explainer, linter, ReDoS detector, complexity scorer, test generator, and fuzzer — none of which exist upstream.
• Shipped Maven artifacts, a C-FFI shared library, and a CLI binary in 22 commits over 6 days.

• Built a stack detector that reads a project's version catalog to identify its DI framework, navigation library, networking stack, and KMP UI split.
• Added drift detection — generated rule files carry a content hash so re-running the installer can tell what's changed.
• Built a token-usage optimizer subcommand — backs up existing config, installs a session-start hook, curates which MCP servers load per project, and trims the base context footprint by roughly two-thirds.

• Designed and built the entire toolkit from scratch in one sitting — a stack detector, a slim CLAUDE.md generator, and a compiler for 14 code-generation skills.
• In active use across roughly a dozen real projects with different stacks (DI, navigation, networking, KMP or not).
• Added a token-usage optimizer for Claude Code sessions, grounded in published context-engineering research.

• Built the devops-facing layer — runner topology config plus host-side maintenance scripts (metrics, image pruning, stale-emulator sweep) for a three-runner fleet.
• Wrote per-topic documentation with diagrams covering architecture, templates, scripts, and both developer/devops workflows.

• Owned the architecture solo: unified GitLab CI YAML templates plus 29 Bash scripts, replacing per-project, drifting CI pipelines.
• Built cache choreography with flock-based locking across a multi-runner topology, plus emulator lifecycle and UI-test orchestration.
• Added a cross-platform smoke-test harness (shellcheck + functional tests) gating every merge.
• Root-caused a chronic disk-fill outage — GitLab's Docker executor treats /cache as a persistent managed volume that nothing was clearing; freed 51GB across 31 orphaned volumes and shipped a universal after_script fix.

The same three build servers double as the egress point for their own proxy traffic and the target of their own monitoring — compute, network, and observability sharing one fleet.

• Split the GitHub Actions runner pool into "queen" and "worker" roles — heavy release builds versus PR validation and daily builds.
• Added a daily Docker cleanup job pruning stale images and orphaned volumes.
• Routed CI git operations through the same proxy tunnel, with a Gradle-specific bypass for the internal build-cache host.

• Ran three build servers in production hosting GitHub Actions and GitLab Runner side by side for Android builds, sharing a Gradle cache with per-runner memory limits.
• Stood up Reposilite, a self-hosted Postgres-backed Maven proxy, so runners stop round-tripping to external repositories on every build.
• Deployed a self-hosted Telegram Bot API server to push CI-built APKs/AABs and changelogs straight from the pipeline, bypassing the public Bot API's 50MB upload cap.
• Added Cronitor heartbeat monitoring across all three servers with an auto-recovering health assertion, plus a Squid/Xray proxy fixing an IPv6 resolution bug that 404'd non-standard Maven artifacts.

• Added a database scope with SQLDelight migration-safety rules — sequential migration numbering, ALTER-TABLE-only changes, required defaults on NOT NULL columns, and a DROP COLUMN ban.
• Added platform-tag rules so a shared KMP config could scope policies like the changelog requirement to Android-only changes.
• Kept the config in sync with breaking engine changes — migrated policy semantics and added remote-fallback config resolution.

• Designed and built the shared base config that lets every KODE Android/KMP project inherit one set of MR-validation and AI-review rules instead of duplicating config.
• Adopted by multiple internal Android/KMP repos through config inheritance.

• Built a consistency-check tool that flags zero-hour days, anomalous hours, and duplicate entry descriptions.
• Made bulk operations dry-run by default, requiring an explicit confirmation flag to apply.
• Built a resilient API client — transparent session re-auth on expiry, typed error mapping (not-found/rate-limit/validation), and short-lived response caching.
• Wrote per-client connection guides covering every major MCP client the tool supports.

• Built a 35-tool MCP server wrapping the company's time-tracking system solo, end to end, in two weeks.
• Shipped a multi-tenant hosted mode with a hand-rolled OAuth 2.1 flow and self-deployed it in production.
• Covered all 35 tools with a live black-box test suite before calling it done.

• Fixed a Windows-only path-resolution bug in the schema-directory lookup.
• Migrated the library off legacy root-publication logic onto vanniktech-maven-publish, and upgraded Dokka to V2.
• Moved Gradle plugin configuration onto lazy providers for configuration-cache compatibility.

• Modernized the library's build/tooling/publishing and stood up CI/release workflows from scratch.
• Shipped parallel-flow nodes (AND-states) — one of the library's headline features — on top of the existing statechart core.
• Added Android product-flavor support to the Gradle plugin's schema resolution, letting a flavor override or extend the base navigation graph instead of every flavor sharing one flat schema.

Mirrors the apt original's module boundaries — annotation-rule/util helpers, a presenter-binder generator, a view-state generator, and a MoxyReflector generator — with generic View/Presenter resolution ported from Types.asMemberOf to KSP's Resolver.asMemberOf.

• Ported the full annotation-processing pipeline — @InjectPresenter/@InjectViewState/@ProvidePresenter/@ProvidePresenterTag/@RegisterMoxyReflectorPackages — generating identical class shapes to the apt compiler.
• Shipped a runnable sample module with behavioral tests covering all five StateStrategy implementations.
• Fixed a KSP2-only lifetime crash in the reflector generator, caused by dereferencing stale symbols across processing-round boundaries.
• Fixed a KSP1/KSP2 vararg-detection mismatch that silently mis-generated vararg view-method overrides.
• Closed a CI gap where the sample module depended on a local Maven publish step no workflow actually ran.

• Ported moxy-compiler from kapt to KSP, targeting Moxy 1.5.6, published as ru.kode.moxy-ksp:moxy-ksp.

• Added Java 17 support and git-lfs to the image, alongside build-tools path/version fixes.
• Extended the variant matrix — added Allure to the UI-test image and new API-level/NDK/emulator combinations up through API 37.

• Reworked a multi-year-old set of Dockerfile branches into one parameterized Dockerfile + variants.json, cutting the cost of adding a new Java/API/NDK combination.
• Set up tag-triggered publishing to Docker Hub via GitHub Actions.
• Carried a personal 2020 fork through 5+ years and two employer changes, eventually formalizing it as company tooling.

• Traced a platform-level Android 14/15 bug from a vague visual symptom to its exact root cause (a resizeableActivity=false + resetConfig interaction) by tracking it through the Android Framework source.
• Isolated it into a minimal reproducible sample and filed it with Google's Issue Tracker with video evidence.

• Classic branch — a hand-rolled adapter with manual view-type dispatch and a nested adapter for an inner counter list.
• AdapterDelegates branch — one delegate class per row type, wired through DiffUtil.
• Groupie and Epoxy branches — a library-provided generic adapter (Groupie) and an annotation-processor-generated DSL (Epoxy), the two lowest-boilerplate approaches.

• Built the same list screen four ways (classic adapter, AdapterDelegates, Groupie, Epoxy) as conference material.
• Presented the comparison at DevFest Kaliningrad 2018 and wrote it up on Habr.

Flutter client talking to a self-hosted Go backend built on PocketBase (embedded SQLite) via its official Dart SDK — realtime UI updates through PocketBase's subscription API rather than polling; product/place names are multi-language via a dedicated translations table, not locale fields.

• Photo receipts attached per spending entry.
• Realtime sync across devices via PocketBase's live-subscription API.
• Multi-language product/place names through a translations table shared across records.

• Self-hosted service with Telegram-based login for tracking personal spending.
• Designed and built the whole product solo — a Flutter client plus a Go backend — after migrating off an earlier local-only data layer that didn't scale to multi-device sync.
• Extracted the Telegram-login flow into a standalone open-source library, published separately from the app itself.

TypeScript monorepo: a framework-agnostic core (canonical data model, CRDT sync on Yjs, GEDCOM import/export), a React client, and an optional self-hostable Node server that acts purely as a sync/licensing/payments relay — client-side sealed sync means the server never sees real tree data, only ciphertext and account metadata.

• GEDCOM import/export for interoperability with existing genealogy tools.
• Offline-first PWA with zero outbound network calls by default.
• Tree federation — linking two independent users' family trees, with cross-tree DNA-confidence matching and merge review for duplicates.
• Feature tiering and payments (two payment providers) for an eventual self-host-free / managed-paid model.

• Built a local-first data model with CRDT sync, solo, in an intense sprint — works offline across devices.
• Designed and built the entire system solo as a three-package monorepo, reaching a feature-rich beta in under three weeks.
• Built cross-tree relative-finding that matches records between two users' trees using keys only, without either side exposing raw family data.

Static site (Zola) with a hand-rolled Workshop Ledger theme — no JS framework, vanilla self-guarding JS modules only.

• Designed and built this site's theme from scratch, including a generative per-post signature/fingerprint system.

Single-screen Compose Multiplatform desktop app (Kotlin), packaged as native macOS/Windows/Linux installers — local file parsing only, no network layer.

• Configurable detail levels — collapse down to just messages, or expand date/source/other fields.
• Chronological re-sorting (Splunk exports newest-first; call debugging reads better oldest-first).
• Regex-based highlighting of significant log lines, and filtered JSON/log export.
• Multi-file workflow — load, compare, and switch between several log files at once.

• Built a Kotlin Multiplatform parser for Splunk logs in a two-week sprint.
• Solved a recurring personal pain point — turned a slow manual log-triage step into a two-click desktop tool.
• Refactored its own architecture mid-build — moved logic from the UI layer into a ViewModel, then split it into separate reactive interactors as the tool grew.

Flutter client with WebRTC video calling, signaled through an inherited Elixir/Phoenix real-time backend (Channels over a single socket, plus a REST layer for CRUD) — took over and stabilized an existing multi-year-old codebase rather than building from scratch.

• Anonymous device-based login — no password, re-authenticates automatically per install.
• Patched three inherited third-party libraries for null-safety and modern platform APIs to get the app buildable again.

• Kept it alive across multiple rebrands over its history; revived once after its SSL cert lapsed, backed by an in-house server.
• Diagnosed why the product had fallen out of the app stores — a lapsed iOS certificate and a pulled Android listing — and re-published the Android build.
• Migrated the backend to new hosting and stabilized it after several years without maintenance.

• Wrote a working file-system-walking snippet that derived tags from folder structure across ~4,000 notes — the idea was later superseded by a more deliberate frontmatter and tag-taxonomy system instead of purely mechanical folder-based tagging.