Pranay Bhowmik

Always up for new challenges
Coding enthusiast

[Shivam Bhadani @shivambhadani_]

Connection Pooling Explained and Low-Level Networking Internals

If you are trying to connect two applications (be it an application server and a DB, or anything else), these concepts will be useful.

🧵Thread

(1/24)

[Neo Kim @systemdesignone]

API Design Playbook (Giveaway Alert)

• Core API fundamentals.
• Clean & scalable design principles.
• Popular patterns used in real-world systems.
• Practical concepts for interviews & building projects.

24 HOURS ONLY!

To get it for free:

1 Follow @systemdesignone [MUST]
2 Like & Retweet to get DM
3 Reply "Playbook"

Then I'll DM you the details.

[Pranay Bhowmik @pranayhere]

@systemdesignone Playbook

[Praveen Kumar Verma @Alacritic_Super]

🚀 The Complete Machine Learning & AI Knowledge Map

🧮 Mathematics

The foundation of every ML algorithm.

Learn:

• Linear Algebra
• Vectors
• Matrices
• Dot Product
• Matrix Multiplication
• Matrix Inverse
• Determinants
• Rank
• Span
• Linear Independence
• Orthogonality
• Null Space
• Image Space
• Eigenvectors
• Eigenvalues
• Singular Matrices
• Positive Semi-Definite Matrices
• Jacobian Matrix
• Hessian Matrix

Without linear algebra, modern AI becomes a black box.

---

📊 Probability & Statistics

Machine learning is applied statistics at scale.

Learn:

• Probability
• Random Variables
• Probability Mass Function (PMF)
• Probability Density Function (PDF)
• Expectation
• Variance
• Covariance
• Correlation
• Bayes Theorem
• Entropy
• Cross Entropy
• Confidence Intervals
• Hypothesis Testing
• KL Divergence
• Jensen-Shannon Divergence

These concepts explain uncertainty and information.

---

🌳 Classical Machine Learning

Understand how models learn patterns.

Learn:

• Linear Regression
• Logistic Regression
• K-Nearest Neighbours (KNN)
• Naive Bayes
• Decision Trees
• Random Forests
• Support Vector Machines (SVM)
• Clustering
• K-Means
• Hierarchical Clustering
• DBSCAN
• Principal Component Analysis (PCA)
• Ensemble Learning
• Bagging
• Boosting
• XGBoost
• LightGBM
• CatBoost

Most modern ML builds on these ideas.

---

⚙️ Optimization

Training is optimization.

Learn:

• Gradient Descent
• Stochastic Gradient Descent (SGD)
• Mini-Batch Gradient Descent
• Momentum
• Nesterov Momentum
• Adagrad
• RMSProp
• Adam
• AdamW
• Second-Order Methods
• Newton's Method
• Learning Rate Scheduling

Optimization is often more important than model architecture.

---

🧠 Deep Learning

The engine behind modern AI.

Learn:

• Artificial Neural Networks
• Perceptrons
• Backpropagation
• Computational Graphs
• Activation Functions

- Sigmoid
- Tanh
- ReLU
- GELU
- Swish
• Loss Functions
- MSE
- MAE
- Cross Entropy
- Hinge Loss
• Weight Initialization
- Xavier
- He Initialization
• Batch Normalization
• Layer Normalization
• RMSNorm
• Residual Connections
• Dropout

These concepts power every modern LLM.

---

🎯 Generalization

A model that memorizes is useless.

Learn:

• Overfitting
• Underfitting
• Bias
• Variance
• Bias-Variance Tradeoff
• Cross Validation
• Regularization

- L1
- L2
- ElasticNet
• Early Stopping
• Data Augmentation

Generalization separates research demos from production systems.

---

🔍 Representation Learning

How machines understand data.

Learn:

• Feature Engineering
• Embeddings
• Dimensionality Reduction
• PCA
• t-SNE
• UMAP
• Transfer Learning
• Domain Adaptation
• Few-Shot Learning
• Zero-Shot Learning
• Self-Supervised Learning

