I am a Staff Engineer & Techlead at Meta. I have 
- Mentored many senior & staff engineers and managers. 
- Designed & built multiple systems with critical focus on scalability & reliability. 
- Solved many cross team & organization misalignments with my inter-personal skills. 

I love writing about the importance of soft skills combined with stories from my 10+ years of experience. If this interests you, follow me and subscribe to my newsletter Techlead mentor.

If you are looking for guidance on navigating your career ladder, you can reach out to me.

Raviraj Achar

I help in skyrocketing 🚀 your career & finances | Engineering Manager @ Amazon | Ex GS | IIMK | Career coach | Personal finance coach

4 years before I got demoted from leading a team of 15 engineers to 1 engineer.

I doubted myself, if I am good at leading teams or not.

My managers, colleagues (𝘪𝘯𝘥𝘪𝘳𝘦𝘤𝘵𝘭𝘺) told me to stop leading the team.

Then one day without any agenda, I called my ex-manager, who then had moved to Amazon.

We spoke for an hour. He reminded me of my work and abilities when he used to be my manager.

He told me what matters in career and how I was in a wrong place at a wrong time

We then met again, but this time with agenda of exactly what I needed to do, to crack Amazon interview.

I applied, and cracked the interview in the very first attempt.

And after joining Amazon, I already got promoted once.

𝘛𝘩𝘢𝘵 𝘶𝘯𝘪𝘯𝘵𝘦𝘯𝘥𝘦𝘥 𝘤𝘢𝘭𝘭 𝘸𝘢𝘴 𝘵𝘩𝘦 𝘵𝘶𝘳𝘯𝘪𝘯𝘨 𝘱𝘰𝘪𝘯𝘵 𝘪𝘯 𝘮𝘺 𝘤𝘢𝘳𝘦𝘦𝘳.

Which taught me 3 very important lessons.

# 1
You are given one life.
Don't spoil it because of being in wrong place.

# 2
Be closer to those who motivate & mentor you.
Avoid everyone else.

# 3
Learning is the only thing that doesn't change.
Rest all is temporary.

In last 5 months I spoke to 50+ of you from LinkedIn. 

In those meetings, I realised there are many in the same place where I was 4 years ago.

It is the state of "self doubt", "constant confusion", "frustration". 

This state not only stops your career growth but also kills your personal life. 

Thats why I made it my mission to help software professionals in achieving their true career potential and  live fulfilling life.

I do it in 2 ways.

[1] By coaching on how to crack Big tech FAANG+ interviews (behavioural)  
[2] By coaching on how to get promoted (career growth).


I do it by sharing result and action oriented "systems" and "frameworks".  

These are proven frameworks that I have developed for myself & learned from others. 


Follow me (and press bell icon) for getting these systems and frameworks.

If you want advise or coaching for your unique situation, DM me "COACH"

Chandra Shekhar Joshi

The most dangerous Staff engineer promotion is the internal one.

Getting hired externally as a Staff Engineer is hard. You get grilled on system design and behavioral questions for weeks.

Getting promoted internally is relatively easier. You have context. You have trust. You shipped a big project.

So they give you the title. And you stay in the same team.

This is where things go wrong.

Because nothing around you changed, you assume your job hasn't changed either.

You keep doing exactly what got you promoted.
- You review every PR.
- You write the most code.
- You pick up the hardest tickets.
- You keep designing beautiful diagrams

Six months later, you are exhausted. And your manager drops the bomb during feedback: "You are unable to scale."

It feels unfair. You are working harder than ever. You know the tech stack better than anyone.

But you are missing the point. You are solving Senior Engineer problems with a Staff Engineer title.

When this feedback hits, most engineers panic. They think, "I need a fresh start."

So they interview at a new company.

You see, changing zip codes does not fix a skill gap.

Unless you join a company where "Staff" is just a glorified Senior, you will hit the exact same wall in the new job. Only this time, you won't have the domain context to save you.

You don't need a new company. 
You need a new operating model.

The "unable to scale" feedback means you are still trying to scale the code yourself.

Senior Engineers scale software. 
Staff Engineers scale teams.

Stop running away from actual problem. Fix the gap.

I will break down exactly how to scale yourself in the coming posts. Hit follow so you don't miss it.

Crack FAANG+ Sr., Staff+, EM Behavioural, and System Design HLD interviews | DM me “COACH” | Engineering Manager @ Amazon | Engineering Career Coach | FAANG+ Interview Coach

Interviewer: "Why are you using WebSockets here?" Candidate: "To reduce latency for client requests."

The interviewer is smiling, but you just failed the scalability check.

When you say this in a system design interview, you have set up yourself for a trap.

The interviewer will ask: "If latency is the goal, why not just use a cache or HTTP/2?"

And suddenly, you are stuck.

You don't choose WebSockets for speed. You choose them for direction.

Standard HTTP is request-response. The client has to ask. 

If your design requires the server to send data without being asked (like a chat app or a live score), standard HTTP doesn't work well. 

You need a protocol that supports Server Push. That is the primary reason you use WebSockets.

