AValeradev12
RU
Get in touch
Alexey MatvienkoMobile · Frontend · Backend

I build the whole product — from hypothesis to revenue.

Strongest in frontend, with deep experience in React Native mobile apps. I write backends and set up CI/CD and servers — by hand and with AI agents.

Message me on Telegram →See projects
Pronto test DGTmy own card engine
Story Pulsequests with an AI game master
4+ years
of React Native
3 stores
Google Play, App Store and RuStore — published myself
12
merged open-source PRs
2009
first project with a real audience — forws.net
00 · In short

What people usually ask first

— What are you strongest at?

Frontend and mobile apps: UI, gestures, animation, performance, builds and store releases. I write backend regularly — GraphQL and Node.js, NestJS with PostgreSQL, features in .NET — and can take a feature from migration to screen.

01 · By hand and with AI

Code by hand — and with AI agents

I started long before AI agents: the forws.net catalog in PHP, WPF at university, then several years of commercial mobile and backend development — all by hand. So I understand what a model generates and can see where it goes wrong. With agents I'm many times faster — and I decide where they can be trusted.

Before AI agents

By hand

I wrote all the code myself — from extending a PHP catalog in 2009 to medical and fintech apps. That's where the habit comes from — read the code, profile, get to the root cause.

  • The forws.net catalog in PHP — my first product people actually used
  • WPF gaze-track player for eye-tracker research
  • Medical apps over Bluetooth: React Native and .NET
  • A map with 13,000 points and 4 merged PRs to its library
  • My own card engine on Reanimated — from profiling to the UI thread
  • An ERP in a Telegram bot on NestJS: clients, inventory, orders, work
With AI agents

Many times faster

Several agents write, test and deploy in parallel while I set the tasks and review the results. That is how I built the second version of Multstand Hub — a web app with CDEK and a document generator — in about a month.

  • Story Pulse: web, Telegram Mini App and iOS/Android from one codebase, plus the server and the AI game-master engine
  • Multstand Hub: an ERP that grew from a Telegram bot into a web app with CDEK and its own document generator
  • Agent instructions live in one package that plugs into all my projects
  • AI players play through Story Pulse games and rate them — these are the playtests
  • An agent opens the right Storybook screen from a deep link and checks it itself

Company production

AI is a pair partner. Architecture decisions and code review are mine, and I own them. Not "the AI wrote it, I pushed it."

Prototypes and my own products

I orchestrate several agents at once, each in its own worktree: prototyping, development, debugging, tests, deployment. My part is the tasks, the review and the merge.

Servers and deployment

I set up and configure servers, deploy and maintain applications. At home I run Proxmox with lots of LXC containers for different jobs.

02 · Projects

Seven IT projects and two offline businesses

  1. 01Workplace platform for VkusVill staffAlly SoftwareFullstack developer1 month
  2. 02Pronto test DGTDevarchReact Native developer7 months
  3. 03Invoice for AccountantInvoiceboxReact Native developer, sole developer on the app1 year 8 months
  4. 04Prisma App and LuisaMCC-SOFTReact Native + .NET backend2 years 3 months
  5. 05Online quests with an AI game masterStory PulseFullstack, my own startup
  6. 06Multstand HubMultstandOwn project: first version by hand, second with AI agents
  7. 07AleraplanAleraplanOwn project, solo
  8. 08Multistorya network of animation workshopsCo-founder and headsince 2013
  9. 09Animation standsmultstand.ruI design and build the standssince 2016

Commercial projects

01
Ally Softwarecommercial1 month

Web, mobile app and server of a platform tens of thousands of employees work in

Workplace platform for VkusVill staff. The service tens of thousands of employees at VkusVill, a Russian grocery chain, use for shift schedules, the calendar, requests and the knowledge base. Web, mobile app and GraphQL server — all in one monorepo.Fullstack developer

1button instead of explanations

One-button bug report

Employees struggle to explain to support what exactly broke. I built a report the app collects on its own: the user presses a button in the Support section, and a snapshot of the app state — without passwords or tokens — goes to secure storage. Once the report is accepted, the user gets a notification, and after a set period the report deletes itself.

read-onlydata stays untouched by default

Debugging through the user's eyes

A developer opens the report in a separate isolated tab and sees the app exactly as the user saw it — without knowing their password. Access is single-use and time-limited, signing out and changing credentials are disabled, and by default no changes reach the server at all.

ADRdecision documented for the team

Shared platform modules

To make this work I extended shared parts of the platform — on the server, in client auth and in the notification center. New capabilities switch on only where a module explicitly opts in, so the rest of the code is untouched. I wrote the decision up as an ADR so the team can see what changed and why.

1 queryfor the whole staff list

Workplace and next shift