Modern AI depends on learning useful representations.

---

🤖 Learning Paradigms

Every AI system falls into one of these categories.

Learn:

• Supervised Learning
• Unsupervised Learning
• Semi-Supervised Learning
• Self-Supervised Learning
• Reinforcement Learning

Different problems require different learning strategies.

---

📈 Information Theory

The hidden foundation of AI.

Learn:

• Entropy
• Cross Entropy
• Mutual Information
• KL Divergence
• Jensen-Shannon Divergence
• Information Gain

Many deep learning losses originate here.

---

🏛️ Theoretical Foundations

Research-level understanding.

Learn:

• Convex Functions
• Convex Optimization
• Non-Convex Optimization
• No Free Lunch Theorem
• Statistical Learning Theory
• VC Dimension

These concepts explain why models behave the way they do.

---

🚀 Modern AI Stack

Linear Algebra
↓
Probability & Statistics
↓
Classical Machine Learning
↓
Optimization
↓
Deep Learning
↓
Representation Learning
↓
Transformers
↓
LLMs
↓
RAG
↓
AI Agents
↓
Embodied AI

Most people try to start at the top.

The fastest way to master AI is to build an unshakable foundation at the bottom.

[trish @TrisH0x2A]

someone asked Beej how sockets work in C. he got tired of explaining it. so in 1995 he put it all online.

it's been the definitive socket programming guide for 30 years.

it covers everything: TCP, UDP, IPv4, IPv6, non-blocking I/O, select(), poll().

graduate OS courses worldwide assign it. it's funnier than any technical book has a right to be.

it's free and always will be.

[Akhilesh Mishra @livingdevops]

Want a beginner-friendly project that teaches real DevOps skills?

👉 Deploy a containerized web app with a private database, load-balanced HTTPS, custom domain, and proper network segmentation.

Follow these steps:

- Design a custom VPC. Public subnets for the load balancer. Private subnets for compute and database, spread across two AZs.
- Use ChatGPT to create a Flask app that reads and writes posts to Postgres. Add a /health endpoint for health checks.
- Containerize it with a multi-stage Docker build. Push to ECR (use the platform flag, linux/amd64).
- Store DB credentials in AWS Secrets Manager. No passwords in env files. No passwords in code.
- Run RDS PostgreSQL in the private subnets. Multi-AZ. Public access off.
- Deploy the container on ECS Fargate behind an Application Load Balancer.
- Terminate TLS at the ALB with an ACM certificate. Free, auto-renewing, no cert.pem to babysit on a server.
- Build security groups as a chain: Internet → ALB → ECS tasks → RDS. Each layer only talks to the next one.
- Create an IAM task role with least privilege. ECR pull and Secrets Manager read. Nothing more.
- Ship container logs to CloudWatch. Wire the ALB health check to /health.
- Point your custom domain at the ALB with a Route 53 alias record.

Level up the project:

• Terraform for all of it. Remote state in S3 with DynamoDB locking. Reusable modules.
• GitHub Actions for CI/CD with OIDC. Assume an AWS role. No long-lived access keys.
• Scan every image with Trivy before it reaches ECR. Fail the build on critical CVEs.
• Autoscale ECS on CPU. Roll deployments with zero downtime.

What you'll learn:

• Real AWS networking with public and private subnets
• How containers run behind a load balancer in production
• Security group chaining and least-privilege IAM
• Where TLS actually terminates and why HTTPS matters
• Secrets management done right
• Real troubleshooting skills

Stop watching tutorials. Start building. This is the version that gets you hired.

[Dhanian 🗯️ @e_opore]

Learn Large Language Models (LLMs) – 15 Modules here in 1 min:⬇️

[Neo Kim @systemdesignone]

If you want to get ahead of 99% of software engineers, learn these system design concepts:

