Oonga✨

Antisocial but curious

[Oonga✨ @Olmost_engineer]

🚀 Excited to share my first article ever On Java's map() vs. flatMap() .
If you've ever wondered about the difference, this is for you!

please give your valuable comments so i can improve next time.
https://t.co/u8UUmQdwSH

[terminally onλine εngineer @tekbog]

code review in 2026

[Swapna Kumar Panda @swapnakpanda]

Once you watch ALL THESE VIDEOS, System Design becomes ABSOLUTELY EASY:

[Gabbar @GabbbarSingh]

Corruption is like a cancer for this country. It has been embedded in the DNA of a drought-coded, resource starved nation.

It grows & consumes a ruling govt, then a new govt comes in, fresh, vowing to root out previous corruption, people get hopeful, time passes, corruption creeps up again, but this time it feeds on the ego of the incumbent.

To accept it has come back, will belie the promises the new govt made, of ending all prev corruption. And hence it consumes again

It’s like a virus, a parasite that needs a host, like a mosquito or a bat. The hosts are usually caste, religion, language politics. Corruption grows covertly as its host gets stronger. And one day it kills it. Until a new host emerges.

The cycle continues.

[Anuj @anujcodes_21]

🚨Anthropic just showed a 24-minute workshop on how to actually do prompts for Claude.

Taught by the people who built it.

Free. No registration. No paywall.

I've seen $300 courses that don't cover what they teach in the first 8 minutes.

Watch it and bookmark it now.

[Tanuj @tanujDE3180]

Senior Backend Interview in 2026.

How many of these can you explain without Googling?

- Event Sourcing
- CQRS
- Saga Pattern
- Outbox Pattern
- Idempotency Keys
- Consistent Hashing
- Distributed Locks
- Backpressure
- Write-Ahead Logging (WAL)
- Read-Your-Writes Consistency
- Quorum Reads & Writes
- Vector Clocks
- Gossip Protocol
- Bloom Filters
- Tombstone Records
- Token Bucket vs Leaky Bucket
- Circuit Breakers
- Bulkhead Isolation
- Cache Invalidation
- Leader Election
- Split Brain Problem
- Exactly-Once vs At-Least-Once Delivery
- Change Data Capture (CDC)
- Two-Phase Commit (2PC)
- Raft vs Paxos

If you know more than 10, you are ready for system design interview.

[ANIL GALGALI @ANILGALGALIRTI]

🧾 Bulk Booking in Indian Railways (More than 200 Tickets)

✅ 1. Group Booking Procedure (Official Way):

Indian Railways allows group bookings for 200 or more passengers (schools, religious groups, political rallies, weddings, etc.) through a formal process.

Step-by-step Process:

1. Write a Request Letter:

Address it to the Chief Reservation Supervisor at the departure station.

Include:

Number of passengers

Names (or confirmation you’ll submit later)

Journey date & train number

Boarding & destination stations

Class (e.g., Sleeper, 3AC)

Purpose (pilgrimage, student tour, etc.)

2. Submit the Request 1–2 Months in Advance:

Visit the reservation counter (station) at least 30 days in advance for large groups.

Earlier is better — many quotas are limited.

3. Approval & Quota Allocation:

Railways may allot you a special quota, or ask you to book in available seats.

If approved, they block the required number of berths.

4. Payment & Ticket Issuance:

You’ll pay the fare in bulk (may be done via DD, cheque, or cash).

Tickets will be issued after payment and name list submission.

5. Name List Submission:

Final passenger list must be submitted at least 48 hours before departure.

---

⚠️ Important Rules & Notes:

No online portal allows 200+ bookings in one go. You must go offline via the reservation office.

For school/college tours, attach a letter from the head of the institution.

You can request a special coach or entire bogie, but subject to availability and approval by Railway Headquarters.

For very large groups, Indian Railways may attach a special coach to the train.

---

🛑 Don't:

Don’t try booking 200 Tatkal tickets online — not possible; IRCTC limits per login.

Avoid brokers or illegal agents — it’s risky and can lead to ticket cancellation or blacklisting.

[Arpit Bhayani @arpit_bhayani]

GitHub went down for ~70 minutes yesterday. Interestingly, the root cause was not a database (the usual suspect), but an auth was returning 401s. Although outages are not good, we as engineers can learn a thing or two from them. Here's a quick dissection...

So, about 15% of API traffic started getting "Unauthorized" responses for requests that were perfectly valid. The credentials were fine. But the 'infra' was lying. Here is the part that makes this interesting.

Every well-behaved HTTP client reauths when it receives 401. So thousands of apps did exactly what they were supposed to do - and that made things worse.