Employee profiles — on web and in the mobile app — now show workplaces and the next shift. For the staff list the server loads this data with a single database query rather than one per employee; a shift already in progress also counts as the next one.

  • React 19
  • React Native
  • Expo
  • GraphQL
  • Apollo
  • Node.js
  • PostgreSQL
  • Jest
02
Devarchcommercial7 months

Subscriptions in two stores, a custom card engine and a rewritten core

Pronto test DGT. An app for preparing for the Spanish driving licence exam: practice tests, theory, question translation, paid subscription.React Native developer

3promo code sources

Subscriptions and promo codes

I joined at the prototype stage, before the public release. Set up subscriptions in Google Play and the App Store and unified them in RevenueCat. Replaced the stock RevenueCatUI paywall with my own: per-day price, discount size, purchase restore, promo-code entry and waiting for the backend to confirm Premium. Promo codes arrive from AppsFlyer on install, from a deep link or by hand; an unfinished activation resumes after a restart, and when a code comes from several sources the conflict is resolved by defined rules.

0Redux in the test module after the rework

Rewrote the product's core

The test-taking screen was a dozen nested components, each reading and writing shared Redux fields — a change in one place broke a neighbouring flow. For about five months I worked with the module as it was, until time was set aside for a rework. I left the old code alone until the new one was ready: first built the components in Storybook on mock data, then replaced the data flow — the test mode is set at launch and passed down through props.

UI threadgestures and positioning

Card engine

Question cards swipe on my own engine built on Reanimated and Gesture Handler. I started with profiling and built diagnostics into the engine, then fixed what its readings pointed at: cut redundant React renders, moved gestures and positioning to the UI thread, added windowed rendering and priority loading. Freezes, dropped swipes and blank cards on low-end devices went away.

FSDlayer boundaries enforced in ESLint

Engineering foundation

Moved the app to FSD and enforced layer boundaries with my own ESLint rules — violations get caught before review, as does an accidental Storybook import in the production build. Upgraded React Native step by step from 0.76 to 0.86 and moved the app to the New Architecture. Storybook opens from a deep link in a separate QA build without Metro, so both QA and an AI agent can launch the story they need; that took patching Storybook itself.

live codingin the real app on an emulator

Hiring and team

For React Native interviews I prepared questions and a task in the real app on an emulator: the candidate finds and fixes a problem instead of reciting definitions. I ran the interviews and took part in the decision. Onboarded the new developer — architecture, key flows, release process — and reviewed their first tasks.

  • React Native
  • TypeScript
  • Reanimated
  • Gesture Handler
  • Redux Toolkit
  • TanStack Query
  • OpenAPI codegen
  • RevenueCat
  • AppsFlyer
  • Sentry
  • Storybook
  • Unistyles
  • FSD
  • Jest
All tasks and results50 items
Payments and promo codes
  • Configured subscription products in Google Play and App Store, unified them behind RevenueCat, implemented the full purchase and restore cycle in the app.
  • Promo codes from three sources: AppsFlyer install attribution, deep links, and manual entry.
  • Validation and activation through the backend, with expired, already-used and not-eligible offers handled separately.
  • Recovery of an unfinished promo flow after an app restart.
  • Conflict resolution when several promo-code sources fire at once.
  • Replaced RevenueCatUI paywall with our own: plan selection, purchase, restore, Premium confirmation by polling the backend after purchase, promo entry, platform-correct discount figures.
  • Server-driven promo offers and flash-sale banners with countdown.
Test flow rewrite
  • Replaced the legacy flow — many components mutating interlinked Redux fields — with a module holding one session state and one-way data flow.
  • Built a custom card engine on Reanimated and Gesture Handler with built-in diagnostics.
  • Profiled component render speed, trimmed the component tree, removed redundant React renders and input latency.
  • Moved gesture handling and positioning to the UI thread so animations no longer depend on JS-thread load.
  • Windowed rendering, sparse cache, priority loading of cards.
  • Fixed freezes, skipped swipes and blank cards during fast navigation, including on low-end devices.
  • Replaced jumpy state transitions with controlled animations.
  • Delivered the heavy card design without losing frames: language switch on long press, animated gradient by answer state, theory bottom sheet, Markdown in questions and answers, hints, result review.
Architecture
  • Migrated an all-in-one component structure to FSD in stages: UI, business logic and data access separated, global state reduced.
  • Wrote custom ESLint rules that enforce FSD layer boundaries and code style automatically.
  • Introduced Storybook for isolated UI development and review.
  • ESLint constraints that keep Storybook code out of production builds.
  • Migrated bottom sheets from Gorhom to TrueSheet behind one interface, solving platform scroll, keyboard and safe-area issues.
  • Migrated styling from Styled Components to Unistyles 3.
