Hi, I am
Rishikesh Agrawani
hygull on GitHub, Stack Overflow, X and Instagram. Music on Spotify, Apple Music and Amazon Music.
Backend engineer with 10+ years of experience. This site is where I keep the notes I write while learning: short tutorials with code you can run. Away from the keyboard I write and record songs.
Short tutorials with runnable code
Learnings
Notes written while learning, kept short on purpose. Each tutorial explains a concept in a few lines, shows the code, and tells you how to run it. Pick a path and read it in order.
- Frontend: React to Next
- Python Basics
- Python Advanced
- Python in Practice
- Python Design
- System Design
- Command line: Bash
- Go
- QA and Testing
- Planned: Languages
- Planned: Web Frontend
- Planned: Databases
- Planned: APIs and Formats
- Planned: Package Tools
Frontend learning path
React to Next
Four tutorials. Learn React first, then Next, use the comparison to lock in what Next changed, and finish with the design skills that turn a Figma file into components.
Components, props, state, effects, hooks, context, routing with React Router, auth with a protected route, styling, and turning a Figma file into components.
File based pages and layouts, server and client components, data fetching and caching, Server Actions, API routes, cookie based auth, images, fonts, SEO and deployment.
Seventeen tasks shown side by side, React on the left and Next on the right, each with one line on what Next added. Only topics where Next changed something.
Reading a Figma file, design tokens, spacing, typography, color, responsive layout, states, a reusable component kit, accessibility, and the Figma MCP and Code Connect workflow.
Python learning path
Python Basics
Six tutorials that start from the first print(). They are Python 3 rewrites of the 2017 Pythofrank lessons, with the original examples kept where they still make sense.
What Python is, running it, variables, indentation, numbers, and decisions with if, elif and else.
Strings, lists, tuples, dictionaries and sets: how to create, read and change each one, and which to pick.
for and while loops over numbers, strings, lists and dictionaries, with range, enumerate, zip and comprehensions.
Defining functions, arguments and defaults, *args and **kwargs, scope, lambda, map and filter, recursion.
Classes and objects, inheritance, class and static methods, properties, and dataclasses, built on a small bank.
Handling exceptions, reading and writing text, CSV and JSON files, and working with dates and times.
Python learning path
Python Advanced
Five tutorials on the parts of Python that take longest to click. Each idea is built up one small step at a time, and every example was run before it was published.
Closures, plain and parameterised decorators, functools.wraps, class-based decorators, and real uses: logging, retry, caching, permission checks.
What a for loop really does, writing your own iterator, generators with yield, pipelines, yield from and itertools.
Concurrency versus parallelism, the GIL, threads, race conditions, locks and deadlock, queues, and multiprocessing.
The event loop, async and await, running tasks together, timeouts, semaphores and locks, and how not to block the loop.
Context managers, special methods, descriptors, __slots__, dataclasses in depth, Enum, Protocol, metaclasses and type hints.
Python learning path
Python in Practice
Nine tutorials on everything around the language that a working project needs: setting up, testing, debugging, tooling, data and the web.
Virtual environments, pip, modules and packages, imports, if __name__ == "__main__", project layout and pyproject.toml.
Writing tests with pytest: fixtures, parametrised tests, fakes and mocks, test-driven development and coverage.
Reading tracebacks, the pdb debugger, a method for finding bugs, and the logging module in place of print.
PEP 8, formatting with black, linting with ruff, type checking with mypy, and pre-commit hooks.
A tour of the modules worth knowing: re, pathlib, argparse, subprocess, json, decimal, hashlib and more.
Big-O in plain words, the cost of list, dict and set operations, deque, heapq and bisect, searching, sorting, recursion and graph search.
Measuring with timeit and cProfile, writing faster Python, and how references, reference counting and garbage collection work.
SQL with sqlite3, safe queries, transactions that keep a transfer all-or-nothing, and the SQLAlchemy ORM.
How HTTP works, calling an API, and building and testing a small bank API with FastAPI.
Python learning path
Python Design
Two tutorials built on one small bank. Every example is a few lines long, runs with only the standard library, and reuses the same Person and Account classes.
The five SOLID principles, then six general ones: DRY, KISS, YAGNI, composition over inheritance, tell don't ask and encapsulation. Each one shown as the code that breaks it, then the fix.
All 23 classic patterns, grouped into creational, structural and behavioural, with what each family means. Every pattern has the problem it solves, a small example and the shortcut Python gives you.
Interview learning path
System Design
Twelve tutorials for senior and staff design interviews: the foundations, the building blocks, the patterns behind them, sixteen high-level and ten low-level worked designs, and a playbook for the day. Built around diagrams and comparison tables.
The interview framework, estimation, the numbers worth memorising, CAP and consistency trade-offs, and scaling a design step by step.
DNS, CDN, load balancers, caching, database families, replication, sharding, consistent hashing, queues, rate limiters and ID generation.
Storage engines, indexes, isolation levels, replication and partitioning in depth, data modelling, stream processing and Kafka.
Clocks, consensus and Raft, two-phase commit and sagas, the outbox, idempotency, delivery guarantees, circuit breakers and distributed locks.
REST, gRPC and GraphQL, pagination and versioning, real-time options, service-to-service calls, OAuth, JWT and API security.
Monolith to microservices, finding service boundaries, event-driven design, CQRS, event sourcing and multi-tenancy.
SLOs and error budgets, designing for failure, multi-region and disaster recovery, observability, safe deployments and capacity planning.
Eight worked designs: URL shortener, rate limiter, key-value store, ID generator, notifications, news feed, chat and typeahead.
Eight harder designs: payments and wallet, seat booking, ride hailing, video streaming, file sync, web crawler, job scheduler and metrics.
The low-level design method, reading UML, modelling decisions, the patterns that come up, concurrency and a machine-coding playbook.
Ten designs with class diagrams and runnable Python: parking lot, LRU cache, elevator, vending machine, Splitwise, movie booking and more.
How senior loops are scored, running the session, a question bank, common mistakes and a six-week study plan.
Command line
Bash
Notes on the shell, added as they come up. Each topic is a few short chapters with commands you can paste into a terminal.
What !!, !$ and !git really do, why they can run a command you have not read, and the one setting that shows it to you first.
Backend language
Go
Five tutorials: setup, three pages of concepts, then practice. Read them in order. Every program was run on Go 1.27 and its output pasted from that run.
Install Go on macOS, Linux or Windows, learn what GOROOT, GOPATH and GOBIN are for, then build a small bank module with packages, a dependency, a test and two commands.
Variables and zero values, constants and iota, UTF-8 strings, the one for loop, switch and defer, functions and closures, slices and maps with their aliasing traps, and pointers.
How Go models data and behaviour without classes: structs, methods, embedding instead of inheritance, implicit interfaces, errors as values, panic and defer, and generics, all on one small bank example.
How goroutines are scheduled on threads, channels and select, mutexes and atomics, context cancellation, the standard patterns, goroutine leaks and the interview questions about them, compared with Python threads, asyncio and processes.
25 exercises with hidden solutions that drill the earlier pages, from FizzBuzz and slice puzzles to a race-free concurrent bank, an LRU cache and a JSON API.
Quality assurance
QA and Test Automation
Testing tools and practice, written for someone who has never automated a test. Everything QA-related on this site lives here.
What UI and API automation are, then a complete pytest suite for a tiny bank app: browser tests with locators and expect, API tests with status codes and JSON, and tests that combine both.
Planned, not written yet
Backend and Systems Languages
Languages I have worked with or want to learn properly, each to get the same treatment as Python: short chapters with code that was run before it was published.
To do
Java
Classes and interfaces, collections, generics, streams, concurrency with executors, the JVM and Spring Boot basics.
To do
TypeScript
Types, interfaces, generics, narrowing and utility types, then a typed Node.js service.
To do
Node.js
The event loop, modules, async patterns, streams, and building an API with Express or Fastify.
To do
C#
Classes, LINQ, async and await, dependency injection and a small ASP.NET Core API.
To do
C
Pointers, memory, structs, the build toolchain, and what the machine actually does.
To do
C++
RAII, references, templates, the STL, smart pointers and move semantics.
To do
Rust
Ownership and borrowing, enums and pattern matching, traits, error handling and fearless concurrency.
To do
PHP
Modern PHP: types, Composer, PDO, and the request lifecycle behind Laravel.
To do
Kotlin
Null safety, data classes, coroutines, and Kotlin on the backend with Ktor or Spring.
To do
Ruby
Blocks, modules, metaprogramming at a sensible depth, and the ideas behind Rails.
To do
R
Vectors, data frames, the tidyverse, plotting and basic statistics.
To do
SQL
Joins, grouping, window functions, indexes and reading a query plan, with exercises.
Planned, not written yet
Web Frontend
The foundations under React and Next.js, plus the other frameworks worth knowing. Same format: a concept in a few lines, then working code.
To do
HTML5
Semantic elements, forms and validation, media, accessibility basics and the document outline.
To do
CSS
The box model, selectors and specificity, flexbox, grid, custom properties and responsive layout.
To do
JavaScript
Values and types, functions and closures, promises and async, modules, and the DOM.
To do
Bootstrap
The grid, components, utilities and theming, and when a framework helps or gets in the way.
To do
Tailwind CSS
Utility-first styling, the config, responsive and state variants, and extracting components.
To do
Sass
Variables, nesting, mixins and partials, and what plain CSS now does without it.
To do
Vue
The reactivity model, components, the composition API, routing and state.
To do
Angular
Components, templates, services and dependency injection, RxJS basics and routing.
To do
Svelte
Compiled components, reactivity, stores, and SvelteKit in outline.
Planned, not written yet
Databases and Data Stores
One tutorial per store: what it is good at, how to model data for it, and the commands you actually use, on a small running example.
To do
PostgreSQL
Data types, indexes, transactions and MVCC, JSONB, EXPLAIN, and the extensions worth knowing.
To do
MySQL
InnoDB, indexes, isolation levels, replication, and how it differs from PostgreSQL in practice.
To do
SQLite
The single-file database: when it is the right choice, WAL mode, and its limits.
To do
MongoDB
Documents and collections, schema design, the aggregation pipeline, indexes and replica sets.
To do
Redis
Strings, hashes, sorted sets and streams, expiry, persistence, and patterns such as caching, locks and rate limits.
To do
Elasticsearch and OpenSearch
The inverted index, mappings and analysers, queries and aggregations, shards and replicas.
To do
Cassandra
Partition and clustering keys, tunable consistency, and modelling tables around queries.
To do
DynamoDB
Keys and indexes, single-table design, capacity modes and streams.
To do
Neo4j
Nodes, relationships and Cypher, and when a graph beats joins.
To do
ClickHouse
Columnar storage, MergeTree tables and fast analytics over large event data.
To do
Kafka
Topics, partitions and consumer groups, delivery guarantees, and using a log as the backbone of a system.
Planned, not written yet
APIs, Formats and Tools
The formats and protocols services speak, and the tools for calling and testing them.
To do
Postman
Collections, environments and variables, tests and scripts, and running a collection in CI.
To do
cURL and HTTPie
Calling and debugging any API from the terminal: headers, bodies, auth and timing.
To do
JSON
The format precisely, JSON Schema for validation, and the edge cases around numbers and dates.
To do
XML
Elements, attributes and namespaces, XPath, and where XML is still the standard.
To do
YAML
The syntax and its traps: indentation, anchors, and values that change type by accident.
To do
GraphQL
Schemas, queries and mutations, resolvers, the N+1 problem, and when it fits better than REST.
To do
SOAP
Envelopes, WSDL and XML schemas, and working with the enterprise services that still use it.
To do
gRPC and Protocol Buffers
Defining services in .proto files, the four call types, and backward-compatible changes.
To do
OpenAPI and Swagger
Describing a REST API in one file, then generating docs, clients and tests from it.
To do
WebSockets
The handshake, messages and heartbeats, reconnection, and scaling beyond one server.
Planned, not written yet
Package and Environment Tools
Installing dependencies reproducibly in Python, JavaScript and beyond: what each tool does and when to pick it.
To do
pip
Installing and pinning, requirements files, constraints, and how dependency resolution works.
To do
pip-tools
Compiling a locked requirements file from a short list of direct dependencies.
To do
Poetry
pyproject.toml, the lock file, dependency groups, virtual environments and publishing.
To do
uv
The fast all-in-one tool: installing Python itself, projects, lock files and running scripts.
To do
pipx
Installing command-line tools in isolation so they never clash with a project.
To do
Conda
Environments that include non-Python libraries, channels, and when to prefer it over pip.
To do
npm
package.json, the lock file, scripts, semantic versions and workspaces.
To do
Yarn
Classic versus Berry, workspaces, Plug and Play, and moving from npm.
To do
pnpm
The content-addressed store, strict node_modules and fast monorepo installs.
To do
Maven and Gradle
Build lifecycles, dependencies and plugins for Java and Kotlin projects.
To do
Cargo and Go modules
How Rust and Go handle dependencies, versions and builds out of the box.