"But wait," you might ask. "WebSockets are faster because they keep the connection open. Why not use them for everything?"

Because WebSockets force your server to hold state.

To keep that connection open, the server must hold the connection details in memory (RAM). 

Now imagine you have 100,000 active users connected to Server A.

Server A crashes. 
- 100,000 users are instantly disconnected. 
- 100,000 clients immediately try to reconnect to the remaining servers.

This is the reconnect storm problem. It can cascade and take down your entire fleet.

In distributed systems, stateless is preferable (for application servers).

WebSockets scale, but they move complexity from the protocol layer into connection lifecycle management and failure handling.

Stateless HTTP requests are easy to load balance and easy to scale. If a server dies, the next request just goes to a different one. No drama.

Use this decision framework to choose right protocol:
 
[𝟭] Do you need the server to initiate communication to the client with low latency and at high frequency (true real-time updates, bidirectional interaction)?

Yes → Use WebSockets (and design for connection state, reconnection storms, and load-balancer stickiness).

[𝟮] Do you only need occasional server push in one direction (notifications, live feeds, progress updates)?

Yes → Consider Server-Sent Events (SSE) or long polling.

[𝟯] Is the interaction purely request-response?

Yes → Stick with stateless HTTP. It is simpler, more resilient under failure, and scales more easily.


Don't trade architectural resilience for a few milliseconds of latency unless the product forces you to.

If you are preparing for mid-senior/staff SDE, EM system design HLD interviews, and need help, DM me COACH.

Engineer : "We have a hotspot problem. Let's just add more shards."

This is a red flag for a senior candidate.

It shows they don't understand the difference between scaling a dataset and scaling a single key.

Sharding is great for storing petabytes of data. But sharding fails when a single piece of data goes viral.

A hot key lives on exactly one shard. If you split your database into 1,000 shards, that one hot node still takes 100% of the traffic and crashes.

Average traffic doesn't kill systems. Spikes do.

Here is how a staff engineer handles the two types of hotspots.

𝟭. 𝗛𝗼𝘁 𝗥𝗲𝗮𝗱𝘀 (𝗧𝗵𝗲 𝗰𝗲𝗹𝗲𝗯𝗿𝗶𝘁𝘆 𝗽𝗿𝗼𝗯𝗹𝗲𝗺) This happens when millions of users try to read the exact same data at the same time. Think of a viral tweet or a flash sale item.

• Solution: Replication.
• You cannot split a single key, so you must clone it.
• In Redis, use Read Replicas. The leader handles updates, but multiple replica nodes serve the read traffic.
• Move the data to the application server's RAM (Local Caching - L1). If you have 100 app servers, the database only sees one request per cache cycle.

𝟮. 𝗛𝗼𝘁 𝗪𝗿𝗶𝘁𝗲𝘀 (𝗧𝗵𝗲 𝘃𝗶𝗿𝗮𝗹 𝗰𝗼𝘂𝗻𝘁𝗲𝗿) This happens when you update the same key thousands of times per second. Think of "Likes" on a viral post.

• Solution: The Sharded Counter.
• You cannot write to multiple replicas at once without massive conflicts. You must turn "one key" into "many keys."
• Scatter (Write): Create sub-counters like likes:100:1 to likes:100:N.
• The app picks a random shard and increments it, spreading the load across the cluster.
• Gather (Read): When you need the total, the app reads all N counters and sums them up in memory.

Hot Reads require replication (copying the data). Hot Writes require partitioning (splitting the data).

If you treat every key as equal, your system will fail exactly when you succeed the most.

If you are preparing for mid-senior/staff SDE, EM system design HLD interviews, and need help, DM me COACH.

Definition of an AI leader these days:

• Have used ChatGPT
• Knows about embeddings 
• Says MCP is REST for models 
• Wants to directly build multi-agents
• Keep saying, ”AI will replace those who don't use AI”
• Has build a JS based tic tac toe game in single prompt using Claude
• Doesn’t code, but keeps asking why can’t you do this with AI in 2 mins
• Keep saying, I want to code using AI, but don't get time to do it. 

What else will you add to this list?

Most engineers know Cassandra is "write-optimized." But few can explain the physics behind it during an interview.

If you say "it uses a log," you are only halfway there.

The real difference lies in how it handles disk I/O compared to a traditional database.

In a B-Tree system (like PostgreSQL), an update is expensive. You have to find the specific page on the disk, load it, change it, and write it back. This requires random I/O. Physics limits how fast this can happen.

Cassandra cheats.

It uses an LSM-Tree structure that refuses to modify data in place. 

