Devanshu

A few weeks ago, I posted about me looking for distributed systems and infra engineering role. And Honestly? I wasn't expecting much. But then things got interesting. I ended up in conversations with founders, CTOs, and engineers from frontier AI labs, SF startups, and EU infra companies. And companies doing alot of crazy stuffs on High performance GPU infrastructure and sandboxes. One after another. And every single one of those conversations gave me alot of clarity, learnings and wisdom. About how real systems are built. About engineering culture at scale. About what separates engineers who just ship things from engineers who actually understand what they're shipping. About what customer obsession really means when your infrastructure is the product. Some of those conversations genuinely changed how I think about software. And now I just want more of that. Because somewhere in all of this, I realized something about myself what I actually enjoy isn't just writing code. It's being close to hard problems. Close to ambitious people who are building things that matter. Close to the messy, real-world constraints that make engineering actually interesting. Because getting access to this priviledge easily while living in dehradun is not a piece of cake for me. So here's some of what I've worked on: 1. At @calcom, I dug into scheduling infrastructure, the kind of problems that look simple until you're dealing bookings, timezone edge cases, and race conditions that only show up in production at 2am. 2. You know that smooth sidebar dropdown in the @supabase Docs? Yes I Built that. 3. I've built distributed search infrastructure where I built a production-grade system in Go indexing 24K+ documents across 8 shards, achieving 28ms p99 latency at 7K+ QPS. The system uses a hybrid ranking pipeline combining BM25 and vector embeddings, etcd-based service discovery for fault tolerance, and a Redis caching layer with distributed locking to prevent thundering herd. The parallel fan-out query engine reduced latency by 12 times compared to single-node search. 4. Worked on Vitess specifically VTGate internals and query planning and debugged more XSS vulnerabilities, scheduling bugs, and distributed coordination failures than I care to count. But here's the thing. A lot of engineers can build features. That's table stakes. What fewer engineers can do: like Debugging a production incident under pressure without losing their head Reasoning about correctness at load, not just in theory Thinking through tradeoffs and communicate them clearly to non-engineers Catching the edge cases before they become incidents Ship fast without quietly destroying reliability That's the part I love. That's the work I want to be doing. I care about p99s, not averages. Observability before optimism. Idempotency and exactly-once semantics. Systems that don't just work in demos, they survive contact with reality. Lately I've been going deep on designing infra systems for the next generation of AI systems. Some of what I've been exploring: 1. Distributed Agent Sandboxes at Scale - thinking through what it takes to run thousands of untrusted AI-generated workloads concurrently. microVMs isolation, syscall filtering, ephemeral filesystem snapshots, container escape prevention. The kind of stuff that sounds theoretical until an autonomous agent tries to do something it shouldn't. 2. @stripe scale payment systems - I wrote about this in "The Talk of the Trillions." Idempotency guarantees, exactly-once semantics, ledger consistency, reconciliation pipelines. The reason correctness matters more than throughput when you're moving money. 3, Distributed execution for AI agents - task queues, DAG execution engines, fault-tolerant orchestration, checkpointing. Infrastructure where autonomous agents can reliably run long-running workflows. This is the space I think gets really interesting in the next few years. 4. "Git for database schemas." - database schemas deserve the same primitives Git gives code. Branches, commits, diffs, merges, conflict detection. So I built it in Go: PostgreSQL DDL parsed into structured ASTs, three-way schema merges, auto-generated migrations from diffs, CLI + HTTP API, Postgres in prod and in-memory stores for tests. and shhhhh 🤫 (just between us) And I'm learning Rust right now while building a distributed web crawler, because apparently I enjoy pain and learning the hard way. Writing about all of it here if you're curious: @devanshusharma658" target="_blank" rel="nofollow noopener">medium.com/@devanshusharm… Tech stacks will keep changing. But the The fundamentals? distributed systems, debugging, clear communication, reliable execution Those don't. After all these conversations over the last few weeks, I'm more obsessed with this space than ever. If you're hiring a Software Engineer or even the Hottest job in the tech Forward deployed engineer, like someone who can go deep on infra, reason about hard systems problems, and actually talk to customers and translate messy real-world needs into things that work, I'd genuinely love to chat. DMs open.

@erentrkg @Percona Happy to meet him.

@DevanshuXi @Percona I can help. I know a guy.

Do I know anybody from @Percona ? I need a tiny bit of help. DMS Open.

@beadle1989 Hmm. I need to improve a lot man. ^^

