system-design-bangla teaches the fundamentals in the language a lot of developers think in

A course, not a codebase

The first thing to know about this repository is what it is not. There is no source code, no build system and no package to install. The top level contains a.github/ directory, a.gitignore, a CONTRIBUTING.md, a License file, a README.md, an images/ directory and a sections/ directory. The tutorial content lives in sections/, and the site is published at lahin31.github.io/system-design-bangla/, which means GitHub Pages is serving the Markdown.

The README states the purpose plainly. It is a repository where the fundamentals of system design are discussed, and the goal of the tutorial is to give you the concepts of the basics. If you like it, the README asks you to star, watch or fork it.

That is a modest and specific promise, and it is worth holding it in mind while reading the rest of the curriculum. This is not a course with exercises, labs or a build you can run. It is a written curriculum, and the value of a written curriculum of this kind is that it gives you a defensible order of study, which is exactly what most people lack when they try to learn system design from scattered blog posts.

The single published release is system-design-0.0.1 from November 2022, and the repository is not archived with the last push on 2026-08-15. So the artefact you read is a version 0.0.1 document that has been revised many times since its tag, and the version number tells you about the packaging, not the content.

The audience is a Bangla speaking developer, and specifically one preparing for system design interviews, which the final sections of the curriculum make explicit.

Forty-seven sections, and the ordering is the argument

The table of contents runs to 47 sections, and the sequence is itself a statement about how the subject should be taught.

It starts with system design, then goes into database engineering, the B+ tree and database indexing, database transactions, and then client server architecture. From there it covers reliability, performance metrics, distributed systems, and then a run of networking fundamentals: the domain name system, TCP, UDP, HTTP, TLS and HTTPS, and what happens when you type a URL in your browser. After that come concurrency and parallelism, high concurrency control, functional and non functional requirements, back of the envelope estimation, authentication and authorization, stateful and stateless architecture, proxy, and the REST API.

The scaling and infrastructure material follows: scalability, database sharding, database replication, caching, content delivery network, rate limiter, the CAP theorem, consistent hashing, then the asynchronous and communication material on polling, WebSocket, server sent events and webhooks, stream and batch processing, message queues, and RPC and gRPC. The closing run is on single sign-on, Elasticsearch, bloom filters, load balancing algorithms, how OAuth2 works, serverless architecture, how to choose the right database for your application, designing reliable batch processing for large scale data, high availability best practices by Netflix, production outages, real world problems, backend interview questions and answers, and finally resources.

The ordering argument is the interesting part. Networking fundamentals sit at positions 9 to 13, before the distributed systems material, which is the opposite of how the subject is usually arranged in English language material, where distributed systems are often taught as an advanced topic and the networking is assumed.

There is a structural quirk too. The numbering skips section 39, going from 38 on how OAuth2 works to 40 on serverless architecture, which suggests a section was removed rather than never planned.

The learning path groups the sections into nine tracks

The second navigation element in the README is a System Design Learning Path, and it is more useful than the raw table of contents because it tells you which order to read the sections in. The README says that following this path lets you read step by step from beginner to advanced.

The tracks are Basic Architecture with sections 1, 5, 19 and 22; Networking Basics with sections 9 to 13; Backend Fundamentals with sections 16, 17, 18, 20 and 21; Database Basics with sections 2, 3, 4 and 41; Performance and Reliability with sections 6, 7, 14 and 15; Distributed Systems Core with sections 8, 27, 28 and 29; Data Scaling and Performance Optimization with sections 23, 24, 25 and 26; Async and Communication Patterns with sections 30, 31, 32 and 33; and Security and Identity with sections 34 and 38. A further group covers Advanced Infrastructure Concepts, starting with section 35 on Elasticsearch.

What the path does is decouple the dependency order from the numbering. A reader who starts at the beginning of the tutorial hits reliability and distributed systems before they have seen DNS, and the path is the fix, telling a beginner to do architecture first, then networking, then the backend and database basics, and only then the scaling and distributed material.

It is also a candid statement about the intended reader. The first track has four sections and the networking track has five, which tells you the tutorial assumes you are starting from the beginning and intends to take a while.

