All blog posts
Unused packages
Unused dependencies are invisibly slowing down your app and frustrating users. Here's how to identify and eliminate the bloat.
Var, let, const: clean code starts here
Guide to JavaScript Variable Declarations: Why Using Const and Let Instead of Var Prevents Bugs and Improves UX
Typescript generics: write code that adapts
Type placeholders that make your code adaptable and reusable while maintaining type safety – essential for generic functions and components.
Lucide react: icons that feel right
A library of minimalist, React-optimized icons that enhances UX with consistent, lightweight, and perfectly legible symbols.
Lodash.uniq: clean data, better UX
Lodash utility that removes duplicate arrays to create cleaner interfaces and improve user experience
Fuzzy find: fast search, happy users
Smart search that finds relevant results even with typos or partial words to improve UX and conversions.
Zod: runtime validation for typescript data
Librería de validación runtime para TypeScript que infiere tipos estáticos desde esquemas para validar datos externos.
Webpack-bundle-analyzer
Tool that visualizes the contents of your Webpack bundles to identify and reduce files that impact performance.
Understanding the DOM element lifecycle
DOM Lifecycle Guide (Create, Mount, Update, Unmount) and Why It Matters for Performance and Memory Leaks
ESLint: Clean code starts here
Linting tool for JavaScript/TypeScript that detects errors, inconsistencies, and style issues before runtime
Google analytics
What is Google Analytics 4 and what is it for?: user tracking, custom events, and best practices for SPAs
What is SEO?
Search engine optimization: technical, content, and performance improvements so your site is found and ranks better.
Core web vitals
Google metrics that measure loading speed, interactivity, and visual stability to improve UX and SEO.
What are micro frontends?
Architecture that divides large frontends into independent apps developed by separate teams
What is storybook?
A Storybook guide that explains how to develop and test UI components in isolation, with code examples, pros/cons, and usage recommendations.
Npm vs pnpm vs yarn vs bun vs deno
Learn the key differences between npm, pnpm, Yarn, Bun, and Deno to choose the perfect tool for your next JavaScript project.
Axios vs fetch
An explanation of why Axios remains the preferred HTTP client over fetch in modern JavaScript development, with examples and best practices.
What is a DDoS attack?
An explanation of DDoS attacks, covering everything from basic concepts to advanced defenses.
Imperative vs declarative code in javascript
Discover the key difference between imperative and declarative code in JavaScript. Learn when to focus on the "how" versus the "what" to write cleaner, more maintainable code.
Understanding recursion in javascript
Recursion in JavaScript step by step. Learn when and how to use self-referencing functions to elegantly solve complex problems.
What is ARPC?
Discover ARPC the metric that combines observability and cost analysis to measure how much each request actually consumes on your system
What is latency?
About latency: what it is, how to measure it correctly, and practical strategies to reduce response times in your systems
What is garbage collection?
Learn how garbage collection keeps your application running smoothly and how to identify and prevent memory leaks that can affect performance.
What are webhooks?
A comprehensive guide to understanding and building reliable webhooks, covering event-driven architecture, security validation, and best practices for real-time API notifications.
Caching strategies for APIs
A practical guide to API caching strategies, covering Redis, HTTP headers, and in-memory solutions to optimize performance and reduce server load.
How to use environment variables correctly in frontend and backend
A comprehensive guide to using environment variables safely in frontend and backend applications, covering best practices for configuration management and protecting sensitive data across different environments.
Domain-driven Design (DDD)
A guide to Domain-Driven Design principles, core concepts, and building software that mirrors real business domains and workflows.
What’s the difference between unit, integration, and e2e tests?
A comprehensive guide explaining the differences between unit, integration, and E2E tests, when to use each, and how to balance them effectively.
Playwright vs cypress
A practical comparison guide for choosing between Cypress and Playwright for end-to-end testing based on features, browser support, and workflow needs
What is a monolith?
Understanding Monolithic Architecture in Modern Web Development
What is cypress?
A developer-friendly guide to Cypress testing framework, end-to-end automation, and modern web app testing techniques
What is prettier?
A guide to Prettier code formatter, covering setup, editor integration, and how it eliminates formatting debates in development teams.
What is playwright?
A modern web testing and automation blog exploring tools like Playwright, end-to-end testing techniques, and best practices for reliable web applications.
Geolocation in web apps: how to use it (and when you should)
Learn how to implement geolocation in web apps to detect user location, build location-aware features, and create personalized experiences with the Geolocation API.
Performance optimization in react: a practical guide
React performance optimization with practical techniques to eliminate unnecessary re-renders, reduce bundle sizes, and build faster, more responsive applications.
Monitoring & alerts: why every developer should care
Learn why monitoring and alerts are essential for keeping your applications healthy in production and how to catch issues before your users do
What are feature flags? the power to ship code without fear
Discover feature flags to deploy code safely while controlling when features go live, enabling gradual rollouts and risk-free production releases.
What are CI/CD pipelines? a developer’s guide to automation
Learn CI/CD pipelines to automate testing, building, and deployment processes, enabling faster releases and more confident code delivery to production.
Javascript array methods: map, filter, reduce and more
Essential JavaScript array methods like map, filter, and reduce to write cleaner, more functional code that transforms and manipulates data efficiently.
What is nexus? a code-first way to build GraphQL APIs in typescript
Build type-safe GraphQL APIs with Nexus, a code-first TypeScript schema builder that eliminates duplication and keeps your types and resolvers perfectly synchronized.
Javascript destructuring: the what, why, and how
Master JavaScript destructuring to write cleaner, more readable code by efficiently extracting values from objects and arrays in modern applications.
The javascript lifecycle: what it is and why it matters
Understand the JavaScript lifecycle from script execution to component management to write more predictable, bug-free code that handles timing and resources properly.
Queues in programming: what they are and why you should use them
Learn what queues are in programming and how they help decouple processes, handle high loads, and build more scalable, resilient backend systems.
Test-driven development in javascript: why you should always use it
Test-Driven Development in JavaScript to write more reliable, maintainable code with fewer bugs by testing first and coding second
How to protect private routes in next.js (app router + middleware)
Secure your Next.js App Router applications by protecting private routes with middleware to prevent unauthorized access to sensitive pages and user data.
What is CORS? understanding cross-origin resource sharing
Understand CORS errors and fix cross-origin request blocking to build secure, functional web applications that communicate properly between different domains.
Pure functions in javascript: what, why, and how
Learn how to write pure functions in JavaScript to build more predictable, testable, and maintainable code.
Currying vs partial application: function transformation in javascript
Learn the difference between currying and partial application in JavaScript: transform functions for better reusability and cleaner functional programming.
Debounce vs throttle in javascript: stop the noise, keep the signal
Learn the difference between debounce and throttle in JavaScript: control function execution frequency to handle user input spam and repeated events efficiently.
Prototypal inheritance in javascript: how objects share behavior
Learn JavaScript's prototypal inheritance: how objects delegate behavior through prototype chains instead of traditional class-based inheritance.
The mysterious this in javascript: explained simply
Understand JavaScript's confusing this keyword: learn how context changes based on function calls and master arrow functions, bind, call, and apply.
Scope vs block scope in javascript: know the difference
Learn the difference between function scope and block scope in JavaScript. Understand why let and const are safer than var for variable declarations.
Hoisting in javascript: what it is and how it works
Understand JavaScript hoisting: how variable and function declarations are moved to the top of their scope and why let, const, and var behave differently.
Memoization in javascript and react: why and when to use it
Optimize React performance with memoization techniques. Learn when to cache calculations and prevent unnecessary component re-renders.
React query: is it state or just data?
Understand the difference between state and data in React. Learn why React Query manages server state differently than local UI state and when to use each approach
Closures in javascript: what they are and why they matter
JavaScript closures and understand how functions can 'remember' their environment even after execution.
Stress testing web apps: what it is, why it matters, and how to do it right
Learn how to stress test your web applications to identify breaking points and ensure reliable performance under extreme load.
Datadog: what it is, why it matters, and how to get started
Discover how Datadog can transform your application monitoring with unified observability across your entire tech stack.
Authentication methods: JWT vs sessions vs OAuth - complete guide
Authentication in modern web applications: Understand when to use JWT, sessions, or OAuth and why it's important for security, scalability, and user experience.
PostgreSQL: Why developers love it and when to use it
Discover why PostgreSQL is the go-to database for serious developers—reliable, powerful, and ready for anything from analytics to high-concurrency apps
Docker for developers: why "it works on my machine" is now history
A practical guide to what Docker is, how it works, and why it’s a must-have for developers who want consistent, reliable environments across local, CI/CD, and production.
Traces vs spans: what’s the difference in distributed tracing?
Learn the difference between traces and spans in distributed tracing, and how they help you monitor and debug complex systems.
Regular expressions (regex): master text pattern matching
Master Regular Expressions (regex) with practical examples, common patterns, and real-world use cases. Learn text pattern matching, validation, and data extraction efficiently.
Redis: the in-memory data store revolution
Explore Redis - the powerful in-memory data store, its features, use cases, and best practices for implementation in modern applications.
Git for developers: how to use it with real examples
Learn how to use Git effectively with real commands and workflows. Understand its purpose, common commands, and how it helps you collaborate and manage your code.
Redux: what it is, why it matters, and when to use it
Understand what Redux is, how it works, and when it makes sense to use it in modern frontend applications.
Javascript caching: the essential guide
Learn how to implement effective caching in JavaScript applications to boost performance and enhance user experience.
Express.js: what it is, why use it, and when to choose it
Learn what Express.js is, why it’s the most popular web framework for Node.js, and when to use it in your full stack applications.
Why use react? a practical guide for developers
Learn what makes React so powerful and popular among developers. Discover its key features, advantages, and best practices for building dynamic user interfaces.
Incremental Static Regeneration (ISR): the best of both worlds
Master Incremental Static Regeneration (ISR) - the hybrid rendering technique that delivers static site performance with dynamic content freshness. Learn when and how to implement ISR effectively.
Server-side rendering vs static site generation: choosing the right approach
Learn the key differences between Server-Side Rendering (SSR) and Static Site Generation (SSG), when to use each approach, and how to make the right choice for your web development projects.
Next.js: what it is, why use it, and when it shines
Learn what Next.js is, why it's one of the most powerful frameworks for React developers, and when to use it in your full stack projects.
Git vs github: what's the difference and how to use them
Understand the difference between Git and GitHub, and learn how to use them effectively in your development workflow.
Why use node.js? build fast, scalable apps with javascript
Learn what makes Node.js a top choice for backend development. Discover its features, use cases, and how it fits into full-stack JavaScript workflows.
Advanced SQL queries: mastering complex database operations
Master advanced SQL techniques including HAVING, window functions, CTEs, complex JOINs, and performance optimization to handle sophisticated database operations
Why use javascript? advantages, use cases & recommendations
Discover why JavaScript remains the most widely used programming language in the world. Learn its advantages, use cases, and best practices.
Mastering useeffect in react: a complete guide
Learn how to use the useEffect hook in React to manage side effects like data fetching, event listeners, and more.
Understanding SQL queries: a practical guide for beginners
Learn how to write and understand SQL queries with practical examples to manage and manipulate relational databases effectively.
How i design RESTful endpoints that scale over time
Learn how to design RESTful API endpoints with scalability and maintainability in mind from day one.
How i structure my projects in react + typescript
Discover a clean and scalable way to organize your React + TypeScript projects, with folder conventions, separation of concerns, and real-world tips.
When to use usememo and usecallback in react
Learn when and how to use useMemo and useCallback in React to boost performance without falling into premature optimization.
How to implement lazy loading for images in react
Improve your app's performance by loading images only when they're needed using lazy loading in React.
Managing multiple environments in an application
Learn how to manage multiple environments in your app to ensure smooth development, testing, and production workflows.
Modern alternatives to REST
Discover how tRPC, gRPC, and GraphQL offer modern alternatives to REST APIs and help you build faster, more flexible applications.
React server components
Learn what React Server Components are, how they differ from traditional components, and when to use them for optimal performance.
What is a rate limiter and how to implement one with express
Understand what rate limiting is, why it matters for web applications, and how to implement it in Express to protect your APIs.
Database migrations with prisma and knex.js
Learn how to manage and run safe, version-controlled database migrations using Prisma or Knex.js in your Node.js projects.
How to optimize the performance of a react application
Discover practical techniques to boost the performance of your React apps, including memoization, code splitting, and avoiding unnecessary re-renders.
How to use prisma as an ORM in node.js projects
Learn how to set up and use Prisma as an ORM in Node.js to interact with your database in a modern and type-safe way.
Common web attacks
Discover the most common web security threats like XSS and CSRF, and how to defend your applications from them.
How to efficiently consume APIs with react query
Learn how to simplify and optimize API requests in React applications using React Query.Tags: React, React Query, API, Web Development, Frontend
How authentication differs from authorization
Understand the key differences between authentication and authorization in web applications, and why both are critical for security.
Node.js clustering and load balancing
Discover how to improve performance and scalability in Node.js applications using clustering and load balancing techniques.
Creating custom react hooks
Learn how to build custom React hooks to encapsulate logic, reuse functionality, and simplify your components.
Typescript utility types explained
Learn how to use TypeScript’s built-in utility types like partial, pick, omit and record to write cleaner and more maintainable code.
Introduction to webassembly for web developers
Get started with WebAssembly (Wasm) and learn how it empowers web developers to run high-performance code alongside JavaScript in the browser.
Security best practices in express.js
Learn key security practices to protect your Express.js applications against common web vulnerabilities like XSS, CSRF, and injection attacks.
Docker basics for javascript developers
Discover how JavaScript developers can use Docker to containerize applications, simplify development environments, and streamline deployments.
Rate limiting and throttling in APIs
Learn the difference between rate limiting and throttling in APIs, and how they help protect and scale backend services effectively.
Microservices vs monolith architecture
Understand the key differences between microservices and monolithic architecture to choose the right design for your next web application.