1 Scalability
2 Availability
3 Reliability
4 Latency
5 Throughput
6 Capacity
7 Client-Server
8 Database
9 SQL vs NoSQL
10 Load Balancing
11 Caching
12 Cache Invalidation
13 CDN
14 DNS
15 API Design
16 REST
17 GraphQL
18 gRPC
19 Authentication
20 Authorization
21 Rate Limiting
22 Fault Tolerance
23 High Availability
24 CAP Theorem
25 Consistency Models
26 Replication
27 Partitioning
28 Sharding
29 Indexing
30 Denormalization
31 ACID
32 BASE
33 Microservices
34 Monolith
35 Event-Driven
36 Message Queue
37 Pub/Sub
38 Sync vs Async
39 Idempotency
40 Backpressure
41 Circuit Breaker
42 Bulkhead
43 Retry Logic
44 Timeout
45 Service Discovery
46 API Gateway
47 Load Shedding
48 Autoscaling
49 Blue-Green
50 Canary Release
51 Feature Flags
52 Observability
53 Logging
54 Metrics
55 Tracing
56 Correlation ID
57 Monitoring
58 Alerting
59 Full-Text Search
60 Time Series
61 Vector DB
62 Materialized View
63 Query Optimization
64 Connection Pooling
65 Cache Stampede
66 Cache Warming
67 CDN Caching
68 Data Compression
69 Serialization
70 Deserialization
71 WebSockets
72 WebRTC
73 CQRS
74 Event Sourcing
75 Service Mesh
76 Sidecar
77 BFF
78 Strangler Pattern
79 LSM Trees
80 B-Trees
81 Merkle Trees
82 Bloom Filter
83 HyperLogLog
84 MapReduce
85 Batch Processing
86 Stream Processing
87 ETL
88 Data Pipeline
89 Data Lake
90 Data Warehouse
91 Secrets Management
92 RBAC
93 SSO
94 Encryption
95 Checksum
96 Erasure Coding
97 Consensus
98 Leader Election

...and 16 more concepts.

===

💾 Save & RT to help others master system design.
👤 Follow @systemdesignone + turn on notifications.

[Fernando @Franc0Fernand0]

If I had to learn system design fundamentals from scratch, I would read the following 16 curated articles (links below): ↓

[Yoshik @AskYoshik]

If I had to become a DevOps / SRE in 90 days, I would skip random YouTube and bootcamps.

I'd ship projects from these 10 repos.

1. kubernetes/kubernetes
Run it locally with kind or k3d. Learn deployments, services, ingress, HPA, PDB.
https://t.co/r1TuIfYlfD

2. prometheus-operator / kube-prometheus
Install it on your cluster. Build real alerts and Grafana dashboards.
https://t.co/ZzPZMRGCQm

3. argoproj/argo-cd
GitOps for real. One repo, one cluster, PR based deployments.
https://t.co/GfJaf7ygao

4. hashicorp/terraform
Infra as Code. Spin up a full VPC + EKS + RDS stack.
https://t.co/wL2XaXgTbG

5. crossplane/crossplane
Treat cloud infra as CRDs. This is what "platform team" JD is talking about.
https://t.co/sts6izxdlH

6. grafana/loki
Centralised logs without ELK. Wire it with Promtail and Grafana.
https://t.co/J7ENRnvRXq

7. open-telemetry/opentelemetry-collector
End to end traces, metrics, logs for a demo microservice.
https://t.co/eiiBWwlT83

8. argoproj/argo-workflows
Build a CI-style workflow running inside K8s.
https://t.co/9iqhrCLSFs

9. kubernetes-sigs/karpenter
Hands-on with cluster autoscaling and cost tuning.
https://t.co/2UjhQ6AWzG

10. fluxcd/flux2
Another GitOps engine many companies already use.
https://t.co/pLSYkguQbH

Most DevOps / SRE JDs in 2026 repeat the same stack: K8s, GitOps, IaC, observability, autoscaling.

These 10 repos are that stack.

Pick one. Build a project. Push to GitHub.

No cert needed. Just proof of work.