(𝘘𝘶𝘪𝘤𝘬 𝘵𝘪𝘱 : 𝘈𝘵𝘵𝘢𝘤𝘩𝘦𝘥 𝘥𝘰𝘤𝘶𝘮𝘦𝘯𝘵 𝘩𝘢𝘴 𝘵𝘩𝘦 𝘤𝘰𝘮𝘱𝘭𝘦𝘵𝘦 𝘮𝘦𝘤𝘩𝘢𝘯𝘪𝘤𝘴 𝘰𝘧 𝘩𝘰𝘸. 𝘚𝘢𝘷𝘦 𝘵𝘩𝘪𝘴 𝘧𝘰𝘳 𝘺𝘰𝘶𝘳 𝘯𝘦𝘹𝘵 𝘴𝘺𝘴𝘵𝘦𝘮 𝘥𝘦𝘴𝘪𝘨𝘯 𝘱𝘳𝘦𝘱 𝘴𝘦𝘴𝘴𝘪𝘰𝘯 𝘣𝘦𝘧𝘰𝘳𝘦 𝘪𝘵 𝘥𝘪𝘴𝘢𝘱𝘱𝘦𝘢𝘳𝘴 𝘧𝘳𝘰𝘮 𝘺𝘰𝘶𝘳 𝘧𝘦𝘦𝘥)

It turns every write operation, no matter how random, into a fast, sequential append.

But this "cheat code" creates a massive problem for your reads.

By optimizing for writes, Cassandra scatters your data across memory and multiple files on the disk. 

Technically, this should make your reads terrible.

So, how does it maintain fast reads despite this fragmentation?

𝘐 𝘣𝘳𝘰𝘬𝘦 𝘥𝘰𝘸𝘯 𝘵𝘩𝘦 𝘤𝘰𝘮𝘱𝘭𝘦𝘵𝘦 𝘮𝘦𝘤𝘩𝘢𝘯𝘪𝘤𝘴, 𝘵𝘩𝘦 𝘵𝘳𝘢𝘥𝘦-𝘰𝘧𝘧𝘴, 𝘢𝘯𝘥 𝘵𝘩𝘦 𝘢𝘳𝘤𝘩𝘪𝘵𝘦𝘤𝘵𝘶𝘳𝘦 𝘪𝘯 𝘵𝘩𝘦 𝘢𝘵𝘵𝘢𝘤𝘩𝘦𝘥 𝘥𝘰𝘤𝘶𝘮𝘦𝘯𝘵. 𝘚𝘸𝘪𝘱𝘦 𝘵𝘰 𝘴𝘦𝘦 𝘩𝘰𝘸 𝘵𝘩𝘦 𝘓𝘚𝘔-𝘛𝘳𝘦𝘦 𝘸𝘰𝘳𝘬𝘴 𝘶𝘯𝘥𝘦𝘳 𝘵𝘩𝘦 𝘩𝘰𝘰𝘥.

If you are preparing for mid-senior/staff SDE, EM system design HLD interviews, and need help, DM me COACH.

Why is Cassandra so fast at writes

Interviewer: "Design a rate limiter for 1 million requests per second." Candidate: "Easy. I will use Redis Sentinel for scalability and high availability."

This is an immediate red flag.

The interviewer knows you just architected a bottleneck, not a solution.

To a junior engineer, Redis is just "fast caching." To a Staff engineer, Redis is a distributed system with strict trade-offs.

The architectural difference you missed is - Redis Sentinel vs. Redis Cluster. 

Think of Sentinel as "One active master node + Many backup replica nodes." 

It solves High Availability (failover), and it can scale reads. But rate limiting is write-heavy. 

Every "check" requires a state change (write). Since Sentinel sends all writes to the single master, you hit a hard ceiling.

Redis Cluster is "Many active master nodes + Many backup replica nodes." 

It splits the data across multiple masters (Sharding). This allows you to handle massive write traffic by adding more nodes.

The Staff-Level Solution:

For this scale, you need Redis Cluster:

𝟭. 𝗦𝗰𝗮𝗹𝗲 𝘃𝗶𝗮 𝘀𝗵𝗮𝗿𝗱𝗶𝗻𝗴 (𝘀𝗽𝗹𝗶𝘁𝘁𝗶𝗻𝗴 𝘁𝗵𝗲 𝘄𝗼𝗿𝗸): 

To handle 1M RPS, you need to split the write traffic.
- Cluster divides data into 16,384 hash slots (partitions).
- A single hash slot is served by a single master node (replicas exist for HA or stale reads).
 - Add 2 nodes. Node A handles Users 1-1000. Node B handles Users 1001-2000.
- If traffic doubles, you add Node C. This is linear scaling.

𝟮. 𝗙𝗼𝗿 𝘀𝘁𝗿𝗶𝗰𝘁 𝗿𝗮𝘁𝗲 𝗹𝗶𝗺𝗶𝘁𝘀, 𝗿𝗲𝗽𝗹𝗶𝗰𝗮𝘀 𝗮𝗿𝗲 𝗼𝗻𝗹𝘆 𝗳𝗼𝗿 𝗯𝗮𝗰𝗸𝘂𝗽: 

If your requirements allow for "fuzzy" limits, reading from replicas is fine. 

But for strict rate limiting, do not offload reads to replicas. Because:
- Redis replication is asynchronous.
- The Master might say "0 requests left," but the Replica due to lag says "10 requests left."
- To guarantee correctness, you must read from the Master.