For anyone reading this in English, the structure is the transferable part. The track groupings are a defensible ordering of system design fundamentals that is not tied to any particular language, and applying them to an English course or to primary documentation costs nothing.

Five sections are still marked as work in progress

Several entries in the table of contents carry a parenthetical marker meaning that the section is in progress. These are section 29 on consistent hashing, section 31 on stream and batch processing, section 33 on RPC and gRPC, section 37 on load balancing algorithms, and section 40 on serverless architecture.

That is worth noting plainly, because these are not peripheral topics. Consistent hashing sits inside the Distributed Systems Core track, load balancing and serverless sit in the advanced infrastructure material, and RPC and gRPC is the messaging section's endpoint. A reader who follows the path will hit gaps in exactly the places where the material is most likely to be wanted, whether for an interview or for work.

The marking itself is a point in the project's favour. Nothing in the README claims the tutorial is complete, and the in progress labels are visible in the contents rather than buried, so a reader knows what they are getting before they start rather than discovering a half written section at the point they need it.

The practical response is to treat the marked sections as a to-do list of gaps to fill from elsewhere, which is also where the final resources section becomes useful. A Bangla speaking developer who needs consistent hashing in the next week has a specific hole to plug, and the repository has told them so.

The closing sections aim at the interview

The last three sections of the curriculum are the ones that tell you what the tutorial is for.

Section 45 is real world problems, section 46 is backend interview questions and answers, and section 47 is resources. Section 43 is high availability best practices by Netflix and section 44 is production outages, which is a pair that is unusual to see in a fundamentals tutorial and suggests the author is drawing on operational experience rather than only on textbook material.

Section 41, how to choose the right database for your application, and section 42, designing reliable batch processing for large scale data, are the two most applied sections, and they are placed inside the numbered run rather than in a closing appendix, which is a reasonable choice for a curriculum whose goal is interview preparation.

A system design interview, in the format this curriculum is aimed at, asks a candidate to design a system and then talk through the tradeoffs. The relevant sections for that are the ones on back of the envelope estimation, on choosing a database, on the CAP theorem, on sharding, replication and caching, and on the reliability material. The interview question section is best understood as the index into the rest.

The main limitation of the format is worth stating as well. Nothing in the repository provides a worked system design, with a diagram, a set of requirements and a design discussion. The interview questions and real world problems sections come closest, and the images/ directory holds a wallpaper rather than a diagram set, so a reader who wants to see a design drawn will not find it here.

How to read it, and what the repository gives you

There is no install step, because there is nothing to install, and the published site is the artefact to read. The repository layout tells the rest of the story: sections/ for the content, images/ for the assets including the wallpaper the README shows, and the standard community files.

So the practical way to use it is to read the site, work through the learning path in the order it gives, and treat the sections marked as in progress as known gaps. The site's table of contents is the same as the README's, so it can be navigated directly by section.

For a reader who already knows some of this, the highest value sections are the ones that are hardest to find elsewhere in one place, the B+ tree and indexing material, the CAP theorem, consistent hashing once it is finished, the section on choosing a database, and the production outages and Netflix availability sections. The networking run from DNS through TCP and UDP to HTTP and TLS is standard material, and the tutorial's value there is the ordering and the language rather than the content.

For a reader who is new, the basic architecture and networking tracks are the entry point, and the back of the envelope estimation section is the one to do early, because it is the technique that turns a vague system design question into a sequence of numbers.

Editorial conclusion

system-design-bangla suits a Bangla speaking developer who wants a structured route through system design fundamentals, and who is preparing for backend interviews where the theory has to be recalled rather than looked up. It does not suit a reader who wants worked examples, code or diagrams beyond the basics, and the five sections still marked as in progress are gaps you will have to fill elsewhere. Verify first which sections are complete, that five of them are marked in progress, and that the interview questions section covers the topics you are being asked about, and pair it with English primary sources for the topics where the treatment is brief.

Frequently asked questions

Official sources

1. lahin31/system-design-bangla on GitHub
2. License: MIT
3. Project website
4. README
5. Releases