TypeScript: The go-to language for modern web development. TypeScript adds static typing to JavaScript, drastically reducing production bugs and speeding up refactoring. I use it across the entire stack — from React frontend to Node.js backend — ensuring full type consistency across all layers.
React 19: The most popular frontend library for building reactive, high-performance user interfaces. React 19 introduces Server Components, streaming SSR and major rendering optimizations. I use it daily for everything from complex internal dashboards to high-traffic B2B SaaS applications.
Next.js: The reference full-stack React framework. Next.js provides SSR, ISR, App Router and Server Components for optimal performance and flawless SEO. It's my default choice for any new project — including this very site, built entirely with Next.js.
GraphQL / Apollo: A modern API approach that fetches exactly the data needed in a single request. Apollo simplifies client-side caching, pagination and optimistic updates. Especially effective for applications with deeply nested data structures and real-time UI requirements.
Socket.io: Bidirectional real-time communication between browser and server via WebSockets. Perfect for chat apps, push notifications, live dashboards and collaborative features. I've deployed it in production on systems handling thousands of concurrent connections with automatic reconnection.
React Router v7: The standard for navigation in React applications. React Router v7 unifies client and server routing with loaders, actions and native error handling. Ideal for SPAs and universal applications that require fine-grained control over page transitions.
Playwright / Cypress: End-to-end testing frameworks to validate user journeys in a real browser. Playwright excels at multi-browser and parallel CI, Cypress at developer experience and interactive debugging. I systematically integrate E2E tests into CI/CD pipelines to catch regressions before every deployment.
Node.js: Server-side JavaScript for fast, scalable backend applications. Node.js excels at high-traffic APIs thanks to its non-blocking event-driven model. I've been using it in production for over 10 years — REST APIs, microservices, async workers and CLI tools.
REST / GraphQL: Robust, well-documented API design. REST for simplicity and universal compatibility, GraphQL for query flexibility and reduced over-fetching. I choose the right approach for each context — typically REST for public APIs, GraphQL for data-rich frontends.
Microservices: Distributed architecture where each service handles a single responsibility and can be deployed independently. Enables progressive scaling and system resilience. I've led several monolith-to-microservices migrations — with a progressive strategy that avoids big bangs and guarantees zero downtime.
RabbitMQ: Message queue for asynchronous communication between services. RabbitMQ ensures reliable exchanges with advanced routing, dead-letter queues and message persistence. I use it to decouple heavy processing — email delivery, report generation, cross-system data synchronization.
Golang: Google's compiled language, ultra-performant for critical backend services. Its native concurrency model with goroutines makes it ideal for high-performance workers and CLI tools. I reach for Go when latency or throughput constraints exceed what Node.js can deliver.
Redis: Ultra-fast in-memory database for caching, sessions, rate limiting and pub/sub. Redis drastically reduces latency on frequent queries and enables real-time patterns like leaderboards and distributed counters. An essential building block in all my production architectures.
AWS Lambda / SNS / SQS: Serverless compute and event-driven messaging on AWS. Lambda runs code with automatic scaling and no servers to manage, SNS/SQS orchestrate asynchronous workflows with retry and dead-letter queues. This powers the core of Flashpricer's architecture — hundreds of Lambda functions processing tens of thousands of products in real time.
AWS RDS / Aurora / S3: Managed AWS data services. RDS/Aurora provides highly available relational databases with automatic failover and read replicas. S3 delivers virtually unlimited object storage. I configure these services with advanced monitoring, automated backups and fine-tuned cost optimization.
GCP / Firebase: Google's cloud ecosystem. Firebase for rapid prototyping with built-in Auth, Firestore and Hosting. GCP for production infrastructure — Cloud Run, Pub/Sub, BigQuery. I spent several years on GCP at PathMotion, managing the migration from a monolithic infrastructure to managed services.
Kubernetes: Container orchestration for deploying and managing applications at scale. K8s automates scaling, load balancing, rolling updates and self-healing. I've operated it in production on GKE and EKS for mission-critical applications requiring high availability.
Serverless / SST: Serverless deployment framework on AWS that dramatically accelerates the development cycle. SST provides a local workflow with Live Lambda, hot reload and instant deployments. My go-to tool for bootstrapping and rapidly iterating on complex serverless architectures.
CloudWatch / Sentry: Production monitoring and error tracking. CloudWatch monitors infrastructure metrics, logs and triggers alerts. Sentry captures application errors with full context — stack traces, breadcrumbs, user data. Together they provide complete visibility from system-wide health down to individual bugs.
Docker / ECS: Application containerization and managed orchestration on AWS. Docker standardizes environments from dev to prod, eliminating the 'works on my machine' syndrome. ECS Fargate simplifies deployment at scale without managing underlying EC2 instances.
PostgreSQL / Kysely: The most advanced open-source relational database — ACID transactions, native JSON, full-text search and powerful extensions. Kysely provides a 100% type-safe TypeScript query builder that catches SQL errors at compile time. My default choice for any application requiring complex queries and strong data integrity.
DynamoDB / Firestore: Managed NoSQL databases for ultra-fast reads and writes with consistent latency. DynamoDB on AWS and Firestore on GCP scale automatically from zero to millions of requests per second. I use them for high-volume data — sessions, analytics events, application caches.
MongoDB: Flexible, high-performance document-oriented database. Its dynamic schema accelerates prototyping and adapts to rapidly evolving data structures. I've used it in production on multiple projects with the aggregation pipeline for complex data processing and change streams for real-time updates.
Meilisearch: Lightning-fast open-source search engine with typo tolerance and millisecond response times. Multi-criteria filtering, facets, synonyms and customizable ranking built in. Ideal for adding instant search to a product catalog, document base or back-office application.
OpenAI / Claude / Mistral: Integration of the leading language models — GPT-4, Claude and Mistral. Each model has its strengths: GPT-4 for versatility, Claude for long reasoning and reliability, Mistral for cost-performance ratio. I select and fine-tune the right model for each production use case.
RAG / Agents IA: Retrieval-Augmented Generation and autonomous agents for precise answers grounded in your business data. Full pipeline: document ingestion, chunking, vector embeddings, semantic search and contextual generation. I've built production RAG systems with quality evaluation, cost monitoring and feedback loops.
Jest / TDD: Automated testing and test-driven development. Jest for unit and integration tests with minimal setup and fast feedback. TDD shapes how I code — writing the test first forces you to design the API before the implementation, producing cleaner and more maintainable code.