So you shouldn't optimise everything through LLMs but you should optimise the repetitive tasks, this will give you more time to spend on the high value tasks. Things like domain modelling, coming up with clean abstractions and thinking about the complex architecture decisions. LLMs are not meant to remove the struggle of doing work that you feel rewarded by, there's just a new struggle. The writing of precise prompts into some higher order form of thinking that allows you to abstract out the domain you are working on shows your thinking behind the code that is being produced, proving your understanding of the complex processes involved in writing software.

That’s what I genuinely feel these days. I don’t provide value to any company right now. I don’t have customers waiting on me. No production outage depends on my code. No market pressure is forcing me to ship faster. So why the hell should I optimize everything through LLMs? Lately I’ve just been sitting alone, thinking deeply, writing completely raw code with my own hands, staring at logs for hours, debugging stupid failing test cases that nobody in the world cares about except me. And weirdly… I enjoy it. Because for the first time in a while, the process actually feels real. The failing tests frustrate me. The broken abstractions annoy me. The ugly edge cases make me question my own thinking. But at least I’m feeling something while building. Maybe this is inefficient. Maybe I should be “10x productive.” Maybe I should automate half my thinking away. But honestly, at this stage of my life, it literally doesn’t matter. Nobody is dying if my side project ships two weeks later. No investor dashboard is tracking my velocity. No PM is asking for updates. So I’d rather struggle through the code myself, understand every ugly detail, and let the frustration shape how I think. Because somewhere in those failing logs and terrible midnight debugging sessions, it still feels like I’m actually learning computers instead of just operating them.

@simeonGriggs Bruh I am just 21. Don't give me urge to have kids.

Benefit of having kids early is you’re young enough when they’re old enough to do epic stuff together. Coledale Horseshoe in the Lakes done 😤 ripper day

These days I’ve been coding a lot in Rust just to observe the runtime memory behavior more closely. Kinda fascinating how the language forces you to think about ownership, allocations, borrowing, stack vs heap, and memory layout instead of treating memory like some invisible abstraction. Initially I picked it up mostly out of curiosity for performance and memory efficiency during runtime… but honestly the language is pretty cool.

@craig_certo It's leetcode.com

@DevanshuXi What IDE is this?

Cool morning tbh, I was solving the classic “Jump Game V” DP problem and got something interesting to know. Top-down memoization and bottom-up tabulation do not reveal dependencies the same way, even if the recurrence looks identical. The problem itself looked pretty straightforward at first. From an index i, you can jump at most d positions left or right, but only to smaller values, and every element in-between should’ve also been smaller. My memoized DFS got accepted at first. The recurrence was basically: cache[i] = 1 + max(cache[j]) where: arr[j] < arr[i] now while writing the recursive solution, I honestly didn’t even think much about dependency ordering. DFS just naturally handled everything. And that’s the interesting part. When recursion solves solve(i), it automatically goes and computes all the smaller reachable states first. Only after those answers come back does it memoize cache[i]. So even though the graph dependencies are directional, recursion kinda performs a lazy topological traversal for you behind the scenes. That’s why the memoized version works perfectly fine without sorting anything. But then I tried converting the exact same logic into bottom-up DP, and things suddenly started feeling weird. Initially I thought I could just do something like: for(i = 0; i < n; i++) compute cache[i] But this ordering completely falls apart. The issue is that cache[i] depends on states having strictly smaller VALUES, not smaller INDICES. And that distinction changes the whole problem. While computing: cache[i] = 1 + cache[j] there’s absolutely no guarantee that cache[j] already exists if we’re simply iterating left-to-right. Some dependencies are on the left. Some are on the right. The graph literally does not care about positional ordering. The actual dependency rule is arr[i] > arr[j], that means edges always go larger value -> smaller value That was the key realization for me. The graph isn’t index-ordered at all. It’s value-ordered. Not it looked more like a DAG ordering problem. So for bottom-up DP, states should’ve been processed in increasing order of values. That’s why sorting suddenly becomes necessary: sort(states by arr[i]) Now when processing an index i, every smaller reachable state has already been computed. What recursion was handling implicitly, tabulation now forces you to handle explicitly. And honestly, I got to know something new about DP. A lot of people say: “Tabulation is just memoization with loops.” But that’s not really true. Memoization discovers dependency order dynamically during recursion. Tabulation requires you to design the dependency order beforehand. And most of the time, that’s actually the hardest part. This is also why so many bottom-up DP problems suddenly require: sorting, topological ordering, monotonic processing, DAG linearization, coordinate ordering, etc., even though their recursive versions feel completely natural.

@craig_certo It really is.

