SN retweeted
Master the Sacred Art of Offering Water to the Shivling
Namaste friends! Did you know that there is actually a very specific and beautiful way to offer water to the Shivling?
Most of us just pour it on top, but the Shivling actually represents the entire Shiva Parivar, and each part has its own significance.
In this video, We are sharing the traditional step-by-step process of performing Abhishek.
We start by honoring Lord Ganesha on the right side, then Skanda Kumar Kartikeya on the left.
We also pay our respects to Bala Tripur Sundari in the center and Mata Parvati at the base, before finally offering water to Lord Shiva himself with the powerful "Om Namah Shivaya" chant.
It’s all about the small details and the devotion in our hearts.
Watch the full video to learn the right mantras and the correct sequence to connect deeper with the divine energy of the Shiva Parivar.
Har Har Mahadev!
SN retweeted
Great to see so many folks suggesting the outbox pattern for avoiding dual writes. If you want to learn more about how to implement the outbox pattern, why you should use log-based CDC to do so, and what potential alternatives are, check out my post here:
morling.dev/blog/revisiting-…
Imagine your code does this:
> Save Post to the Database.
>Publish PostCreated event to Kafka.
Scenario: The database save succeeds (Step 1), but right before line 2 executes, the server crashes or the network blips.
Result: You have a "Ghost Post." It exists in the database, but downstream (Search, Feed) never heard about it because the event was never sent.
How do you fix this ?
SN retweeted
Imagine you are streaming changes from Postgres to Elasticsearch in Go. Everything works fine in dev. Then traffic ramps up, and suddenly your service can't keep up...
After profiling, you notice the bottleneck: JSON serialization.
Every document going to Elasticsearch needs to be encoded. At thousands of events per second, those microseconds add up fast. Go's standard `encoding/json` library is convenient, but it heavily relies on reflection.
Reflection is flexible, but that flexibility has a cost - it's slower than having the structure known at compile time.
And remember, there is never just one lib to do something in a language. People keep building and rebuilding things, often making them faster than what ships by default.
So instead of relying on the standard `encoding/json`, there is a Go package `jsoniter`. In that, decoding a medium payload takes 35,510 ns/op with 99 allocations using the standard library. jsoniter does it in 5,623 ns/op with just 3 allocations. Over 6x faster with 97% fewer allocations.
Insane.
This doesn't mean you should immediately rewrite your code. But if you ever find JSON serialization sitting at the top of your flame graph :) switching to jsoniter or whatever is most efficient at that time can save you a lot of pain.
Btw, you will find something similar in every language for every kind of work. Use this post as a reminder to look beyond default :)
Hope this helps.
SN retweeted
Two candidates were interviewing for a Sr. Engineer role @ Uber and were given these requirements...for their system design problem...
Requirements:
– The system must have low latency
– It must handle sudden traffic spikes during peak events
– It must enforce strict per-user rate limits
Same question.
Very different interviews.
Hence, Very Different Results.
Candidate 1:
– For low latency, I will add Redis as a cache
– For spikes, I will put Kafka in front of the system
– For rate limiting, I will use a Redis-based token bucket
On paper, it sounds fine.
But this is exactly where many Senior and Staff engineers fail.
They treat requirements like keywords.
They hear “low latency” and respond “Redis”.
They hear “spikes” and respond “Kafka”.
They hear “rate limiting” and respond “token bucket”.
There is no thinking in between.
Candidate 2:
“Before I walk through a design, I want to clarify a few things.”
– When you say low latency, what are we targeting for p95 and p99?
– What is the read-to-write ratio and approximate QPS at peak?
– Are we rate-limiting per user, per IP, per API key, or a combination?
– How strict is the rate limit? Do we drop requests or degrade gracefully?
Only after that, they start.
First, they sketch a simple, single region baseline.
Then they check it against the numbers.
Next, they layer in complexity only where it is needed.
When they reach rate limiting, they do not just say “Redis token bucket”.
They think out loud.
– Local in process rate limiting is simple, but not safe for distributed systems.
– A central Redis based limiter works, but what about race conditions and clock skew?
– If we add per user, per IP, and per API key limits, how does that affect storage and cost?
– What happens when Redis is down, do we fail open or fail closed?
Candidate 1 threw tools at the problem.
Candidate 2 modeled the problem, quantified it, then selected tools.
A few weeks later, Candidate 2 got the offer.
Candidate 1 kept wondering what went wrong.
In 2025, with AI becoming mainstream, you cannot stand out by naming components.
Any decent AI can say “use Redis, Kafka, and a token bucket”.
Senior and Staff level signal is not tool recall.
It is structured reasoning.
If your system design answers sound like a list of technologies, you are competing with a search engine.
If your system design answers sound like careful thinking under constraints, you are competing at a Senior and Staff level.
------------------
Checkout my Java+Microservices+System design ebook here matamgi.com/java-interview-e…
SN retweeted
RabbitMQ vs Kafka: Which One and When?
Both handle messaging, but their architectures solve different problems.
RabbitMQ: Traditional Message Broker
- Push model: broker pushes messages to consumers
- Complex broker, simple consumer
- Throughput: 4K–10K messages/sec
- Messages deleted after acknowledgment
- Flexible routing via exchanges (direct, topic, fanout)
- Multiple protocols: AMQP, STOMP, MQTT
Kafka: Event Streaming Platform
- Pull model: consumers poll for messages
- Simple broker, complex consumer
- Throughput: 1M+ messages/sec
- Messages retained for configurable period (replay anytime)
- Partition-based ordering guarantees
- Exactly-once semantics
Use RabbitMQ when you need flexible routing patterns, priority queues, and the broker should handle delivery complexity.
Use Kafka when you need high-throughput event streaming, event replay capabilities, and strong ordering guarantees for data pipelines.
SN retweeted
MobiKwik is Hiring | SDE II/ SDE III – Backend Developer
📍 Gurgaon | 5 Days On-Site | 🚀 Immediate Joiners Only
📩Apply Now:
lnkd.in/ggpJ7zRZ
SN retweeted
Thread on the divine shlokas of sri Bhagavad Gita with its meaning 🧵
@LostTemple7
SN retweeted
Folks, if you or someone in your network is looking for a highly capable early backend engineer (< 1 year of experience) with hands-on expertise, I wholeheartedly recommend Shashank Hegde.
Shashank worked with me on profile(.)fyi, where he single-handedly managed the backend and infrastructure. He knows Go, MySQL, AWS, and LLM interfacing well and can pick up any backend stack with ease.
He is incredibly smart, dedicated, and a fast learner who can pick up any skill or technology as needed. He consistently operates with extreme ownership, staying on top of every task and delivering exceptional results.
Shashank is immediately available to join, and I'm sharing his LinkedIn and resume below.
LinkedIn: linkedin.com/in/shashank--he…
Resume: drive.google.com/file/d/1SRI…
X, do your magic! RT for good karma, this is someone I can personally vouch for when it comes to work ethic, learnability, and impact.
SN retweeted
speakerdeck.com/madhavjivraj…
This should have some more info and links!

































