Learn with Me

I learn by building, experimenting, and documenting what I discover along the way. This page is a collection of the notes and articles I create while exploring new technologies, concepts, and engineering practices. Everything here is written as part of my learning process, and I hope it helps others on theirs as well.

Technical Notes

16 notes

Git and Github

Version control fundamentals, branching strategies, collaboration workflows, and best practices.

Javascript

Deep dives into core concepts, asynchronous programming, and how JavaScript works under the hood.

Typescript

Building safer, scalable JavaScript applications with static typing and modern language features.

Node.js

Exploring server-side JavaScript, event-driven architecture, streams, and backend development.

Express.js

Building secure, scalable REST APIs with middleware, routing, and backend best practices.

Json Web Token (JWT)

Understanding authentication, authorization, token-based security, and session management.

React.js

Creating modern, component-driven user interfaces with React fundamentals and advanced patterns.

Recoil

Managing global state in React with atoms, selectors, and predictable state updates.

Next.js

Building production-ready React applications with server-side rendering, routing, data fetching, and performance optimizations.

MongoDB

Schema design, indexing, queries, aggregation, and performance optimization in MongoDB.

SQL

Mastering relational databases through efficient queries, schema design, joins, indexing, and optimization.

PostgreSQL

Integrating PostgreSQL with Node.js to build reliable, performant applications using relational data, transactions, and efficient queries.

Prisma (ORM)

Simplifying database access in Node.js with type-safe queries, schema modeling, migrations, and an intuitive developer experience.

Docker

Everything a developer needs to understand Docker—from local development environments to production deployments.

AWS

Learning the core AWS services used to deploy, scale, secure, and operate modern cloud applications.

CI/CD

A deep dive into Continuous Integration (CI) and Continuous Deployment/Delivery (CD), covering automated builds, testing, deployment pipelines, GitHub Actions, artifacts, caching, runners, and production-ready CI/CD workflows.

Articles & Writings

7 articles

Vercel Under the Hood: Why Framework Auto-Detection Breaks Production Apps

A technical deep dive into Vercel's request pipeline, vercel.json configurations, and fixing silent build overrides, page refresh 404s, and broken social cards.

Continuous Evaluation for LLMs: The Missing CI/CD Layer

A guide on building a production-grade Continuous Evaluation (CE) system for Large Language Models.

DNS Delegation Done Right: Why You Should Not Mix Authoritative Nameservers

A deep dive into DNS delegation, covering how registrars, TLDs, authoritative nameservers, recursive resolvers, caching, and TTLs work.

How I Built a Lightning-Fast Headless CMS Using Notion, Node.js, and React

Why pay for a headless CMS when you can write in Notion and compile directly to local static assets?

Rate Limiting: From Simple In-Memory Code to Distributed Production Systems

Local code vs. Production reality. In-memory rate limiting is fast, free, and super easy to build—until multi-instance servers, Vercel serverless cold starts, and round-robin load balancers wipe your state.

The Hidden Layer of WebSockets: Understanding Frames

A deep dive into WebSocket frames, message boundaries, fragmentation, the FIN bit, opcodes, control frames, client masking, and the relationship between WebSocket frames and TCP segments.

Why Does ENV Exist in a Dockerfile If We Already Have .env?

Learn the difference between Docker's ENV instruction and a .env file, when to use each, and how to manage environment variables and secrets using Docker best practices.