🐍 Python | 🤖 AI/ML | Software Engineer | Practical roadmaps • Hands-on tutorials | Freelance & collabs open | DM 📩
Pune, India
Joined February 2019
- Tweets68.2K
- Following669
- Followers32.1K
- Likes34.2K
Pinned Tweet
Building AI applications is one thing. Making sure they behave as expected under adversarial conditions is another.
As LLMs and AI agents become part of real-world workflows, testing them goes beyond checking whether they produce the right answer. You also need to evaluate how they respond to malicious inputs, how agents execute actions, and where the underlying infrastructure might introduce risks.
That's what makes AIBeat worth exploring.
The toolkit brings together three components:
🔹 PromptBeat — for testing prompts and LLM behavior against adversarial inputs.
🔹 AgentBeat — for testing AI agents and investigating their behavior during execution.
🔹 RouterBeat — for evaluating the security of AI routing and relay infrastructure.
Each targets a different layer of the AI stack, helping developers think more systematically about security and reliability.
If you're building LLM-powered applications or AI agents, AIBeat is worth a look.
Explore it: aibeat.ai/
@Tophant001
🤝 Paid partnership
Dario Amodei right now
Introducing Kimi K3.1 Pro: our most capable 3T-class open-weight model.
🔹 1M-token context, 2.8T total / 104B active params (MoE), Multimodal.
🔹 Full-project coding: games in Unreal, Unity & Godot.
🔹 Excels at parametric 3D modeling in Blender & CAD.
🔹 More reliable at finance work: Accurate modeling with hallucination down by 65%.
🔹 Matching the strongest proprietary models across coding, agentic and knowledge benchmarks.
Kimi K3.1 Pro and K3.1 Pro Highspeed (2–3× faster) are now live on Kimi.ai, Kimi Work, Kimi Code, and the Kimi API.
Open weights by Nov 4, 2026.
🔗 API: platform.kimi.ai
🔗 Tech blog: kimi.ai/blog/kimi-k3-1-pro
Me listening to teams Friday night plans knowing my plan is to leave early and be home with the wife & kids
US & China both have people working regular IT jobs.
The differentiation is the builder mindset.
The post seems to confused Infosys employee mindert with a Blinkit founder mindset
Dear Indian IT companies....
If you want to build superior software like USA or China.... please pay salaries like them...
You can't pay 6 LPA & expect engineers to build products that are built by engineers who are getting crores of salary.
Start paying min 60 lpa - 1cr salaries....
In 1 year, we will overtake China
In 2 years, we will overtake USA
In 3 years, we will overtake Alien technology
You get what you pay for
10 resources to learn System Design better than most college courses.
Don't start by memorizing how Netflix, Uber or WhatsApp work.
First, understand the concepts that make these systems possible. Then study how real engineering teams apply them.
Here are 10 resources I'd recommend, in the order I'd learn them.
PART 1: MASTER THE FUNDAMENTALS
1. System Design: The Complete Course
Start here if you want a structured introduction to databases, scaling, load balancing, APIs and security.
🎥 System Design Course – APIs, Databases, Caching, CDNs, Load Balancing & Production Infra — freeCodeCamp
youtube.com/watch?v=C842vFY5…
2. Distributed Systems Fundamentals
Learn caching, replication, sharding, consistent hashing, message queues and the trade-offs behind distributed architectures.
📚 System Design Primer — GitHub
github.com/donnemartin/syste…
3. Databases and Distributed Data
Understand how real systems store, process and distribute data, and why consistency, reliability and scalability involve trade-offs.
📚 Designing Data-Intensive Applications — Martin Kleppmann
dataintensive.net/
4. How to Think Through a System Design Problem
Learn to translate requirements into architecture, estimate capacity, identify bottlenecks and justify your design decisions.
🎥 System Design Explained: APIs, Databases, Scaling, Load Balancing, Auth & Security — Hayk Simonyan
youtube.com/watch?v=oYxTTirK…
PART 2: LEARN FROM REAL-WORLD SYSTEMS
5. Netflix: Designing for Global Scale
How do you deliver video reliably to millions of viewers while managing latency, traffic and infrastructure costs?
🎥 Demystifying the Unusual Evolution of the Netflix API Architecture — ByteByteGo
youtube.com/watch?v=Uu32ggF-…
6. Uber: Real-Time Location and Matching
Explore geospatial indexing, real-time updates, dispatch systems and the challenge of matching riders with nearby drivers.
🎥 System Design: Uber Ride-Sharing Platform — Mukul Raina
youtube.com/watch?v=2k2QBX9A…
7. WhatsApp: Messaging at Scale
How do you build a messaging platform that delivers messages reliably, supports concurrent connections and keeps conversations private?
📚 WhatsApp Engineering — Meta Engineering
engineering.fb.com/
8. Discord: Real-Time Communication
Explore the challenges behind real-time messaging, persistent connections, data storage and scaling communication across millions of users.
📚 Discord Engineering Blog
discord.com/blog
9. Dropbox: File Storage and Synchronization
Learn about file synchronization, metadata, storage systems and the engineering challenges of keeping files consistent across devices.
📚 Dropbox Tech Blog
dropbox.tech/
10. YouTube: Video Processing and Delivery
Understand the architecture behind uploading, processing, storing and delivering videos to users across the world.
📚 Google Cloud Architecture Center
cloud.google.com/architectur…
One final piece of advice:
Don't just watch these resources.
For every system, ask yourself:
• What are the functional and non-functional requirements?
• What breaks first when traffic grows?
• Why was this architecture chosen over the alternatives?
• What trade-offs did the engineers make?
• How would I design it differently today?
That's how you move from memorizing architecture diagrams to actually learning system design.
Save this list for your next learning session.
Everytime someone tells me coding is dead I show them supply chain attack examples
People are using it to expose CVEs but the maintainers or devs cannot patch or bring out new versions at the same speed because SWE isnt about just writing code.
The whole process around code generation is complex, and requires human coordination, judgements and expertise
Currently the AI tools are doing more harm than good to the world
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.
One of my favourite quotes:
"I helped a stranger climb a mountain, and then I realized, I too was at the top."
As you transition from an individual contributor to a manager, your impact shifts from what you can accomplish yourself to what you enable others to accomplish.
That might mean helping someone develop confidence, removing a blocker, or giving a teammate the context they need to make better decisions independently.
Your success is no longer just about how good you are at solving problems. It's also about how much better the people around you become because they work with you.
Sometimes, helping others climb higher is how you reach the next level yourself.
Big big kudos to my buddy @techyoutbe for the launch of his latest product PostDeck.
As a content creator, this is an awesome utility which streamlines writing, style and planning.
Give it a try !!!
🚀 PostDesk is LIVE!
I built a tool to solve a problem I face as a tech creator.
Write. Style. Plan. Design. Your social posts, all in one tab.
Built for creators and engineers who share tech content.
Less tool switching. More creating.
Try it out 👇
🔗 postdesk.techfusionist.com/
Would love your feedback! ❤️
What should a parser learn after it gets a messy page wrong?
OXR's answer, a first among document parsers, is RSI during post-training: review the output with a VLM, detect disagreement across runs, cluster the causes, then generate data for another training round. That's how a 1.3B model ends up atop olmOCR-Bench, OmniDocBench, DocParsingBench and open-source speed (101s vs DeepSeek-OCR-2's 161.1s, one RTX PRO 6000).
I'd start evaluating it on handwritten notes mixed with tables. Its layout model swaps out without touching recognition or reading order.
github.com/SoMarkAI/OXR
🤝 Paid partnership
Production Debugging Playbook, Part 3: Debugging CPU, Memory & Resource Saturation
High CPU usage doesn't always mean you need more replicas.
High memory usage doesn't always mean you have a memory leak.
The goal is to identify what's saturated, understand why, and apply the right fix.
1. Spot the symptoms
Look at CPU and memory usage, pod restarts, OOMKilled events, request latency, and error rates.
Check whether the problem affects one pod, an entire service, or the Kubernetes node.
2. Identify the affected component
Use metrics to find the overloaded pod or node.
If one worker pod is at 95% CPU while other pods remain healthy, investigate that workload before scaling the entire cluster.
3. Gather evidence
Useful Kubernetes commands:
• "kubectl top pods -n prod"
• "kubectl describe pod -n prod"
• "kubectl logs -n prod --previous"
Check CPU throttling, memory limits, restart reasons, application logs, and resource requests. Compare the affected pod with healthy instances.
4. Find the root cause
• High CPU: inefficient code, expensive loops, increased traffic, or CPU throttling.
• High memory: memory leaks, large in-memory objects, or excessive caching.
• Thread/connection exhaustion: blocked workers, saturated connection pools, or slow dependencies.
• Node pressure: insufficient node capacity, resource limits, or noisy neighbours.
Remember: CPU usage measures consumption, while CPU throttling indicates the container is being restricted by its CPU limit. They are related, but not the same.
5. Apply a targeted fix
Optimize code, fix memory leaks, tune connection pools, or address slow dependencies.
Scale horizontally when additional replicas can distribute the workload. Adjust CPU or memory limits only after checking actual usage and capacity. Raising a memory limit may delay OOMKills, but it won't fix a leak.
6. Verify the result
After the fix, compare CPU, memory, throttling, restarts, latency, and error rates against the baseline.
Confirm the improvement persists under representative traffic and that the bottleneck hasn't shifted elsewhere.
The debugging sequence:
Observe → Isolate → Investigate → Diagnose → Fix → Verify
Don't scale blindly. Use evidence to distinguish an application bottleneck from a container limit or a node-capacity problem.
Next: Debugging Database Bottlenecks.
Production Debugging Playbook, Part 2: Debugging 5xx Errors
A spike in 5xx errors is a symptom, not a root cause.
The service returning the error may not be the service causing it. Here's how to investigate.
1. Scope the impact
• Error rate vs. total request volume
• Affected endpoints, regions, instances, and versions
• Recent deployments or configuration changes
• Changes in latency, traffic, and resource usage
2. Trace the failing request
Follow the request across the gateway, application, and downstream dependencies.
Example: Product Service returns 502, but the trace shows it spent most of its time waiting for Pricing Service.
The failure surfaces in Product Service; the underlying problem may be Pricing Service.
3. Interpret the status code
• 500: Application exception or processing failure
• 502: Invalid or unexpected upstream response
• 503: Service unavailable, overloaded, or unhealthy
• 504: Upstream response timeout
These are clues, not root-cause diagnoses. The component generating the response determines what the code tells you.
4. Correlate the three signals
• Metrics: Which error rates, latencies, or saturation levels changed?
• Traces: Where did the request fail or stall?
• Logs: What exception, timeout, or connection failure occurred?
Use trace/request IDs to connect evidence across services.
5. Validate the hypothesis
If Pricing Service is suspected, check its latency, error rate, logs, and connection pools. Compare the incident timeline with deployments and configuration changes.
Also investigate retries. They can amplify load on an already struggling dependency.
Follow the evidence beyond the immediate timeout to find the underlying cause.
6. Fix and verify
Roll back faulty deployments, fix application errors, address resource exhaustion, or correct dependency/network issues. Adjust timeouts and retries only when the evidence supports it.
Then verify recovery using the same metrics that exposed the incident. Confirm errors and latency have normalized without creating new problems.
The debugging sequence:
Detect → Scope → Trace → Correlate → Validate → Fix → Verify
Don't assume the service returning a 5xx is the root cause. Follow the request, gather evidence, and prove the fix worked.
Next: Debugging CPU, Memory & Resource Saturation.
It was good while it lasted @bot