Every client getting a false 401 (root cause for 401 not mentioned yet) kicked off a token refresh, which piled more load onto an already struggling auth layer. Here is my key takeaway...

When a 401 comes back, we typically reauthenticate, and we should. But if we get 10 consecutive 401s on a token that was just refreshed, reauthenticating again is not the answer. That is a circuit-breaker moment - back off, raise an alert, and stop hammering the system.

Retrying blindly in an auth-failure loop could turn an incident into a full outage. So, this is something you can account for when building your next system :)

Hope this helps.

[Arpit Bhayani @arpit_bhayani]

Redis has a reputation for being an incredibly fast in-memory store, but a surprisingly large number of engineers don't realize that Redis also provides robust persistence.

The primary mechanism for this is the Append-Only File (AOF). Instead of just taking snapshots, Redis logs every write operation it receives, ensuring that the state can be perfectly reconstructed by replaying these logs.

And, I just published a video where we implement AOF persistence from scratch.

This is the 12th video in the Redis Internals series. We go deep into the Redis source code to understand how it handles file descriptors, synchronization strategies, and the trade-offs between performance and data safety. We then take those learnings and build the persistence engine ourselves to see exactly how those bytes hit the disk.

If you are looking to bridge the gap between high-level API usage and low-level systems engineering, this episode is a deep dive into how modern databases guarantee durability without sacrificing extreme throughput. 12 videos are now live:

1. Why Single-Threaded Redis Is Fast
2. Writing a TCP Echo Server
3. Wire Protocols
4. Implementing RESP
5. Implementing PING
6. Understanding Event Loops
7. Implementing Event Loops
8. Implementing GET, SET, and TTL
9. Implementing DEL, EXPIRE, and Cleanup
10. Key Eviction Strats and Implementing First Eviction
11. Implementing Command Pipelining
12. Implementing AOF Persistence

For anyone passionate about database internals, file systems, or building resilient backend infrastructure, this series provides the hands-on intuition needed to master high-performance data stores.

Hope this fuels your curiosity for systems engineering and the mechanics of data durability.

Give it a watch.

[Asmit @coolcoder56]

[Offer] JioHotstar | Staff Software Engineer | Bangalore | Aug 2025 for 80 LPA experience :

Round 1 - High Level Design (1 Hour)

Question: Design Uber
How to handle high throughput
Discussion on GeoHashing vs Quad Tree
Concurrency and Race Condition
Fault Tolerance and Sudden Spikes
Client-Server Communications

NOTE: Overall in depth discussion for any topics I had mentioned to check my technical depth.

Round 2 - Low Level Design (1 Hour)

Question: API Rate Limiting
Discuss various algorithms
Choose to implpement one of them in Java
Slight hint of DSA (<5%) during the imnplementation to understand my knowledge
Had to have full running code
Focus was one Design Patterns, Concurrency(Thread)
Other optimisation techniques (Background periodical memory cleanups and other AdHoc Edge cases).
Scale & Performance Bottlenecks (Due to Single thread blocks using synchronized)
Round 3 - Hiring Manager (1 Hour)
Questions aroundJunior engineer mentoring
Your role in current team/org
How do you handle the vision of the team(tech roadmap)
My approach towards oncall
Various situational based (Tell me about a time when you did X).
Questions around previous projects(in depth) and try to give me a situation to scale those system (Covered HLD).

Round 4 - Bar Raiser (1 Hour)

Lots of discussion about my background and about life journey. He was mostly trying to understand what kind of person I am and what motivates me kind of thing.
Towards the end he gave me problem, we discussed briefly and then he gave me 30 mins more (after the interview) to complete whatever I had discussed and share it with him.

Round 5 - HR Round (30 Mins)

Basic HR based question, just do a ChatGPT. No curve ball.

[Aman Kumar @amanaryan23]

You are not able to clear Tech Interviews and get a high paying job even after doing everything right?

Then you are not preparing well.

I see this pattern every single day:

> Grinding 300 LeetCode problems randomly

> Watching YouTube tutorials and feeling ready

> Applying once and giving up after rejection

Here’s what actually works:

> Solve 100-150 problems deeply.

Understand the problem, pattern and try to build pattern matching skills to solve the problems.

Understand which DS to apply and why?

You need to understand fundamentals and not just remember the solutions.

✅ Mock interviews > solo practice.

You can solve a problem alone.

Can you solve it while someone stares at you?

Or when someone cross questions you ?

Or can you build a scalable solution which takes care of any follow-up questions

Practice that.

✅ Study the company

Google wants structured thinkers.

Amazon problem solvers and people who imbibe their values.

Microsoft wants growth mindset.

Netflix wants senior-level ownership mindset. Each company has a personality. Learn it.