Attribution, analytics, monitoring
  • Designed the AppsFlyer attribution flow: first-touch install source collected, stored before auth, and guaranteed to sync with backend and RevenueCat after a restart or network error.
  • App Tracking Transparency on iOS and platform-specific OneLink handling on both platforms.
  • Influencer promo codes and marketing parameters carried from deep links into product and payment scenarios.
  • One product-analytics layer: event catalogue, routing to AppsFlyer and Firebase Analytics, protection against re-sending one-shot events.
  • Sentry context, network errors, navigation breadcrumbs, environment tags, HTTP error grouping; cut false and duplicate events.
API, data, resilience
  • Type-safe OpenAPI pipeline: generated TypeScript DTOs, Axios SDK and TanStack Query helpers.
  • Generated type names normalised to project conventions, client adapted for React Native, API operation and type maps generated automatically.
  • Migrated API calls from RTK Query and raw Axios to the generated SDK plus TanStack Query.
  • Offline mode that distinguishes 'no network' from 'backend down', with a persisted answer queue — test results are not lost and are sent when the connection returns.
  • Centralised API error handling and structured request logging with token masking and payload size limits.
Build and infrastructure
  • Upgraded React Native 0.76 → 0.86 in steps, moved fully onto the New Architecture, resolved dependency conflicts and post-upgrade regressions.
  • Build and dev scripts — Android: AAB, APK, standalone QA build with Storybook, device picker, uninstall across all Android profiles.
  • iOS: simulator or device selection, Debug/Release runs, CocoaPods preparation.
  • Faster Android builds: single-architecture builds for the connected device plus ccache.
  • Mobile Storybook as a real dev and QA tool: stories and controls opened via deep links, ADB and iOS tooling — including unattended use by AI agents.
  • Separate QA build with Storybook that runs without Metro.
Team
  • Prepared questions that test understanding of React Native specifics and live coding in a real app with an emulator — the candidate had to find and fix a problem rather than reproduce memorised definitions.
  • Onboarded a new teammate: architecture, key product flows, environment, release flow.
  • Code review: business logic, architectural boundaries, platform-specific cases, test coverage.
  • Worked scenarios out with the manager before development: user flows, edge cases, acceptance criteria, technical limits.
  • Documented architecture, code style, complex subsystems and release preparation; wrote skills for consistent AI-agent work.
Also shipped
  • Email + OTP auth, Google OAuth, Apple ID, and an IMEI-based sign-in scenario.
  • Protected debug menu: internal state, product-scenario emulation, runtime staging/production switch.
  • Interactive onboarding on a lightweight in-house Stories component with animations.
  • Linking a user to a driving school by code or a personal AppsFlyer link.
  • App-rating prompt: scoring logic for the right moment, custom banner plus the system review UI.
  • Jest tests for business logic, with timezone/DST-dependent tests run separately.
  • Redux Persist migration generator.
  • Type-safe localisation with per-module translation storage.
03
Invoiceboxcommercial1 year 8 months

Sole owner of a fintech product's mobile app: code, builds, three stores

Invoice for Accountant. A B2B app from the Invoicebox payment platform: loyalty cards that company employees use to pay for fuel, restaurants and flights, while accounting receives the closing documents.React Native developer, sole developer on the app

48 → 53Expo SDK + New Architecture

The whole app

I was the only developer on the Android and iOS app: screens, navigation, builds in EAS and locally, signing, publishing to Google Play, the App Store and RuStore. Upgraded Expo SDK from 48 to 53 and enabled the New Architecture, adapting the native projects, the map, Storybook and third-party libraries. The product went through two pilots with real payments: an employee filled up with fuel using a QR code from the app, charged to the loyalty-card account.

13,000partner locations on the map

Partner map

About 13,000 partner locations came from the backend as a single list with no clustering, and the backend team was busy. I did it all on the client on top of Yandex Map: tiled loading, clustering, filtering by the visible area and caching marker snapshots — the map stopped lagging on pan and zoom. Marker bugs that traced back to the library itself I fixed in its repository: four PRs merged.

2WebViews in one payment cycle

Payment across two WebViews

The app passed data into the first WebView, a partner mini-app, and waited while the user went through several steps in it. Then, without closing it, it opened a second one — the payment page — passed the collected data there, received the payment result and returned it to the first. I built the whole cycle with error handling at every hand-off, fitted the embedded pages to the safe area and status bar, and updated the mini-app SDK — the changes went through PRs in the company's public repository.

3field criticality levels

Data that doesn't crash the UI

The API response format could change without warning. I built a validation layer on Yup: schemas are declared through a validator factory, and every field is marked as critical, replaceable or optional. An error in a critical field stops the flow, a replaceable one falls back to a default, an optional one is skipped. Every mismatch goes to Sentry with the field name, so the team learns about a broken contract before users do.

  • React Native
  • Expo SDK 53
  • Expo Router
  • New Architecture
  • TypeScript
  • Redux
  • TanStack Query
  • Yup
  • Yandex Map
  • Sentry
  • Storybook
  • EAS Build
  • FSD
