Fedor Makareev
Lead Frontend Engineer / Frontend Architect
Remote · Buenos Aires, Argentina (GMT-3) · fmakareev@gmail.com · fmakareev.github.io · github.com/FMakareev · Telegram: @fmakareev
Who I am
Frontend engineer with 10+ years of commercial experience. I have worked in all three modes: co-founder owning a domain outright, tech lead running a team of contractors, and engineer inside an enterprise process (Sber, Rosatom projects). The product team around me is typically 4–5 people.
For the last 3.5 years I have been co-founder and sole frontend engineer of a B2B/B2C real-estate platform in the UAE. This is not ticket work: I own the frontend and the SSR server end to end — architecture, build, deploy, observability, SEO, performance, the release process and rollbacks.
What I am good at:
- Holding scale. ~520k lines of TypeScript, 41 pages, 86 features — and the architecture has not calcified: current stack and live layer boundaries, with Feature-Sliced Design holding up at that size without decay.
- Changing the stack in a live product without pausing delivery. React 19, React Router v7 → v8, Vite on Rolldown, Zod 3 → 4, ESLint/Prettier → Biome, a move to design tokens — every migration carried through to the full removal of the old code.
- Turning rules into infrastructure. An agreement becomes a CI check. A decision becomes an ADR. Repetitive work becomes a script. This is what separates a tech lead from a strong solo developer.
- Treating performance as a process. Dozens of targeted changes each with a stated reason, not one heroic “refactor for speed”.
- Walking into the unknown. A project with no source code, someone else’s Ruby-backed codebase two weeks before release, Steamworks, Web3, React Native, Godot — each taken to a working result.
Technical stack
| Area | Technologies |
|---|---|
| Languages | TypeScript (strict), JavaScript, GDScript, some Python |
| Frontend | React 19, React Router v8 (framework mode / SSR), Next.js (App Router), Astro, Svelte, Preact, React Native |
| State & data | Effector, TanStack Query, Redux / Redux Toolkit / Saga, Apollo GraphQL, Zustand, React Hook Form, Zod |
| Architecture | Feature-Sliced Design, modular monoliths, microfrontends, NX monorepos, design systems and tokens |
| Styling | CSS Modules, design tokens (primitive/semantic/component), Tailwind, styled-components, Emotion |
| Build & DX | Vite 8 + Rolldown, Webpack, pnpm, Biome, ESLint/Prettier, custom linters and code generation |
| Backend | Node.js — Hono, NestJS, Express; PostgreSQL, TypeORM, Drizzle, GraphQL, REST, OpenAPI, WebSockets |
| Testing | Vitest, Jest, React Testing Library, Playwright, Cypress, MSW, Storybook |
| Infrastructure | Bitbucket Pipelines, GitHub Actions, Docker, Nginx, semantic-release, Heroku, Linux |
| Observability | Sentry (self-hosted), Server-Timing, memory monitor, heap snapshots, Mixpanel, Lighthouse CI |
| i18n / SEO | i18next, 27 locales with RTL, multi-domain canonicalisation, hreflang, JSON-LD, sitemap generation |
| AI tooling | Claude Code, agents and MCP servers, ComfyUI; Blender for 3D assets |
Experience
Co-founder & Lead Frontend Engineer — Alnair (PropTech, UAE)
Jan 2023 — Present · sole frontend engineer · B2B + B2C real-estate platform
A professional platform for realtors, agencies and property buyers in the UAE: 830k+ listings, 2,700+ developer projects, international audience. I joined a frozen SPA, restarted development and carried the product through two full redesigns and a move into B2C.
Team and role
- Co-founder: I take part in product and prioritisation decisions, not just their implementation.
- The development team is 3 people; at various stages a designer, product owner and an outsourced mobile WebView team joined. The frontend domain is entirely mine — standards, architectural decisions, code review.
Scale and ownership
- 41 pages, 43 routes, 33 business entities, 86 product features, 21 widgets; ~7,800 files and ~520k lines in
src/. - ~5,500 of the repository’s 5,821 commits are mine (94% authorship) across 3 years and 7 months of continuous development.
- Kept Feature-Sliced Design intact on a codebase this size: explicit layer boundaries, no barrel exports, automated chunk-graph checks in CI.
SSR migration
- Migrated a client-side SPA to SSR: React Router framework mode + Hono on Node. Section streaming, per-request Effector scopes, systematic hydration-mismatch elimination across all catalogues.
- Rebuilt product patterns for server rendering: catalogue popups became full project, developer and district pages — which also produced indexable pages for SEO.
- Replaced libraries with no SSR support (dozens of carousel components) and reworked the data layer for the server.
- Result: key page load time cut from 10+ s to 1–3 s. Released after 4 months, fully stabilised two months later.
- Published a post-mortem of the migration: where those months went and why SSR is a litmus test for technical debt.
Stack migrations without pausing the product
- React 19; React Router v7 → v8; Vite 8 on Rolldown; Zod 3 → 4 with the API layer unified on a single
ApiResult; ESLint/Prettier → Biome. - Legacy CSS → a three-tier design-token system (primitive / semantic / component) with the legacy stylesheet fully removed and a token migration script.
- Ran a technical spike on React Server Components against our own build and recorded the conditions for adoption as an ADR — rather than adopting it on hype.
Performance: pulling mobile Core Web Vitals out of the red (Aug 2026)
Not a one-off “refactor for speed” but a series of targeted fixes, each measured before and after.
| What was fixed | Before | After |
|---|---|---|
| Mobile Lighthouse, home page | score 29, FCP 7.6 s, LCP 10.7 s, 7.7 MB | score 61, FCP 2.7 s, LCP 3.0 s |
| Hero video on mobile | 5,372 KB — 70% of page weight | not loaded |
| Font fallback: LCP text jumped on swap | LCP 11.4 s against FCP 5.2 s | LCP level with FCP, single candidate |
| Developer page on SSR | LCP 13.2 s | LCP level with FCP |
| CSS as one bundle on every page | 159 KB; /en 5.5 s, news 5.7 s, project 6.1 s, developer 5.4 s | 56–76 KB per chunk; 2.8 / 2.4 / 4.3 / 3.1 s |
| CSS cascade on the developer page | 49 links to 28 files, 6,057 rules | 32 links to 32 files, 2,792 rules |
| LCP image (hero, articles) | 688 KB, 1999×1695 — CMS original | 54 KB, preset sized for display |
| Mosaic tiles / card covers on home | 2,464 KB / 1,605 KB | 238 KB / 321 KB; one thumbnail 352 → 23 KB |
| Eager JS before first render | 1,064 KB — payment logos, Sentry, zod | 935 KB; document gzip down 30–99 KB per page |
| Translation dictionary per visit | 64 KB gzipped (en), ~128 KB (ru) | 3–7 KB (en), 6 KB (ru) |
| Developer page TTFB | 1.05 s | 0.41–0.46 s — GET deduplication + news streaming |
| Project page TTFB | 787 ms | 494 ms across 15 measurements |
| CLS of the developer news block | 0.109 | 0 — data moved into the loader |
| GA4 via GTM | 490 KB across three scripts | 305 KB, single load |
Measured on a production build under mobile throttling; the final Lighthouse run was taken on a clean profile on the same branch.
The tooling that holds this in place:
- Semantic code splitting on Rolldown
codeSplitting.groups, plus a custom detector for lazy modules leaking into eager chunks: a new critical-path regression fails CI instead of production. - Per-chunk CSS instead of one bundle; Sentry / Mixpanel / DOMPurify / Zod moved out of first render; images served at display size instead of CMS originals; font-fallback metrics against LCP shift; translation dictionaries trimmed to the namespaces actually needed.
- On the server: deduplication of identical GETs within a single request, removal of blocking waits before first byte, section streaming, and export of the server-call waterfall to
Server-Timingfor observability directly in the browser.
SEO and multi-domain
- Multi-domain canonicalisation across 6 country domains: region-aware canonical and hreflang, per-host
robots.txtandsitemap.xml, noindex for countries without a domain. Decisions recorded as ADRs. - Data-driven SEO metadata and server-rendered content for district, project and developer pages; JSON-LD with entities correctly bound to canonical pages.
Localisation
- 27 locales, 38 namespaces, ~5,200 keys, RTL support, multi-currency and measurement units — all introduced into a running system that was never designed for international markets.
- Automated key and placeholder validation in CI, generated locale types.
Infrastructure, quality, DX
- CI/CD on Bitbucket Pipelines: separate dev/feature/prod builds, atomic deploy with an active-version switch and instant rollback; semantic-release (14 major lines, 27 minor releases).
- Observability: self-hosted Sentry for both client and SSR, a memory monitor and alert middleware on the server, Telegram alerts, heap-snapshot analysis tooling.
- Quality: 241 test files, 649 Storybook stories, strict TypeScript, Biome, custom linters.
- Custom tooling instead of manual process: chunk-graph validator, i18n checks, CSS token migration, icon and type generation, Lighthouse runs.
Product subsystems I built
- Virtualised unit inventory grid; catalogues filtering across 830k+ listings.
- Maps: Leaflet + Google — clustering, residential master plans, nearby infrastructure.
- Booking, billing and payments, subscriptions, White Label.
- Roles, permissions, agency invitations; client-facing collections; chat and real-time notifications.
- Mortgage calculator, ROI forecast, CMS blocks, feeds and analytics dashboards for agencies.
- Telegram and WhatsApp authentication.
Stack: TypeScript (strict), React 19, React Router v8 (SSR), Hono/Node, Vite 8 + Rolldown, Effector, TanStack Query, React Hook Form, Zod, CSS Modules + design tokens, i18next, Leaflet/Google Maps, Vitest, Storybook, MSW, Biome, Sentry, Bitbucket Pipelines, pnpm.
Tech Lead (Web) & IT Administrator — Phren Games / RC Revolution
Oct 2022 — Jan 2024 · contract, in parallel with main role · GameDev / Web
Web infrastructure for an arcade racing simulator on Steam, plus full IT administration of the studio (~10 people).
- Technical leadership: hired and coordinated frontend and backend contractors, ran the full cycle from requirements gathering and architecture design to acceptance and testing. Performed in-depth code review.
- CMS and API: a React Admin + TypeScript admin panel for game content; a NestJS API for both game and CMS with Swagger/OpenAPI contracts; data on TypeORM + PostgreSQL.
- Statistics service: server side for collecting and displaying multiplayer race results and global leaderboards.
- Releases: Steamworks publishing and updates, CI/CD for automated build delivery; release infrastructure on Heroku, domains and Nginx, Docker.
- IT administration: built the access management system across all services for a distributed team, consolidated invoices and controlled software budgets.
Tech Lead (Frontend / Fullstack) — NFTAlcohol (Web3)
Feb 2022 — Dec 2023 · contract, in parallel with main role
An NFT marketplace at the intersection of classic e-commerce and Web3.
- Web3 infrastructure: a fullstack minting solution supporting both testnet and mainnet; IPFS for publishing and storing collection metadata; a user account with Metamask and Coinbase Wallet authentication.
- Architecture: introduced Feature-Sliced Design (adopted in 2022) — the project survived a full redesign without rewriting business logic, and onboarding of new developers accelerated.
- NFT generator: a client application assembling collections from designer-provided layers. Generation and image export happen entirely client-side — less server load, more privacy.
- TypeScript across the whole stack (Next.js + NestJS) for reliable typing of complex Web3 structures.
The project did not reach production for funding reasons; the MVP was technically complete.
Frontend Developer — Evrone (agency)
Sep 2021 — Jan 2023
Level.travel (travel / e-commerce, 2022)
- The project was at risk of missing its deadline: authentication was unfinished and the previous developer had left. Within 2 weeks I got up to speed on an unfamiliar codebase (React + Ruby backend), completed the main authentication flow and implemented VK, OK and Facebook sign-in — unblocking the release.
- Built a set of lightweight Preact widgets for high-traffic pages.
HR Portal (HR tech / enterprise, 2022)
- Owned the project’s first months: established frontend development standards and chose the stack (NX monorepo + Effector).
- Designed and built the design-system foundation (Emotion + Theme UI), giving all subsequent development a consistent base.
- Built an interactive organisational-structure graph — complex navigation across an employee hierarchy.
Teachbase (EdTech / LMS, 2021–2022)
- Developed course-builder and assessment features; refactored legacy Immutable.js modules and migrated them to TypeScript; worked within a Lerna-based microfrontend setup.
React Developer — Sber
Mar 2020 — Apr 2021 · Fintech / Enterprise
Two frontend microservices inside a banking ecosystem.
Credit-agreement monitoring management system
- Interface for department heads: complex virtualised tables, interactive charts, custom filters.
- Drove the shift to automated testing: raised coverage from 0% to ~80% (unit + integration) within a year, effectively removing critical bugs from releases.
- Worked closely with the backend team (Java Spring) on GraphQL and REST contract design.
- Inner Source: contributed to bank-wide UI libraries used by other teams. Ran code reviews and took part in hiring.
Automated reporting service
- An engine that builds the parameter-input interface from backend JSON configurations.
- A report queue monitoring panel with real-time status updates.
- Introduced mandatory tests for every new generator feature.
Lead Frontend Developer / Architect — GSR, Rosatom and other projects
2019 — 2020
AsPlanning (GovTech / enterprise, 2019) — a planning and reporting system for Rosatom’s network of public offices.
- Designed the entire frontend architecture: 11 functional modules, 20+ pages, 3 layout types, a custom modular structure that prefigured what later became FSD.
- Data layer on GraphQL + Apollo Client; complex calendars, statistical analysis, a multi-level report approval workflow; a Draft.js editor; Sentry.
GSR Ecosystem (2020) — a mobile social network for Rosatom’s host cities.
- Offline-first:
redux-offline-queue+apollo-cache-persist— user actions queue up and are sent with exponential backoff once connectivity returns. - Hybrid API layer:
apollo-link-restto consume a legacy REST API through GraphQL queries — cache normalisation and strict typing. - Auth: 6 providers (Apple, Facebook, VK, OK, Email) plus FaceID/TouchID biometrics, tokens in Keychain/Keystore.
- Gamification: an arcade game on Matter.js with sprite animation, embedded quizzes and games in WebViews with immersive mode; FCM push notification handling across all app states.
- Infrastructure: a React Admin back office, Firebase Remote Config for feature flags and endpoint switching without a store release.
- In parallel I mentored a junior developer, designed APIs and contributed to backend work. Recovered a project after the previous contractor left with no source code available.
Other work (2019–2021): Self AR Admin (Electron + embedded Express), Trinnov Dashboard (React, Apollo REST, EditorJS), Lauf App (React Native interval timers), BilAgro and Star Media (Next.js + Strapi), Eda TV (React, Framer Motion, Gatsby), Deine-Tür, Cocoon Skin, Marta Kot, Strike Pro.
Architect / Lead Frontend — Bureau, OKAN
2017 — 2019 · Fintech / ConTech
Bureau — a credit-history marketplace connecting banks, bureaus and private clients.
- A custom isomorphic SSR engine in 2017, before Next.js became the standard: Express middleware rendering the React tree server-side with Redux state and GraphQL data injected into the HTML, seamless hydration with no flicker, server-side critical style collection from styled-components.
- A system of independent modules (Bank, Bureau, Client) with lazy loading; a custom recursive route and layout builder allowing functional blocks to be included or excluded via CLI at build time.
- Secure encrypted document exchange with email-code access confirmation; a 50+ component UI kit; i18n on both server and client.
- Two separate Webpack builds (SPA and SSR) with HMR for both.
OKAN — a collaborative technical documentation platform for the construction industry.
- Documents modelled as trees of typed cells: custom navigation with 1,200+ lines of logic, drag-to-bind cross-document references built on raw DOM APIs.
- Three-tier state: Redux (global) + Apollo Cache (domain data with optimistic updates) + Context (editor modes).
- Isomorphic rendering with hydration of three independent state snapshots.
- Guaranteed autosave (interval + debounced save-on-blur); RBAC with 4 editor modes and permissions enforced at both routing and UI level.
AI-augmented development
- Daily work with coding agents, MCP servers and custom tooling around them — on the main product and on side projects.
- I approach it as engineering: I know where an agent gives a step-change in speed and where it hits a wall (visual creativity, complex Canvas interfaces, flexible layout systems) and it is cheaper to open the code myself. I write about those boundaries publicly.
- Practice also includes ComfyUI for generative graphics and Blender for 3D assets in side projects.
Side projects
- Games: web games on JS/Canvas and projects in Godot (GDScript) — from mechanics prototypes to scenes and shaders.
- Local-first application: offline-first storage and sync without a mandatory server.
- Portfolio and blog: my own site and technical writing — an SSR migration post-mortem, architectural challenges of AI products, the engineer’s role in the age of agents.
Teaching and mentoring
- GeekBrains (2021): React course instructor — live-coding webinars, reworking course materials, detailed homework reviews.
- Code review and mentoring at Sber, leading a junior developer on GSR projects, hiring and coordinating contractors at Phren Games.
What I am looking for
- Lead / Senior Frontend or Frontend Architect; fullstack (frontend-heavy) is also of interest.
- Products with a genuinely complex domain: platforms, SaaS, data-heavy interfaces, international products with i18n and SEO.
- Fully remote; asynchronous, written-first collaboration or a Russian-speaking team (see Languages).
Languages
Russian — native.
English — A2: I read technical documentation, specifications and unfamiliar code without difficulty, and handle written correspondence and code review. Spoken English is basic and actively improving. The format that works best for me is an asynchronous, written-first team; a Russian-speaking team also works.
Spanish — none.