✅ Apply rejection as data.

Every “no” tells you exactly what to fix.

I kept a rejection journal.

It’s why I cracked Microsoft in 2nd attempt.

✅ Communication under pressure

Can you explain your thinking while you’re thinking it?

This is solved by mock interviews. Not solo grinding.

The engineers getting 50LPA+ packages aren’t smarter than you.

They just prepared smarter.

Your next offer is one structured preparation cycle away.

Start today.

[Puneet Patwari @system_monarch]

Message Queues & Event-Driven Patterns are the backbone of every scalable modern system - Netflix, Uber, and Atlassian all run on them.

Most engineers know the basics (“just throw a queue in there”), but interviewers destroy you with the deep follow-ups:
“How do you guarantee exactly-once processing when a Kafka broker dies mid-replay?”
“How do you handle poison messages without crashing your entire consumer fleet?”
“What happens to your Sagas during a partial failure at 50k events/sec?”

These 20 must-know Message Queues & Event-Driven Patterns take you from high-level overview to production-grade depth that actually ships reliably at scale.

Save this thread. Read till the end.

[SumitM @SumitM_X]

10 Terms Every Developer Should Know in 2026 :

1. LLM (Large Language Models)

2. RAG (Retrieval Augmented Generation)

3. Edge Computing

4. Zero Trust

5. Idempotency

6. Event-Driven Architecture

7. Serverless

8. Observability

9. Feature Flags

10. Data Mesh

[Puneet Patwari @system_monarch]

https://t.co/fgcYERMW5B

[Aman Kumar @amanaryan23]

23 system design questions which will help you to understand fundamentals concepts and help you crack system design interviews of Google, Meta, Microsoft, Netflix, Uber, Stripe, Amazon 👇

[Puneet Patwari @system_monarch]

A candidate interviewing for an L5 role at Google gets asked:

“How would you design a web crawler that keeps 5 billion pages fresh?”

And says, “I will add more crawler workers and increase throughput.”

Another candidate gets the same question and walks through crawl budget, URL frontier, page-change frequency, politeness limits, conditional fetches, deduplication, and index freshness.

One sounds like they know crawling.
The other sounds like they understand search infrastructure.

Same question.
Same 45 minutes.
Very different understanding of system design.
Hence, different results in interviews.

[Isha singh @isha_singh06]

Preparing for DSA interview, do these leetcode problems!

1. Sliding Window: 3, 76, 424, 904
2. Two Pointers: 11, 15, 167, 42
3. Binary Search: 33, 153, 875, 1011
4. Hashing + Prefix: 1, 49, 560, 128
5. Monotonic Stack: 739, 503, 84, 901
6. Heap (Top K): 215, 347, 973, 703
7. Intervals: 56, 435, 57, 252
8. BFS/DFS: 200, 994, 102, 133
9. Trees: 104, 236, 543, 124
10. DP basics: 70, 198, 322, 300

You need to solve 2-3 problems per pattern and that's enought to understand problem solving

[Puneet Patwari @system_monarch]

Candidate Studying:
- CAP theorem
- Kafka internals
- microservices
- How to train LLMs

Interviewer: What’s the difference between a library and a framework?

Candidate: Gives a shallow answer, panics when question is twisted.

Sometimes, the most tricky questions can come from fundamentals.

[Ritesh Roushan @devXritesh]

System Design Series - Day 10/30

Your database will become the bottleneck.

Not your API.
Not your cache.
Your database.

At 1K users everything works fine.
At 10K users queries slow down and CPU hits 80%.
At 50K users the database crashes, your app goes down, and users leave.

The solution is Database Replication.

How it works:

- 1 Primary (Master) handles all writes
- Multiple Replicas (Read Slaves) handle all reads

Most applications are 90% reads and 10% writes.

Real Production Impact (E-commerce App):

Before (Single DB):
- Max capacity: 2,500 req/sec
- Read latency: 300ms
- CPU: 85%
- Cost: $800/month

After (1 Primary + 3 Replicas):
- Total capacity: 12,000 req/sec
- Read latency: 45ms (6.6x faster)
- Primary CPU: 25%
- Cost: $600/month

The magic is that reads scale horizontally.
Just add more replicas.

Trade-offs:
- 5-10x better read performance
- High availability (promote replica if primary fails)
- Replication lag (100-500ms)
- Slightly more complex application code

Bottom line:
If your database CPU is consistently above 50%,
it is time to think about replication.

What is your current database CPU usage?

Drop it below 👇

[Abhishek Singh @0xlelouch_]

90% of PostgreSQL database interviews are these 7 topics.

[Abhishek Singh @0xlelouch_]

95.7% of senior Java interviews are these 7 topics.