All tasks and results40 items
Product features
  • Deep links tuned so external links from several subdomains open the right content in the app.
  • Rebuilt the auth screens: local data pulled out of global state, better error handling, correct timers, entering a still-valid code without requesting a new one, reworked API interaction and UI.
  • Rebuilt the home screen for the new interface version.
  • Bank-card binding and management, including the bank's webview flow.
  • Full loyalty-card scenario: binding by code, per-partner display, expiry control, renewal, card selection when interacting with a partner.
  • Partner mini-apps and payment pages inside the app: third-party sign-in, checkout launch, payment status passed back, correct exit to the mini-app.
  • Rebuilt the partner map on Yandex Map: tiled data loading, spatial and native clustering, viewport filtering, cached marker snapshots — stable with thousands of points.
  • Fallback approximate location via an external address directory when geolocation is denied or unavailable.
  • Home-screen counters for unpaid invoices and unread notifications, organisation display, quick jump to filtered operations.
  • Multi-currency support in invoices, orders and cart: currency reference data, caching, one amount formatter.
  • App version check with a suggested or required update.
  • Sign-in through the service for third-party apps over OAuth: the app is opened through an intent, the user confirms, and the session is returned to the calling app.
API and data
  • Integrated backend APIs for fetching and processing data.
  • Replaced client-side Google reCAPTCHA with Yandex SmartCaptcha through the backend; built a reusable CAPTCHA module for auth, payment and document requests.
  • Server-data validation system on Yup: fields split into critical, replaceable and optional levels for flexible error handling.
  • Validator factory for declarative rules per data type and criticality level.
  • Automatic default substitution for non-critical fields on validation failure.
  • Detailed validation logging to Sentry — hard and soft failures — with the problem field and context.
  • UI resilience when the server returns incomplete or malformed data.
  • Optimised API requests and migrated part of them from RTK to TanStack Query.
Navigation and resilience
  • Rebuilt navigation: public and authenticated routes separated, protected screens, one auth lifecycle with PIN and biometrics.
  • Removed redirect loops and transition errors between auth scenarios.
  • Global interception of fatal JavaScript errors: fallback screen, cause logged, safe restart instead of a crash.
Build and environment
  • Upgraded Expo SDK 48 → 53 and enabled the New Architecture; adapted the native Android and iOS projects, navigation, map, Storybook and third-party libraries.
  • Reworked a large part of the codebase along FSD; documented project structure and layer boundaries.
  • Development environment on Windows via WSL for local builds, and on macOS.
  • Set up and maintained builds locally and through EAS Build for both platforms, including signing and certificates.
  • Integrated Sentry for error monitoring and analysis.
  • Reduced app bundle size.
  • Builds with different Bundle IDs so test and release versions install side by side on one device.
Release and support
  • Published and regularly updated the app in Google Play, App Store, RuStore and others; handled store support correspondence.
  • Prepared changelogs for users and for the technical team.
Mini-app SDK
  • Extended the in-house SDK for event exchange between the host app and partner mini-apps.
  • Published new SDK versions to npm and kept the public documentation current.
  • Integrated pages without the SDK through typed WebView message handling.
UI library and team
  • Built and maintained reusable UI components, including platform-dependent ones.
  • Global platform switch in Storybook for easier testing.
  • Analysed architectural questions and proposed solutions.
  • Documentation on builds and releases, data validation and project architecture.
  • Daily work with backend developers, designers and QA — dailies, planning, retros, demos.
04
MCC-SOFTcommercial2 years 3 months

Medical apps that work in tandem with a device over Bluetooth

Prisma App and Luisa. Löwenstein Medical apps for therapy devices: data exchange with the device over Bluetooth, therapy statistics, firmware updates, reports for the doctor.React Native + .NET backend

RN + .NETone feature — both sides of the API

Features across client and server

I took features end to end, from migrations and logic in .NET to screens in React Native. Device-ownership confirmation: if the user hasn't confirmed the device is theirs, it is cut off from syncing with the server. I split the single Data Privacy consent into separate agreements — the server side, a screen with their statuses, and showing the new version to existing users at launch.

50+UI issues fixed

UI audit

The UI fell apart on devices with different screen and font sizes. At first I filed and fixed individual bugs myself, then ran an audit of the whole app together with the designer. I connected three emulators with different settings to one Metro and went through every screen on all of them at once. Extracted reusable components, added screen-reader labels to image buttons for blind users, and gave a 61-slide presentation to developers from several projects.

100+bug reports, most of them fixed by me

Production

