Day 79 of my coding journey 🚀
Leetcode POTD done..
Gave leetcode biweekly contest..
DSA-2hrs
Dev-2hrs
Revision-1hrs
Below image clears your confusion on time complexity.
Before You Go for a DevOps Interview ✅
Check yourself honestly.
→ Set up CI/CD from scratch?
→ Create production-ready infrastructure with IaC ?
→ Debug network issues when apps can’t connect ?
→ Containerize legacy apps (not just hello-world) ?
→ Deploy to Kubernetes with zero downtime on failures ?
→ Design & manage Ingress (TLS, routing, canary) ?
→ Write automation scripts (Shell / Python) ?
→ Set up centralized logging ?
→ Implement monitoring + actionable alerting ?
→ Troubleshoot live incidents under pressure ?
→ Manage secrets securely (no hard-coding)?
→ Troubleshoot live incidents under pressure?
Most people fail DevOps interviews not on theory but on "have you done this in anger ?"
Which one is your weakest ?
Be honest 👇
If you want to crack top interviews, you MUST master System Design.
Most candidates practice random problems…
Top companies ask very specific ones.
This cheatsheet brings together 35 real system design questions asked at companies like Google, Meta, Amazon, Uber, Netflix, Stripe, Airbnb, Microsoft, and more.
These cover every core area you’re expected to know:
✅ Distributed Systems
– Metrics logging & aggregation
– Distributed queues (RabbitMQ/Kafka)
– Stream processing engines
– Distributed tracing
– Job schedulers & notification systems
✅ High-Scale Architecture
– Rate limiters
– Surge pricing (Uber/Lyft)
– A/B testing systems
– Price alerting engines
– Monitoring cluster health
✅ Real-World Applications
– Dropbox/Google Drive design
– Hotel booking systems
– ETA prediction for Uber
– Calendar systems
– File downloaders
– Photo-sharing platforms
✅ Advanced Topics
– Dependency injection frameworks
– Control plane for distributed DBs
– Marketplace features
– IoC systems
– Complex pipeline orchestrators
If you are preparing for SDE2+, Senior Engineer, System Design rounds, or Architect roles, this list should be your roadmap.
Save this. Practice each one deeply. Build mental patterns.
System Design is not about memorizing, it’s about thinking in systems.
How my resume got shortlisted at Amazon and multiple tech startup’s
One thing that clearly stood out on my resume was building real systems, not just solving DSA problems.
A big part of that came from exploring the CodeCrafters GitHub org.
Their repos focus on recreating real tech from scratch, the kind of work recruiters and senior engineers instantly recognize.
Some examples from the org:
•Build your own Git
•Build your own Redis
•Build your own SQLite
•Build your own HTTP server
•Build your own Unix shell
These are not toy projects.
They force you to understand protocols, storage, parsing, concurrency, and edge cases.
On my resume, instead of listing generic projects, I highlighted:
•What system I built
•What parts I implemented end to end
•What scale or constraints I handled
•The exact tech stack used
This made interviews more about design and reasoning, not surface level questions.
If you want your resume to stand out:
•Show ownership of real systems
•Link to strong GitHub repos
•Write impact focused bullets, not responsibilities
Full repo list here:
https://t.co/ArztnUHaoB
Bookmark this, this is the only resource you need to build good projects
You’re building an app.
You don’t want slow pages.
You don’t want the database to struggle under load.
You don’t want to recompute the same things on every request.
So you add Redis.
Reads get faster.
Latency drops.
The database finally gets some breathing room.
You ship with confidence.
It feels like performance is handled.
Then the app grows.
More users.
More features.
More places where “just cache it” seems like the right answer.
And production starts acting strange.
Some users see old data.
Counters drift out of sync.
Memory usage keeps climbing.
A cache miss suddenly sends a flood of traffic to the database.
Nothing is crashing.
But the system feels… fragile.
What’s actually happening isn’t mysterious.
You didn’t remove complexity.
You moved it.
Redis is not “free speed”.
It’s:
•A separate data layer
•With its own data model
•Its own failure modes
•And its own trade-offs
That changes how your system behaves.
Without Redis:
App → Database
One source of truth.
Clear consistency.
With Redis:
App → Redis → Database
Now Redis becomes:
•The first place your app looks for data
•A shield protecting the database
•A potential source of inconsistency
•A major factor in correctness
Cache invalidation stops being a joke.
You have to decide:
•What expires
•What must stay in sync
•What can safely be stale
Redis won’t help you make those decisions.
It will do exactly what you tell it to do.
Even if that slowly makes things worse.
Performance still obeys the same rules.
Keys matter.
TTL choices matter.
Data shape matters.
Redis removes repeated work.
It removes unnecessary database load.
But it doesn’t remove responsibility.
You still have to:
•Be deliberate about what you cache
•Understand read vs write patterns
•Plan for cache misses
•Treat Redis as a performance tool, not a source of truth
Redis makes fast systems possible.
Keeping them correct, predictable,
and easy to change later,
that part is still on you.
The DevOps roadmap everyone shares on LinkedIn is broken.
Here's a realistic 6-month roadmap that will get your Devops job in 2026. (Already helped 200+ folks in 2025)
Month 1: Foundation (Linux + Networking + Git)
- Master Linux commands you'll use daily
- Learn networking basics (DNS, TCP/IP, firewalls)
- Get comfortable with shell scripting
- Learn Git for version control
Month 2: Cloud + Containers
- Start with AWS (EC2, S3, VPC, IAM, RDS)
- Learn Docker containerization
- Understand Docker Compose for multi-container apps
- Focus on one cloud platform deeply, not surface-level knowledge of all
Month 3: Infrastructure as Code + CI/CD
- Master Terraform for infrastructure automation
- Build CI/CD pipelines with GitHub Actions
- Learn AWS ECS for container orchestration
- This is what separates junior from senior engineers
Month 4: Kubernetes Ecosystem
- Kubernetes fundamentals (pods, deployments, services)
- Advanced features (StatefulSets, HPA, RBAC) • Monitoring with Prometheus and Grafana
- GitOps with ArgoCD and Helm
Month 5: Automation + Serverless
- Python for DevOps automation
- AWS Lambda and serverless patterns
- Event-driven architecture (SQS, SNS, EventBridge)
- Learn to automate everything
Month 6: Real Projects + Interview Prep
- Build 5 portfolio projects that solve real problems
- Production-ready 3-tier application on EKS
- DevSecOps pipeline with compliance
- Optimize your resume, LinkedIn, and GitHub profile
The mistakes most people make:
❌ Trying to learn everything at once
❌ Following every "hot new tool" on LinkedIn
❌ Watching tutorials without building projects
❌ Learning tools without understanding why they exist
What actually works:
✅ Master one tool at a time
✅ Build projects that combine multiple tools
✅ Focus on fundamentals, ignore the noise
✅ Show up consistently, even when motivation is low
Just keep going for 6 months without
- looking back and questioning your decision
- thinking you are not good enough or you can't do it
- and hearing that NOISE on LinkedIn that confuses you
Every month, you will be better than last month and will realize your. Devops dream.
If you want the best resources to help you learn, then do these 3 things
- Comment "Devops Resource"
- Retweet
- Follow me
And I will personally message you the best Devops resources to learn on your own.
In college, I always struggled with ACID properties in DBMS.
I knew the full form.
Atomicity, Consistency, Isolation, Durability.
But honestly, none of it made sense to me back then.
I only understood it properly years later, while working on real systems at Cisco.
Let me explain it the way I finally understood it.
Imagine you have a savings account with 25,000 in it.
Your bank needs you to maintain a minimum balance of 5,000.
And you are transferring some amount to a friend.
A transfer has two steps.
Money goes out of your account.
Money goes into your friend’s account.
If the first happens and the second fails,
you end up losing money
and your friend still doesn’t receive anything.
That is an inconsistent and unfair state for the system.
Atomicity simply means
both steps must succeed together
or none of them should happen.
Consistency means
your transfer should not break the rules of the system.
If you try to send your full 25,000
your balance becomes zero
which violates the minimum 5,000 requirement.
So the system should not allow it.
Isolation is about timing.
Your account gets debited at one moment.
Your friend gets credited a little later.
If someone checks the balances in between,
they should not see half-done data.
They should either see the situation before the transfer
or after the transfer,
but never the messy middle.
Durability is the simple idea
that once the money has been transferred and committed,
it should never be lost
even if there is a crash or power failure.
That’s ACID.
The real version.
The version that finally clicked for me.
If you want me to simplify more concepts like this,
tell me which one I should take up next.
P.S. My new Data Engineering batch starts this Saturday. DM to know more!
#bigdata #sql #dataengineering
Backend isn’t just APIs and CRUD.
This is the roadmap companies like Google, Meta, Amazon expect you to know.
DSA
> Companies like Google don’t care about your projects if you fail here.
> This is the real filter.
> Conquer this, and every door in tech opens.
> Struggle here, and those doors stay shut.
0. Ground Setup
Before going crazy with topics, you need:
> One main backend language (JavaScript/TypeScript, Go, Java, Rust — pick one and master it)
> Git + GitHub: branching, PRs, rebases, conflict resolution
> Linux basics: ls, cd, cat, grep, find, permissions, SSH
> Editor mastery: VS Code or any solid setup
First principles here:
> What is a program? How does source code become a running process?
> What is an OS process vs thread?
> What does it mean to run a server on a port?
You should be able to:
> SSH into a Linux box, pull a repo, install deps, run a server on a port, view it via browser
---
1. Core Backend Fundamentals
1.1 Networking and HTTP
You cannot be a strong backend engineer if HTTP is just “that thing Express uses”.
Understand:
> DNS → IP → TCP → HTTP
> Difference between IP / TCP / UDP / HTTP / HTTPS
> HTTP methods, status codes, headers, idempotency, safe methods
> REST vs RPC vs GraphQL
Practice:
> Build a backend without any framework using native http
> Parse JSON body manually
> Implement basic rate limiting
> Add API versioning (/v1, /v2)
---
1.2 API Design and Backend Architecture Basics
First principles:
> Resource modeling
> Stateless vs stateful
> Consistent naming, validation, clear errors
> Pagination, filtering, sorting
Layered architecture:
> Controller → Service → Repository (DAO)
You should be able to:
> Design APIs for Task Manager or Expense Tracker
> Keep error and response structure consistent everywhere
---
2. Databases and Data Modeling
Big companies will grill you here.
2.1 Relational Databases
SQL is non-negotiable.
Understand:
> Table, row, column, primary key, foreign key
> Normalization: 1NF, 2NF, 3NF basics
> Joins: inner, left, right, full
> Transactions and ACID
> Indexes and their impact
You should be able to:
> Instagram schema: users, posts, likes, comments, followers
> Query top posts, mutual followers
> Use migrations, not manual DB edits
---
2.2 NoSQL and When to Use It
Understand:
> Document DB vs relational DB
> Denormalization
> Event logs and analytics needs
> CAP theorem basics
> Collections, documents, indexes, aggregation pipeline
Be able to decide:
> When a feature needs SQL vs NoSQL
---
3. Authentication, Authorization and Security
3.1 Auth Basics
Understand:
> Authentication vs authorization
> State vs stateless auth
> Password hashing (bcrypt/argon2)
> Cookies: HttpOnly, Secure, SameSite
> Access vs refresh tokens
> Token revocation and rotation
> Basics of OAuth2 / OpenID Connect
You should be able to:
> Implement email/password auth with verification and forgot password
> Explain cookies vs localStorage
> Explain token invalidation strategies
---
3.2 Web Security Core
Understand:
> SQL injection, XSS, CSRF, IDOR (OWASP Top 10)
> Input validation and output encoding
> CORS and preflight
You should be able to:
> Identify common vulnerabilities in APIs
> Configure CORS correctly
---
4. Concurrency, Performance and Scalability
4.1 Concurrency and Asynchrony
Understand:
> Event loop, callback queue, microtasks
> Blocking vs non-blocking I/O
> CPU-heavy work blocks Node
You should be able to:
> Explain when to use worker threads and offloading
---
4.2 Caching
Concepts:
> In-memory vs Redis caches
> TTL, LRU, invalidation
> HTTP caching: ETag, Last-Modified, Cache-Control
You should be able to:
> Use Redis to cache DB queries and rate limit
> Plan cache keys well
---
4.3 Scaling and Architecture Patterns
Understand:
> Vertical vs horizontal scaling
> Stateless services for scale-out
> Load balancers
> Monolith vs microservices
> Sync vs async flows (queues)
Patterns:
> Circuit breaker
> Retry with backoff
> Idempotency keys for POST
You should be able to:
> Split a monolith into services and make them communicate
---
5. Messaging, Queues and Async Systems
Understand:
> RabbitMQ, Kafka, Redis streams
> Producers, consumers, delivery semantics
Use cases:
> Emails, uploads, payment pipelines, logs
You should be able to:
> Offload heavy jobs to background workers
> Build async workflows
6. Testing and Quality
Understand:
> Unit, integration, E2E tests
> Test pyramid
> Deterministic vs flaky tests
You should be able to:
> Test auth flows and business logic
> Run tests in CI (GitHub Actions or similar)
7. DevOps Basics for Backend Engineers
7.1 Containers and Deployment
Understand:
> Dockerfile basics (FROM, COPY, RUN…)
> Docker Compose for app + DB
> Environment variables and config
You should be able to:
> Containerize backend and DB
> Deploy to any cloud provider
7.2 CI/CD and Observability
Understand:
> CI pipelines: tests, lint, build
> Auto deploy workflows
> Logging and metrics
You should be able to:
> Add logging middleware with request IDs
> Monitor latency, error rate, throughput
8. System Design
This becomes crucial for big tech interviews.
Understand:
> Load balancer, app server, DB, cache, queue, file storage
> Consistency models
> API Gateway and BFF patterns
> Unique ID generation (UUID, Snowflake)
Practice on paper:
> URL shortener
> Instagram feed
> E-commerce checkout
> Notification systems
Consider:
> DB schema, caching, queue usage, failure handling
9. Domain-Specific Knowledge
Depending on role and product:
> Fintech: strong consistency, audit logs, idempotency
> E-commerce: carts, pricing, orders, inventory
> Real-time: WebSockets, SSE, backpressure
Choose what aligns with your career direction and keep grinding.
ACE Your next Backend interview like a Pro 🧑💻
This PDF Includes almost everything that a backend developer could be asked in their interviews.
To get it:
- Like, Retweet and Follow
- Reply "Backend"
Excel is difficult to learn, but not anymore!
Introducing "The Ultimate Excel ebook "PDF.
You will get:
• 74+ pages cheatsheet
• Save 100+ hours on research
And for 48 hrs, it's 100% FREE!
To get it, just:
1. Like & Retweet
2. Reply "SEND"
3. Follow
@_evon3929
[MUST]
Bookmarks also and [ you will recieve directly in your DM within 72 Hours ]