𝟯. 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗲 𝘁𝗵𝗲 𝗻𝗲𝘁𝘄𝗼𝗿𝗸 𝗿𝗼𝘂𝗻𝗱 𝘁𝗿𝗶𝗽. 

At 1 million RPS, the network is slower than the CPU.
- Don't send 10 separate requests to decrement 10 limits.
- Use Lua scripts to bundle atomic logic into a single network hop.

Stop throwing "Sentinel" at every problem that needs Redis.

If you do, you aren't designing a distributed system. You are designing a bottleneck.

If you are preparing for mid-senior/staff SDE, EM system design HLD interviews, and need help, DM me COACH.

Crack mid-senior/staff level FAANG+ SDE and EM Behavioural, and System Design HLD interviews | DM me “COACH” | Engineering Manager @ Amazon | Engineering Career Coach | FAANG+ Interview Coach

Interviewer: "Tell me about at time you had to prioritize between Speed vs. Quality. Which one did you prioritize?"

Candidate: "I believe in both, but I usually lean toward quality to avoid technical debt."

This is a common script, and for Staff+ level interviews, it is an immediate red flag.

The interviewer is nodding, but they have checked out.

You are giving a safe, generic answer because you think there is a right choice.

You are "hiding" in engineering ideals because you do not understand the business problem.

In a staff-level interview, they do not care about your preference.

They care about your reasoning.

This is a trade-off question designed to test your decision-making process.

The "Why" matters more than the "What."

Weak: "I chose quality because I wanted clean code." 
Strong: "Rushing this payment ledger would have created compliance risks and direct revenue loss."

Weak: "I chose speed to meet the deadline." 
Strong: "We had a security vulnerability. We pushed a temporary fix to contain the risk within 24 hours and scheduled a full audit for next week."

Staff engineers do not prioritize tech. They prioritize impact.

When you fail to tie tech decisions to business goals, you lose the signal.

Great engineering. Wrong requirement.

You just shipped your answer to /dev/null.

If you are preparing for mid-senior/staff SDE, EM behavioural interviews, and need help, DM me COACH.

Stop complaining about the lack of depth in your daily work.

In 99% of cases, your manager and your team are not looking for depth from you.
They are looking for breadth.

They need you to understand how the pieces fit together, how to scale the system, and how to deliver.

The problem is that most engineers wait for their Jira tickets to provide "interesting" deep work.

They expect the company to carve out a path for them to become an expert in a specific niche.

But depth is not a team sport.
It is the result of individual curiosity.

The root cause of your frustration is a misunderstanding of what work is for.

Work is about solving business problems at scale.

If every job required every engineer to go deep into the kernel or language internals, everyone would be Linus Torvalds or Dennis Ritchie.

The truth is that the depth you are looking for happens after 5 PM or in the gaps between your tasks.

It happens when you look at a library you use every day and decide to read the source code.

It happens when you see a performance bottleneck and spend your time understanding the underlying hardware limits.

Instead of complaining about the lack of depth in your tasks, start questioning your own curiosity.

Breadth is what makes you a great teammate and a reliable senior engineer.

Individual curiosity is what makes you an expert.

Depth is something you take from the work, not something the work gives to you.

Last month in my team, a senior engineer said "yes" to an impossible deadline.
Three days later, it was delivered.

The same engineer said "no" to another request immediately after.
Both times, they were right.

This is called high-velocity decision-making.

You might wonder what data they had that you didn't.

But if you wait for 100% of the data, you aren't making a decision. You are just processing information.

This superpower works when you have data gaps.

It is experience. 
It is technical depth. 
It is business knowledge.
And in one word, we call it gut feeling.

Now you might ask, how do you build it? Here is what you can do.

𝟭. 𝗕𝘂𝗶𝗹𝗱 𝗯𝘂𝘀𝗶𝗻𝗲𝘀𝘀 𝗰𝗼𝗻𝘁𝗲𝘅𝘁 (𝘁𝗵𝗲 𝗵𝗮𝗿𝗱 𝘄𝗮𝘆)

You need to know the risk of acting versus the risk of waiting. To do this, you must understand where your system falls in the customer's life.

There are no textbooks for this. You learn it by talking to people. You learn it by listening.

You learn it by sitting in project meetings where you have no role other than to absorb.

Most engineers make a fatal mistake here. They keep coding during the meeting. 

They think they are being "productive" because they are writing code.

But productivity isn't just output. By tuning out, they miss the context.

No one will schedule a 30-minute meeting just to teach you business logic. You have to build that understanding yourself.

This is where the gap widens between an engineer who thrives in decision-making and one who just thrives in coding.

𝟮. 𝗥𝘂𝗻 𝗺𝗲𝗻𝘁𝗮𝗹 𝘀𝗶𝗺𝘂𝗹𝗮𝘁𝗶𝗼𝗻𝘀

You need to know your architecture well enough to predict breaking points.

Do a dry run in your head. Ask how upstream systems will use this and how downstream systems will react.

You won't have all the answers. Start with an assumption to get moving, and correct it over time.