[Pranay Bhowmik @pranayhere]

@systemdesignone Playbook

[Tech with Mak @techNmak]

Harvard made its Senior Engineer roadmap available to the public at no cost.

Stop paying for $2,000 bootcamps. Prof. Vijay Janapa Reddi just put the entire ML Systems (CS249r) curriculum on GitHub.

If you master these 6 pillars, you're ahead of 99% of the field:
🏛️ Architecture
🚿 Data Pipelines
🚢 Production
🛠️ MLOps
🔋 Edge AI
🔒 Privacy

This is the "Black Box" of Big Tech infrastructure, open-sourced.

Read. Learn. Bookmark.

[Suryansh Tiwari @Suryanshti777]

Holy shit… someone just made machine learning click.

Not static diagrams.
Not math-heavy PDFs.
Not black-box training.

Real algorithms — training step-by-step — visually.

It’s called Machine Learning Visualized
and it lets you watch models learn in real time.

Here’s why this is different:

Instead of dumping theory first,
it shows optimization happening live:

• gradients moving
• weights updating
• decision boundaries shifting
• loss decreasing
• models converging

You literally see learning happen.

Everything is built from first principles:

• Gradient Descent
• Logistic Regression
• Perceptron
• PCA
• K-Means
• Neural Networks
• Backpropagation

No magic. Just math → code → visualization.

Each chapter is a Jupyter notebook
that derives the math
then implements it
then animates training.

So you can watch:

• neural nets shape decision surfaces
• PCA rotate feature space
• K-means clusters form live
• gradient descent find minima
• sigmoid reshape boundaries
• backprop update weights step-by-step

This solves a huge problem:

Most ML resources teach: math → code → ??? → trained model

This shows: math → code → learning process → result

Which means you finally understand:

• why gradients matter
• how weights evolve
• what loss landscapes look like
• how convergence actually happens
• why deep nets learn non-linear functions

Even better:

You can open any notebook
modify parameters
and watch behavior change instantly.

Learning ML becomes interactive.

Not passive.
Not abstract.
Not confusing.

Just… visible.

Perfect for:

• beginners learning ML
• devs moving into AI
• interview prep
• teaching concepts
• understanding backprop
• visual learners
• building intuition

This is the kind of resource
that makes neural networks finally “click”.

Link: https://t.co/i0k7LzGbJt

We’re moving from:

reading about ML
→ watching ML learn

That’s a big shift.

Because once you can see training,
you stop memorizing… and start understanding.

AI education just got visual.

[Piyush @piyush784066]

For people who keep asking what to build in AI Engineering

> Build your own Reasoner (Chain of Thought implementation)
> Build your own Agent loop (ReAct pattern)
> Build your own Inference Server (in C++/Rust)
> Build your own Transformer from scratch (Attention is all you need)
> Build your own Vector Database (HNSW index)
> Build your own RAG pipeline
> Build your own Flash Attention kernel (CUDA)
> Build your own Quantization library (Int8/FP4 implementation)
> Build your own Mixture of Experts (MoE) routing layer
> Build your own Distributed training loop (FSDP/Tensor Parallelism)
> Build your own KV Cache paging system (like vLLM)
> Build your own Speculative Decoding system
> Build your own State Space Model (Mamba implementation)
> Build your own RLHF pipeline (PPO implementation)
> Build your own Small Language Model (SLM)
> Build your own Matrix Multiplication kernel
> Build your own LoRA (Low-Rank Adaptation) trainer
> Build your own Code interpreter sandbox
> Build your own DPO (Direct Preference Optimization) loss function
> Build your own Graph RAG system
> Build your own Model merger (Model Soups/Spherical Linear Interpolation)
> Build your own Interpretability tool (SAE - Sparse Autoencoders)
> Build your own Synthetic data generator
> Build your own Function Calling router
> Build your own Structured Output parser (Context Free Grammars)
> Build your own Multi-modal projector (CLIP implementation)
> Build your own LLM Eval harness
> Build your own Guardrails system (Input/Output filtering)
> Build your own Prompt caching mechanism
> Build your own Tokenizer (BPE implementation)
> Build your own Autograd engine (like Micrograd)
> Build your own Diffusion model (UNet + Scheduler)
> Build your own Vision Transformer (ViT)
> Build your own Whisper-style ASR model
> Build your own Text-to-Speech pipeline
> Build your own Semantic Router
> Build your own Knowledge Graph builder
> Build your own Data curation pipeline (MinHash/Deduplication)
> Build your own AI Gateway (Load Balancing/Failover)
> Build your own Parameter Efficient Fine-Tuning (PEFT) library
> Build your own Text-to-SQL engine
> Build your own Recommendation system (Two-tower architecture)
> Build your own Embedding model
> Build your own Logit Processor
> Build your own Softmax kernel optimization
> Build your own Adversarial attack generator
> Build your own Audio Spectrogram transformer
> Build your own Neural Architecture Search
> Build your own Model Distillation pipeline
> Build your own Feature Store
> Build your own Database driver (for Vectors)

