01 · Stack
Full technology map
Two honest layers: what I code daily, and what I choose, integrate, and direct with AI agents under my architecture. Grouped by role, with context on how deep I go.
Frameworks & UI
Libraries for web, mobile, and interface work.
Core UI stack across SPAs, SSR apps, and mobile. Strongest in React and Vue ecosystems with a recent shift toward Next.js for production products.
Component architecture, hooks, performance tuning, and large app structure. Daily driver for dashboards, AI UIs, and admin tools.
Strict typing across frontend and shared API contracts. Used in all current production work.
Years of client and product work with Vue 2/3, composition API, and Nuxt on legacy and active codebases.
App Router, SSR/SSG, API routes, and deployment on Vercel. Primary framework for new Kalyna products.
SSR Vue apps and marketplace-style products. Solid experience, less frequent in the current stack.
Cross-platform mobile apps sharing logic with web. Expo and native modules on client projects.
Utility-first styling, design tokens, and rapid UI iteration. Default for new interfaces.
Deep ES fundamentals — async flows, modules, browser APIs, and legacy codebase maintenance.
Architecture for large stylesheets — variables, mixins, BEM-style structure on older projects.
Page transitions, scroll reveals, and micro-interactions without hurting performance.
Fullstack & Integrations
Backend services, deploy, auth, data, and third-party APIs.
Connecting UI to real backends — auth, databases, webhooks, and third-party services across multiple project layers.
Postgres schema, RLS, auth, storage, Edge Functions, migrations, and cron in production apps.
Deploy, preview environments, edge config, and hosting for Next.js products.
React Native build and release — EAS Build, OTA updates, dev clients, and store deployment workflows.
Email/password and Google sign-in for ComVis, with role-aware account and company workspace flows.
Designing and consuming REST endpoints — error handling, pagination, caching, and typed clients.
Inbound/outbound integrations, signature verification, and retry-safe handlers.
AI Integrations
Model APIs and SDKs wired into product features.
Shipping AI in apps — LLM routes, hosted models, and structured outputs. Separate from transport: these are the providers and SDKs, not how bytes move over the wire.
Streaming LLM responses, tool calling patterns, and edge-friendly AI routes in Next.js apps.
Chat completions, embeddings, and structured outputs wired into product features and internal tooling.
Running and integrating ML models via API — image, audio, and generative pipelines in production.
Claude models in product flows — long-context tasks, tool use, and assistant-style UX.
Browser-side Face Landmarker integration for ComVis liveness challenges — blink, head pose, and expression metrics without uploading the raw video stream.
AI Dev Tooling
AI-native editors, coding agents, and local model experiments.
The development instrument layer — separate from product AI. Daily drivers for writing code faster, plus light local LLM setup when exploring models offline.
Primary AI-native IDE — context-aware edits, agent workflows, MCP integration, and day-to-day shipping.
Agentic terminal workflows — multi-file refactors, reviews, and faster delivery on complex tasks.
Inline completions and chat as a provider — used alongside other AI tools depending on the task and editor.
Minimal local setup with Llama-family models via Ollama — trying AI offline without cloud APIs.
Dev Tooling
Build pipelines, bundlers, and version control.
From Webpack-era setups to Vite-first workflows. Comfortable owning build config and CI-friendly output.
Branching strategies, code review flow, and clean history on team projects.
Default dev server and build tool for React/Vue SPAs — fast HMR and lean config.
Custom loaders, code splitting, and maintaining legacy build pipelines.
Analytics
Measuring what ships — setup, events, and sanity checks.
Surface-level analytics work: wire up tracking in apps, define a minimal event schema, and verify data actually lands. Not deep marketing analytics — enough to connect, configure, and debug the basics.
GA4 property setup, web data streams, and gtag / Google tag integration in React and Next.js apps.
Container install, data layer pushes, and tag triggers — keeping analytics config out of app code where it fits.
Naming events and parameters consistently, mapping key user actions, and keeping a small readable tracking plan.
Realtime and DebugView checks after deploy — confirming events fire, parameters look right, and nothing obvious is missing.
Payments
Stripe checkout, callbacks, and Supabase-backed access on SSR apps.
Minimal but complete payment flows on Next.js — customized checkout UI, server-created sessions, webhook callbacks, and syncing subscription state into Supabase for gated features.
Checkout Sessions and Payment Element on SSR apps — products, prices, test mode, and keeping secret keys server-side only.
Customizing payment forms — Element appearance, layout, and branded checkout without fighting Stripe defaults.
Webhook endpoints for payment and subscription events — signature verification, idempotent handlers, and reliable post-checkout updates.
Map Stripe customers to Supabase users — persist subscription status in Postgres, gate features with RLS, update state from webhook callbacks.
Realtime
Live data, streaming transport, and persistent connections.
Classic realtime plumbing — long-lived connections and push updates. Used across chat, dashboards, insurance quotes, and AI UIs alike; not tied to a single vendor or to AI itself.
Bidirectional events over WebSockets — rooms, fallbacks, and live app state without polling.
Native WS channels — low-latency dashboards, collaborative UI, and custom protocols alongside REST.
Server-sent events for token streams, progress updates, and one-way live feeds in the browser.
Postgres changes, presence, and broadcast — live data pushed from Supabase to the client.
Minimal MCP server — tools/resources, client wiring, and basic auth. Transport layer for AI clients, not a model provider.
Architected & AI-orchestrated
Chosen, integrated, and directed — implementation via AI agents under my architecture.
Not a daily hands-on backend stack. I pick these pieces, design the boundaries, and direct implementation — then review and own the result.
Chosen for parse workers and service-side jobs. I set the approach and review the output; implementation is directed, not daily hand-coding.
Selected when a Python service boundary is the right fit. Architecture and contracts are mine; agents implement under that plan.
Chosen for isolating workers and services. I decide when a container boundary is worth it and how it fits the rest of the system.
Data-layer choice behind Supabase and service work — schema, RLS, and what belongs in SQL versus the client.
Picked when retrieval needs embeddings rather than Postgres alone. I set the integration boundary; I do not claim deep vendor-ops expertise.
Designed retrieval vs generation split so the expensive model is not the default path. Directed, reviewed, and owned — not a specialist RAG résumé.
Selected for controlled server-side face detection in ComVis. I designed the browser/server privacy boundary and directed the model integration.
Closed face embeddings for selfie-to-document matching. Integrated as a short-lived processing step rather than a third-party cloud KYC call.
Optional best-effort extraction from document captures, kept behind company configuration and the same discard-after-processing boundary.