𝟯. 𝗥𝗲𝘀𝗶𝘀𝘁 𝘁𝗵𝗲 𝗽𝗿𝗲𝘀𝘀𝘂𝗿𝗲

Never say "yes" just because a manager or stakeholder wants to hear it.

They might support you in the moment, but if you haven't given it deep thought, you aren't doing the job at a senior level.

If you need to say "no," do not just refuse. People have ego. Quickly gather evidence that supports your hypothesis.

Go to the stakeholders with data. Tell them directly why it is the wrong decision so they can make an informed choice based on facts, not just your opinion.

𝟰. 𝗘𝘅𝘁𝗿𝗲𝗺𝗲 𝗼𝘄𝗻𝗲𝗿𝘀𝗵𝗶𝗽

Once the decision is made, you must be on top of it.

Do not assume someone else on the team has the details. They might, but you cannot rely on it.

You must own the execution. 

That is the only way to navigate the situation without looking like a person who has no clue about their own domain.

Now you might be wondering, isn't it very hard?
Yes, high-velocity decision-making is very hard.
And that is the reason why there are very few people who are good at it.

Most engineers say we use message queues for "decoupling."
 
That is the textbook answer. 
 
When you stop at "decoupling," you miss the business, reliability, and cost advantages of asynchronous architecture.
 
Here are the three real reasons we introduce this complexity.
 
1. The fan-out pattern (evolution without destabilization)
2. True spike absorption (latency vs cost tradeoff)
3. Workflow reliability (sagas and failure isolation)
 
Read the carousel to understand the:
- nuances
- when, why, and what
- and, with examples

(𝘛𝘪𝘱: 𝘚𝘢𝘷𝘦 𝘪𝘵 𝘧𝘰𝘳 𝘭𝘢𝘵𝘦𝘳, 𝘧𝘰𝘳 𝘺𝘰𝘶𝘳 𝘯𝘦𝘹𝘵 𝘪𝘯𝘵𝘦𝘳𝘷𝘪𝘦𝘸 𝘵𝘰 𝘤𝘰𝘳𝘳𝘦𝘤𝘵𝘭𝘺 𝘶𝘴𝘦 𝘦𝘷𝘦𝘯𝘵𝘴, 𝘰𝘯𝘭𝘺 𝘸𝘩𝘦𝘯 𝘵𝘩𝘦𝘺 𝘢𝘳𝘦 𝘳𝘦𝘢𝘭𝘭𝘺 𝘯𝘦𝘦𝘥𝘦𝘥.)

Good architecture is not just about drawing boxes and arrows.

It is about aligning technical decisions with SLAs, cost, and risk.

If you are preparing for mid-senior/staff SDE, EM system design HLD interviews, and need help, DM me COACH.

3 real reasons  to introduce queues  in your architecture 

At the Staff+ level, your coding skills will not save you in an interview, if your behavioral stories are weak.

Most candidates fail this round because they optimize for "being right" instead of "being effective."

They tell stories about writing great code, while the interviewer is looking for stories about driving impact through ambiguity.

To pass the Staff bar, you need to master three specific story type.
1. Disagreement
2. Decision making
3. Failure/mistakes

Read this carousel to know: 
- what is interviewer looking for
- what will reduce the impact 
- and, multiple examples

(𝘛𝘪𝘱: 𝘴𝘢𝘷𝘦 𝘵𝘩𝘪𝘴 𝘱𝘰𝘴𝘵 for your interviews in future)

Senior engineers solve technical problems of a project.

Staff engineers solve organizational and business problems through technical means.
Your stories must reflect that shift in scope.

If you are preparing for mid-senior/staff SDE, EM behavioural interviews, and need help, DM me COACH.

The 3  behavioural stories you need to crack the Staff+ in

How to thrive in the noisy, tough software engineering market of 2026. Here is the playbook for Engineers and Managers.

1. Stay focused on your core skills. 
If you are an IC, you need both Coding AND System Design. If you are a Senior IC or EM, you need those plus strong Leadership skills. Hype comes and goes. But when companies need to build complex systems, they don't hire "AI prompt engineers." They hire people who understand software and people.

2. Master the business. 
Code does not make money. Outcomes do. 
ICs: Do not just build features. Understand how they drive revenue or save costs. 
EMs: You are at risk of being seen as "overhead." Your survival strategy is proving that Engineering = Business Growth. The closer you are to the money, the safer you are.

3. Play the "Hype Game" (you have bills to pay). 
You cannot afford to look like a dinosaur. If your leadership talks about Agents and Chatbots, speak that language. Read the blogs. Build a quick POC. Standing alone against a corporate narrative is dangerous when you have EMIs to pay. Treat "learning AI" as a mandatory side project for your job security.

4. Use AI to clear your backlog. 
Don't just use it for documentation. 
ICs: Use it to finish that automation script you kept putting off. Show you can deliver more. 
EMs: Use AI to handle the reporting and admin overhead of your larger team. This buys you the time to focus on your actual job: Outcomes and People.