I investigated production issues: Sentry and OpenSearch events, support tickets, logs from users' devices. Traced each one to the cause and filed a task — over a hundred bug reports, most of which I fixed myself. Wrote an Azure Function that connected two support ticketing systems and removed manual ticket transfer.

1 → 3services after the split

Backend and tests

Split an overgrown backend service into three. Together with a colleague I reworked two similar classes that people kept confusing: the shared part moved into an abstract class, leaving two explicit implementations. Gathered test-data setup for automated tests into a scenario factory — a new test starts by describing the user and device state it needs.

  • React Native
  • TypeScript
  • Redux
  • TanStack Query
  • React Navigation
  • Reanimated
  • Bluetooth
  • .NET
  • PostgreSQL
  • Azure
  • Sentry
  • OpenSearch
All tasks and results17 items
Real-time and device work
  • Therapy device control over Bluetooth: real-time data exchange, statistics, firmware update.
  • Therapy statistics display, report generation, feedback sent to the doctor.
  • Finished the feature for adding a new device to a user account — backend and mobile.
  • Feature that disconnects a device from server sync until the user confirms ownership — backend and mobile.
Production and quality
  • Worked Sentry and OpenSearch tickets and helped process customer support tickets.
  • Investigated logs from user devices, found root causes, turned them into tasks.
  • Filed 100+ bug reports and fixed most of them.
  • Fixed and improved a large part of the app UI together with the designer.
Backend and integrations
  • Split a single Data Privacy agreement into several separate ones: backend, migrations, UI with agreement list and status.
  • New agreement version shown on launch to existing users.
  • Refactored a backend service into three services, materially improving readability.
  • Azure Function integrating two support services.
UI and accessibility
  • Adapted the interface to different screen sizes and shapes and to different font sizes.
  • Added spoken labels for image buttons for users with low vision.
Team
  • Worked in an international team.
  • Summarised what I'd learned into a talk and shared it with colleagues.
  • Wrote several project Wiki articles for knowledge sharing.

Own projects

05
Story Pulseown project

The AI runs the game; the server makes sure it plays by the world's rules

Online quests with an AI game master. Text quests for a group of players: each writes what their character does, and the AI game master weaves everyone's moves into one story and tells each player their part. Play in the browser or in Telegram.Fullstack, my own startup

3AI roles: gatekeeper, game master, narrator

A turn as a pipeline

A turn is a time window. A player describes their character's move in free text, and the AI gatekeeper immediately says whether it fits. Once the window closes or everyone has moved, the game master decides in a single call what happened to each character, and the narrator writes each player their own text plus 2–4 options for the next move. The game master sees the whole world; the narrator sees only its character's outcome, so the solution simply isn't in its prompt.

JSONvalidated before it touches the world

The server doesn't trust the model

The server checks the game master's response against a schema and against the world: every move has an outcome, the item is actually nearby, the location exists. Anything invalid is dropped; the rest becomes a new version of the world. The status line — time, place, inventory, who's nearby — is assembled by the server itself from world data. A separate check catches texts where the AI made a decision for a human player, and only those get rewritten.

outboxnotifications with retries

Reliability

Turn state lives in PostgreSQL: only one process can close a turn, world versions are never overwritten, and the game isn't locked while the model is thinking. Telegram notifications go out through a queue with retries. Model providers are chained with fallbacks, and the cost of a game is tracked per attempt.

Expoweb, Telegram Mini App, iOS and Android

One codebase, three clients

The game is a single Expo app that runs in the browser, inside Telegram and on phones. Players get their own UI skins; the operator gets a console for managing games. When there aren't enough players, AI players fill the empty seats at the operator's request.

6AI agents at the table per run

Playtests with AI players

I run games with AI agents as players: each gets its own transcript of the game and a rating. After the agents complained about the game feeling on rails, I rebuilt the world into three layers — fixed canon, author hints, and the state of a specific game, which the game master updates every turn.

  • Expo
  • React Native
  • react-native-web
  • Reanimated 4
  • Unistyles
  • NestJS
  • PostgreSQL
  • zod
  • grammY
  • Telegram Mini App
  • Vitest
  • Playwright
  • Turbo
06
Multstandown project

An ERP: first by hand, then with AI agents

Multstand Hub. ERP for a workshop that builds animation stands (rigs for stop-motion animation). Orders, production, component inventory, craftsmen's work reports with payouts, documents and shipping. The manager works from a computer, the craftsmen from their phones.Own project: first version by hand, second with AI agents

2023–2024an ERP inside a Telegram bot

First version — by hand

I wrote the core of the system myself: clients, orders, product configurations, components with stock in and out, work orders and finances. The interface was a Telegram bot, with input through step-by-step forms — all built by one generic engine from field types, so a new entity didn't need a new flow.

