Shikher Shukla

MERN Developer | Javascript 💙 | Self-improvement - into books and fitness | psychology 🧐

[Shikher Shukla @ShikherShukla]

Going to start sharing interesting system design concepts and terms I learn along the way. Mostly to keep track of them, but maybe they'll be useful to someone else too.

[Arpit Bhayani @arpit_bhayani]

If you are letting AI agents write large chunks of your codebase, here is something I would recommend - decide your tradeoff per file, not as a blanket policy.

You cannot get both. Ship faster with AI-generated code, and deeply understand the codebase you are shipping. Trying to have both everywhere just means you get neither properly.

I recommend - sort modules within a codebase into two buckets before you hand anything to an agent.

Bucket one is code where being fast matters more than knowing every line. Think one-off scripts, internal tooling, throwaway prototypes. Let the agent own these fully. Do not waste your "attention" re-deriving understanding you will never need again.

Bucket two is code where a failure is expensive or hard to reverse. Think auth, payments, anything touching data integrity. For this bucket, treat the agent's output as a first draft. Read the diff line by line, trace how it touches the rest of the system, and make the agent explain its own reasoning before you merge.

If you pick one side for everything, you are smart enough to figure out what you would be losing out on. I would not repeat and restate the obvious :)

So spend the time you saved on shipping fast by reading deeply, but only where it counts. That is the whole tradeoff.

Hope this helps.

[Arpit Bhayani @arpit_bhayani]

Just finished reading "The Minimalist Entrepreneur" by @shl. The core idea is simple: you do not need to chase a billion-dollar company.

Find people who want what you are building, stay profitable, and let momentum do the rest. A few things that stuck with me:

- Telling people about your project passionately works better than trying to sell it to them.

- You need a manual, valuable process before you even think about building a minimum viable product.

- Hiring is really about defining your values first, then finding people who fit them, not the other way around.

- Every company should operate like it is fully remote and async. It forces you to write things down, build a knowledge base, and be more thoughtful by default.

- Do not aim to be a dollar billionaire. Aim to be a time billionaire. Once money is not the constraint, use it to buy back your time.

That last one is going to stay with me for a while.

He also mentioned the "dizziness of freedom" - that feeling when you are staring at infinite choices and do not know which one to take.

If you are building something on your own, or even just thinking about it, this one is worth your time :)

Give it a read. Hope this helps :)

[Shikher Shukla @ShikherShukla]

NoSQL doesn't magically scale better—it makes the scalable path the default.

[Shikher Shukla @ShikherShukla]

"NoSQL scales better than SQL."

True or false?

Mostly true.

NoSQL databases are designed to make horizontal scaling easier.

But that doesn't mean SQL can't scale.

[Shikher Shukla @ShikherShukla]

SQL databases can absolutely scale too.

If you minimize cross-shard joins, partition your data well, and avoid distributed transactions, SQL systems can handle massive workloads.

In many cases, you're adopting the same design principles that NoSQL databases encourage by default

[Shikher Shukla @ShikherShukla]

If this resonates, I'd recommend following @arpit_bhayani for system design and checking out this video by @waitin4agi_ on why keeping things simple is so important.

https://t.co/d2fHW7YEBI

[Shikher Shukla @ShikherShukla]

Going to start sharing interesting system design concepts and terms I learn along the way. Mostly to keep track of them, but maybe they'll be useful to someone else too.

[Shikher Shukla @ShikherShukla]

Anyone can add complexity. Good engineers remove it.

Every new service means another deployment, another dashboard, another alert, another failure point.

If a modular monolith solves the problem, that's probably the better design.

[Shikher Shukla @ShikherShukla]

Redis stores data in memory... so does a restart wipe everything?

Only if persistence isn't enabled.

Redis can persist data using:
• RDB snapshots
• AOF (Append Only File)
• Or both together
Memory-first doesn't have to mean data-loss-first.

[Shikher Shukla @ShikherShukla]

Still using WSGI in 2026?

It might be holding your app back.