[Ujjwal Chadha @ujjwalscript]

Be an AI Engineer in 2026. Learn this:

1. The Vector Stack:

- Embeddings (Text-to-Vector)
- Vector Databases (Storage)
- Semantic vs. Hybrid Search

2. RAG & Context:

- Advanced Retrieval (Reranking)
- GraphRAG (Knowledge Graphs + Vectors)
- Long-context window management

3. Pipelines & Orchestration:

- Chaining (Deterministic flows)
- Routing (Selecting the right model for the task)
- Frameworks: LangChain / LlamaIndex

4. The Agentic Layer:

- Tool Use (Search, APIs, Code Interpreters)
- Planning Loops (Reasoning before acting)
- Multi-Agent Orchestration (Swarms)

5. Evaluation & Testing:

- Golden Datasets (Establishing Ground Truth)
- LLM-as-a-Judge (Using strong models to grade weak ones)
- Metrics: Faithfulness, Answer Relevance, Recall
- Continuous Eval in CI/CD pipelines

6. Ops & Monitoring:

- Tracing (Debugging the chain)
- Cost & Latency optimization

[Pranay Bhowmik @pranayhere]

@Suryanshti777 Book

[Jaydeep @_jaydeepkarale]

📂 Kubernetes Engineer
├─ 📂 Foundations (START HERE)
│ ├─ 📂 Linux Fundamentals ⭐ FIRST
│ │ ├─ Processes & PID
│ │ ├─ Signals
│ │ ├─ File systems & inodes
│ │ ├─ Users, groups & permissions
│ │ ├─ Networking basics (TCP/IP, ports, DNS)
│ │ └─ cgroups & namespaces (conceptual)
│ │
│ ├─ 📂 Containers
│ │ ├─ What containers really are
│ │ ├─ Containers vs VMs
│ │ ├─ Docker architecture
│ │ ├─ Images, layers & registries
│ │ └─ Container networking basics
│ │
│ ├─ 📂 YAML & CLI
│ │ ├─ YAML structure & indentation
│ │ ├─ kubectl basics
│ │ ├─ Imperative vs Declarative
│ │ └─ Reading manifests confidently
│ │
│ └─ 📂 Why Kubernetes?
│ ├─ Scheduling problem
│ ├─ Scaling problem
│ ├─ Self-healing systems
│ └─ Desired state management
│
├─ 📂 Core Kubernetes
│ ├─ 📂 Architecture
│ │ ├─ Control Plane components
│ │ ├─ Worker Nodes
│ │ ├─ API Server
│ │ ├─ Scheduler
│ │ └─ etcd basics
│ │
│ ├─ 📂 Core Workloads
│ │ ├─ Pod
│ │ ├─ ReplicaSet
│ │ ├─ Deployment
│ │ ├─ StatefulSet
│ │ └─ DaemonSet
│ │
│ ├─ 📂 Configuration
│ │ ├─ ConfigMaps
│ │ ├─ Secrets
│ │ └─ Environment variables
│ │
│ └─ 📂 Services & Networking
│ ├─ ClusterIP
│ ├─ NodePort
│ ├─ LoadBalancer
│ ├─ Ingress basics
│ └─ DNS inside cluster
│
├─ 📂 Storage & Scheduling
│ ├─ 📂 Storage
│ │ ├─ Volumes
│ │ ├─ PersistentVolume (PV)
│ │ ├─ PersistentVolumeClaim (PVC)
│ │ └─ StorageClasses
│ │
│ ├─ 📂 Resource Management
│ │ ├─ Requests & Limits
│ │ ├─ Resource Quotas
│ │ └─ LimitRanges
│ │
│ └─ 📂 Advanced Scheduling
│ ├─ Node Selectors
│ ├─ Node Affinity
│ ├─ Taints & Tolerations
│ └─ Pod Anti-Affinity
│
├─ 📂 Security (NON-NEGOTIABLE)
│ ├─ 📂 Access Control
│ │ ├─ RBAC
│ │ ├─ Roles vs ClusterRoles
│ │ ├─ Service Accounts
│ │ └─ Principle of Least Privilege
│ │
│ ├─ 📂 Pod Security
│ │ ├─ Security Context
│ │ ├─ Pod Security Standards
│ │ └─ Image security basics
│ │
│ └─ 📂 Network Security
│ ├─ Network Policies
│ ├─ Internal-only services
│ └─ mTLS concepts
│
├─ 📂 Advanced Kubernetes (LATER)
│ ├─ 📂 Helm
│ │ ├─ Charts
│ │ ├─ Values
│ │ └─ Releases
│ │
│ ├─ 📂 Autoscaling
│ │ ├─ HPA
│ │ ├─ VPA
│ │ └─ Cluster Autoscaler
│ │
│ ├─ 📂 Observability
│ │ ├─ Logs
│ │ ├─ Metrics
│ │ ├─ Traces
│ │ └─ Debugging live systems
│ │
│ └─ 📂 Troubleshooting
│ ├─ CrashLoopBackOff
│ ├─ OOMKilled
│ ├─ Pending Pods
│ └─ Networking failures
│
├─ 📂 Production & Platform Engineering (LAST)
│ ├─ 📂 CI/CD
│ │ ├─ GitOps concepts
│ │ ├─ Deployment strategies
│ │ ├─ Rollbacks
│ │ └─ Progressive delivery
│ │
│ ├─ 📂 Multi-Environment Strategy
│ │ ├─ Dev / Stage / Prod
│ │ ├─ Namespaces vs Clusters
│ │ └─ Promotion flows
│ │
│ └─ 📂 Cloud Kubernetes
│ ├─ Managed Kubernetes (EKS/GKE/AKS)
│ ├─ Cloud networking
│ └─ Cost optimization
│

[Pranay Bhowmik @pranayhere]

@TivadarDanka Roadmap

[Andrej Karpathy @karpathy]

I've never felt this much behind as a programmer. The profession is being dramatically refactored as the bits contributed by the programmer are increasingly sparse and between. I have a sense that I could be 10X more powerful if I just properly string together what has become available over the last ~year and a failure to claim the boost feels decidedly like skill issue. There's a new programmable layer of abstraction to master (in addition to the usual layers below) involving agents, subagents, their prompts, contexts, memory, modes, permissions, tools, plugins, skills, hooks, MCP, LSP, slash commands, workflows, IDE integrations, and a need to build an all-encompassing mental model for strengths and pitfalls of fundamentally stochastic, fallible, unintelligible and changing entities suddenly intermingled with what used to be good old fashioned engineering. Clearly some powerful alien tool was handed around except it comes with no manual and everyone has to figure out how to hold it and operate it, while the resulting magnitude 9 earthquake is rocking the profession. Roll up your sleeves to not fall behind.