2026bot → web app

Second version — with AI agents

In a chat it was hard to see orders and component shortages, and there was a lot of typing. In 2026, working with AI agents, I rewrote the system on a new stack: a desktop workspace for the manager, a phone screen for craftsmen, CDEK integration and my own document generator. I kept tasks, review and deployment for myself; the server and frontend are covered by automated tests.

BOMmodules and cost from the spec

Product from a spec

The manager picks the stand model, number of glass panes, LED strip type, dimmers and options — the system works out the modules, the cost and a product name like 112-TM-2ст-пп-прем-ткань. The power supply is picked automatically too: by strip power and length, with headroom.

PDFcontract, quote, invoice, acceptance act, delivery note

Documents and shipping

Documents are built from order data. The server is small, so Chromium for PDFs lives outside the API in a separate service: it starts on a queued job and runs with a memory limit. Templates are versioned, and the seller on a document is checked against the order. Shipping goes through the CDEK API: cities, pickup points, rates, shipment creation and printable forms.

backupbefore every migration

Risk-free production

Production database migrations run only after a verified backup, and restoring from a backup is tested separately. Deployment is one script: release into a separate folder, migrate, switch to the new version and check that the server responds.

  • TypeScript
  • NestJS
  • GraphQL
  • TypeORM
  • SQLite
  • Telegraf
  • React 19
  • Vite
  • Apollo Client
  • Zustand
  • Tailwind
  • Radix UI
  • Playwright
  • pdf-lib
  • CDEK API
  • Jest
  • Vitest
07
Aleraplanown project

A planner built end to end — from gesture to database

Aleraplan. A personal planner: the day on a timeline, tasks and goals, notes, habits, a time tracker that exports to an external service, and an AI assistant.Own project, solo

5 minblock snap step

A gesture-driven timeline

The day is a timeline where you change a block's length by dragging its edge. Gestures on Gesture Handler, animations on Reanimated 4 with shared values, snapping to a five-minute grid and an enlarged hit area so a finger lands on the edge. I wrote the 12-week habit heatmap myself, without a charting library.

outboxoffline operation queue

Offline and streaming

Notes work without a network: operations pile up in a persistent queue, and the sync engine drains it, tells transient errors from conflicts, and swaps a temporary client id for the server one once an entity is created. AI assistant replies stream over SSE; because of tool calls, one message gets several completion signals, so the reply is finalized on a debounced timer.

4interval overlap cases

Server

REST API on NestJS: 11 modules, thin controllers, OpenAPI from DTOs, JWT for the app and a separate API key for the AI agent. Prisma schema — 13 entities and 14 migrations. The time tracker resolves overlapping entries in four cases: swallow, trim left, trim right, split in two. Time is stored in UTC and grouped by the user's local day.

PM2home server, reachable through WireGuard

Tests and deployment

Integration tests (~1,600 lines) run against a separate test database: auth, notes, categories, projects, the tracker, sync with the external service, the agent API. The server runs under PM2 on my home server, reachable from outside through WireGuard.

  • React Native 0.81
  • Expo SDK 54
  • Expo Router
  • Reanimated 4
  • Gesture Handler
  • TanStack Query
  • Zustand
  • Unistyles 3
  • SSE
  • NestJS
  • Prisma
  • SQLite
  • Jest
  • supertest
  • PM2
All tasks and results31 items
App architecture
  • Feature-Sliced Design: 12 domain entities, features / widgets / pages layers and a shared layer of 19 UI components.
  • Server and client state kept apart: TanStack Query owns server data and cache, Zustand handles narrow client concerns — session, offline queue, debug mode.
  • Storybook in two configurations at once, on device and on web, 28 component stories — used as a working tool, not a formality.
  • Current stack throughout: React Native 0.81, React 19, Expo SDK 54 with the New Architecture, Expo Router, Unistyles 3 with a dark theme.
  • Debug panel behind a floating button for inspecting internal state during development.
Gestures, animation, visualisation
  • Day timeline where a block's duration changes by dragging: Gesture Handler for gestures, Reanimated 4 with shared values and animated styles, snapping to a five-minute grid, an extended touch zone for fingers.
  • Own heat-map component for 12-week habit statistics — no chart library, with a legend and metric plates.
Data and network
  • One HTTP client: token injection, a custom error type that parses the server's error format, request cancellation.
  • Outbox offline mode for notes: operations go into a persistent queue, a separate sync engine drains it, classifying errors as temporary or conflicting, and maps the temporary client id to the server id after creation.
  • Streamed AI answers over SSE — React Native's fetch doesn't expose a stream, so a dedicated SSE client; the completion race (several done signals per message because of tool calls) is resolved with a deferred finalisation timer.