5. Run the "Replacement Simulation." 
If you are scared an LLM will replace you, do this exercise. Write down every single decision you make in a day. Now, try to define an AI that can do all of them flawlessly. You will quickly find your answer.

6. Don't panic and do stupid things. 
Anxiety makes you act irrationally. Do not stop delivering on time. Do not become the person who argues in every meeting. Nothing ruins a career faster than being labeled "difficult" during a crisis.

7. Ignore the noise from above. 
You will hear senior leaders talk about AI in buzzwords. 
ICs: Ignore it. Just because someone is a Senior VP doesn't mean they are "Senior" for every word they utter. 
EMs: Your job is harder. You have to filter this. Translate the "Senior Fluff" into focused execution for your team. Don't let the noise distract them.

8. Write down your war stories. 
Document every single damn thing. These stories will be your strongest pitch in your next behavioural interview.
- How did you navigate a sudden pivot?
- How did you deliver despite the noise?
- How did you influence stakeholders without authority?
- How did you innovate when resources were cut? 
- How did you manage a doubled team size without quality dropping? 
- How did you keep morale high when the roadmap changed weekly? 

Engineers and Managers are here to stay as long as Engineering is driving business outcomes.

Stay focused on the outcome. Ignore the noise.

Want the exact playbook for SD and BI interviews? 

I will be sharing it tomorrow. Stay tuned..

Most Staff engineer candidates down-level themselves in the first 5 minutes of a behavioral interview.

It happens when they try to set the context for a story.

It starts innocently enough. 

You mention "Kafka" or "Redis" to explain the architecture. Then, you notice a blank look on the interviewer's face.

You panic.

You assume the interviewer needs more detail to understand. Since they are also from engineering background, you switch to the universal language of engineering: Code.

You start explaining the logic. 
You talk about specific components. 
You explain the if/else blocks.

You think you are being clear.
In reality, you are interviewing for a demotion.

Why you should not make this mistake?

[𝟭] 𝗜𝘁 𝘀𝗶𝗴𝗻𝗮𝗹𝘀 𝘁𝗵𝗲 𝘄𝗿𝗼𝗻𝗴 𝘀𝗰𝗼𝗽𝗲 

Staff-plus roles are about scope, ambiguity, and influence. 

When you fall back to explaining code, you retreat to the "lowest unit of work." 

You are proving you can do the job of an SDE II, but failing to prove you can lead like a Staff engineer.

[𝟮] 𝗜𝘁 𝘀𝗵𝗼𝘄𝘀 𝗮 𝘄𝗼𝗿𝗸𝗽𝗹𝗮𝗰𝗲 𝗳𝗮𝗶𝗹𝘂𝗿𝗲 

This habit rarely starts in the interview. 

It usually exists in your daily work. 

When you present to a Product Manager, do you talk about the database schema? When you talk to external teams, do you get stuck in the implementation details?

If you do this in an interview, the hiring manager assumes you will do this at work. 

This kills your candidacy. You are being hired to reduce your manager's workload. 

If they still have to join every meeting just to translate for you, you are not a Staff engineer.

They will give you feedback that you are a "strong cultural fit" but "better suited for a Sr role."

That is code for: "We can't trust you to communicate with stakeholders."

𝗛𝗼𝘄 𝘁𝗼 𝗳𝗶𝘅 𝘁𝗵𝗶𝘀

You need to change your default setting from "How" to "Why."
- Stop relying on technical words to explain the problem.
- Start explaining the business problem, the scale, and the friction.
- Save the technical implementation for the system design round.

You are not paid a Staff salary to explain how a loop works. You are paid to explain why the loop matters to the business.

If you want the Staff title, stop speaking the SDE II language.

If you are preparing for mid-senior/staff SDE, EM behavioural interviews, and need help, DM me COACH.

Humans have a terrifying stamina for living in pain.

Almost everyone is doing it.

It feels like company.

You hear people say, "Oh, that is your problem? Look at mine. My situation is worse."

They compare scars. 
They validate each other. 
And then they go back to living in pain.

It is a vicious cycle.
Pain leads to company. 
Company leads to tolerating more pain.

This is why you see people stuck in the same dead-end relationship for years.

Stuck in the same stagnating company for ages.

Stuck in the same routine every single day.

They only realize it when the situation becomes unbearable.

But that realization is momentary.

The human threshold to bear pain increases automatically.

What was unbearable last week becomes the new normal next week. The limit moves. They stay stuck.

The few who escape this cycle do one thing differently.

They catch that small moment when it feels unbearable.

They do not wait for the threshold to adjust.

They examine their life. Their career. Their exact 24 hours.

They realize the limit has been reached, and they take action immediately.

They choose to change things, even if it means losing the comfort of shared misery.

It is possible to fall back into it if you stop examining your life.

But you have to decide what you want.

Living without pain is a lot less crowded than living with it.

Most people won't move.

Humans find great comfort in pain because it comes with company.

That is why you won't leave that job.

That is why you won't prepare for that interview.

That is why you will keep asking for resources instead of doing the hard work.

Because deep down, you want to stay in the pain.

