<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Shruti on Medium]]></title>
        <description><![CDATA[Stories by Shruti on Medium]]></description>
        <link>https://medium.com/@shrutiakkala?source=rss-8dd6cdccf322------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*azu-FUlPUeFVbsq8ep6RCA.jpeg</url>
            <title>Stories by Shruti on Medium</title>
            <link>https://medium.com/@shrutiakkala?source=rss-8dd6cdccf322------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 02:49:57 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@shrutiakkala/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[AI Observability, Grafana Assistant, and Loki: My Biggest Takeaways from GrafanaCON Local 2026]]></title>
            <link>https://medium.com/@shrutiakkala/ai-observability-grafana-assistant-and-loki-my-biggest-takeaways-from-grafanacon-local-2026-362bf6e45c17?source=rss-8dd6cdccf322------2</link>
            <guid isPermaLink="false">https://medium.com/p/362bf6e45c17</guid>
            <category><![CDATA[grafana-observability]]></category>
            <dc:creator><![CDATA[Shruti]]></dc:creator>
            <pubDate>Fri, 05 Jun 2026 02:26:00 GMT</pubDate>
            <atom:updated>2026-06-05T02:26:00.280Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CgBbzWagfPHh0eWvSvv5Ag.png" /></figure><p><em>A backend engineer’s firsthand look at what Grafana 13 shipped — and why it matters for everyone on-call at 3 am.</em></p><p>As a backend software engineer, I’ve spent countless hours troubleshooting production issues, analyzing logs, tuning dashboards, and responding to alerts. That’s why Grafana has always been one of my favorite tools in the observability ecosystem.</p><p>Attending GrafanaCON Local 2026 gave me a chance to see where the platform is heading next — and after seeing the announcements around AI Observability, Grafana Assistant, Loki, and Git Sync, I left more excited about observability than I have been in years.</p><p>I was particularly interested in seeing how observability is evolving in the age of AI. As more teams build AI-powered applications and agents, the challenges extend beyond monitoring infrastructure to understanding conversations, costs, quality, and behavior. Grafana’s announcements showed a clear vision for tackling those challenges.</p><p>I attended a GrafanaCON Local 2026 meetup — one of the local events Grafana organized worldwide in the wake of the main conference held in <strong>Barcelona this past April 21–22</strong>. The main event was where Grafana Labs officially unveiled <strong>Grafana 13</strong>, and the local meetup did a brilliant job of walking through all the major announcements. I want to share what stood out most to me — not as a press release recap, but as someone who actually lives inside dashboards and runbooks day to day.</p><p>A fun piece of trivia from the keynote: Grafana was <em>born</em> in Barcelona. Co-founder Torkel Ödegaard made the very first commit while on a Christmas holiday there in 2013 — stuck in bed with a cold, coding obsessively. Thirteen years later, the project has more than <strong>35 million users worldwide</strong>. Fitting place for a comeback.</p><p>Let me break down the features that genuinely impressed me.</p><h3>🤖 Grafana Assistant: Your Smartest On-Call Teammate</h3><p>This was the one that got the room buzzing.</p><p><strong>Grafana Assistant</strong> is now generally available — and critically, it’s no longer just a Grafana Cloud feature. At GrafanaCON, Grafana announced that <strong>self-managed OSS and Enterprise users</strong> can now access it too, via a one-click connection to Grafana Cloud. That’s a big deal for teams running on-prem who’ve been watching this feature from the sidelines.</p><p>It’s not just another chatbot bolted onto a dashboard. It’s deeply integrated into the observability workflow in a way that actually changes how you handle incidents.</p><p>The slide said it best: <em>“Chat with your telemetry.”</em></p><p>What does that mean in practice? Imagine getting paged at 3am for a Mimir storage alert. Instead of frantically clicking through dashboards, correlating logs, and pulling up runbooks, you ask: <em>“What’s wrong with Mimir storage right now?”</em> — and the assistant investigates, pulls telemetry context, and walks you through it.</p><p>Key capabilities shown at the event:</p><ul><li><strong>Teach yourself observability</strong> — it explains what’s happening, not just what the numbers are</li><li><strong>Advanced SRE tasks</strong> — it can handle complex multi-step investigations autonomously</li><li><strong>Agentic investigations</strong> — it doesn’t just answer questions, it goes and finds answers using your actual data</li><li><strong>Ask high-level questions</strong> — “Is our error rate trending worse than last week?” becomes a simple prompt</li><li><strong>Fully customizable</strong> via <strong>Skills (now GA)</strong> — create documents that give Assistant agents instructions, context, and specialized knowledge about your team’s workflows. Write runbooks, connect to third-party tools, auto-approve tool calls, and set up auto-remediation pipelines.</li></ul><p>Beyond the core assistant, Grafana also shipped <strong>Assistant Automations</strong> — which can generate regular summaries of activity in your instance so nothing falls through the cracks. And they’ve expanded <em>where</em> you can access it: <strong>Slack, Microsoft Teams, API, or CLI</strong>. There’s also a hosted remote <strong>MCP server</strong> and the new <strong>GCX CLI</strong> (more on that below) so your agents can talk to Grafana programmatically.</p><p>For anyone who’s ever been the on-call engineer staring at a wall of metrics at midnight, this is the feature that fundamentally changes that experience. <strong>Grafana Assistant is how observability becomes actionable.</strong></p><h3>👁️ AI Observability: Track What Your AI Actually Costs (and Does)</h3><p>This was the deepest, most technically dense section of the keynote — and the one I found most fascinating.</p><p>Grafana introduced <strong>AI Observability</strong> (currently in public preview for Grafana Cloud), billed as <em>“visibility for teams building modern agentic apps.”</em> Interestingly, it started as an <strong>internal hackathon project</strong> to improve how Grafana monitors its own Grafana Assistant. They built it for themselves, it worked brilliantly, and now they’re sharing it with the community.</p><p>Here’s the core problem it solves: as organizations start building AI-powered features and agents, they quickly lose track of what those agents are actually doing, how much they cost, and whether they’re working correctly. Token counts spiral. Costs balloon. You have no idea which agent is the culprit.</p><p>AI Observability brings the same rigor Grafana applies to infrastructure metrics to your LLM workloads.</p><p>What impressed me most wasn’t just the dashboards — it was the realization that AI workloads introduce a completely new operational challenge. For years we’ve monitored CPU, memory, latency, and error rates. Now engineering teams must also monitor prompts, conversations, tokens, costs, and agent behavior. AI Observability feels like the natural evolution of observability for the next generation of applications.</p><h3>Insights Dashboard — The Numbers Are Wild</h3><p>The live demo showed a real production environment with:</p><ul><li><strong>2.77 Billion total tokens</strong> processed</li><li><strong>398 Million input tokens</strong>, <strong>61.5 Million output tokens</strong>, <strong>1.67 Billion cache-read tokens</strong></li><li><strong>80.7% cache hit rate</strong></li><li><strong>Estimated cost: $4.21K</strong>, avg cost per conversation: <strong>$2.66</strong>, avg cost per call: <strong>$0.0566</strong></li></ul><p>These numbers are broken down <strong>by agent</strong>, <strong>by model</strong>, and <strong>by token type</strong>. The built-in AI analysis even flagged automatically: <em>“investigation_prometheus_specialist consumes 834.6M tokens (30% of total); verify cache strategy is optimal.”</em> That’s the kind of actionable insight that can meaningfully reduce your LLM bill.</p><h3>Conversations: A New First-Class Telemetry Primitive</h3><p>The <strong>Conversations</strong> view is genuinely novel thinking. Every LLM interaction is elevated to a first-class observable primitive — you can drill into any conversation and see which models were called (the demo showed claude-haiku-4-5 and claude-sonnet-4-6 being used together), exact token counts, latency, and cost. You can even view the tokenized input/output and catch discrepancies — the demo flagged a &quot;164x logging discrepancy in metrics collection.&quot;</p><p>This is what debugging AI in production actually looks like.</p><h3>Agents: System Prompt Analysis Against Real Data</h3><p>The <strong>Agents</strong> view analyzes your agents’ system prompts against real conversation data and scores them — the demo showed a <strong>7/10</strong> rating with concrete strengths and improvement areas. This closes the loop on AI development: ship an agent, see how it actually performs, get actionable feedback.</p><h3>Evaluations: Quality Gates for Your AI</h3><p>Set up LLM judges to continuously monitor agent quality. The demo showed an evaluator called assistant.prompt_injection_attempt — a security-focused scanner for prompt injection attacks in live conversations. You can build evaluators using LLM judges, regex, JSON schema, or custom heuristics, then wire them into Grafana alerting rules.</p><p>This is how you build AI features responsibly: with quality gates that catch regressions before your users do.</p><h3>🏗️ Loki: A Major Architecture Overhaul</h3><p>Having worked with distributed systems and production support, I know how critical logs become during incident investigations. Some of the most frustrating situations occur when you’re searching through massive volumes of logs trying to isolate a single failing request or user journey. Seeing Grafana continue investing heavily in Loki was particularly exciting because logging remains one of the most important pillars of observability.</p><p>Grafana’s logging stack got the most significant architectural investment it’s seen in years — and the numbers back it up.</p><p>The rise of structured logs and OpenTelemetry has fundamentally shifted how teams use Loki, moving from simple text search toward more analytical, high-cardinality queries. To accommodate this, Grafana shipped two foundational changes:</p><ul><li><strong>Kafka-backed ingestion</strong> — more efficient, durable pipelines at the ingestion layer</li><li><strong>Redesigned query engine and scheduler</strong> — built to handle large-scale analytical workloads</li></ul><p>Together, these deliver up to <strong>20x less data scanned</strong> and <strong>10x faster performance</strong> on aggregated queries. That’s not a minor improvement — that’s a different tier of capability.</p><p>And Grafana didn’t stop there. They also announced the <strong>acquisition of Logline</strong>, a startup specializing in “needle-in-the-haystack” log queries — finding a specific user ID or error string across truly massive datasets. This is one of the most common and frustrating use cases in log analysis, and Logline’s technology introduces a new indexing approach specifically designed for it.</p><p>The columnar storage improvements shown at the local event tie directly into all of this — Loki is being rebuilt for the analytical query patterns that modern observability demands.</p><p>Another recurring theme throughout the event was Grafana’s continued investment in OpenTelemetry. As observability expands across metrics, logs, traces, profiles, and AI workloads, OpenTelemetry is increasingly becoming the foundation that connects everything together.</p><h3>🔄 Git Sync: Dashboard-as-Code, Finally Done Right</h3><p><strong>Git Sync</strong> (generally available for Enterprise, Cloud, and OSS) lets you manage dashboards like code — with a real GitOps workflow:</p><ol><li>Save your dashboard in dev on a branch</li><li>Open a PR and merge</li><li>Changes automatically propagate to staging and prod Grafana environments</li></ol><p>What stood out to me during the demo was seeing dashboard changes flow through a familiar software development process. Changes could be committed to a branch, reviewed through a pull request, merged, and then automatically reflected inside Grafana. For organizations practicing GitOps, this finally brings observability assets into the same governance model as application code.</p><p>This solves one of the most painful problems in mature Grafana deployments: <em>dashboard drift</em>. No more undocumented prod edits, no more “who changed this and why?” The lock icon on the prod path in the demo made the intent clear — production changes go through the PR process, full stop.</p><h3>📊 New Visualizations Worth Getting Excited About</h3><h3>Dynamic Dashboards (GA)</h3><p>Interactive, responsive dashboards with proper tab navigation (Executive / Sales / Marketing / Engineering views), persistent filter bars, and live KPI tiles. These feel like real business intelligence products.</p><h3>Gauge Panel Update</h3><p>Three new styles: a classic speedometer, a segmented ring with multi-color status segments, and a smooth arc gauge with a live sparkline embedded inside. Genuinely beautiful, executive-dashboard-ready.</p><h3>Annotation, Clarified!</h3><p>Multi-row annotations, annotation clustering, and show/hide lines — available for Enterprise, Cloud, and OSS. Dense annotation data is now actually readable.</p><h3>Graphviz Panel (Private Preview — Enterprise only)</h3><p>Define flowcharts and diagrams as code using Graphviz DOT language, connected to live Grafana metrics. The demo showed live data bindings, color overrides, and interactive hover/click handlers. For teams visualizing system topology alongside performance data, this is a game-changer.</p><h3>Suggested Dashboards (Grafana 13)</h3><p>A new Grafana 13 feature that was also highlighted: Grafana now automatically surfaces pre-built dashboards tailored to your connected data sources, reducing the blank-canvas problem for new users and teams onboarding to observability.</p><h3>🖥️ GCX: The Official Grafana Cloud CLI</h3><p>Announced at GrafanaCON: <strong>GCX</strong> (github.com/grafana/gcx), the official Grafana Cloud CLI, optimized specifically for agents. It lets your AI agents and automation workflows talk to Grafana Cloud programmatically. Available everywhere, available now.</p><h3>📐 Grafana Advisor: New Health Check Tool</h3><p>A smaller but practical addition in Grafana 13: <strong>Grafana Advisor</strong> lets you run regular health checks on your Grafana server and get actionable recommendations for maintaining optimal performance. Think of it as a built-in best-practices scanner for your Grafana instance.</p><h3>🧪 More From the Ecosystem</h3><p>A few other announcements worth knowing about:</p><p><strong>Pyroscope 2.0</strong> — A ground-up rearchitecture of Grafana’s continuous profiling database, eliminating write-path replication and introducing stateless querying. Result: lower cost, lower complexity, and new features like generating metrics from profiles and heatmap queries.</p><p><strong>k6 2.0</strong> (upcoming) — The popular open source load testing tool is getting AI-driven testing subcommands (agent, mcp, docs, explore), a Playwright-inspired Assertions API, and a formalized extension ecosystem.</p><p><strong>Grafana Marketplace</strong> — A new marketplace making it easier for partners to sell and distribute Grafana plugins, expanding the ecosystem significantly.</p><p><strong>o11y-bench</strong> — The open benchmark for AI agents on observability tasks (grafana/o11y-bench / o11ybench.ai), built on the Harbor framework. Grafana seeded it with frontier model benchmarks and is inviting the community to run their own agent configurations and push the leaderboard.</p><h3>Final Thoughts</h3><p>GrafanaCON Local 2026 — and the main Barcelona conference behind it — felt like a genuine inflection point. Grafana has always been exceptional at visualization. What’s new is that it’s exceptional at <em>intelligence</em>: understanding what your data means, what your AI agents are costing, and helping your team act faster.</p><p>The combination of:</p><ul><li><strong>Grafana Assistant</strong> (everywhere, not just Cloud) for incident response and SRE automation</li><li><strong>AI Observability</strong> for understanding LLM cost, quality, and behavior</li><li><strong>Loki’s architectural overhaul</strong> for 10–20x performance gains</li><li><strong>Git Sync</strong> for disciplined dashboard governance</li></ul><p>…represents a platform that’s matured significantly. These aren’t features for a narrow audience — they’re solving problems every engineering team at scale is grappling with right now.</p><p>The biggest takeaway for me was that observability is no longer just about understanding systems. It’s about understanding intelligence.</p><p>Whether it’s infrastructure, applications, AI agents, conversations, costs, or user experiences, engineering teams need visibility across every layer of the stack. Grafana appears to be building exactly that future — and after attending GrafanaCON Local 2026, I’m excited to see where it goes next.</p><p>#Grafana #Observability #AI #SoftwareEngineering</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=362bf6e45c17" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Everyone Told Me to Grind LeetCode. The Interview Had No LeetCode.]]></title>
            <link>https://medium.com/@shrutiakkala/everyone-told-me-to-grind-leetcode-the-interview-had-no-leetcode-af5b32539d15?source=rss-8dd6cdccf322------2</link>
            <guid isPermaLink="false">https://medium.com/p/af5b32539d15</guid>
            <dc:creator><![CDATA[Shruti]]></dc:creator>
            <pubDate>Wed, 22 Apr 2026 00:13:57 GMT</pubDate>
            <atom:updated>2026-04-22T00:13:57.655Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KX7BRh0AQCgI5PA1LQ70Ug.png" /></figure><p><em>A story about over-preparing the wrong way, freezing under pressure, and the one thing I wish I’d done when my mind went blank.</em></p><p>I had done everything everyone tells you to do.</p><p>Revised every concept. Wrote code every day. Watched tutorials. Read documentation. By the time the interview came around, I felt like I had earned it on paper.</p><p>What I hadn’t prepared for was myself.</p><h3>The Setup</h3><p>This was my first interview in years.</p><p>Not months. Years. And I think I underestimated what that meant — not technically, but mentally. There’s a version of nerves that sharpens you, that puts you in flow. And then there’s the other kind. The kind that sits on your chest the moment you wake up that morning. The kind that makes you second-guess every answer before you’ve even given it.</p><p>I had the second kind.</p><p>The role was at a well-known company — an established name in the B2B space, not the kind of flashy startup that dominates tech Twitter. The interview format was different from anything I had specifically prepared for: a <strong>project-based, application development round</strong>. Not LeetCode. Not “reverse this linked list.” They gave me a real-world scenario and asked me to build.</p><p>Which, honestly, should have been more comfortable than algorithm puzzles. I build things. That’s what I do.</p><p>But comfort and panic don’t coexist well.</p><h3>The Interview</h3><p>I froze.</p><p>Not immediately — it crept in. The first few minutes were okay. And then the weight of everything hit at once: <em>this is my first interview in years, I really need this to go well, what if I can’t do this, why am I hesitating, I should know this —</em></p><p>And just like that, I was in my head instead of in the problem.</p><p>The technical knowledge was there. I had put in the work. But stress has this way of making everything you know feel suddenly inaccessible, like it’s behind a door you can’t find the handle for. I kept reaching and coming back empty.</p><p>I stumbled through parts I genuinely knew. I went quiet when I should have been talking. And I left the interview knowing it hadn’t gone the way it could have — not because I wasn’t capable, but because I let the pressure take over.</p><h3>What I Got Wrong</h3><p><strong>Mistake #1: I prepared for the interview everyone talks about, not the one I was actually in.</strong></p><p>Almost every prep resource, every YouTube video, every Reddit thread is built around LeetCode-style interviews. Algorithms, data structures, time complexity. And for good reason — that <em>is</em> the most common format. But project-based and application development interviews exist, and they test something different: not whether you can solve a puzzle, but whether you can think through a real system under real conditions.</p><p>I had sharpened one kind of thinking and walked into a round that needed another.</p><p><strong>Mistake #2: I let the pressure become the main character.</strong></p><p>Because this was my first interview after a long gap, I had loaded it with too much meaning. Every pause felt catastrophic. Every moment of hesitation felt like confirmation of something I was afraid of. The pressure I put on myself didn’t motivate me — it paralyzed me.</p><p><strong>Mistake #3: When I blanked, I went silent instead of thinking out loud.</strong></p><p>This is the one I keep coming back to, because it’s also the most fixable.</p><p>When you’re in a project-based or application development interview and your mind goes blank — and it might, even when you know your stuff — going silent is the worst thing you can do. Not because it’s rude, but because it cuts you off from everything that could help you move forward.</p><p>What I should have done, even mid-blank, was just start narrating.</p><p><em>“Okay — this method probably belongs in the service layer, in the ServiceImpl. From there I’d want to think about what the controller needs to pass in. For test cases, I’d start with the happy path, then think about what breaks it — null inputs, edge cases, boundary values. Let me write a rough pseudo code first before I touch the actual implementation…”</em></p><p>That’s it. That’s all it would have taken.</p><h3>Why Talking Through It Actually Matters</h3><p>This wasn’t just a regular coding interview. It was <strong>pair programming</strong> — which is exactly how teams working in a TDD approach actually operate day-to-day. The interviewer wasn’t waiting for a perfect, polished solution delivered in silence. They were watching how I think, how I collaborate, how I move through uncertainty.</p><p>That’s the whole point.</p><p>In a real TDD team, nobody sits in silence when they’re stuck. You talk to your pair. You say “I’m thinking the logic goes here, does that make sense to you?” You write a failing test first and let it guide you. The conversation is the work.</p><p>By going quiet, I accidentally demonstrated the opposite of what they were looking for.</p><p>Even a pseudo-code walkthrough — rough, incomplete, thinking-out-loud — would have shown the interviewer that I understood the structure of the problem. It would have opened the door for them to ask questions, offer nudges, or redirect me. It would have turned a frozen moment into a conversation.</p><p>And a conversation was exactly what the interview was designed to be.</p><h3>What I Do Differently Now</h3><p><strong>For project-based interviews specifically:</strong></p><p>Before I write a single line of code, I narrate the structure. Where does this method live — controller, service, repository? What are the inputs and outputs? What test cases should I cover before I write the implementation? What does the pseudo-code look like?</p><p>This isn’t stalling. This is the job. Architects think before they build. TDD practitioners write the test before they write the code. Talking through structure first is a signal of experience, not a sign of hesitation.</p><p><strong>When I blank, I speak the blank out loud.</strong></p><p>“I’m going to think through the flow first” is a complete sentence. It buys you time. It keeps the interviewer in the loop. It gives your brain something to do other than panic. Nine times out of ten, the act of talking through where you are unsticks whatever was stuck.</p><p><strong>I practice under pressure, not just in comfort.</strong></p><p>Most of my prep had been done alone, unhurried, with no one watching. That’s useful for building knowledge. It’s not enough for building the skill of performing under stress. Now I do mock interviews, I set timers, I practice talking through problems out loud even when I feel silly doing it. The goal isn’t to eliminate nerves — it’s to make sure my knowledge stays accessible when they show up.</p><h3>Where I Am Now</h3><p>That interview stung for a while. The gap-after-years pressure, the format I hadn’t specifically prepared for, the freeze — it was a lot hitting at once.</p><p>But looking back, the failure wasn’t in my preparation. It was in my silence.</p><p>I knew more than I showed. And the lesson I took from that is: <strong>in a collaborative interview, showing your thinking is the preparation.</strong> Not just what you know, but how you communicate it when it’s hard.</p><p>That’s a skill. It can be practiced. I’m practicing it.</p><p><em>If you’ve ever frozen in an interview you were technically ready for, you’re not alone — and it’s more fixable than it feels in the moment. Next time: just start talking.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=af5b32539d15" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Knowing About Concurrency vs. Actually Knowing Concurrency — I Learned the Hard Way]]></title>
            <link>https://medium.com/@shrutiakkala/knowing-about-concurrency-vs-actually-knowing-concurrency-i-learned-the-hard-way-c8aa9250ca66?source=rss-8dd6cdccf322------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8aa9250ca66</guid>
            <dc:creator><![CDATA[Shruti]]></dc:creator>
            <pubDate>Tue, 21 Apr 2026 23:53:15 GMT</pubDate>
            <atom:updated>2026-04-21T23:53:15.838Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mJc_f_9-XLjP4jCs0WAYQQ.png" /></figure><p><em>A story about knowing the theory, missing the practice, and what I do differently now.</em></p><p>I did everything “right” before that interview.</p><p>I checked Glassdoor. I read every review I could find for the role. I took notes. Multiple people mentioned the same thing: <strong>concurrency and multithreading come up a lot</strong>. So I nodded, pulled up a few articles, watched a couple of YouTube videos on thread safety and locks, and told myself: <em>I’ve got this covered.</em></p><p>I did not have it covered.</p><h3>The Setup</h3><p>This was a backend engineering role at a product company — one of those infrastructure-layer names that’s everywhere in developer stacks but rarely makes headlines. I won’t name them here, not because I’m bitter (genuinely, I’m not), but because this story isn’t about them. It’s about me.</p><p>The recruiter call was smooth. I felt confident. I had my LeetCode streak going, I had theory in my back pocket, and I had Glassdoor receipts telling me what to expect.</p><p>What I didn’t have was a single line of written concurrency code that I had typed with my own hands.</p><h3>The Interview</h3><p>The question wasn’t from a LeetCode tag I had filtered for. It wasn’t a “which of these is thread-safe?” multiple choice. It was something every backend system does quietly in production — the kind of resilience logic that kicks in when things go wrong and your system needs to decide how to recover gracefully. The kind of thing you’d never think twice about until someone asks you to build it from scratch, with concurrency baked in, in real time.</p><p>My brain immediately did that thing where it tries to recall information it only ever read, never practiced. I could narrate the concepts back to you. I could describe what a mutex does. I could tell you <em>about</em> the producer-consumer problem.</p><p>But writing it? In the moment? That gap between “I know this exists” and “I can build this right now” had never felt so wide.</p><p>I stumbled. I recovered partially. But it wasn’t the interview I’d prepared for, because I had only prepared for the interview I imagined — not the one where someone hands you a blank editor and says <em>go</em>.</p><h3>What I Got Wrong</h3><p><strong>Mistake #1: I confused recognition with recall.</strong></p><p>Reading about concurrency and being able to implement concurrency are two completely different skills. Theory lives in your head. Code lives in your fingers. I had trained one and ignored the other entirely.</p><p><strong>Mistake #2: I treated Glassdoor as a syllabus.</strong></p><p>Glassdoor reviews told me <em>what</em> mattered. They did not tell me <em>how deep</em> it would go. “Concurrency is important” does not mean “brush up on the definition of a thread.” It means write code that handles race conditions. Know it cold.</p><p><strong>Mistake #3: I knew the team — and still didn’t ask the right questions.</strong></p><p>I actually had the team name. I knew enough to look them up. But I stopped there. What I didn’t do was go back to the recruiter and ask: Are<em> there any specific resources or areas you’d recommend focusing on?</em> Recruiters won’t always tell you everything, but they’ll often give you enough of a nudge to aim your prep in the right direction. A five-minute follow-up email could have saved me a lot of guessing.</p><h3>What It Taught Me</h3><p>I walked out of that interview feeling the specific frustration of someone who <em>studied</em> but <em>didn’t prepare</em>. Those aren’t the same thing.</p><p>Studying is passive. Preparing is active.</p><p>From that day forward, I changed a few things:</p><p><strong>1. I ask recruiters for specific resources, not just role details.</strong> I had the team name. That wasn’t the missing piece. What I should have done is follow up and ask: <em>Is there anything specific you’d recommend I brush up on? Any areas the team cares about deeply?</em> You won’t always get a direct answer, but you’d be surprised how often a recruiter will point you somewhere useful if you just ask.</p><p><strong>2. I code the concepts, not just read them.</strong> For every topic I flag as “important,” I now have a self-imposed rule: I have to write at least one implementation from scratch before I consider myself prepared. Not copy-paste. Do not run someone else’s example. Write it. Break it. Fix it.</p><p><strong>3. I finally stopped skipping concurrency in my prep — and I think you should too.</strong> This is the one I want to sit on for a second, because I think a lot of engineers are in the same spot I was.</p><p>Most of us don’t use concurrency heavily at work. Day-to-day, our jobs don’t demand that we write thread-safe queues or reason carefully about lock ordering. So it quietly drops off the prep list. It feels like an edge case. Something “advanced.” Something you’ll get to later.</p><p>But “later” doesn’t come until an interview forces it — and by then, you’re trying to learn it under pressure.</p><p>Concurrency is one of those topics that genuinely requires dedicated time to build intuition. Not a weekend skim. Real, hands-on time writing implementations, breaking them, and understanding why they break. I’d spent years treating it as optional background knowledge. I’m treating it as a core skill now, and it’s made a real difference in how confidently I can reason about system problems.</p><p>If you’re preparing for backend or distributed systems roles, don’t let concurrency be the thing you “kind of know.” Put it on the list early. Give it real time.</p><p><strong>4. I share resources with other people preparing for similar roles.</strong> Teaching something is the fastest way to find the holes in your own understanding. When I explain thread safety to someone else, I find out exactly where my mental model falls apart.</p><h3>Where I Am Now</h3><p>I’ve since built out a real practice set around concurrency: producer-consumer queues, thread-safe caches, simple lock implementations, and semaphore problems. Not because I’m obsessed with getting that specific interview right — that ship has sailed — but because I genuinely understand now that this is a real skill used in real systems, and I want to actually have it.</p><p>The rejection email was polite. I appreciated that. And honestly, I appreciate the interview itself more now than I did when I left it.</p><p>It gave me a very specific, undeniable data point: <strong>there’s a version of “knowing” something that will completely abandon you when the stakes are real.</strong></p><p>I don’t want that version anymore.</p><p><em>If you’re preparing for backend or systems roles and want to compare notes on concurrency resources, feel free to reach out. I’m putting together a list of the questions and implementations that actually helped me build the real skill — not just the feeling of it.</em></p><p>#SoftwareEngineering #InterviewPrep #Concurrency #Backend #Learning</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8aa9250ca66" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>