Ilia Nekrasov

Clean Architecture + MVP across dedicated Gradle modules — domain/data/presentation split, Conductor-based routing, Kodein-DI.

• Flight list v2 — reworked flight-search parameter retrieval/storage and domain models, plus routing between the search and results screens.
• Tariff cards — expandable tariff details with a standby-status display and a disabled-tariff alert state.
• Push notification handling — support for non-standard notification channel IDs and default data-notification display logic.
• Payment-state handling — a dedicated "already paid" order error and routing.

• Shipped the full class-upgrade flow end to end — boarding pass → order → services — with upgrade state persisted per flight segment.
• Built the async WebSocket booking layer from scratch (Socket.IO + a reactive RxSocket wrapper) as a new layer in the app's architecture.
• Laid the feature-analytics tracking pattern (a reusable AnalyticsAdapter) later reused across the app, not a one-off.

MVP-style client (Dagger DI, Moxy presentation layer, Cicerone navigation) on top of a proprietary SIP calling SDK, plus a separate cross-product design-system library — outstaff engagement embedded directly in the client's product team, not a delivered-and-handed-off project.

• Built call-quality instrumentation — MOS scoring and RTP statistics (jitter, RTT, loss) in the SIP SDK, surfaced through a QoS diagnostic dialog in the app.
• Built codec configuration — remote-config and dev-settings-driven Opus codec tuning, plus SDP override support in the SIP SDK.
• Migrated the Settings screen to Jetpack Compose with a full theme switcher, converting the underlying screen from Java to Kotlin.
• Migrated voicemail onto a new backend API and shipped a feature-flagged redesigned voicemail UI.
• Handled new Android runtime call-permission rules (Android 13+) and adapted incoming-call push/answer-from-push handling around them.
• Founded a cross-product design-system library from its first commit — module structure, CI/CD, publishing pipeline, and a Figma-to-code design-token pipeline (colors/typography) for both Compose and legacy XML theming.
• Built most of that design system's base components from scratch (buttons, selection controls, tabs, snackbar, avatar, list items) with a screenshot-testing suite and a storybook-style demo app for designers.
• Migrated the design system from Material 2 to Material 3 as it grew to be shared by a second product in the same suite.

• Diagnosed and fixed ~30 flaky or broken UI acceptance tests across calling, chat, voicemail, and hunt-group flows — root causes ranged from missing click-readiness waits to notification-timing races to hidden dialogs blocking interaction.
• Built a custom Espresso failure handler that auto-captures a screenshot and full stack trace on any test failure, cutting the guesswork out of debugging flaky UI runs.
• Carried the app across three Android platform-target migrations (Android 14/15/16), replacing legacy background-work APIs with WorkManager and adapting to predictive back.
• Became the lead maintainer of the client's shared design-system library, the majority contributor across its lifetime and the foundation both the main app and a second product build on.
• Sustained a multi-year, top-tier contribution to the main app itself alongside the SDK and design-system work, spanning platform migrations, calling/voicemail features, and ongoing QA hardening.

Feature work sits on top of a large legacy C++ mapping core exposed to Android via hand-written JNI; newer feature modules layer Compose plus a modular core/feature split over the untouched legacy engine.

• Added a ruler mode and an offline/online mobile-network toggle to the map view.
• Added star-rating filters to hotel-booking search.
• Redesigned the bottom navigation bar and bottom sheet, and unified text styles/theming into a shared UI kit.
• Wired up feature toggles and CI integrations with the team's issue tracker and chat tooling.
• Integrated an internal MR/commit-policy validator and set up automated test pipelines.

• Shipped search and bookmarks (categories, history, suggestions, filters, result highlighting, sync, sharing) end to end in the client app of a large open-source mapping engine.
• Migrated legacy modules onto a new core/feature/data/domain structure.
• Modernized CI/CD in a later return phase — build-cache warm-up, linter migration, dependency updates.

plugin-core supplies shared DSL/build-service infrastructure; each integration (Firebase, Play, Slack, Telegram, Jira, Confluence, ClickUp, Nextcloud) is its own Gradle module with a thin HTTP client behind it.

• Migrated the whole toolchain to version catalogs and KSP (from kapt), moving build scripts onto Kotlin DSL conventions.
• Moved the Jira integration onto a shared build service — one HTTP client per integration instead of recreating one on every task invocation.
• Migrated Confluence and Jira serialization from Moshi to Kotlinx Serialization, and added test coverage for the Confluence and Telegram integrations.

• Sole maintainer for ~83% of the project's history — led the move from a monolithic plugin to the modular "build-publish-novo" line (plugin-core + independent integration modules).
• Introduced a provider-agnostic issue-resolver seam shared by the Jira and ClickUp integrations.
• Shipped major version 2.0 (a deliberate DSL break) followed by 2.1 with multi-instance/multi-project Jira support.

Layered plugin system (core → plugins-core → plugins-extended → plugins-ai) with AI providers wrapped in Decorator layers for caching, fallback, and multi-model consensus.

• Decomposed the core validation API into separate modules with registry-based defaults.
• Added a knowledge-enrichment layer (issue tracker, wiki, CI, and symbol context) with prompt-injection protection, PII redaction, and SSRF hardening.

• Defined the architecture for a 131-module MR/PR validator — 21 built-in rules, 8 output formats, AI review across 7 LLM providers with consensus/fallback/caching.
• Directed the implementation (largely AI-agent-executed under this oversight) through 43 releases in under 3 months.
• Ported the tool's regex engine to a from-scratch Kotlin port of Pomsky, embedded via WASM instead of a subprocess.

Content (33 competency matrices) and code live in separate repositories so data can be edited independently of the viewer; the backend owns all lifecycle logic, the frontend consumes it via React Query.

• Built a process-manager CLI (start/stop/status/logs) that checks Postgres readiness and runs pending Prisma migrations before bringing the stack up.

• Built and shipped a full-stack grading tool solo in 6 weeks — React/TypeScript frontend, Express/Prisma backend.
• Grew it into a full employee-lifecycle tool: onboarding, 1:1/probation, review cycles, compensation, offboarding, analytics.
• Built an interactive setup wizard covering Google OAuth, database, Redis queues, and email config.