Shipped sections
  • Day planner with timeline.
  • Hierarchical tasks with subtasks, linked to projects and goals.
  • Notes with categories and cursor pagination.
  • Habits with detailed statistics.
  • Time tracker plus export to an external service with duplicate resolution.
  • AI chat with session history and Markdown rendering.
  • Authentication.
Server: API and data
  • REST API on NestJS: thin controllers, business logic in services, 11 domain modules.
  • End-to-end input validation through a global pipe that strips undeclared fields and coerces types; OpenAPI documentation generated from DTO descriptions.
  • Two independent auth mechanisms for two client types: JWT with a passport strategy and bcrypt for the app, API-key auth bound to a user for the AI agent.
  • 13-entity Prisma schema: task hierarchy via self-reference, many-to-many links between tracker records and projects, tasks, habits and notes, deliberate delete behaviour — cascade in some places, null in others.
  • Schema evolved through 14 migrations over three months.
  • Composite indexes for specific queries, including one for cursor pagination sorted by date and id.
Server: non-trivial logic
  • Interval overlap resolution in the tracker: starting or editing a record handles four cases — full absorption of an existing record, left trim, right trim, splitting into two.
  • Shadow tracker records: a separate entity that overrides a finished record for reporting and export without touching the original data.
  • Integration with an external time-tracking service: HTTP client, manual time parsing and formatting with timezone offset, deduplication within 60-second tolerances on start time and duration between local and external events.
  • Habit statistics: current and best streak, 30-day completion rate, weekly aggregation, with different daily-target formulas for three habit types — dose, counter, checkmark.
  • End-to-end timezone handling: server stores UTC, groups by the user's local day using a client-supplied offset — applied systematically on both layers.
Testing and operations
  • 7 integration test suites on Jest and supertest (~1 600 lines) against a separate test database: auth, notes, categories, projects, tracker, external sync, agent API.
  • Self-hosted environment: built and run under PM2 on a home server, with access documentation in the repository.
  • Volume: app ~22 000 lines of TypeScript and 138 commits; server ~9 000 lines, 51 commits, 14 migrations.

Offline business

A detour into business: an animation studio

since 2013

I helped open a children's media arts center, expecting to build a website and set up a CRM. I ended up as a co-founder running «Multistory», a network of stop-motion animation workshops.

multstory.ru ↗multstand.ru ↗
3500+cartoons made in our Tomsk studio

Team and network

Hired and trained staff, packed our know-how into a wiki and launched a franchise. Ran the business remotely from another city.

Inside the product

Not just managing: I worked as an animation instructor myself, taught kids and ran holiday camps. Hosted parties, workshops and cartoon screenings in cinemas — and got over my fear of public speaking along the way.

Sales and commissions

Did the selling myself. Took stop-motion commissions from organizations and split the work across the team.

Website, accounting and design

Handled web and graphic design for the studio: built its website and blog, designed flyers, banners and posters. Set up a CRM and kept track of finances and attendance.

400+animation stands since 2016

The studio grew its own production: I designed stands for stop-motion animation for schools, kindergartens and homes. I built the workshop's accounting and automation into Multstand Hub.

Multstand Hub in projects ↑
03 · How I work

Five habits — and where they showed up

  1. 01

    I notice what's easy to miss

    I walk through the whole flow and check for risk, even when the problem code sits next to my task rather than inside it.

    • Prisma App · UI auditthree emulators with different screens and fonts on one Metro; over 50 UI issues fixed
    • Release riskafter hours I spotted a failing scenario in neighbouring code; the rollout was paused, and checks confirmed the problem
  2. 02

    I turn a recurring problem into a tool

    When the same difficulty keeps coming back across tasks, I look for a shared mechanism and leave it in a form the whole team uses.

    • Prisma App · testsgathered repetitive test-data setup into a factory of user and device scenarios
    • Prisma App · knowledge sharingafter the UI audit — a 61-slide presentation for developers across several projects
    • Own projects · agentsgathered AI-agent instructions into one package that plugs into every project
    • Pronto · architectureFSD layer boundaries and code style enforced with my own ESLint rules
  3. 03

    Understand the system first, then change it

    I spend some time working with the existing code to see how it's really wired. Small improvements go in small commits; a big rework starts once time for it is agreed.

    • Pronto · test moduleworked with it as it was for about five months; built the new UI next to the old one in Storybook and only then replaced the data flow
    • Prisma App · backenduntangled two constantly confused classes with a colleague via an abstract class
  4. 04

    I break complex flows into explicit states

    Where the client, backend, stores and external services meet, I define states and transitions explicitly — including waiting, errors, restarts and incomplete data.

    • Pronto · monetizationtwo stores, RevenueCat, AppsFlyer and the backend; purchases and promo codes recover after an error or restart
    • Story Pulse · turnevery turn goes through explicit stages — steps accepted, the game master decides, players get their story — and none runs twice
    • Prisma App · devicewarning, confirmation deadline, unbinding and re-binding — on client and server
  5. 05

    I make my colleagues' work easier

    I look beyond my own code at where the team loses time — and take that on.

    • Prisma App · supportconnected two ticketing systems via webhooks, checking with the colleague who worked with them; tickets are no longer moved by hand
    • Ally · ADRdocumented the changes to shared platform modules in an ADR so the team can see what changed and why
    • Pronto · hiringlive coding in the real app instead of quizzing definitions; onboarded the new developer
