Founder, LivingDevOps | AI Platform Engineer | Tech Storyteller DM/email for collab ( [email protected] )
Noida, India
Joined February 2023
- Tweets8K
- Following805
- Followers23.1K
- Likes7.1K
Pinned Tweet
After 14 years in production DevOps and training 400+ engineers, I just launched my most advanced bootcamp to date.
28 weeks. 56 live classes. DevOps + MLOps + AIOps.
Built for experienced engineers who want to move into MLOps and AIOps without faking it on their resume.
Check it out ๐
livingdevops.com/courses/28-โฆ
Launch offer: up to 30% off if you book by 15th June.
Akhilesh Mishra retweeted
If you are giving an SRE interview, learn to answer this one question well.
"Walk me through an incident you were part of."
Most candidates prepare for Kubernetes and Terraform questions.
But this is the question that tells the interviewer who you really are.
Here is how to structure your answer.
1. How you found out.โจ- Was it an alert you built?
- A customer complaint or Pure luck? -
- Be honest. If it was luck, say what you changed so it wouldn't be luck next time.
- This shows how you think about detection.
2. Where you got stuck.โจ- Don't tell a clean story.
- Name the moment you were wrong. - Say what you assumed, and what evidence changed your mind. - Interviewers trust people who admit wrong turns.
3. What you did after.โจ- The fix that got things running is only half the answer.
- Talk about the work nobody asked for. - The alert you added.
- The runbook you rewrote.
- The toil you automated.
4. Who else was in the story.โจ- Reliability is a team sport.
- Mention the handoffs.
- How you communicated with stakeholders.
- Who you pulled in, and why.
Tools can be learned in weeks.
Judgment under pressure takes years. So does the habit of leaving systems better than you found them.
Pick one real incident today.
Write it down using these four points. Practice it out loud.
That one story can carry your interview.
If you are giving an SRE interview, learn to answer this one question well.
"Walk me through an incident you were part of."
Most candidates prepare for Kubernetes and Terraform questions.
But this is the question that tells the interviewer who you really are.
Here is how to structure your answer.
1. How you found out.โจ- Was it an alert you built?
- A customer complaint or Pure luck? -
- Be honest. If it was luck, say what you changed so it wouldn't be luck next time.
- This shows how you think about detection.
2. Where you got stuck.โจ- Don't tell a clean story.
- Name the moment you were wrong. - Say what you assumed, and what evidence changed your mind. - Interviewers trust people who admit wrong turns.
3. What you did after.โจ- The fix that got things running is only half the answer.
- Talk about the work nobody asked for. - The alert you added.
- The runbook you rewrote.
- The toil you automated.
4. Who else was in the story.โจ- Reliability is a team sport.
- Mention the handoffs.
- How you communicated with stakeholders.
- Who you pulled in, and why.
Tools can be learned in weeks.
Judgment under pressure takes years. So does the habit of leaving systems better than you found them.
Pick one real incident today.
Write it down using these four points. Practice it out loud.
That one story can carry your interview.
Throw your 8GB RAM laptop in the trash. Itโs 2026.
16GB is the bare minimum now.
32GB is what I would get.
Akhilesh Mishra retweeted
DevOps, SRE, and Platform Engineering will be the same job by 2027.
If you look at job postings, you'll see the thin lines between them are already gone.
Open any three postings with these titles.
You'll see the same list:
โ Kubernetes
โ Terraform
โ CI/CD pipelines
โ Observability
โ On-call and incident response
โ Cloud, multi-cloud
โ Building internal tooling for developers
โ LLM, AI agents
โ Python, Go
Different titles. Same job.
Companies don't care what you call yourself.
They care if you can keep production running and help developers ship faster.
So companies won't hire three people for three titles. They'll hire one engineer who understands the whole system.
SOMEONE WITH:
โ End-to-end understanding. Code to cloud to cost.
โ Reliability thinking. SLOs, failure modes, blast radius.
โ Platform mindset. Build things others can use without you.
โ Decision making. AI gives you options. You pick one and own it.
โ Communication. Explaining trade-offs to leadership.
And AI will be a big part of your workflow
โ AI will generate most of the pipelines, manifests, and IaC.
โ AI will take up the toil work
โ AI will help you troubleshoot faster. But someone still has to own the incident.
โ You will build, run and monitor AI agents like you used to do it for apps
โ AI observability will become a core skill. Models fail differently than servers.
The engineers who own outcomes will win.
And the ones waiting to be told what to do will become obsolete.
DevOps, SRE, and Platform Engineering will be the same job by 2027.
If you look at job postings, you'll see the thin lines between them are already gone.
Open any three postings with these titles.
You'll see the same list:
โ Kubernetes
โ Terraform
โ CI/CD pipelines
โ Observability
โ On-call and incident response
โ Cloud, multi-cloud
โ Building internal tooling for developers
โ LLM, AI agents
โ Python, Go
Different titles. Same job.
Companies don't care what you call yourself.
They care if you can keep production running and help developers ship faster.
So companies won't hire three people for three titles. They'll hire one engineer who understands the whole system.
SOMEONE WITH:
โ End-to-end understanding. Code to cloud to cost.
โ Reliability thinking. SLOs, failure modes, blast radius.
โ Platform mindset. Build things others can use without you.
โ Decision making. AI gives you options. You pick one and own it.
โ Communication. Explaining trade-offs to leadership.
And AI will be a big part of your workflow
โ AI will generate most of the pipelines, manifests, and IaC.
โ AI will take up the toil work
โ AI will help you troubleshoot faster. But someone still has to own the incident.
โ You will build, run and monitor AI agents like you used to do it for apps
โ AI observability will become a core skill. Models fail differently than servers.
The engineers who own outcomes will win.
And the ones waiting to be told what to do will become obsolete.
Dear job seekers from India.
If you are not getting interview calls from Naukri even after updating your profile, do this.
- Delete your current Naukri account
- Create a new one with different email
- Update a ATS compliant resume that shows relevant skills and experience
- Use metrics in your resume points with right context ( Achieved this by doing that and Star format)
Add some AI relevent experience and you will start getting a lot of calls.
Akhilesh Mishra retweeted
Just because AI can write code doesnโt mean you shouldnโt learn it.
Learn Python or go obsolete in the age of AI driven Devops and everything.
People pay me money for this advice, and i am giving you for free.
DevOps engineers who skip Python will hit a wall in 2027.
Your next platform won't serve web apps.
It'll serve LLMs, RAG pipelines, and AI agents.
- Every model is trained in Python.
- Every RAG app is served with FastAPI.
- Every agent framework ships Python first.
- Every MCP server prefers Python SDK
You can't run what you can't read.
Stop collecting AI certificates. Learn Python.
Just because AI can write code doesnโt mean you shouldnโt learn it.
Learn Python or go obsolete in the age of AI driven Devops and everything.
People pay me money for this advice, and i am giving you for free.
DevOps engineers who skip Python will hit a wall in 2027.
Your next platform won't serve web apps.
It'll serve LLMs, RAG pipelines, and AI agents.
- Every model is trained in Python.
- Every RAG app is served with FastAPI.
- Every agent framework ships Python first.
- Every MCP server prefers Python SDK
You can't run what you can't read.
Stop collecting AI certificates. Learn Python.
Akhilesh Mishra retweeted
Dear job seekers from India.
If you are not getting interview calls from Naukri even after updating your profile, do this.
- Delete your current Naukri account
- Create a new one with different email
- Update a ATS compliant resume that shows relevant skills and experience
- Use metrics in your resume points with right context ( Achieved this by doing that and Star format)
Add some AI relevent experience and you will start getting a lot of calls.
๐ฌ๐ผ๐๐ฟ ๐๐ ๐ฑ๐ฒ๐บ๐ผ ๐๐ผ๐ฟ๐ธ๐. ๐ง๐ต๐ฎ๐ ๐ถ๐ ๐๐ต๐ฒ๐ฟ๐ฒ ๐๐ต๐ฒ ๐ฟ๐ฒ๐ฎ๐น ๐๐๐ผ๐ฟ๐ ๐๐๐ฎ๐ฟ๐๐.
๐๐๐ ๐๐๐๐๐ ๐๐ ๐ฐ๐ธ ๐๐๐๐๐๐๐๐๐ ๐๐๐ ๐ข๐๐๐ ๐๐๐๐. ๐ธ๐ ๐๐๐๐ ๐๐๐ ๐ ๐๐๐ ๐๐๐ ๐๐๐๐๐ข๐๐๐ ๐๐ ๐๐๐๐๐๐๐๐๐.
๐๐๐๐ ๐๐๐๐๐๐ ๐๐๐๐๐๐๐๐ข ๐๐๐ ๐๐. ๐๐๐ ๐๐๐๐ ๐๐๐๐๐๐๐๐ ๐๐๐๐ ๐ ๐๐๐๐๐ ๐๐๐๐ ๐๐ ๐๐๐ ๐๐๐ข ๐๐๐ ๐ ๐ ๐๐๐ ๐๐๐ ๐๐๐ ๐๐๐ก๐.
>> ๐๐ ๐ข๐๐ ๐ ๐๐๐๐ ๐ ๐๐๐๐๐๐ ๐๐๐๐๐๐.
๐๐๐ ๐๐๐๐ ๐๐๐ ๐๐๐๐๐ ๐ ๐๐ ๐๐ ๐๐, ๐ ๐๐ ๐๐'๐ ๐๐๐๐๐๐๐ ๐๐๐ ๐ ๐๐๐ ๐ ๐๐๐๐ ๐๐๐๐ ๐๐ ๐๐๐๐๐ ๐๐๐๐. ๐๐๐ ๐๐๐ ๐ ๐๐๐ ๐๐ก๐๐๐๐๐๐. ๐ฝ๐๐ ๐๐๐ ๐๐๐๐ ๐๐๐ ๐๐๐ ๐๐๐๐๐๐๐๐๐๐.
๐ฝ๐๐ก๐, ๐ข๐๐ ๐ ๐๐๐ ๐๐ ๐๐ ๐๐๐๐ ๐๐๐๐๐๐๐ ๐๐๐๐๐๐๐ ๐๐๐๐๐๐๐๐๐๐๐๐๐ข. ๐ฑ๐๐ ๐๐ ๐๐๐๐๐๐๐ "๐๐๐๐! ๐๐๐๐ ๐๐๐๐๐ ๐๐๐๐ ๐ ๐๐๐๐๐๐๐ ๐๐๐๐๐." ๐๐๐๐ ๐๐๐๐ ๐๐๐'๐ ๐๐๐๐ ๐๐๐๐.
>> ๐๐ ๐ข๐๐ ๐๐๐ ๐๐๐๐๐๐๐๐๐๐ ๐๐๐๐๐๐.
๐๐๐ ๐๐๐๐ ๐๐๐ ๐๐๐๐๐ ๐๐ก๐๐๐๐๐ข ๐ ๐๐๐๐ ๐๐๐๐๐๐ ๐๐ ๐๐๐๐, ๐๐๐ ๐๐ ๐๐๐๐๐๐๐ ๐๐ ๐๐๐๐๐ ๐น๐๐พ๐ฝ ๐ข๐๐๐ ๐๐๐๐ ๐๐๐ ๐๐๐.
๐ฝ๐๐ ๐ข๐๐ ๐ ๐๐๐ ๐๐๐๐ ๐๐๐ ๐๐๐๐ ๐ข๐๐๐ ๐๐๐๐๐๐๐ข ๐๐๐๐, ๐๐ ๐ข๐๐ ๐๐๐ ๐๐ฐ๐ถ ๐๐๐๐ ๐๐๐๐ ๐๐๐๐. ๐ฑ๐๐ ๐๐ ๐๐๐๐๐ ๐๐๐๐๐๐๐ ๐๐๐ ๐ ๐๐๐๐ ๐๐๐๐๐.
>> ๐๐ ๐ข๐๐ ๐๐๐๐๐๐๐ ๐๐๐ ๐๐๐๐๐๐.
๐๐๐ ๐๐๐๐๐ ๐๐๐๐ ๐๐ข ๐๐๐๐๐๐๐ ๐๐๐ ๐๐๐๐๐๐ ๐๐ข ๐๐๐๐๐๐๐ ๐๐๐ ๐๐ข ๐๐ก๐๐๐ ๐ ๐๐๐๐. ๐๐๐๐ ๐ข๐๐ ๐๐๐๐๐๐-๐๐๐๐๐ ๐๐๐ ๐๐๐ ๐๐๐๐๐๐๐ ๐๐๐๐๐๐ ๐๐๐ ๐๐๐๐๐ ๐๐๐๐ ๐๐๐๐. ๐๐๐๐๐ ๐๐๐๐๐ ๐๐, ๐๐๐๐๐ ๐๐๐๐ ๐๐๐ ๐๐๐.
๐๐๐ ๐๐๐๐๐๐๐๐๐ ๐๐๐๐ ๐๐๐๐๐๐๐. ๐ด๐๐๐๐ข ๐๐๐๐ ๐๐๐๐๐๐ ๐๐๐ ๐๐ ๐ ๐๐๐๐๐ ๐๐๐ ๐ ๐๐๐๐๐ ๐๐๐ ๐๐ ๐ ๐๐๐๐ ๐๐ ๐๐๐๐๐๐๐ ๐๐ ๐น๐๐๐, ๐ถ๐๐๐ท๐๐ ๐๐๐ ๐๐๐ ๐๐๐๐๐๐๐๐.
>> ๐๐ ๐ข๐๐ ๐๐๐ ๐ผ๐ฒ๐ฟ.
๐ด๐๐๐ ๐๐๐๐ ๐๐ ๐๐๐๐๐๐๐๐๐ ๐๐๐๐, ๐๐ ๐ ๐๐๐๐๐๐๐๐ ๐ ๐๐ข, ๐๐๐ ๐๐๐๐๐ข ๐๐๐๐๐ ๐๐๐ ๐๐๐๐ ๐๐๐๐ ๐๐. ๐๐๐๐๐ ๐๐ ๐๐ ๐๐ ๐๐๐ฑ ๐๐๐ ๐ฐ๐ธ.
๐๐๐๐ ๐๐ ๐๐๐๐ข ๐๐๐๐๐๐ ๐๐๐๐๐๐๐๐ ๐๐๐๐๐๐, ๐๐๐๐๐ ๐๐๐๐๐๐ ๐๐๐๐๐๐๐ข. ๐พ๐๐ ๐๐๐๐๐๐ ๐๐ ๐๐๐ ๐๐๐ก๐๐ ๐๐๐ ๐๐๐๐ ๐๐ ๐๐๐ ๐๐๐๐๐ ๐๐๐๐๐๐๐.
>> ๐๐ ๐ข๐๐ ๐ ๐๐๐๐ ๐๐๐๐๐.
๐๐๐๐๐ ๐๐๐ ๐๐๐๐ ๐๐๐๐๐๐๐๐๐ ๐ ๐๐๐ ๐๐๐๐ ๐ ๐๐๐๐ ๐๐๐๐ ๐๐๐, ๐๐๐ ๐ข๐๐ ๐๐๐ ๐๐๐๐ ๐๐ ๐๐๐๐๐ข ๐๐๐๐๐๐, ๐๐๐๐ ๐๐๐๐๐ ๐๐ ๐ฒ๐ธ. ๐ธ๐ ๐๐๐ ๐๐๐๐๐ ๐๐๐๐๐, ๐๐๐ ๐๐๐๐๐๐ ๐๐๐๐๐'๐ ๐๐๐๐.
๐ฝ๐๐ ๐๐๐๐ ๐๐'๐ ๐๐๐๐, ๐๐๐๐๐๐ ๐๐๐ข ๐๐ ๐๐๐๐๐ ๐๐. "๐ธ๐๐๐๐๐ ๐ข๐๐๐ ๐๐๐๐๐๐๐๐๐๐๐๐ ๐๐๐ ๐๐๐๐ ๐๐ ๐๐๐ ๐๐๐๐๐ ๐๐๐๐๐ ๐๐๐."
>> ๐๐ ๐ข๐๐ ๐๐๐ ๐๐๐๐๐๐๐๐๐๐.
๐๐๐ ๐๐๐๐๐ ๐ ๐๐๐ ๐๐๐๐ ๐๐๐๐ ๐๐๐ ๐๐๐๐๐ ๐๐๐ ๐ ๐๐๐ ๐๐๐๐๐ ๐๐๐. ๐ด๐๐๐ ๐๐๐๐๐ ๐๐๐๐ ๐๐๐๐ข ๐๐๐ ๐๐๐๐๐๐ ๐๐ ๐๐๐๐๐, ๐๐ ๐๐๐๐ ๐ ๐๐๐๐๐๐๐ ๐๐๐๐๐ ๐๐๐'๐ ๐๐ ๐๐๐๐ ๐๐๐๐๐๐.
๐๐๐๐๐, ๐ ๐๐๐๐ ๐๐๐๐๐๐๐๐๐ ๐๐๐๐๐ ๐ ๐ ๐๐๐๐ ๐๐๐๐ ๐๐, ๐๐๐ ๐ข๐๐๐ ๐๐๐๐ ๐๐๐๐ ๐๐๐ข "๐ธ๐ถ๐ถ ๐พ๐บ".
>> ๐๐ ๐ข๐๐ ๐๐๐ ๐๐๐๐๐๐๐๐๐๐๐๐๐ข.
๐๐๐ ๐๐๐๐๐๐ ๐๐๐๐๐ข ๐๐๐๐ ๐๐ ๐๐๐๐๐ข ๐๐๐๐๐๐๐: ๐ ๐๐๐ ๐๐ ๐๐๐๐๐๐๐๐, ๐ ๐๐๐ ๐๐ ๐๐๐๐, ๐ ๐๐๐๐ ๐๐๐๐๐ ๐๐ ๐๐๐๐ ๐๐๐ ๐ ๐๐๐ ๐๐ ๐๐๐๐. ๐ณ๐๐๐๐๐๐๐๐ ๐๐๐๐๐ ๐๐๐๐๐๐๐, ๐๐๐ ๐๐๐ข๐.
๐๐๐๐ ๐๐๐๐ ๐๐๐๐ ๐๐๐๐ ๐ ๐๐๐๐๐๐๐๐๐ ๐๐๐๐. ๐๐๐ ๐๐๐๐ ๐๐ ๐๐๐๐ ๐๐๐ ๐๐๐๐.
>> ๐๐ ๐ข๐๐ ๐๐๐ ๐๐๐ ๐ ๐๐๐๐.
๐๐๐ ๐๐๐๐๐ ๐๐๐ ๐๐๐๐๐ ๐๐๐๐ ๐๐๐๐๐๐. ๐๐๐๐๐๐ ๐๐๐๐๐๐๐๐๐ ๐๐ ๐๐ ๐ ๐๐๐๐๐, ๐๐๐๐๐ ๐๐๐๐๐, ๐๐๐ ๐๐๐ ๐๐๐ ๐๐๐ ๐๐๐๐๐๐๐ ๐๐๐ ๐๐๐๐ ๐๐๐๐๐๐๐๐.
๐๐๐๐ ๐ ๐๐๐๐ ๐๐๐๐๐ ๐๐ ๐๐ ๐ ๐๐๐๐๐๐๐๐. ๐๐๐๐๐ ๐๐๐๐ ๐๐๐'๐ ๐๐๐๐๐ ๐ข๐๐๐ ๐๐๐๐๐.
>> ๐๐ ๐ข๐๐ ๐๐๐ ๐๐๐ ๐๐๐๐๐ ๐ข๐๐๐๐๐๐๐.
๐๐๐ ๐๐๐ ๐๐๐๐๐ ๐๐ ๐๐๐๐ ๐๐๐๐๐, ๐๐๐๐๐๐ ๐๐ ๐๐ ๐๐๐ ๐ข๐๐๐ ๐ถ๐ฟ๐๐ ๐๐๐ ๐๐๐ ๐๐ ๐๐ ๐ข๐๐๐ ๐๐ ๐ ๐บ๐๐๐๐๐๐๐๐๐ ๐๐๐๐๐๐๐.
๐ป๐๐๐ ๐๐ ๐ ๐๐๐ ๐ข๐๐'๐๐ ๐๐๐๐๐๐๐ ๐๐๐ : ๐๐๐๐๐๐๐, ๐๐๐๐๐, ๐๐๐๐๐๐, ๐๐๐๐๐๐ ๐๐๐๐๐ก๐๐, ๐๐๐๐๐๐๐๐ข ๐๐๐๐๐๐, ๐๐๐๐๐๐๐๐๐๐ ๐๐๐ ๐ถ๐ฟ๐๐.
>> ๐๐๐๐ ๐๐ ๐ป๐ป๐ผ๐พ๐๐.
๐ธ๐'๐ ๐๐๐ ๐๐๐๐ ๐๐๐๐๐๐๐๐๐๐ ๐๐ ๐ณ๐๐๐พ๐๐, ๐๐๐ ๐๐๐๐๐ ๐๐๐ ๐๐๐๐ ๐๐๐๐๐ ๐๐๐๐๐ ๐๐๐ ๐๐๐๐ ๐๐๐๐ ๐๐ ๐๐ ๐๐๐.
๐๐๐ ๐๐๐๐๐ ๐๐ ๐๐๐ ๐๐๐๐ข ๐๐๐๐. ๐ด๐๐๐๐ข๐๐๐๐๐ ๐๐๐๐๐๐ ๐๐ ๐๐ ๐๐๐๐๐๐๐๐ ๐๐๐๐๐๐๐๐๐๐๐.
๐ธ๐ ๐ข๐๐'๐๐ ๐๐๐ ๐๐๐๐๐๐๐๐๐๐ ๐๐ข๐๐๐๐๐, ๐ข๐๐'๐๐ ๐๐๐๐๐๐ ๐๐ ๐ฐ๐ธ ๐๐๐๐๐๐๐๐๐๐๐ ๐๐๐๐ ๐ข๐๐ ๐๐๐๐๐.
๐๐๐๐๐ ๐๐๐ข๐๐ ๐๐๐ ๐ข๐๐ ๐๐๐ ๐๐๐๐๐?
Akhilesh Mishra retweeted
If you are interested in high quality content around
- Devops
- SRE
- Platform engineering
- AIops
- Mlops
- Agentic workflows
- Cloud security
Then say Hi
If you are interested in high quality content around
- Devops
- SRE
- Platform engineering
- AIops
- Mlops
- Agentic workflows
- Cloud security
Then say Hi
Akhilesh Mishra retweeted
Everyone Shows You the AI Demo. Nobody Shows You What Makes It Work in Production.
Akhilesh Mishra retweeted
We've never been more exposed to software supply chain attacks than we are today. And AI is making it worse.
Imagine you're building an AI app.
You install LangChain, pull in a bunch of Python packages, connect your AWS account, and deploy everything through GitHub Actions.
Everything works perfectly. But you probably haven't checked most of the packages you just installed.
You trust them because they're popular and widely used.
Now imagine one of them gets compromised.
That is exactly the kind of attack we've seen in 2026.
- In March, attackers compromised the Trivy security scanner used in LiteLLM's CI pipeline. They stole publishing credentials and pushed malicious versions of LiteLLM to PyPI.
The malicious code could steal SSH keys, cloud credentials, Kubernetes configs, and CI/CD secrets.
And it didn't stop there. One compromise helped attackers move further down the supply chain. A security tool intended to protect software became part of the attack.
- In May, attackers poisoned more than 170 npm packages and two PyPI packages. They even abused legitimate GitHub OIDC trusted publishing to distribute malicious releases.
- By June, a Shai-Hulud worm variant was targeting PyPI, stealing credentials and spreading further.
Now think about your own development environment.
- Your laptop has cloud credentials.
- Your .env file has openai api keys
- Your terminal has access to Kubernetes.
- Your GitHub account can deploy to production.
- Your AI coding agent can install packages to get its job done.
One compromised dependency could expose all of them, leading to loss of money and highly sensitive data theft.
Here are five things I do to reduce the risk.
>> I avoid installing brand-new releases and use a minimum release age where possible.
>> I pin dependencies and use lockfiles and hashes to make builds predictable.
>> I use short-lived credentials instead of keeping long-lived cloud keys on my machine.
>> I pin GitHub Actions to full commit SHAs instead of relying on tags that can move.
>> I restrict outbound network access from CI runners so compromised packages have fewer ways to send data out.
None of these practices makes you completely safe, but together they reduce the attack surface.
Especially when AI is writing, installing, and running more of it than ever.