Jai Jalan

How we are evolving as an agency to continue to bring the best of AI to our customers. We are seeing evolution of PM role into Product Builder (not just writing the behaviour but actually shipping it with AI), and engineers to maintain the infrastructure to help product builder ship.

@JulienBek With Better, 8 years building and operating software for startups — Operate is our autopilot for engineering operations. We investigate production issues end to end as a managed service. Every model improvement makes the work faster. bettrsw.com/operate

If you are hiring, I found this article pretty interesting on spotting outliers - x.com/courtne/status…

Most engineering interviews are testing the wrong skill. At Better, we don’t ask algorithm puzzles. Instead, we give candidates 48 hours to build a small product. They can use AI as much as they want. Then we ask for something unusual: a 10–15 minute video walkthrough explaining their architecture, technical decisions, AI usage, tradeoffs, and what they would improve. Because code alone doesn’t tell you how someone thinks. The outliers stand out quickly. Not because they build bigger projects — but because their systems show: • clear boundaries • strong invariants • safe interfaces • thoughtful AI guidance • awareness of risks and tradeoffs In the AI era, typing code is no longer the scarce skill. Clear system thinking is. That’s what we try to hire for — and it’s also how we build software for our clients. If this kind of engineering resonates with you, we’re hiring: piplhq.com/organizations/…

Social club like Champions Studio (championsstudio.com) can help to reduce screen time need.

𝕏 Head Of Product, Nikita Bier on working for Elon Musk: “I worked at META, I worked at Discord— I’ve basically done the roadshow around all the social networks— I’ve seen how they operate. I’ve never an executive with his amount of responsibility that is that deep in the weeds— he cares a lot— he does weekly reviews, basically with every engineer of the company. Elon always takes the high road, he will always do the hard things. That was such a profoundly different approach to what I have been used to working at other companies. A lot of those hard things seem impossible, but when he gives engineers agency to do it— amazing things happen.” Incredible insight.

I once looked at my early startup’s codebase and realised something uncomfortable… It wasn’t code. It was panic-driven typing disguised as progress. If you’ve ever hacked your way through a product deadline, you know this feeling. You move fast. You tape things together faster. And suddenly the whole system feels like a fragile Jenga tower held together by hope and coffee. The 6 rules I wish I had learned earlier, the ones that stop you from cleaning up your own chaos later. 1. Separation of Concerns: When one function tries to do everything, it ends up doing nothing well. It’s like getting stock tips, relationship advice, and fitness routines from the same friend. Split responsibilities. Clean code starts with clean boundaries. 2. Document Your Code: A comment today is a gift to your future self. Because your future self will have zero memory of the clever thing you wrote at 2am. Don’t make debugging a crime scene investigation. 3. Don’t Repeat Yourself (DRY): Copy-paste feels fast. It’s not. Every duplicate is a future bug waiting for its moment. Write once. Reuse everywhere. Let functions do the heavy lifting. 4. Keep It Simple: Complex code looks impressive, until you’re the one maintaining it. The real flex is clarity. Readable > clever. Understandable > magical. 5. Test Driven Development (TDD) TDD is like writing the exam before studying. The test fails → you add logic → the test passes → you clean up. It forces discipline. It prevents surprises. It builds confidence you can’t get from vibes and manual testing alone. 6. YAGNI (You Ain’t Gonna Need It) Founders love planning for the future version of the product. Except most of those imagined features never ship. Focus on what users need now. Earn the right to build more later. So, treat your codebase like a campsite: Leave it cleaner than you found it. Your team and your roadmap will thank you. P.S. What’s the most chaotic codebase sin you’ve ever seen… that still haunts you to this day?

A great API feels like a smooth airport: clear signs, clean routes, zero surprises. A bad API? Missed flights, wrong terminals, chaos. Design for flow, not confusion.

Many of us (developers) learn about threads before we learn how to think about them. And that’s exactly why concurrency vs parallelism still feels like 'same same but different.' Here’s the version I wish someone told me early in my career: When your app is juggling tasks like a caffeinated barista taking five orders at once…That’s concurrency. Lots happening, but not necessarily at the same time. Just really good time-sharing. When your app is actually making five coffees at the same time because you hired four more baristas…That’s parallelism. Multiple workers. Multiple hands. True multitasking. Rob Pike nailed it: Concurrency is about dealing with lots of things at once. Parallelism is about doing lots of things at once. If you’ve ever written Node.js and wondered, How the hell is this single thread handling all this chaos? Welcome, that’s concurrency. If you’ve ever pushed CPU-heavy tasks across multiple cores in C# or Rust and watched performance jump… that’s parallelism flexing. And once you truly get the difference? You stop over-engineering. You stop underestimating bottlenecks. You ship smarter. What was the first moment you realized concurrency ≠ parallelism?

Every team fights about the right deployment strategy… until something breaks in production. If I had to ship code tomorrow, these are the 5 patterns I’d think about, not because they’re trendy, but because they each solve a very different kind of founder pain: 1. Big Bang → When you want speed but you’re okay gambling with downtime. 2. Rolling → When your team can’t afford a hard stop. 3. Blue-Green → When rollback has to be instant. 4. Canary → When you want to test with real users but not risk the whole house. 5. Feature Toggles → When you want to separate deployment from release and sleep better. Here’s the surprising part: none of these guarantee safety. Your system’s maturity, team habits, and observability stack matter way more than the deployment pattern itself. So I’m curious, Which deployment pattern has saved you (or burned you) the most… and why?

If you treated one of your internal problems like a startup idea this weekend, What would you build first?

You can debate an idea for months, or test it in a weekend. The first path burns cash. The second builds conviction.

Our team was drowning in resumes. So we built an AI bot between Saturday and Sunday (part-time). Here’s how a weekend project saved us 50+ hours every week. 👇