04 · Stack

Core stack — and everything else from my projects

  • React
  • React Native
  • TypeScript
  • Reanimated
  • Node.js
  • NestJS
  • GraphQL
  • PostgreSQL
  • CI/CD
  • Linux · Proxmox

Mobile

React Native · React · TypeScript · New Architecture · Expo · Expo Router · React Navigation · Reanimated · Gesture Handler · FlashList · TrueSheet · Unistyles · Styled Components · Storybook · Yandex Maps · WebView · i18next

Data and state

TanStack Query · Redux Toolkit · RTK Query · Redux Persist · Zustand · Axios · OpenAPI codegen · Zod · Yup · MMKV · AsyncStorage · SSE · offline mode

Backend

Node.js · NestJS · Prisma · TypeORM · PostgreSQL · SQLite · REST + OpenAPI · GraphQL / Apollo Server · JWT / Passport · class-validator · Telegraf · .NET · Azure Functions

Builds and native

Xcode · Android Gradle · CocoaPods · EAS Build · ADB · ccache · WSL · AAB / APK · code signing · provisioning profiles · keystore · React Native upgrades · dependency patches · versionCode / buildNumber

Stores and publishing

Google Play Console · App Store Connect · RuStore · release preparation and publishing · agreements and legal data · in-app purchases · subscriptions · RevenueCat · StoreKit · App Tracking Transparency · review and moderation · store support correspondence

Code quality

Jest · React Native Testing Library · unit tests · integration tests · ESLint · custom lint rules · Prettier · Feature-Sliced Design · code review · conventional commits · Git / GitLab

Monitoring and analytics

Sentry · crash reporting · post-release monitoring · Firebase Analytics · AppMetrica · AppsFlyer · OpenSearch · server logs

05 · Open source

Open source — merged PRs to libraries and SDKs

12merged PRs to public repositories
aleradev12/reelconverter ↗

ReelConverter

Native macOS app in Swift: compress a screen recording or change its speed before sending it. Installs from my own Homebrew tap.

  • Swift
  • SwiftPM
  • macOS
  • Homebrew
aleradev12/pi-model-picker ↗

Pi Model Picker

Extension for the Pi agentic CLI: pick a model at the start of a session — fuzzy search, grouping by provider, favourites, context size and pricing. Published on npm.

  • TypeScript
  • npm
  • Pi
  • GitHub Actions
06 · What came before

Writing code since 2009 — long before AI agents

Team WAFT at Imagine Cup 2012 holding a "1st place — ticket to the final" certificate
Imagine Cup · team WAFT · 1st place, a ticket to the Russian national final
before 2011

First code and olympiads

I got hooked on programming and taught myself the classics — PHP, HTML and CSS, writing code in Notepad. For several years in a row I took first place at city olympiads.

2009–2012

forws.net — my first product

The global internet was slow back then, while the regional local network was many times faster. Files were uploaded to its storage, but finding them meant digging through hundreds of forum pages. forws.net became a handy catalog for them: I extended its PHP engine and a team of moderators added new releases. The site lived until fast internet reached everyone.

video ↗
2012–2013

Imagine Cup: Total Recall

Helping people find familiar images through associations. The system shows several images, from broad categories to specific ones; an eye tracker notices which one holds the gaze, and the next selection builds on it. I wrote the testing app and a player that overlays gaze tracks on the images and builds a heatmap. Team WAFT made the Russian national final.

TPU paper ↗news ↗article ↗video ↗
2013

ExGIS — my first paid project

An interactive map for the Ministry of Education. We geocoded the addresses of thousands of schools through map-service APIs and put them on a map: exam data for each school, links showing who takes the exam where, and a big filter panel. Built by two of us, me and a classmate.

Outside work
  • Local AI modelsI run AI models locally and experiment with using them outside the cloud.
  • 3D design and printingI design parts and print them on a 3D printer.
  • Home serversI set up Proxmox and Linux servers for different tasks.
  • A counting app for my daughterI made a mobile app to help her learn to count large numbers.

07 · Contact

Looking for a developer who owns the whole product? Get in touch.

Telegram@aleradev12↗Emailaleradev12@gmail.com↗GitHubgithub.com/aleradev12↗