How to not fail in system design interviews? (a playbook for converting them into offers)

This is how it usually happens: The interviewer asks a vague question you haven't seen before. Panic sets in. You immediately start listing technologies.

- "I'll use a cache here." 
- "I'll use this specific algorithm there."

This is the fastest way to get a "no hire."

The vagueness of the question is not a bug. It is a feature.

At a senior level (at work), no one hands you a database schema or an API contract. You are given an abstract problem and you have to define the solution.

Apply this playbook for SD interviews:

1. First, stop the panic 
Your first job is not to solve the problem. Your first job is to define it without panicking.

2. Respect the requirements phase (5-6 mins)
80% of interview failures happen here.

You must go deeper, instead of rushing through requirements as a formality:
- Functional requirements: Don't just list features. Map the user flow. Understand exactly what you are building.
- Non-functional requirements: Don't just list "consistency" like a checklist. Explain what that means for this specific problem.

3. Do the math (2 mins)
Perform the scaling estimations.
Even if the interviewer doesn't ask, this data protects you. It is the evidence you will use later to justify why you chose Cassandra over MySQL or why you need sharding.

4. Define the APIs (5-6 mins)
Keep it simple. Use REST. Unless you have a very specific edge case, standard REST best practices are the safest path to show competence.

5. Build the high-level design (15 mins) 

Use the standard 6 components to map out your architecture:
a. The Edge (DNS, LB, API Gateway, CDN)
b. Application servers
c. Databases
d. Caches
e. Events
f. Search/Indexing

The mistake here is picking tech without reasoning. Don't just say "I'll use a database." Say which type of database and why it fits your specific requirements.

6. Identify the "Core" (5 mins) 
This is what separates senior engineers.
Most system design problems have 80% "non-core" logic (standard APIs, DBs, caches). But sometimes they have one "core" algorithmic challenge.

If it's Uber, the core is Geohash/S2. If it's Top K, the core is probabilistic data structures.

Identify this early. Spend 5 minutes diving deep here.

7. Wrap up (2 mins) 
Go back to your requirements. Did you solve what you promised in step 2? If you have time, discuss the priority 2 features you skipped earlier.

This structure takes roughly 35-40 minutes. This leaves 10-15 minutes for your interviewer to ask follow-up questions and deep dive into specific components.

That sets you up for a solid 50-55 minute technical conversation.

Structure beats memorization every time.

If you are preparing for mid-senior/staff SDE, EM system design HLD interviews, and need help, DM me COACH.

Most engineers treat the behavioral interview as a soft skills chat. This is a mistake. 

You can crack the system design and coding round. But if you ramble for 15 minutes about a "conflict" without ever explaining the resolution or where was other party coming from, you will get a "no hire."

It happens because candidates listen for keywords, not the question. They hear the keyword "project", and start speaking rehearsed monologue. Ten minutes later, the interviewer is still wondering, "Okay, but what was the difficult decision?"

Apply this playbook to crack the behavioral interview:

1. Understand the question first
Don't just jump on a keyword. If I ask about a "difficult decision," I want to hear about the trade-offs and the risk. If your story doesn't highlight the struggle, you haven't answered the question. If you are unsure, ask me to clarify.

2. Kill the monologue 
Human attention spans are short. If you talk for 15 minutes straight, I stop listening. Keep your initial answer to 3-5 minutes. Give me the headlines. Let me ask follow-up questions to dig deeper.

3. Set the business context
Without context, your engineering work is generic. Start with why this mattered. Who was the customer? What was the business risk? This is what makes your story unique.

4. Don't fake it 
Experienced interviewers can smell a cooked-up story instantly. If you don't have a story that fits the exact prompt, don't lie. Say, "I don't have that exact experience, but I have a related story about [topic]. Would you like to hear that?" Honesty beats a weak lie.

5. Share real failures 
"I delayed a project by one day" is not a failure. It's a humblebrag. Give me a real failure. Show me deep reflection. The learning is more important than the mistake.

6. Zero blame 
Never blame a PM, a manager, or a junior engineer. It is an immediate red flag. Frame conflicts as "differing priorities" or "misaligned goals," not incompetence. Show that you understood their perspective.

7. Lock your numbers 
If you saved 20% latency, memorize that number. Don't say 20% in the first round and 30% in the final round. Inconsistency looks like fabrication.

8. Structure your story
Don't wander. Follow this flow:
- Why: The business context.
- What/How: The action you took and the data you used.
- Impact: The quantifiable result.

Behavioral interviews aren't about being nice. They are about demonstrating ownership and clarity.

If you are preparing for mid-senior/staff SDE, EM behavioural interviews, and need help, DM me COACH.

Most senior engineers fail system design interviews for problems they haven't practiced in the past.

Why? Because their brain immediately races to conclusions like: "Oh, seems like this is less data with heavy reads, so I will use Redis".

And it doesn't stop there. It moves fast to:
- There are many writes, so I should suggest Cassandra.
- Maybe DynamoDB is a better fit for this scale.
- "I’ll use Kafka to decouple the services.