WSGI → One request per worker (synchronous).
ASGI → Handles multiple concurrent connections (asynchronous).
If you're building APIs with WebSockets, SSE, or long-running requests, ASGI is the way to go.

[Shikher Shukla @ShikherShukla]

Most production systems use Token Bucket or Sliding Window, depending on their traffic pat

[Shikher Shukla @ShikherShukla]

Not all API rate limiters work the same way.

The algorithm you choose can affect fairness, traffic spikes, memory usage, and user experience.

Common algorithms:
• Fixed Window – Simple, but allows bursts at window boundaries.

[Shikher Shukla @ShikherShukla]

• Sliding Window – More accurate, smoother request distribution.
• Token Bucket – Allows controlled bursts while maintaining an average rate.
• Leaky Bucket – Processes requests at a constant rate, smoothing traffic spikes.
terns.

[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.

[Arpit Bhayani @arpit_bhayani]

One way to avoid getting overwhelmed when you are designing a system is to approach it with a structure/mental model. Here's a simple one I follow...

Think of any system as having 2 separate paths: a read path and a write path. Your database or storage layer sits at the center, and each path has its own set of problems and its own toolkit to solve them.

The write path is about durability and throughput. You are almost always choosing from the same set of levers: a message queue to absorb bursts, write-ahead logging for durability, batching to reduce I/O, and async processing to keep the critical path thin.

The read path is about latency and scale. Again, a fixed toolkit - caching at various layers (CDN, app-level, query-level), read replicas to offload the primary, denormalizing or pre-computing expensive queries, and pagination or cursor-based traversal to avoid full scans.

Once you start seeing these as two separate concerns, you stop designing a system and start answering two smaller questions: what does the write path need? What does the read path need? Then you wire them together through storage.

This 'framework' (if I can call it that) is not just useful during discussions, but also helps you reason through production systems, especially when you are building an understanding, trying to optimize an existing flow, debugging latency spikes, or planning for scale.

Hope this helps.

[SumitX @Sumits_X]

N+1 query = 1 query + N extra queries (bad for performance)

Example:
You want users and their orders.

First query:

SELECT * FROM users;

Then for each user:

SELECT * FROM orders WHERE user_id = ?;

If there are 100 users:
Total = 1 + 100 = 101 queries

Problem: Too many database calls
Slows down your API
Does not scale

Better approach:

SELECT *
FROM users u
JOIN orders o ON https://t.co/pbAGIwcmi1 = o.user_id;

Now everything comes in 1 query instead of many.

[SumitX @Sumits_X]

As a developer,

Please Slap yourself if you are unable to explain even 10 from below terms :

Indexing
Clustering
Denormalization
Normalization
Read replicas
Leader–Follower replication
Multi-leader replication
Quorum
Consensus
CAP theorem
BASE
ACID
Eventual consistency
Strong consistency
Snapshot isolation
MVCC (Multi-Version Concurrency Control)
Two-phase commit (2PC)
Three-phase commit (3PC)
Write-ahead logging (WAL)
Checkpointing
Compaction
Rebalancing
Resharding
Data locality
Hot partition
Split-brain
Failover
High availability (HA)
Horizontal scaling
Vertical scaling
Load balancing
Connection pooling
Caching
Materialized views
Secondary indexes
Composite index
Covering index
Bloom filter
LSM tree
B-tree
Query planner
Cost-based optimizer
Deadlock
Lock escalation
Optimistic locking
Pessimistic locking
Dirty read
Phantom read
Read skew
Write skew
Data skew
Backpressure
Circuit breaker
Throttling
Rate limiting
CDC (Change Data Capture)
Logical replication
Physical replication
Geo-replication
Federation
Data lake
Data warehouse
Columnar storage
Row-based storage
Time-series partitioning
Hash partitioning
Range partitioning
Consistent hashing
Data migration
Schema evolution
Schema registry
Idempotency
Exactly-once semantics

[Shikher Shukla @ShikherShukla]

@JulianGoldieSEO Yes

[Shikher Shukla @ShikherShukla]

@EXM7777 Printer