@DevanshuXi Love it! I feel the constant pressure to build as quickly as possible, but what you’re describing sounds really peaceful

@brennus_systems me too.

@DevanshuXi I’m doing more of this lately and it’s been great

@dhruv2038 Marketing + engineering. Its a much harder place to be in tbh.

@DevanshuXi so all marketing folks now are FDEs.

The future job role in tech will either be Member of technical staff or Forward deployed engineer. Nothing else.

This is what I open Twitter for. 😂😂

@monkbloc Oh it was Amazing.

@DevanshuXi Wow didn’t seem like at all, how was experience at calai?

@monkbloc Haha. I am just a new grad buddy. Still just a newbie. Alot to learn.

@DevanshuXi You are so advanced in this stuff curious wouldn’t any full time role call to your feet. Respectfully wondering since it seems it’d take forever to get to where you are

@numaan27 this was in reference with a specific problem

@DevanshuXi well, i think the main reason recusrion "naturally"/implicitly handles everything is because u explicitly enforced the arr[j] < arr[i] transition rule, no?

@InspireAmbitio Damn

@DevanshuXi The candidate move that exposes most of these in one interview: ask what the 90-day attrition number is, and how many people took two consecutive weeks off last year. The answers tell you which labels are decoration and which are real.

Just got to know startup hiring jargon in 2026 basically means: “Founding Engineer” = first developer who also handles support calls “Fast-paced environment” = priorities change every 3 hours “Equity-heavy compensation” = salary is emotional support “We move with urgency” = there are no processes “AI-native company” = added ChatGPT to the workflow “Async-first culture” = meetings still happen, just at midnight “Stealth startup” = no product yet “Customer-obsessed” = clients keep changing requirements “Zero to one mindset” = nobody knows what they’re doing yet “Flat organization” = everyone reports to the founder “Unlimited PTO” = nobody actually takes leave “Founder-led sales” = CEO sending cold DMs on LinkedIn

"India is overcrowded" is the most successful gaslighting campaign Indian babus ever ran on their own citizens. They underbuilt the country for forty years and convinced 1.4B Indians to blame themselves for it. Every overcrowded space you've ever queued in is a supply failure the state engineered, not a demographic accident. Five lifts in a hospital, one working. Seven railway counters, one ticketer. Toll plazas, water boards, municipal offices: built once in 1972, patched once in 1996, abandoned ever since. The only exception is airports, and even those lounges are gigafried at peak. Why did this happen? 4 reasons, none of them are "too many people." 1. Cost of capital. Rupee down 60% against the dollar in two decades. Inflation 5-7% on paper, 8-10% in reality. Risk-free rates above 7%. No rational allocator underwrites a hospital with a 30-year payback under those conditions. Capital flows into software and consumer brands; anything with a 3-5 year ROI window. Parks, ports, metros, dams, schools need multi-decade underwriting that India's macro structurally cannot support. 2. The regulatory stack is engineered to prevent construction. 50+ clearances across municipal, state, and central bodies for any large project, each with its IAS gatekeeper extracting rent. Real builders give up. The only construction happening at scale is therefore illegal, which is exactly why slums mushroom while sanctioned housing projects sit at 15% completion for a decade. 3. The corruption tax. Budget 15-20% of project cost in bakshish before pouring a single slab. Stacked on top of GST, stamp duty, capital gains, property tax, labour cess. Software shops escape it; they ship from a laptop. Anyone touching cement, steel, or land pays the surcharge in cash, off the books, with zero recourse and zero deductibility. 4. State capacity has collapsed into pure friction. GST portal crashes on filing deadlines. MCA21 is a relic. Every regulator (SEBI, RBI, IRDAI, FSSAI, BIS) optimises for CYA, never throughput. Babus paid 1990s salaries to administer 2026 complexity respond rationally by doing nothing. India's perpetual undercapacity is a capital allocation story the political class would rather you never learn. The 1.4B is a feature. The people running the country are the bug. Until cost of capital drops, the regulatory fat gets gutted, and the corruption surcharge gets squeezed out, the lifts and the counters and the hospitals will stay exactly as broken as they were when your grandfather first complained about them in 1987.

After my recent interview with an NYC-based startup, a lot of people from New York reached out with opportunities, advice, and kind messages. Genuinely grateful for all of it. Most conversations didn’t go further because I’m currently based in Dehradun, India, and relocation to the US isn’t possible for me right now. That said, I’m actively looking for SWE / backend roles, global remote or onsite within India both work for me. Really appreciate everyone who reached out. Feel free to DM me.