Ten minutes into the interview, you are already designing a solution.

But you have no idea what you are actually building.

The root cause is applying an SDE1 mindset to a Sr/Staff-level interview.

You are focusing on tech setup instead of the actual business problem.

You have not yet figured out what you are building (Functional Requirements) or how it needs to perform (Non-Functional Requirements).

Without these, your mind is just guessing.

What if the data set is tiny without extremely high write TPS? You don't need Cassandra. 
What if there are frequent invalidations? You might not need Redis.

A simple replicated Postgres instance might be all you need.

If you start with tools, you lose track of the problem itself.

The interviewer will let you talk for the remaining 50 minutes.

But in their mind, you have already failed.

You finish the interview thinking you did well because you discussed complex tech.

Then the rejection comes, and you realize you never even started the problem correctly.

Take a step back

Stop reaching for specific databases or message queues in the first five minutes.

Force your mind to stay on the "What" and the "How" first.
- Define the core user needs.
- Define the scale and constraints.
- Let the requirements tell you which tools to use.

Solving a problem you’ve never seen is about your process, not your memory.

System design is not an exam on tech definitions. It is an exercise in requirement-driven thinking (super imp in current AI assisted development).

If you are preparing for mid-senior/staff SDE, EM system design HLD interviews, and need help, DM me COACH.

You have the playbooks. You have the strategy.
But you might still waste 2026.

This week, I shared the complete roadmap for engineers and managers:
- The reality of the AI noise. - https://lnkd.in/gEaUSk5F
- The survival guide for 2026. - https://lnkd.in/gcDdzgqd
- How to clear System Design HLD interviews. - https://lnkd.in/gAVD3_6n
- How to ace behavioral rounds. - https://lnkd.in/gB_j-YW6

If you are a self-learner, this is all you need. You can save this post, use this information to thrive in the 2026.

But before you execute, you need to hit pause.

Information is useless without clear direction.

This weekend, block out 30 minutes.

Do not write code. Do not read another system design paper.

Answer these two questions:
1. What do you exactly want to achieve in 2026?
2. Why do you want to achieve it?

Do not settle for the first answer.
If your answer is "get a staff role," ask why. If the answer is "more money," ask why again.

You need to go 3 to 4 levels deep to find the actual driver.

Build the routine

Once you have the deep answers, build a simple system to stay on track:
- Quarterly analysis: Are you hitting major milestones?
- Weekly reflection: Did you make progress this week?
- Daily nudge: Is today's work aligned with the goal?

This ensures your effort matches your intent.

I did this deep reflection on the last day of 2025.

Now it is your turn.

"Bias for Action" is becoming a lazy excuse in tech these days.

There is a growing population in tech that believes speed is the only metric that matters.

Since AI started writing code, this has gotten worse.

The argument goes like this:
- The cost of producing code is near zero.
- If it is garbage, we can just redo it.
- So just build it now.

I fundamentally disagree.

This logic is dangerous.

It is like saying, "Because producing plastic bags is cheap, let's just flood the world with them."

It ignores the high-order effects.

It is not just about polluting the codebase. It is about polluting the business.

When you act without thinking, you create:
- Confusing product: Features that confuse users and dilute your value proposition.
- Operational debt: Support teams drowning in tickets for half-baked "experiments."
- Strategic drift: Chasing every shiny object instead of executing a clear vision.

We are turning software companies into feature factories. Churning out "polythene" features just because we can.

Bias for action is a virtue only when it is preceded by thought. Without thought, it is just recklessness, and produces only garbage.

The is painful. Even modern LLMs are being trained to think and reason before they generate an answer.

Yet humans are trying to do the opposite.

We are trying to act without thinking.

This doesn't lead to innovation. It leads to one thing.

Mediocrity.

When a company grows, speed wins.

Everyone has a big enough piece of the pie.

People move fast, ship products, and grow their careers.

In this environment, people innovate to solve hard problems because they have to move quickly.

But everything changes when an organization stops growing.

The focus shifts to maintaining the status quo, often called KTLO (Keep the Lights On).

When there isn't much to do, people find other ways to spend their time.

They start playing politics because they have the bandwidth for it.

They create new, complex processes in the name of "innovation" simply because there is nothing else to do.

These processes start a vicious cycle.

Each new process leads to further slowdown.

The slowdown leads to the creation of even more processes to "manage" the lack of speed.

Eventually, the entire organization crumbles under the weight of its own bureaucracy.

Not growing is not just stagnation.

It is slow, eventual death.

taplio

The Battle

Raviraj Achar

Chandra Shekhar Joshi

Followers

Posts

Engagements

Likes

Performance ScoreChandra Shekhar Joshi's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Raviraj Achar

Chandra Shekhar Joshi

Followers

Posts

Engagements

Likes

Performance Score.css-goub6s{font-size:var(--chakra-fontSizes-md);font-weight:500;color:var(--chakra-colors-gray-600);display:block;margin-top:var(--chakra-space-1);}Chandra Shekhar Joshi's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScoreChandra Shekhar Joshi's LinkedIn Performance