<?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 Ayusch Jain on Medium]]></title>
        <description><![CDATA[Stories by Ayusch Jain on Medium]]></description>
        <link>https://medium.com/@jain.ayusch10?source=rss-6052b8a06387------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*YsJXxGqyzvT4Bmew-0yMpg.png</url>
            <title>Stories by Ayusch Jain on Medium</title>
            <link>https://medium.com/@jain.ayusch10?source=rss-6052b8a06387------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 01:41:58 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jain.ayusch10/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[My Engineering Job Has Changed FOREVER— Personal Anecdotes + Thoughts]]></title>
            <link>https://levelup.gitconnected.com/my-engineering-job-has-changed-forever-personal-anecdotes-thoughts-01f1e33b60fe?source=rss-6052b8a06387------2</link>
            <guid isPermaLink="false">https://medium.com/p/01f1e33b60fe</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[business]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Ayusch Jain]]></dc:creator>
            <pubDate>Fri, 10 Jul 2026 16:19:18 GMT</pubDate>
            <atom:updated>2026-07-10T16:19:18.085Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>Three years ago I was writing every line by hand. Today, I’m mostly reviewing code I didn’t write. Here’s what actually changed — and what it means for how you grow.</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2vGRH8mLVhAKNQPZMNoLfg.png" /></figure><p>Two years ago I would have laughed at anyone who told me I’d spend less time writing Kotlin than I spend thinking about process design, <a href="https://www.mockingly.ai/">system design</a>.</p><p>I was a solid Android engineer. I wrote clean code, knew my Jetpack Compose patterns, could navigate the dark corners of the Android lifecycle without flinching.</p><p>My career was built on the craft. The RFCs I wrote for a complex sync architecture. The three days I spent debugging why a touch didn’t propagate from child view to parent. The six hours I spent getting pagination exactly right.</p><p>That version of my job is mostly gone now.</p><p>Not because I got worse at the craft. But because AI got good enough to handle the craft — and what companies need from senior engineers is something entirely different.</p><p>This isn’t a “AI is coming for your job” post. That framing is wrong, and frankly lazy. What actually happened is more interesting and more nuanced than that.</p><p>This is what changed for me, specifically, as an Android engineer at a tech company. And what I think it means for you.</p><h3>What My Day Used to Look Like</h3><p>Before AI tools became genuinely useful — I’m talking pre-2024, when AIs were still mostly autocomplete — my work was roughly what you’d expect from a senior mobile engineer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E7caHRP1CpSGOzUX4t2Ydg.png" /></figure><p>Writing code was the bulk of it. Feature after feature. I’d get a Jira ticket, translate it into a technical plan, then spend the next few days in Android Studio writing the implementation. <strong>Kotlin files, ViewModels, repositories, API calls, UI layer, unit tests. All by hand.</strong></p><p>The other big chunk was documentation. RFCs.</p><p><strong>Every non-trivial feature required one. You wrote it, you sent it to senior engineers and tech leads for review, you addressed comments, you iterated.</strong></p><p>An RFC for a complex background sync feature might take three or four days to get right. Then there were architectural decision records (ADRs) — documenting why you chose internal memory over persistent, why you picked WorkManager, why the offline-first cache was structured the way it was.</p><p>Then there was actual code review. Reviewing other engineers’ PRs. Line by line. Catching logic errors, naming issues, thread-safety problems, memory leaks they’d missed.</p><blockquote><strong>Promotions at companies were largely a function of your architectural track record.</strong></blockquote><p>Had you owned a major feature end to end? Had you written an RFC that got adopted? Had your design decisions held up six months later? Those were the conversations in promotion meetings.</p><p>It was a job built around production. Around doing.</p><h3>What My Day Looks Like Now</h3><p>SO much has changed since AI. I’d say the turning point was Opus 4.6. It wasn’t amazing, but it was GOOD ENOUGH. And that was enough.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*etsEivkueRCgzn1EsPfY8g.png" /></figure><p><strong>Now my days are spent</strong></p><ul><li><strong>Strategizing what to work on next</strong></li><li><strong>Prompting claude code</strong></li><li><strong>Verifying it’s changes</strong></li><li><strong>Testing (it’s a big one)</strong></li><li><strong>Pushing to production.</strong></li></ul><p>The honest version: writing code is now a small fraction of what I do. Because I’m delegating to AI.</p><p>I open a ticket. I describe the problem, the constraints, the existing patterns in the codebase. I run Claude or Cursor or Gemini in Android Studio. In a few minutes, I have a working first draft of the implementation — the ViewModel, the repository layer, the composables, the tests. It’s not always exactly right. But it’s 70–80% of the way there, and the remaining 20% is the part that actually requires engineering judgment and more commonly, prompting further.</p><blockquote>That’s now where I spend my time. <strong>The edge cases</strong>. The threading issues the AI didn’t account for. The business logic that wasn’t described clearly in the ticket and needed a conversation with the product manager.</blockquote><p>The place where the AI confidently produced something that works in isolation but would have caused a race condition in production.</p><p>The other chunk of my time is genuinely different from anything I did three years ago.</p><p>I spend time on <strong>technical strategy</strong>. Not writing strategy documents — thinking through them.</p><ul><li>Which areas of our Android codebase are slowing the team down?</li><li>What’s the right architecture for a new surface we’re building?</li><li>How do we want to handle offline sync across our app, not just in one feature?</li></ul><p>These questions used to get thirty minutes of my time because the writing and implementation consumed everything else. Now they get hours.</p><p>And I spend more time on <strong>cross-team collaboration</strong> than I ever did before.</p><p>This one surprised me. When you’re not buried in implementation, you have time to actually talk to people. Product, design, the backend team, data.</p><p>I’m involved in conversations I would have historically been too busy to show up to.</p><h3>PROMOTIONS: What Actually Changed</h3><p>This is the part nobody talks about honestly.</p><p><strong>Before AI:</strong> promotions were decided on your track record of architectural decisions. Had you designed systems that scaled? Had your technical judgment proven correct? Had you owned a major piece of infrastructure? End to end delivery, cross team impact, RFO, Observability, Monitoring, Mentoring.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AjQLEqaQ7UTUfrHwf2pHfA.png" /></figure><p>That still matters. But it’s no longer the primary signal.</p><p>What I see evaluated now:</p><p><strong>How well you manage, create AI workflows.</strong> Can you take a complex feature and decompose it into tasks that AI can execute reliably? If it’s repetitive, can you create workflows so AI can do it better ?</p><p>Can you build prompts that produce consistent, high-quality output? Can you review AI-generated code quickly and accurately, catching the subtle errors? This is a genuine skill as the MRs have gotten HUGE.</p><p><strong>Whether you’ve made the team measurably faster.</strong> The companies that are winning right now are the ones that have turned AI from a personal productivity tool into a team-wide system.</p><p>The senior engineers who figured this out — who built the reusable workflows, the team-specific AI configurations, the documentation patterns that made AI output more accurate — those engineers are getting noticed.</p><p><strong>The scope of what you can deliver.</strong> AI means one senior engineer can drive projects that previously needed three engineers. The question in promotion discussions is now: what did you <em>ship</em>, and how big was it? Not how well did you implement it.</p><p><strong>Collaboration still counts exactly as much as it ever did.</strong> Nothing has changed here. The engineers who work in silos still plateau.</p><p>What has genuinely faded: pure writing volume as a signal. The engineer who wrote the most PRs, the most RFCs, the most detailed architectural documents — that proxy for productivity doesn’t hold the way it did. When everyone can produce documentation quickly, volume is no longer the differentiator.</p><h3>The Skills That Actually Matter Now</h3><p>Here is what I actually see making a difference:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y7aC9OtVnHtLYJYNCVE4aQ.png" /><figcaption><a href="https://www.mockingly.ai/">mockingly.ai</a></figcaption></figure><p><a href="https://www.mockingly.ai/"><strong>System design</strong></a><strong> and architectural thinking.</strong> This matters more than it ever has, not less. Because AI can write the code, the question becomes: what should the code do, and why?</p><p>The engineers who understand systems deeply — who can reason about trade-offs, who know when to use an event-driven architecture vs. a simple synchronous call, who understand why the Android lifecycle creates specific constraints — those engineers are the ones directing the AI correctly. The engineers who don’t have this foundation are producing fast, confident, wrong code.</p><p>If you’re an Android engineer and you haven’t built a strong mental model for Android system design, this is the highest-leverage thing you can work on. Use <a href="https://www.mockingly.ai/">mockingly</a>, the platform is designed to build exactly the kind of architectural reasoning that AI amplifies when you have it and exposes when you don’t.</p><p><strong>The </strong><a href="https://www.mockingly.ai/blog/complete-android-system-design-interview-framework"><strong>Android system design interview framework</strong></a><strong> is a good starting point for structuring how you think about these problems.</strong></p><p><strong>Judgment about AI output.</strong> This is not a soft skill. It’s a hard one that takes practice. When you read AI-generated code, you need to know — fast — whether it’s right, and where the subtle errors are.</p><p>Thread safety, memory management, lifecycle awareness on Android, edge cases in business logic. The engineers who can review AI output at speed are worth significantly more than the engineers who can’t.</p><p><strong>Prompt and context design.</strong> This sounds like a buzzword, but what it means in practice is: can you describe a problem accurately enough that AI produces something useful?</p><p>This requires knowing your codebase deeply, knowing how to write precise requirements, and knowing what constraints matter. It’s actually a form of communication skill — the same thing that made senior engineers good at writing RFCs.</p><blockquote><strong>Knowing when to not use AI.</strong> This is underrated. There are classes of problems where AI output is genuinely unreliable — novel architecture decisions, complex performance debugging, nuanced security considerations. The engineers who know when to put the AI down and reason from first principles are the ones who catch the expensive mistakes.</blockquote><h3>What This Means If You’re Early in Your Career</h3><p>I want to be direct about this, because the discourse around it is either too optimistic or too doomery.</p><p>The entry-level market is harder right now. The kinds of tasks that used to be how junior engineers learned — isolated, well-specified implementation tasks, simple features, basic CRUD screens — are now largely handled by AI.</p><p>Junior developers aged 22 to 25 saw nearly a 20% drop in employment from late 2022 to mid-2025. Entry-level job postings have declined.</p><p>That’s real, and it’s not going away.</p><p><strong>But here is what I’d tell a junior engineer:</strong> the path is not to compete with AI on implementation speed. You will lose. The path is to become the engineer who understands <em>why</em> a system is built the way it is. Who can look at AI output and know what it missed. Who builds the judgment layer faster than their peers.</p><p><strong>The engineers I see thriving early in their careers right now are the ones who are using AI to learn faster, not to think less.</strong> They run the AI-generated code, they understand it, they break it, they improve it. They are developing intuitions rapidly because they can see orders of magnitude more code than junior engineers could three years ago.</p><p>The ones who are struggling are using AI as a crutch. They don’t know why the code works. When something goes wrong, they prompt their way into a deeper hole.</p><p>The gap between those two groups is going to compound.</p><p>I’ve mentored engineers who’ve picked up Android Development and contributed to production within a couple of weeks rather than Months that it used to take.</p><h3>What This Means If You’re Senior</h3><blockquote>Demand for experienced engineers has held steady or increased.</blockquote><p>Job openings requiring six or more years of experience increased 26% in 2026. The value of senior engineers has shifted from coding output to architectural judgment, system thinking, and the ability to oversee and direct AI output.</p><p>But here’s the part that I don’t think senior engineers are hearing clearly enough: you have to actually engage with the tools.</p><p>I know senior engineers who are sitting this out. Who are still writing everything by hand because <strong>“I prefer to understand what I’m shipping.” </strong>Who are skeptical of AI-generated code for valid reasons that have quietly become rationalizations for not changing.</p><p><strong>Those engineers are going to find the gap between them and their peers widening faster than they expect.</strong></p><p>The engineers who are thriving are the ones who have built repeatable workflows. Who have a set of prompts they trust. Who know how to decompose problems for AI, review the output at speed, and maintain the architectural coherence of a codebase that’s now being written by a mix of humans and models.</p><h3>The Thing Nobody Warned Me About</h3><p>The hardest part wasn’t learning the tools. The tools are learnable.</p><p>The hardest part was the identity shift.</p><p>I had spent years building an identity as an engineer who was good at the craft. Who wrote clean, well-reasoned Kotlin. Who could hold a complex system in my head and implement it correctly. That was the thing I was proud of. The thing I got credit for in performance reviews.</p><p>When AI started doing that — reliably, quickly, often better than I could in a first pass — it was genuinely disorienting. What am I for, if not this?</p><p>What I’m <em>for</em>, it turns out, is the judgment about what to build and why. The conversations where we decide what a system should do. The review that catches what AI missed. The strategy that makes a whole team faster. The cross-team collaboration that means we’re building the right thing in the first place.</p><p>That’s actually a better job. More interesting. More impactful. I have more influence over the direction of my team’s technical work than I ever did when I was buried in implementation.</p><p>But it required genuinely letting go of something I’d built my identity around. I don’t think enough people are having that conversation.</p><h3>The New Bar</h3><blockquote>Three years ago, the bar for a senior Android engineer was: can you design and implement complex systems correctly?</blockquote><p>That bar still exists. But the bar has moved up.</p><p><strong>Now the question is:</strong> given that you can produce an implementation quickly, can you think at the level above that? Can you decide what to build? Can you manage the process of building it? Can you direct AI output at scale, catch its failures, and maintain the coherence of a codebase written by many hands — human and model?</p><p>The engineers who answer yes to that are more valuable than any senior engineer I knew in 2022.</p><p>The engineers who answer no — who are still trying to compete on raw implementation speed — are going to find the next few years increasingly difficult.</p><p>The bar has moved. The question is whether you move with it.</p><h3>🔥 Resources</h3><ul><li><strong>Practice system design thinking:</strong> <a href="https://www.mockingly.ai/">Mockingly.ai</a> — AI-powered mock interviews that build the architectural reasoning that matters most in today’s engineering landscape.</li><li><strong>Android system design questions worth practicing:</strong> <a href="https://www.mockingly.ai/blog/android-system-design-practice-questions">Android system design practice questions</a> — the problems that sharpen the judgment AI can’t replace.</li><li><strong>The framework for thinking about Android architecture:</strong> <a href="https://www.mockingly.ai/blog/complete-android-system-design-interview-framework">Complete Android system design interview framework</a></li><li><strong>The Pragmatic Engineer on AI impact in 2026:</strong> <a href="https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026">newsletter.pragmaticengineer.com</a></li><li>Data: <a href="https://www.finalroundai.com/blog/entry-level-jobs-disappearing-fast-because-of-ai">9 Entry-Level Jobs Are Disappearing Fast Because of AI</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=01f1e33b60fe" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/my-engineering-job-has-changed-forever-personal-anecdotes-thoughts-01f1e33b60fe">My Engineering Job Has Changed FOREVER— Personal Anecdotes + Thoughts</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Finally Understood System Design Interviews]]></title>
            <link>https://aws.plainenglish.io/how-i-finally-understood-system-design-interviews-814c792ac1cc?source=rss-6052b8a06387------2</link>
            <guid isPermaLink="false">https://medium.com/p/814c792ac1cc</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[careers]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Ayusch Jain]]></dc:creator>
            <pubDate>Tue, 09 Jun 2026 16:21:46 GMT</pubDate>
            <atom:updated>2026-06-09T20:40:09.317Z</atom:updated>
            <content:encoded><![CDATA[<p>A personal journey to understanding what System Design is about, thinking like an architect and cracking the (Android) system design interview. This will also resonate with you even if you’re a backend engineer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lfw22vYBW-NL4XnRtwwZqQ.png" /><figcaption>Gemini Generated: <a href="https://www.mockingly.ai/?ref=medjourney">system design interview practice</a></figcaption></figure><p>I’ll be honest, I’ve struggled with System Design since the day I started as a software engineer.</p><p>I’m someone who learns by doing, I can’t really memorise theory, but to be honest, you rarely get to design a system from scratch, especially if you’re working at a large corporation, and ESPECIALLY if you’re talking about <a href="https://www.mockingly.ai/?ref=medjourney"><strong>Android System Design</strong></a>.</p><p>But system design is one of the most important rounds and in many cases, decides what level you’ll be at. Ultimately deciding how much you get paid $$$ 🤑.</p><p>So 1 month before the interviews, I started memorising system design. Memorising talking points, patterns, knowledge about some Trivias like <strong>http vs https</strong> etc.</p><p>And I failed. <strong>MISERABLY!!</strong></p><h3><strong>When I BOMBED A Great Opportunity</strong></h3><p>My first real wake up call was when I bombed the android system design round at Meta where I was asked to design a chat app but only for images, videos.</p><p>Even though I had memorised “Designing a <a href="https://www.mockingly.ai/blog/chat-system-design"><strong>Chat App</strong></a> like Whatsapp”, I FROZE. I couldn’t talk about the building blocks, couldn’t do deep-dives, it was really embarrassing and those 45-minutes couldn’t end sooner.</p><p>I had cleared the coding rounds, but bombed system design. And so missed out on this great opportunity.</p><h3><strong>Then I Knew I Had To Fix This</strong></h3><p>I realised I couldn’t just memorise my way out of these interviews, I needed to change how I think about Android and Software Development in general.</p><p>And for Android System design specifically, I found these recorded <a href="https://www.youtube.com/@alementuev/videos"><strong>interview sessions by Alex Lementuev</strong></a>, really helpful. The video, audio is not the best quality, but the content is GOLD.</p><p>Secondly, to practice, I couldn’t just read and memorise and go to an interview. I needed to practice by giving mocks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c1tTraDLGO50H5H86vxjQQ.png" /><figcaption>Screenshot from a <a href="https://www.mockingly.ai/?ref=medjourney">System Design Interview practice</a></figcaption></figure><blockquote><em>Earlier you had to either pay for </em><strong><em>expensive 🤑 </em></strong><em>mocks with FAANG+ engineers, or ask a friend. But Mockingly now has </em><strong><em>on demand </em></strong><a href="https://www.mockingly.ai/?ref=medjourney"><strong><em>System Design Interview practice</em></strong></a><em>. It’s especially good for practicing Android system design interviews as it has a dedicated category for Android System Design questions. I highly recommend checking it out.</em></blockquote><h3>But I Realised I Still Didn’t Understand “System Design”</h3><p>Cracking an interview is very different from implementing/using the same system design in your work. And while I cracked the design interview at my current job, I still wasn’t good at applying it at work.</p><p>I still couldn’t think in systems. In big corps, you’re sometimes asked to review design documents or huge MRs with architectural decisions. I still couldn’t argue, for example, <strong><em>why a specific piece of code</em></strong><em>, or </em><strong><em>why a composable didn’t belong in a certain package</em></strong>. Or why we should not have a presentation package depending on another presentation package and how it breaks SOLID.</p><p>And it’s not a good place to be when you’re in a room with senior engineers and you can’t come up with any opinion. I felt a big dose of imposter syndrome.</p><p>Something had to change. While I had cracked the interview, I still didn’t develop the core skill of thinking in systems. I just had theoretical knowledge.</p><h3><strong>I Researched A Lot of Resources - These Helped Me</strong></h3><p>Lots of blog posts, repositories helped me in my journey. Talking specifically about android system design, I found one primary resource that helped me recognise patterns in these questions:</p><ol><li><a href="https://github.com/weeeBox/mobile-system-design/tree/master/exercises"><strong>WeeBox</strong></a> — a GitHub repository of some of the most asked system design questions.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z42vLm_nFqS_2V9Jru2mbg.png" /><figcaption>GitHub</figcaption></figure><p>2. <a href="https://www.mockingly.ai/blog/complete-android-system-design-interview-framework"><strong>Android system design interview framework</strong></a><strong>: Framework</strong> which can be applied for most Android system design interviews:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Tjg-oPiZqcPVrifKlM0OkA.png" /><figcaption>Screenshot from <a href="https://www.mockingly.ai/?ref=medjourney">mockingly.ai</a></figcaption></figure><p>I’m talking about Android System design here, but if you’re into Backend, then you can try out Alex Xu’s books which are supposed to be really good and recommended everywhere.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/369/0*6tePmtMPokg33zBi" /><figcaption>Alex Xu’s system design books</figcaption></figure><h3><strong>Learning Real System Design at Work</strong></h3><p>As I said, so far my knowledge was <strong>theoretical</strong>. I needed to design an actual system in order for the concepts to get ingrained in my brain. And this is something only possible on the job.</p><p>But such chances are not easy to come by, you cannot do <a href="https://www.mockingly.ai/?ref=medjourney"><strong>“system design”</strong> </a>for a mature app until it’s a greenfield project. At work, people mostly spend time building features which translates to “<strong>editing</strong>” existing code.</p><p><strong>If you get a chance, good, but if not, then you can try to do this in your day job:</strong></p><ol><li><strong>Use Design Patterns</strong>: And apply them when you’re building new features. Design patterns help you solve a problem in a more maintainable way. <strong>Eg.</strong> if you use the Repository Pattern to wrap your network calls &amp; expose an interface which clients can use to call the repository.<br>Then if tomorrow you need to switch your database provider or network client, you can do so within the repository without your clients having to know anything about it.</li><li><strong>Think about Single Responsibility Principle</strong>: The code you write must be responsible for only one single purpose. If you stick to this, then this alone will help you a lot in thinking about separation of concerns, modularity etc.</li><li><strong>Write Architectural Documents</strong>: This will also help you grow. In most companies this is something expected from senior engineers.<br>Even if you’re building a small feature (not talking about small bug fixes), write a small document around what decisions you’re making and the code that you’re editing.<br>You don’t need to include code in it, small snippets are OK. But the aim is for you to write this doc, and if possible get it reviewed by a Senior Engineer. This will help you learn when the Senior pokes holes in your solution.</li><li><strong>Stretch — Go a step further to force a system design</strong>. If you’re building a small feature which requires editing, think if it can be separated into its own package, have its own <strong>ViewModel, UseCases &amp; API call.</strong><br>You’ll be surprised to know it’s possible more frequently than you think.<br>Of course, not talking about bug fixes, but medium sized features fall into this category.</li></ol><h4>Tips:</h4><ol><li><strong>Create Stories</strong> instead of <strong>Tasks</strong> in <strong>JIRA</strong>: This gives you the ability to break down the story into multiple tickets allowing you to break it down into design problems, rather than one-off tasks.</li><li><strong>Read:</strong> Read architectural docs within your company. Look at MIRO boards (if) designed. Especially from Senior Engineers.</li><li><strong>Interview</strong>: Keep interviewing as it helps you stress test your skills under pressure. Also, keeps you updated with the current job market.</li></ol><h3><strong>Then I Gave Some Mocks Again!</strong></h3><p>With friends of course, but also with companies which I <strong>wasn’t exactly sure about.</strong></p><p>I’m sure you must’ve also felt this, but the pressure compounds when you’re interviewing for a role you <strong>desperately want</strong>. And that added pressure doesn’t help.</p><p>But when you don’t really care about the outcome, you’re much more confident interviewing. And sometimes end up performing even better!</p><p>This is especially true for System design interviews, where a lot depends on communicating your thought process. But if you’re too stressed about failing your dream company, then you will keep second guessing what you’re saying.</p><blockquote><em>So practice with friends, but you can also use this </em><a href="https://www.mockingly.ai/?ref=medjourney"><strong><em>AI Interviewer for system design practice</em></strong></a><em>. It gives you on demand practice for mock system design interviews.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fojrWowD-XGuo6KCFjWotA.png" /><figcaption>Trivia Questions From: <a href="https://www.mockingly.ai/?ref=medjourney">Mockingly’s Trivia</a></figcaption></figure><p>It also has this amazing <a href="https://www.mockingly.ai/?ref=midjourney"><strong>Quiz (Trivia)</strong></a> section which is really required for system design. It covers topics like http vs https, pagination etc. Trivias are frequently asked by interviewers while you’re talking about your design.</p><h3><strong>Getting My Confidence Back!</strong></h3><p>When I started, or “<strong>failed</strong>” I was approaching system design as an exam. Something I had to objectively pass. I tried memorising architectures, answers to common questions.</p><p>But without understanding, the moment the interviewer asked something I hadn’t memorised, I froze! And it went downhill.</p><p>I didn’t realise that <a href="https://www.mockingly.ai/?ref=medjourney">System Design interviews</a> are not Objective interviews. They’re more like discussions where the interviewer wants to know your thought process. And you can explain this only when you’ve experienced it, struggled with the problem, and not just memorised the theory.</p><p>The goal of getting better at <a href="https://www.mockingly.ai/?ref=medjourney"><strong>System Design interviews</strong></a> shouldn’t be to just pass exams. It should be to start thinking in Blocks, like a senior engineer. It should be to make you confident in your ability so you’re not terrified of this round.</p><blockquote><strong>Once you’ve been on this journey and gotten better, you’ll realise that system design interviews were never about memorising. Rather about having a conversation with a fellow engineer.</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MbO27j7gS2aOkWMPZGAu8w.png" /></figure><h3><strong>CheatSheet</strong></h3><p>For any mobile devs out there, especially android devs, I created this <a href="https://www.mockingly.ai/blog/complete-android-system-design-interview-framework">Framework for mobile system design</a>.</p><p>It covers the 2 categories of design questions that exist in Android System design. This will help you structure your thought process when you’re next appearing for the interview.</p><blockquote><strong><em>Thanks for reading. If you liked reading about my journey, clap 👏 for the article, it helps more people discover this post.</em></strong></blockquote><h4>Also check out:</h4><p>If you’re a mobile developer, you’ll find this helpful!</p><p><a href="https://medium.com/@jain.ayusch10/the-mobile-system-design-interview-my-faang-prep-journey-free-practice-resource-96afce1f9583">The Mobile System Design Interview: My FAANG Prep Journey + Free Practice Resource</a></p><h4><a href="https://www.mockingly.ai/?ref=medjourney">Practice Mock System Design Interviews with AI — Mockingly</a></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m_eS8Ywrb-WVP63_vCJizg.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=814c792ac1cc" width="1" height="1" alt=""><hr><p><a href="https://aws.plainenglish.io/how-i-finally-understood-system-design-interviews-814c792ac1cc">How I Finally Understood System Design Interviews</a> was originally published in <a href="https://aws.plainenglish.io/">AWS in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[There’s only 2 Android System Design Interview Questions  You just need a Framework for them]]></title>
            <link>https://medium.com/@jain.ayusch10/complete-android-system-design-interview-framework-8e2697886bc6?source=rss-6052b8a06387------2</link>
            <guid isPermaLink="false">https://medium.com/p/8e2697886bc6</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Ayusch Jain]]></dc:creator>
            <pubDate>Wed, 13 May 2026 15:20:25 GMT</pubDate>
            <atom:updated>2026-05-27T20:45:35.888Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ysRQ_KMCVmp6YrIKlx1AOg.png" /><figcaption>By <a href="https://www.mockingly.ai/">Mockingly.AI</a></figcaption></figure><p><strong>Android system design interviews are less about memorising components and more about showing a structured way to think.</strong></p><p>This guide gives you a repeatable framework for solving Android system design interview questions:</p><p><strong>clarifying requirements, choosing the right architecture, handling offline-first data flow, reasoning about performance and battery, and defending trade-offs.</strong></p><p>If you are preparing for <strong>FAANG</strong>-style system design interviews, this is the framework to practice and refine.</p><blockquote>For preparation, you can use tools like <a href="https://www.mockingly.ai/">Mockingly.AI</a> and Hello Interview to prepare for system design interviews and practice some AI mock interviews.</blockquote><h3>What the interviewers are looking for:</h3><p>What Android interviewers are grading you on:</p><ul><li>Can you clarify scope without getting lost in details?</li><li>Can you design the app/library in layers instead of drawing random boxes?</li><li>Can you explain trade-offs clearly? Important “Signal”.</li><li>Do you know Android-specific concerns like offline-first, lifecycle, memory, battery, and background work?</li><li>Can you communicate a clean, senior-level design under pressure?</li></ul><h3>My Experience with (Android) System Design Interviews</h3><p>I have failed multiple system design interviews. I have botched some of the most lucrative offers due to System Design interview preparation being sub par. Some of the most lucrative company interviews bombed.</p><p>This framework is what helped me consistently approach and solve these questions.</p><h3>The Core Challenges</h3><p>Instead of being generic, I’ll talk about problems that I faced during my interviews and what some of you might also face.</p><h4>1. Clarifying Requirements</h4><p>I started with clarifying requirements, but requirements are “almost” similar for most system design interview questions.</p><p>They revolve around clarifying for <strong>offline support, number of users, battery optimisations, modular architecture</strong> etc….</p><p>A challenge I faced here was if the interviewer challenged my knowledge on a requirement.</p><p><em>Why do you care about number of users? What difference does it make? Why do you care about geography?</em></p><p>It’s important to know about the tradeoffs that come with these choices. If you’ve never designed a system from scratch, or are just unaware of the challenges, then you will not know answers to these. You’ll need to look these up.</p><h4>2. The “Getting Started” Struggle</h4><p>This is where you need to start building components. I struggled here because I was unable to think of my Android apps in terms of building blocks. Didn’t know where to start, should I be drawing UseCases, ViewModels, how ViewModels talk to UseCase, how to picture the data layer?</p><p>If it’s a library, it was even tougher. How do you start? it doesn’t have any screen. Library was my nemesis. The framework we’ll talk about will specifically solve for this.</p><h4>3. The Power of Tradeoffs</h4><p>Drawing the architecture is only part of the interview. The real signal comes from how well you explain your decisions and trade-offs. You don’t need to draw a lot for your interview to go well. What you need is to explain your choices.</p><p>The interviewer will throw technical trivia randomly to test your technical depth. You should be ready to discuss:</p><ul><li><a href="https://www.mockingly.ai/">HTTP vs HTTPS</a></li><li>GraphQL vs REST vs WebSockets</li><li>Offset vs Cursor Pagination</li><li>RecyclerView optimisation and DiffUtils</li><li>Caching strategy (In-memory vs Disk)</li><li>ViewModel vs Plain Presenter</li><li>Room vs DataStore vs SharedPreferences</li><li>Flow vs LiveData</li><li>WorkManager vs Foreground Service</li><li>Paging 3 vs Manual Pagination</li><li>Compose vs XML</li><li>Offline-first vs Network-first</li></ul><h4>4. Backend Signals</h4><p>The interviewer can ask basic questions about APIs even in an Android interview. For example, they could ask you what a basic backend API would look like if you want to fetch a list of items on homescreen. What would you use for mutating some data? A GET or POST api? What would that look like?</p><h3>🔥 Resources for Preparation</h3><ul><li>Practice Mocks: Use <a href="https://www.mockingly.ai/"><strong>mockingly.ai</strong></a> for practicing android system design interview questions. It is the most effective way to practice with AI feedback.</li><li>Company Questions: Use <a href="http://hellointerview.com/">hellointerview</a> to find previously asked questions.</li><li>Discussion: Use <a href="http://leetcode.com/">leetcode</a> discuss section for community insights.</li></ul><h3>Framework 1: Building a Library</h3><p>There are 2 types of questions:</p><ol><li><strong>Build a system design for an app (notes, weather etc…)</strong></li><li><strong>Build a library (notification library, caching library etc…)</strong>. We’ll focus on this in the following section.</li></ol><h4>Phase 1: Scoping</h4><p>Clarify Functional requirements:</p><ul><li>What is the CORE purpose of the library?</li><li>Should it support offline capability?</li><li>Should it encrypt data?</li><li>Should it handle batching for API calls?</li></ul><p>Narrow the Scope:</p><ul><li>Target Audience: Internal vs Public?</li><li>Minimal Supported API level?</li><li>Assets: Can we exclude GIFs or WebPs?</li></ul><p>Non-Functional Requirements:</p><ul><li>Binary Size: Be mindful of the footprint added to the host app.</li><li>Battery Optimization: Handle background tasks gracefully.</li><li>Performance: Move expensive tasks to background threads.</li></ul><h4>Phase 2: The High-Level Diagram</h4><p>A good structure for an Android library system design:</p><ol><li><strong>Request Manager:</strong> Accepts raw input, wraps it into a internal Request Object, and handles deduplication.</li><li><strong>Dispatcher:</strong> Decides where the request executes (Thread Pool / Coroutines).</li><li><strong>Data Source:</strong> Local (Room/File) and Remote (OkHttp/Retrofit).</li><li><strong>Memory Cache:</strong> In-memory LRU cache or Bitmap pools.</li></ol><p>Example: Image Loading Library Data Flow</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WX0YMUedCPChEYQ7uSqboA.png" /><figcaption>Image Loading Library Data Flow: <a href="https://www.mockingly.ai/">Mockingly.AI</a></figcaption></figure><h4>Phase 3: Deep Dive</h4><h4>Request Manager</h4><p>Deduplication is key. If three parts of the app request the same resource, merge them into one task to save bandwidth and CPU.</p><h4>Dispatcher</h4><p>This is the “meat” of the diagram. It validates requests, manages the job queue, handles worker allocation, and controls prioritization.</p><h4>Cache &amp; Storage</h4><ul><li><strong>Memory Cache (L1):</strong> RAM storage (LRU Cache). Fast but volatile.</li><li><strong>Disk Cache (L2):</strong> Persistent storage (Room/File system). Survives restarts.</li></ul><h3>Framework 2: Android App System Design</h3><h4>Phase 1: Functional &amp; Non-Functional Requirements</h4><p>Functional:</p><ul><li><strong>Core Action:</strong> Primary task (Post, Send, Order).</li><li><strong>User Roles:</strong> Buyer vs Seller?</li><li><strong>Data Types:</strong> Text, Media, Streams?</li><li><strong>Discovery:</strong> Search, Feed, Notifications.</li></ul><p><strong>Non-Functional (Senior Signals):</strong></p><ul><li><strong>Offline Usage:</strong> Does it work without network?</li><li><strong>Latency:</strong> What is acceptable for this use case?</li><li><strong>Reliability:</strong> 0-loss policy?</li><li><strong>Efficiency:</strong> Minimize battery and data usage.</li></ul><h4>Phase 2: High-Level Architecture (HLD)</h4><p>Follow Clean Architecture for modularity.</p><ol><li>UI / Presentation Layer: Jetpack Compose + ViewModels.</li><li>Domain Layer: Plain Kotlin UseCases (e.g., GetMessagesUseCase).</li><li>Data Layer: Repository Pattern. Decides between Network and Local sources.</li></ol><p><strong>Visualising the Architecture:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5-9yOMlvdwxrS0s3hqFqnQ.png" /><figcaption>Architecture: <a href="https://www.mockingly.ai/">Mockingly.AI</a></figcaption></figure><h4>Phase 3: Data Flow</h4><ol><li><strong>Single Source of Truth:</strong> UI observes the database (Room) via Flow/LiveData.</li><li><strong>Networking:</strong> Choose REST, GraphQL, or WebSockets based on the frequency of updates.</li><li><strong>Data Strategy:</strong> Use “Cache-First” or “Network-First” depending on the app’s requirements.</li></ol><h4>Offline-First: The Senior Requirement</h4><p>Offline-first architecture is critical.</p><ul><li>UI always reads from local storage.</li><li>Local database acts as the single source of truth.</li><li>Network calls update the database, never the UI directly.</li><li>UI reacts automatically via Flow/LiveData.</li></ul><p>Correct Flow: UI -&gt; observes DB -&gt; Repository syncs with network -&gt; DB updates -&gt; UI reacts</p><h3>Common “How Would You Handle” Questions</h3><ul><li><strong>Battery Drain:</strong> Limit parallel downloads, use WorkManager with constraints.</li><li><strong>Storage Management:</strong> Implement a cache flush mechanism or LRU eviction.</li><li><strong>Data Usage:</strong> Add a “WiFi-only” configuration for large payloads.</li><li><strong>Pagination:</strong> Choose Cursor pagination for large feeds to avoid data consistency issues.</li></ul><h3>Conclusion: The Interview Strategy</h3><ol><li>Clarify the problem and constraints.</li><li>Define core use cases.</li><li>Draw the top-level architecture.</li><li>Explain the data flow (Single Source of Truth).</li><li>Deep dive into a critical subsystem (e.g., Sync or Caching).</li><li>Call out trade-offs.</li><li>End with testing and edge cases.</li></ol><p>Practice makes perfect. Use <a href="https://www.mockingly.ai/">Mockingly.ai</a> to simulate real interview pressure and refine your delivery.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8e2697886bc6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android System Design AI Mock Interview: Design an Image Loading Library]]></title>
            <link>https://medium.com/@jain.ayusch10/android-system-design-interview-design-an-image-loading-library-cb51740ce60d?source=rss-6052b8a06387------2</link>
            <guid isPermaLink="false">https://medium.com/p/cb51740ce60d</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[interview-questions]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[system-design-interview]]></category>
            <dc:creator><![CDATA[Ayusch Jain]]></dc:creator>
            <pubDate>Mon, 09 Mar 2026 21:11:23 GMT</pubDate>
            <atom:updated>2026-05-29T23:18:51.433Z</atom:updated>
            <content:encoded><![CDATA[<p><em>An </em><a href="https://www.mockingly.ai/"><em>android system design interview</em></a><em> covering requirements gathering and the 5 technical topics that come up most in senior Android system design rounds.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*361duCWR48OlkTHzLi8dxQ.png" /></figure><h3>Question: Design an image loading library.</h3><p>It is a staple <a href="https://www.mockingly.ai/"><strong>android system design question</strong></a> in design interviews because it exercises the full stack of platform knowledge: API design, caching, threading, memory, and lifecycle.</p><p>This article simulates the interview as a real conversation — starting with requirements gathering, then moving through five technical deep-dives.</p><p>Each section opens with a brief explanation of what’s being evaluated, then plays out as a dialogue with the follow-up questions a good interviewer will actually ask.</p><blockquote><strong>We’ll be practising and drawing this question on </strong><a href="https://mockingly.ai/"><strong>Mockingly.AI</strong></a></blockquote><h3>Phase 0: Requirements Gathering (5 minutes)</h3><p>Before drawing anything, spend a few minutes clarifying scope. The interviewer is checking whether you understand what you’re building before you start building it.</p><p>This phase has two parts: <strong>functional requirements</strong> (what the library does) and <strong>non-functional requirements</strong> (the constraints it operates under).</p><p><strong>Interviewer: </strong>“Go ahead — design an image loading library.”</p><p><em>(Pause. Don’t start drawing yet)</em></p><p><strong>Candidate: </strong>“Before I start, can I ask a few clarifying questions?”</p><p><strong>Interviewer: </strong>“Go ahead.”</p><h4><strong>Functional Requirements</strong></h4><p><strong>Candidate: </strong>“Are we building a general-purpose library, or something specific to one app?”</p><p><strong>Interviewer: </strong>“General-purpose.”</p><p><strong>Candidate: </strong>“Where do images come from — just network, or also local files and app resources?”</p><p><strong>Interviewer: </strong>“All three.”</p><p><strong>Candidate: </strong>“And where do they load into? I’m assuming ImageView — do we also need non-UI targets, like writing to a file?”</p><p><strong>Interviewer: </strong>“ImageView is the main one. Non-UI targets are a nice-to-have.”</p><p><strong>Candidate: </strong>“Do we need transformation support — things like cropping, circle crop, rounded corners?”</p><p><strong>Interviewer: </strong>“Yes, at minimum resize and circle crop.”</p><p><strong>Candidate: </strong>“Placeholders and error states — should the library handle those?”</p><p><strong>Interviewer: </strong>“Yes.”</p><p><strong>Candidate: </strong>“And should the library manage cancellation when the host screen is destroyed, or does the caller handle that?”</p><p><strong>Interviewer: </strong>“What would you recommend?”</p><p><strong>Candidate: </strong>“Library-managed. If we leave it to callers, someone will always forget to cancel on destroy and leak memory. The library should track the lifecycle and clean up automatically.”</p><pre>📌 What&#39;s being evaluated:<br>Whether you ask the right functional questions - not just &quot;what does it load&quot;<br>but &quot;what does it load into, from where, in what format, and who manages its <br>lifetime.&quot; Each answer here constrains a design decision later. Candidates <br>who skip this and jump straight to LruCache are showing they don&#39;t think in <br>problem space first.</pre><h4><strong>Non-Functional Requirements</strong></h4><p><strong>Candidate: </strong>“What devices do we need to support — high-end only, or budget devices too?”</p><p><strong>Interviewer: </strong>“Assume a wide range. Budget devices are significant.”</p><p><strong>Candidate: </strong>“Good to know — that makes memory management a priority. Are cache hit latency and scroll performance critical?”</p><p><strong>Interviewer: </strong>“Yes. Cache hits should feel instant. No jank during scroll.”</p><p><strong>Candidate: </strong>“Do we need offline support — should in-flight requests retry when connectivity returns, or can we drop them?”</p><p><strong>Interviewer: </strong>“Queue for retry.”</p><p><strong>Candidate: </strong>“Disk cache — configurable max size, or let it grow unchecked?”</p><p><strong>Interviewer: </strong>“Configurable with a sensible default. OS can reclaim the cache dir when disk is low.”</p><p><strong>Candidate: </strong>“Last one — is this a public library that third-party developers will use, or internal to one app?”</p><p><strong>Interviewer: </strong>“Public library.”</p><p><strong>Candidate: </strong>“That affects API design quite a bit — I’ll keep the public surface clean and stable with strong defaults.”</p><pre>📌 What&#39;s being evaluated:<br>Whether each requirement answer triggers a design consequence. <br>&quot;Budget devices&quot; → memory efficiency becomes a hard constraint. <br>&quot;Public library&quot; → stable API surface with strong defaults. A good candidate <br>connects the dots explicitly rather than just listing requirements.</pre><h4><strong>Summarising Before Drawing</strong></h4><p><strong>Candidate: </strong>“Let me capture what I have before drawing. Functional: network, file, and resource sources; ImageView as the main target; transformations; library-managed placeholders and lifecycle. Non-functional: wide device range, fast cache hits, retry on offline, configurable disk cache, public API. Anything to add?”</p><p><strong>Interviewer: </strong>“That covers it. Go ahead.”</p><pre>📌 Why summarise out loud:<br>It confirms you captured requirements correctly before committing to a design. <br>The interviewer will correct you if something&#39;s off. It also signals that <br>what comes next is deliberate - not guesswork.</pre><h3>Drawing High-Level Components</h3><p>Let’s practice by drawing the major building blocks of this <a href="https://www.mockingly.ai/"><strong>android system design on MockinglyAI</strong></a>. There we can also ask AI to give us feedback on our design.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0kaTkOfZS60doRTf4h9lGg.png" /><figcaption>Practice this on <a href="https://mockingly.ai/">Mockingly.AI</a></figcaption></figure><p>Not a complete diagram yet but highlights high level components. In a real interview this is your diagram — the boxes the interviewer will point at when asking follow-ups.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fWXk9T18Dd9VjUZK8_ivbQ.png" /></figure><p>Each deep-dive below zooms into specific blocks from this diagram.</p><h3>Topic 1: API Design — ImageRequest &amp; RequestManager</h3><p>The two components a caller touches directly are <strong>ImageRequest</strong> and <strong>RequestManager</strong>. ImageRequest encapsulates everything about a single load.</p><p>RequestManager is the singleton entry point that accepts it. The API is a contract, harder to change than the internals. The interviewer is checking whether you think from the caller’s perspective first.</p><p><strong>Interviewer: </strong>“What does the public API look like?”</p><p><strong>Candidate: </strong>“A builder pattern that produces an ImageRequest. The caller adds options: source URL, placeholder, transformations, cache strategy, and terminates with .into(imageView), which hands the request to the RequestManager.</p><p>Most options have sensible defaults so the simple case stays simple, and the builder can be extended without breaking existing callers.”</p><pre>ImageLoader.with(context)<br>.load(&quot;https://cdn.example.com/photo.webp&quot;)<br>.placeholder(R.drawable.ic_placeholder)<br>.error(R.drawable.ic_error)<br>.transform(CircleCrop())<br>.diskCacheStrategy(DiskCacheStrategy.ALL)<br>.priority(Priority.HIGH)<br>.into(imageView)</pre><p><strong>Interviewer: </strong>“What if the view hasn’t been laid out yet when load() is called — width is zero?”</p><p><strong>Candidate: </strong>“The ImageTarget defers the load using <strong>view.doOnPreDraw { }</strong> which wraps <strong>ViewTreeObserver</strong> under the hood. On the next pre-draw pass the view has its measured dimensions, and the target fires the load then.”</p><p><strong>Interviewer: </strong>“What context does the <strong>RequestManager</strong> singleton hold?”</p><p><strong>Candidate: </strong>“Application context only. The caller can pass any Context, but the singleton internalises only applicationContext.</p><p>Holding an Activity context in the singleton would keep the entire view hierarchy alive for the app’s lifetime — applicationContext has no UI to leak.”</p><pre><strong>📌 Testing:</strong><br>The view-width-zero problem catches candidates who&#39;ve used Glide but <br>haven&#39;t studied how ImageTarget handles deferred layout.<br><br>The context question is about understanding why the singleton only stores <br>applicationContext - candidates who&#39;ve only used Glide but never thought <br>about what it protects you from won&#39;t raise this unprompted.</pre><h3>Topic 2: Caching Architecture — MemoryCache &amp; DiskCache</h3><p>Two of our diagram blocks live here: <strong>MemoryCache</strong> and <strong>DiskCache</strong>. Together they form the tiered lookup the <strong>Engine</strong> runs before ever touching the network. Cache key design — shared by both tiers — and invalidation are where most candidates run into trouble.</p><p><strong>Interviewer: </strong>“Walk me through your caching strategy.”</p><p><strong>Candidate: </strong>“The Engine checks two caches before hitting the network.</p><p>First the MemoryCache — an LruCache, synchronous, zero I/O on a hit. Then the DiskCache — a DiskLruCache backed by the filesystem, which avoids a network round-trip.</p><p><strong>If both miss, the Fetcher goes to the network</strong>, writes the result to DiskCache, the Decoder processes it, and the result goes into MemoryCache.”</p><p><strong>Interviewer: </strong>“How do you size the memory cache?”</p><p><strong>Candidate: </strong>“<strong>1/8th of available heap </strong>— in kilobytes, since that’s the unit LruCache works in”</p><blockquote>More Advanced: This is unlikely to be asked, but good to know.</blockquote><blockquote><strong>Interviewer: </strong>“Does the size stay fixed for the app’s lifetime?”</blockquote><blockquote><strong>Candidate: </strong>“No. I register ComponentCallbacks2 on applicationContext and respond to onTrimMemory(). For a bitmap cache the key signal is TRIM_MEMORY_UI_HIDDEN, the app just went to background, so I trim aggressively.</blockquote><blockquote>At TRIM_MEMORY_BACKGROUND and above the system is under real pressure, so I clear the cache entirely. The Android docs are explicit that you should use &gt;= comparisons, not exact matches, because new intermediate levels can be added.”</blockquote><p><strong>Interviewer: </strong>“What’s your cache key?”</p><p><strong>Candidate: </strong>“URL alone isn’t enough — <strong>a 200×200 and a 400×400 of the same image would collide.</strong></p><p>The key includes the URL, target dimensions, transformation IDs, and an optional signature for cache-busting when the image changes but the URL doesn’t.”</p><pre>@JvmInline<br>value class CacheKey(val raw: String) {<br>   companion object {<br>      fun from(url: String, width: Int, height: Int, transforms: List&lt;Transformation&gt;, signature: String? = null): CacheKey {<br>          val tKey = transforms.joinToString(&quot;,&quot;) { it.id }<br>          return CacheKey(&quot;$url|${width}x${height}|$tKey|${signature ?: &quot;&quot;}&quot;)<br>    }<br>  }<br>}</pre><p><strong>Interviewer: </strong>“What if the image at a URL changes — say a profile picture — but the URL stays the same?”</p><p><strong>Candidate: </strong>“The <strong>signature</strong> field handles that. The caller bumps a version string or passes a lastModified timestamp, which forces a cache miss even though the URL is identical. Glide calls this the signature API.”</p><p><strong>Interviewer: </strong>“Where does the DiskCache store files?”</p><p><strong>Candidate: </strong>“getCacheDir(). It’s app-private, needs no permissions, and the OS can reclaim it when disk is low — which is the right behaviour for a cache.</p><p>If a DiskCache read fails mid-operation, the Engine treats it as a miss and falls through to the Fetcher.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rv01wYkAzfdl_XRcXKPVvg.png" /><figcaption>Practice this on <a href="https://mockingly.ai/">Mockingly.AI</a></figcaption></figure><h3>Topic 3: Engine</h3><p>The Engine is the component in this <a href="https://www.mockingly.ai/"><strong>system design</strong></a> that coordinates everything else: it checks caches, dispatches to the Fetcher, hands bytes to the Decoder, and writes results back.</p><p>How it uses threads is critical — it does three distinct types of work: blocking I/O (Fetcher, DiskCache read/write), CPU heavy work like decoding + transformation.</p><p><strong>Interviewer: </strong>“How does the Engine manage threading?”</p><p><strong>Candidate: </strong>“With Kotlin Coroutines. The Engine runs a SupervisorJob-backed CoroutineScope per LifecycleOwner.</p><p>Fetcher’s calls and DiskCache operations are on <strong><em>Dispatchers.IO</em></strong>. Decoder work and transformations go on <strong><em>Dispatchers.Default.</em></strong> ImageTarget updates happen on <strong><em>Dispatchers.Main</em></strong>.”</p><p><strong>Interviewer: </strong>“Why SupervisorJob?”</p><p><strong>Candidate: </strong>“With a regular Job, one failed coroutine cancels the whole scope. A 404 on one image would kill every other in-flight load on that screen. SupervisorJob lets each child fail independently.”</p><p><strong>Interviewer: </strong>“Why not put everything on Dispatchers.IO?”</p><p><strong>Candidate: </strong>“<strong><em>Dispatchers.IO </em></strong>is for blocking calls — its pool is large because threads spend time waiting. <strong><em>Dispatchers.Default</em></strong> is sized to CPU cores. Decoder work is CPU-bound. Running it on IO starves the Fetcher threads under load and causes network fetches to queue up.”</p><pre>// Engine.load() - the core dispatch path<br>suspend fun load(key: CacheKey, request: ImageRequest): Bitmap {<br>  // MemoryCache - checked on calling thread (Main), zero overhead on hit<br>  memoryCache.get(key)?.let { return it }<br>  return withContext(Dispatchers.IO) {<br>      // DiskCache - I/O bound<br>      val diskResult = diskCache.get(key)<br>      if (diskResult != null) {<br>        val bitmap = withContext(Dispatchers.Default) {<br>          decoder.decode(diskResult, key.width, key.height) // Decoder - CPU bound<br>        }<br>        memoryCache.put(key, bitmap)<br>        return@withContext bitmap<br>      }<br><br>      // Fetcher - network I/O bound<br>      val response = okHttpClient.newCall(Request.Builder().url(https://medium.com/request.url).build()).await()<br>      if (!response.isSuccessful) throw IOException(&quot;HTTP ${response.code}&quot;)<br>      val bytes = response.body!!.bytes()<br>      diskCache.put(key, bytes)<br>      // Decoder + transformations - CPU bound<br>      withContext(Dispatchers.Default) {<br>          val raw = decoder.decode(bytes, key.width, key.height)<br>          request.transformations.fold(raw) { b, t -&gt; t.transform(b) }.also { memoryCache.put(key, it) }<br>      }<br>  }<br>}</pre><p><strong>Interviewer: </strong>“Why does the Engine check the MemoryCache on the calling thread instead of switching to IO first?”</p><p><strong>Candidate: </strong>“Context switches have overhead. MemoryCache hits are the common case in a scrolling list — keeping that check synchronous on Main means they’re free.”</p><p><strong>Interviewer: </strong>“What about error handling — a network request fails.”</p><p><strong>Candidate: </strong>“I split errors into retry-able and non-retry-able. IOExceptions and 5xx status codes can retry with exponential backoff.</p><p>A 404 is non-retriable and surfaces immediately. One thing to flag: there’s no HttpException in OkHttp — that’s a Retrofit type. In OkHttp you check response.code directly on the Response object.”</p><pre><strong>📌 Testing:</strong><br>The memory cache check on Main is a deliberate optimisation - it only <br>makes sense if you understand dispatcher overhead. The retry location matters <br>too: OkHttp interceptors are synchronous, so backoff delays done there block <br>a thread. Coroutine-layer retry with delay() is the correct approach.<br><br>Mentioning HttpException as an OkHttp type signals the candidate has only <br>used Retrofit&#39;s wrapper, not OkHttp directly.</pre><h3>Topic 4: Memory Management — Decoder &amp; BitmapPool</h3><p>Two diagram blocks live here: Decoder and BitmapPool. The Decoder is responsible for turning raw bytes into a Bitmap at the right size. BitmapPool lets it do that without allocating new heap on every decode.</p><p>On Android, memory is shared with the OS, and an image library that allocates carelessly will have OOM errors — especially on the budget devices that cover a large share of the install base.</p><p><strong>Interviewer: </strong>“How does your library avoid OOM?”</p><p><strong>Candidate: </strong>“The Decoder downsamples at decode time so it never loads more pixels than the target view needs, and it reuses allocations from the BitmapPool”</p><p><strong>Interviewer: </strong>“How does the Decoder downsample?”</p><p><strong>Candidate: </strong>“Two-pass decode. <strong>First pass: inJustDecodeBounds=true</strong> reads just the image header — dimensions, no pixels allocated.</p><p>Second pass: using inSampleSize”</p><p><strong>Interviewer: </strong>“And how does the BitmapPool work?”</p><p><strong>Candidate: </strong>“The Decoder pulls a mutable Bitmap from the BitmapPool. BitmapFactory writes the decoded pixels directly into that existing allocation — no new heap needed for images that fit.”</p><p><strong>Interviewer: </strong>“Does inBitmap work for any two Bitmaps?”</p><p><strong>Candidate: </strong>“No — there are constraints. Pre-API 19, the reused Bitmap must match exactly in dimensions and Bitmap.Config. API 19 onwards the constraint relaxes: the reused Bitmap just needs enough bytes to hold the new image. My pool uses exact-match lookup on older APIs and size-based buckets on 19+.”</p><pre>// Decoder.decode() - two-pass BitmapFactory with BitmapPool reuse<br>fun decode(source: InputStreamProvider, targetW: Int, targetH: Int): Bitmap {<br>  // Pass 1: read header only - no pixel allocation<br>  val opts = BitmapFactory.Options().apply { inJustDecodeBounds = true }<br>  source.open().use { BitmapFactory.decodeStream(it, null, opts) }<br>  // Pass 2: decode with downsampling + pool reuse<br>  opts.apply {<br>    inJustDecodeBounds = false<br>    inSampleSize = calculateSampleSize(outWidth, outHeight, targetW, targetH)<br>    // BitmapPool.get() takes width, height, Config - not an Options object<br>    inBitmap = bitmapPool.get(targetW, targetH, inPreferredConfig)<br>    inMutable = true // required for inBitmap<br>  }<br>// Must open a fresh stream - the first one is fully consumed<br>  return source.open().use { BitmapFactory.decodeStream(it, null, opts) }<br>  ?: throw IOException(&quot;BitmapFactory returned null - corrupt data or inBitmap mismatch&quot;)<br>}</pre><pre><strong>📌 Testing:</strong><br>The two-pass Decoder pattern is straightforward in theory but has a real <br>gotcha: the first stream is fully consumed after the bounds pass, so the <br>Decoder needs a fresh stream for the actual decode - InputStreamProvider <br>as an abstraction is the clean solution to this. <br><br>The API 19 BitmapPool constraint difference - exact Config+dimensions vs <br>byte count - separates candidates who&#39;ve implemented this from those <br>who&#39;ve only read about it.</pre><h3>Topic 5: Lifecycle &amp; View Binding — RequestManager &amp; ImageTarget</h3><p>Earlier we introduced <strong>RequestManager</strong> as the entry point for callers. Now we focus on its second responsibility: <strong>lifecycle management</strong>.</p><p>An image request should automatically cancel when the screen that started it is destroyed. Otherwise background work continues unnecessarily and the result may try to update a dead view.</p><p><strong>Interviewer:</strong> <em>“</em>How does your library attach requests to an Activity or Fragment lifecycle?”</p><p><strong>Candidate:</strong> “Modern Android libraries prefer lifecycle-aware APIs. Instead of implicitly grabbing lifecycle state, the public API should accept a <strong>LifecycleOwner</strong> whenever possible.”</p><p>Example usage:</p><pre>ImageLoader.with(lifecycleOwner)<br>    .load(&quot;https://cdn.example.com/photo.webp&quot;)<br>    .into(imageView)</pre><p><em>“This makes lifecycle ownership explicit and avoids surprising behaviour.”</em></p><p><strong>Interviewer: </strong>“But many image libraries use ImageLoader.with(context). What happens there?&quot;</p><p><strong>Candidate:</strong> “For convenience we can still provide with(context), but internally we attempt to resolve a LifecycleOwner.&quot;</p><p>The logic typically works like this:</p><ol><li>If the Context is a LifecycleOwner (Activity or Fragment), use its lifecycle.</li><li>If it’s a ContextWrapper, unwrap until we find one.</li><li>If none is found (for example Application context), fall back to a global request manager.</li></ol><p>Example resolution logic:</p><pre>fun findLifecycleOwner(context: Context): LifecycleOwner? {<br>    var current = context<br>    while (current is ContextWrapper) {<br>        if (current is LifecycleOwner) return current<br>        current = current.baseContext<br>    }<br>    return null<br>}</pre><p><strong>Interviewer</strong>: “Some libraries inject a headless Fragment to get lifecycle callbacks. Would you do that?”</p><p><strong>Candidate</strong>: “Historically libraries like Glide used a view-less Fragment injected into the Activity’s FragmentManager. That approach works because Fragments receive lifecycle callbacks even without UI.</p><p>However modern Android guidance encourages explicit lifecycle APIs instead. Injecting fragments can introduce subtle FragmentManager edge cases and isn’t necessary if we expose lifecycle-aware APIs.</p><p>So my design prefers accepting a LifecycleOwner. The with(context) overload is just a convenience wrapper.”</p><p><strong>Interviewer</strong>: <em>“</em>When do requests actually cancel?”</p><p><strong>Candidate</strong>: “The RequestManager owns a CoroutineScope tied to the lifecycle. When the lifecycle reaches ON_DESTROY, the scope is cancelled and all in-flight requests terminate.&quot;</p><p>Example:</p><pre>class RequestManager(<br>    lifecycle: Lifecycle,<br>    private val engine: Engine<br>) : DefaultLifecycleObserver {</pre><pre>    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)</pre><pre>    init {<br>        lifecycle.addObserver(this)<br>    }</pre><pre>    override fun onDestroy(owner: LifecycleOwner) {<br>        scope.cancel()<br>    }<br>}</pre><pre><strong>📌 What&#39;s being evaluated:<br></strong><br>Candidates should demonstrate lifecycle awareness, not just API familiarity.<br>Modern Android libraries prefer explicit LifecycleOwner APIs, with <br>with(context) as a convenience layer rather than the primary mechanism.</pre><p>Lifecycle is the topic candidates most often know conceptually but struggle to explain clearly under pressure. Practicing it against an AI Interviewer is what closes that gap. Screenshot from a <a href="https://mockingly.ai/"><strong>Mockingly.ai</strong></a> session:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bRuSPGl-Px5KpCuorN6Hbw.png" /><figcaption>Practice this on <a href="https://mockingly.ai/">Mockingly.AI</a></figcaption></figure><h3>Putting It Together</h3><p>Requirements gathering + five technical topics — this is the full shape of a <a href="https://www.mockingly.ai/"><strong>senior Android system design round</strong></a>. Here’s what good answers look like across all phases:</p><ul><li><strong>Requirements:</strong> functional (sources, targets, formats, transformations, lifecycle ownership) and non-functional (device range, cache hit latency, concurrency, offline behaviour, public API contract) — and visibly connecting each to a downstream design decision.</li><li><strong>API Design:</strong> fluent builder for extensibility; applicationContext only in singleton; ViewTreeObserver for deferred layout.</li><li><strong>Caching:</strong> three-tier hierarchy; LruCache sized from heap with <strong>onTrimMemory</strong> response; cache key encodes URL + dimensions + transforms + signature; DiskCacheStrategy trade-offs; getCacheDir() for disk storage.</li><li><strong>Threading:</strong> Dispatchers.IO for network/disk, Dispatchers.Default for decode; SupervisorJob for independent failure; memory cache check on Main for zero-overhead hits; OkHttp response.code for HTTP errors, not HttpException.</li><li><strong>Memory:</strong> two-pass inJustDecodeBounds decode; power-of-two inSampleSize; inBitmap pool with Config+dimension matching pre-API-19 and byte-count matching post-API-19; decodeStream null handling.</li></ul><h3>Practice Under Realistic Conditions</h3><blockquote><em>Reading about these topics and defending a diagram you drew — live, with follow-ups pointed at it — are different skills. </em><a href="https://www.mockingly.ai/"><strong><em>Mockingly.ai is an AI interviewer</em></strong></a><em> built specifically for mobile system design.</em></blockquote><p>You sketch the architecture on an interactive canvas mid-session; the AI sees it in real time and drills into whatever you’ve drawn, the same way a real interviewer does.</p><p>There’s also a trivia drill mode for rapid-fire questions on Android fundamentals. Worth a few runs before the real thing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5iRqDm9eG9kwjwfz0VOh2A.png" /><figcaption><a href="https://mockingly.ai/">Practice this question on Mockingly.AI</a></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cb51740ce60d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[You’re Over Complicating LeetCode | The only LeetCode post you’ll need to read]]></title>
            <link>https://medium.com/@jain.ayusch10/youre-over-complicating-leetcode-the-only-leetcode-post-you-ll-need-to-read-92d7d16ac84b?source=rss-6052b8a06387------2</link>
            <guid isPermaLink="false">https://medium.com/p/92d7d16ac84b</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Ayusch Jain]]></dc:creator>
            <pubDate>Sun, 01 Mar 2026 18:50:06 GMT</pubDate>
            <atom:updated>2026-03-01T18:50:06.238Z</atom:updated>
            <content:encoded><![CDATA[<p>If you’re trying to figure out <strong>how to prepare for LeetCode</strong> or searching for the perfect <strong>coding interview preparation strategy</strong>, let me save you some time:</p><p>You’re probably overcomplicating it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OEK-S__RZoL6zXzf-vkgLg.png" /><figcaption>Check your Readiness Score on PocketDSA: <a href="https://onelink.to/2fs8h3">https://onelink.to/2fs8h3</a></figcaption></figure><p>I see students obsess over:</p><ul><li>The “best” DSA roadmap</li><li>The perfect 300-question list</li><li>Whether they should start with DP</li><li>Which company-tagged problems matter</li></ul><p>None of that is the real issue.</p><p>I had the same concerns when I started college. Now, after working for years and going through multiple interviews, here’s the simple <strong>LeetCode prep plan</strong> that actually worked for me.</p><h3>A Simple LeetCode Study Plan That Actually Works:</h3><h3>1. Pick the Core DSA Topics (Don’t Chase Resources)</h3><p>Go to InterviewBit and look at their structured pathway. It’s roughly 10–12 core topics:</p><ul><li>Arrays</li><li>Strings</li><li>Hashing</li><li>Two pointers</li><li>Sliding window</li><li>Stack / Queue</li><li>Recursion &amp; Backtracking</li><li>Binary Search</li><li>Trees (especially BST)</li><li>Heaps</li><li>Graphs</li><li>Dynamic Programming</li></ul><p>That’s it.</p><p>This is your <strong>data structures and algorithms roadmap</strong>. You don’t need 50 YouTube playlists.</p><h3>2. Build Your Base Slowly (This Is Where Most People Fail)</h3><p>Go to LeetCode Explore and complete the topic cards one by one.</p><p>This phase is about building understanding, not counting solved problems.</p><p>For each topic:</p><ul><li>Read the concept clearly.</li><li>Solve the example yourself.</li><li>Re-implement without looking.</li><li>Understand <em>why</em> the algorithm works.</li></ul><p>If you rush this phase, everything later feels hard. If you go deep here, everything later feels mechanical.</p><p>Spend “months” on this phase if you have to. But don’t rush it.</p><h3>3. Practice Intentionally (Not Randomly)</h3><p>Once you finish a topic card, start solving problems.</p><p>You should:</p><ul><li>Solve topic-based problems.</li><li>Or solve company-tagged questions, I find this more interesting.</li><li>Use <a href="https://onelink.to/2fs8h3">PocketDSA</a> for Habit building. Complete 3 cards daily looking at solution, time &amp; space complexities within the app. Takes 20 seconds.</li></ul><p>Personally, I like company-tagged questions because they show realistic patterns in interviews.</p><blockquote>But here’s the key: Don’t aim to solve 10 problems <strong>fast.</strong></blockquote><p>Solve 1 problem deeply. Ask yourself:</p><ul><li>Why does this approach work?</li><li>What’s the time and space complexity?</li><li>Can I derive this again without memorizing?</li></ul><p>That’s real coding interview preparation.</p><h3>4. Build the DSA Habit (This Is the Hidden Multiplier)</h3><p>Here’s something nobody talks about:</p><p>The hardest part of LeetCode prep isn’t difficulty. It’s consistency.</p><p>There are days when:</p><ul><li>You don’t feel like solving problems.</li><li>You’re in a comfortable job.</li><li>You’re not actively interviewing.</li><li>You just want to skip DSA entirely.</li></ul><p>This is exactly why I built <strong>PocketDSA</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3vgWIyr1jHdzpMxIbvfv3Q.png" /><figcaption>Check your interview readiness: <a href="https://onelink.to/2fs8h3">https://onelink.to/2fs8h3</a></figcaption></figure><p><strong>Not as a “magic prep tool”. But as a daily nudge system.</strong></p><p>It helps you:</p><ul><li>Stay in touch with DSA daily</li><li>Practice small, focused sets</li><li>Maintain streaks</li><li>Avoid falling completely out of rhythm</li></ul><p>And honestly? That’s when it helps the most.</p><p>You don’t need more resources. You need fewer excuses.</p><h3>How to Actually Study a LeetCode Problem</h3><p>Here’s the method that changed things for me:</p><ol><li>Try solving for 15–25 minutes.</li><li>If stuck, read a solution carefully.</li><li>Close it.</li><li>Re-write the code yourself.</li><li>Write the complexity.</li></ol><p>If you want to go one level deeper: Write code by hand on paper. As it helps you focus without Autocomplete. It’s a game-changer. It also helps you prepare notes.</p><h3>Depth &gt; Quantity in DSA Preparation</h3><p>Most people brag about:<br><strong> “I solved 300 problems.”</strong></p><p>But during interviews, they freeze.</p><p>Because they optimised for count - not understanding.</p><p>If you deeply understand:</p><ul><li>Sliding window</li><li>Two pointers</li><li>Tree traversal</li><li>Binary search patterns</li></ul><p>You can derive solutions live.</p><p>That’s what interviewers care about.</p><h3>Final Thoughts on LeetCode Prep</h3><p>LeetCode prep is not rocket science.</p><p>It’s:</p><ul><li>Structured learning</li><li>Deep understanding</li><li>Daily repetition</li><li>Long-term consistency</li></ul><p>If you’re overwhelmed, simplify.</p><p>Pick 10–12 topics.<br>Study deeply.<br>Practice intentionally.<br>Stay consistent.</p><p>And if you need a small system to stay disciplined daily, that’s exactly why I built <a href="https://onelink.to/2fs8h3">PocketDSA</a>.</p><p>But even without it — the plan above is enough.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=92d7d16ac84b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[LeetCoding in the AI Era + Useful Tools for Interview Prep]]></title>
            <link>https://medium.com/@jain.ayusch10/leetcoding-in-the-ai-era-useful-tools-for-interview-prep-280627a6603f?source=rss-6052b8a06387------2</link>
            <guid isPermaLink="false">https://medium.com/p/280627a6603f</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[careers]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Ayusch Jain]]></dc:creator>
            <pubDate>Mon, 23 Feb 2026 16:32:30 GMT</pubDate>
            <atom:updated>2026-02-23T16:32:30.587Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L8OlK-bU1AJ9Ce4Ua2I0kQ.png" /><figcaption>PocketDSA App: <a href="https://pocketdsa.github.io/">https://pocketdsa.github.io</a></figcaption></figure><p>I’ve been a Mobile Engineer (mostly Android) since last 7+ years and this is the most anxious I’ve felt about losing my job.</p><p>Trust me, I’ve been through React Native, Flutter and hybrid dev hype cycles which promised to replace native devs, and I’ve survived that. But this one feels different.</p><p>Software Engineering as we knew it pre-2023 wouldn’t exist anymore in that shape or form. AI would become central to everything we do as Software Engineers, for example:</p><ol><li><strong>Creating a implementation plan document (RFC):</strong> Upload the PRD to glean, prompt it to identify dependencies. <br>Or, upload the PRD to Windsurf, attach figma design screenshots, and prompt it to generate a document focused on Architecture.</li><li><strong>Breaking down JIRA Stories:</strong> Ask Rovo (Atlassian’s AI) to break down the implementation plan/story to actionable tickets.</li><li><strong>Implementation:</strong> Copy the ticket description to Windsurf and have it implement the task.</li><li><strong>Verify:</strong> While AI is good at implementation — this is where humans would still be valuable. To verify the implementation, and see if it could’ve been done better.</li><li><strong>Testing:</strong> Windurf to write Unit, E2E tests.</li></ol><p>And so on….</p><h3>About DSA Interviews ?</h3><p>LeetCoding or Data Structures and Algorithms (DSA) have been an integral part of coding interviews, and have worked well enough for the past couple of decades.</p><p>Sure, we have cases where an excellent dev was ignored since they couldn’t invert a Binary Tree. But in general, they’ve been able to successfully filter out excellent engineers for top tech companies.</p><p><em>LeetCoding showed that an engineer had problem solving skills and could think from first-principles.</em></p><p>But that’s being increasingly commoditised. LLMs can solve a complex problem really well as long as it’s not a new/novel problem.</p><p>And let’s be honest, how many problems in day-to-day software engineering are novel ? Not many, most of the software engineering is eventually CRUD.</p><h3><strong>Will LeetCoding disappear ?</strong></h3><p>Not entirely — but YES!</p><p><strong>LeetCoding would be around maybe not as a 45 min technical interview.</strong></p><p><strong>Meta</strong> has already transitioned to AI assisted interviews. (I’m not sure what it look like, since I’ve not interviewed at meta recently).</p><p>But they haven’t eliminated DSA. Inverting a binary tree was never about INVERTING. It was about seeing if you knew how Trees work and if you can think from first principles to come up with something that can work to invert them.</p><p>Maybe the future looks like a 45 min interview where you’d be expected to solve a couple of optimisation problems with a <strong>Trivia</strong> on DSA.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*68G38Apn7bwtD_ZShcB0hg.png" /><figcaption>Check your interview readiness score on PocketDSA</figcaption></figure><p>Maybe you’re asked to implement multiple algorithms side by side to solve 1 overarching problem.</p><p>As an Android Engineer, maybe you’re quizzed about how Recycling works, and how’s it optimised vs ListView. The algorithmic knowledge behind it.</p><p>I feel in a couple of years, objectively solving 2 problems in 45 mins won’t be a requirement.</p><h3>How to prepare for Leetcoding / DSA interviews then + Useful Tools ?</h3><p>Don’t give up on leetcoding just yet. At least if you’re interviewing in the next 1 year.</p><p>But if you’re not, I’d NOT suggest spending hours a day grinding leetcode.</p><p>Here’s a simple plan to keep your DSA muscle updated:</p><ol><li><strong>Use </strong><a href="https://pocketdsa.github.io/"><strong>PocketDSA</strong></a><strong> to keep yourself updated with DSA:</strong> Takes just 1 minute to look at 3 cards which have dsa problems. This’ll help you build a habit and stay in touch with DSA.</li><li>3 Months before interview: Start active preparation. Use “<a href="https://leetcode.com/explore">Explore section</a>” in LeetCode to brush up on concepts. Solve atleast 5 questions on every topic.</li><li>Use LLMs: Use either Gemini or ChatGPT to delve deep into any algorithm or topic you don’t understand. Prompt it to explain with examples.</li><li>1 month before: Solve frequently asked questions in the last 30 days. Sort by frequency. Spend 30 mins to try to solve the problem yourself. If you can’t, look at the hint, and try again. If you can’t in 15 mins, look at the complete solution and move on.</li></ol><p>This is the basic. This has worked really well for me, as someone who’s not interested in Competitive programming.</p><p>Building a habit, keeping in touch with DSA is more important than grinding hard.</p><p>Interview landscape is changing and Coding interviews will look very different 1–2 years from now. It would evolve into something more than just objectively being able to solve 2 problems within 45 minutes.</p><p>Good luck :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=280627a6603f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Most Important System Design Interview Tip No One Talks About]]></title>
            <link>https://medium.com/@jain.ayusch10/the-most-important-system-design-interview-tip-no-one-talks-about-406f053ef3af?source=rss-6052b8a06387------2</link>
            <guid isPermaLink="false">https://medium.com/p/406f053ef3af</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[system-design-interview]]></category>
            <category><![CDATA[interview]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Ayusch Jain]]></dc:creator>
            <pubDate>Wed, 19 Nov 2025 06:52:04 GMT</pubDate>
            <atom:updated>2025-11-19T06:52:04.682Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D38TVFKc3qwOQrJRsgUomw.png" /></figure><p>System design interviews can feel overwhelming. You draw big boxes. You label them. You sketch arrows.You talk about APIs, queues, caching, scalability, data models, and failure modes.</p><blockquote><strong><em>And even after all that, your interviewer can still say, “What happens when this part fails?” or “Walk me through your data consistency model.” It feels endless 😭</em></strong></blockquote><p>But after seeing hundreds of candidates prepare, practice, and interview, one pattern has become incredibly clear.</p><h3>Why instincts matter more than memorizing architectures</h3><p>You can memorize dozens of famous system designs from YouTube videos or GitHub repositories. You can replicate architecture diagrams for Netflix, Uber, or Instagram. But real interviews almost never follow that script.</p><p>Instead, interviewers test how you think.</p><p><strong>They ask questions like:</strong></p><ul><li>Explain <a href="https://mockingly.ai/trivia">http vs https</a></li><li>Why would you choose REST over GraphQL here</li><li>How would you design pagination for millions of records</li><li>When would you use Redis over a database cache</li><li>What consistency model would you pick and why</li><li>How would you handle offline sync in a mobile app</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UrarXuI-kJweKzGVAhiLsA.png" /><figcaption>Solve these questions on <a href="https://mockingly.ai/trivia">https://mockingly.ai/trivia</a></figcaption></figure><blockquote><strong>Image above is a screenshot from </strong><a href="https://mockingly.ai/trivia"><strong>Mockingly</strong></a><strong> which has these tradeoff-like questions to help you understand the concepts.</strong></blockquote><p>These are all <strong>fundamental concepts</strong>, not full systems.</p><p>If you know the fundamentals well, the interview becomes more like a conversation than an exam. You can explain trade-offs clearly. You can reason on the fly. You can adapt when the interviewer changes constraints.</p><h3>The problem with most preparation approaches</h3><p>Most candidates prepare in a way that looks productive, but actually creates a false sense of readiness.</p><p>They binge long system design videos. They read architecture posts. They memorize high-level diagrams.</p><p>But when the interviewer digs into details, everything suddenly feels shaky.</p><p><strong>If your fundamentals are weak, you end up:</strong></p><ul><li><strong>Over-explaining obvious things</strong></li><li><strong>Forgetting key trade-offs</strong></li><li><strong>Struggling to justify decisions</strong></li><li><strong>Repeating the same patterns regardless of the question</strong></li><li><strong>Freezing when asked about bottlenecks, failure modes, or data flow</strong></li></ul><p>Strong candidates look confident because they know the basics so well that they can build any system step by step.</p><h3>So how do you build these instincts</h3><p>By practicing the fundamentals in short, focused, repeated bursts.</p><p>This is the same way people train for chess, competitive programming, language learning, or fitness. Consistent, small reps beat long, passive study sessions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v4Kk5yDYq_4poHc0p_HZDA.png" /><figcaption>These fundamentals are essential for any system design interview preparation: <a href="https://mockingly.ai/trivia">https://mockingly.ai/trivia</a></figcaption></figure><p>You want to quickly test yourself on topics like:</p><ul><li>REST vs GraphQL vs WebSockets</li><li>SQL vs NoSQL</li><li>Types of pagination and when to use each</li><li>Caching patterns</li><li>Rate limiting techniques</li><li>Message queues vs streams</li><li>Horizontal vs vertical scaling</li><li>Types of consistency models</li></ul><p>These are the high-signal areas that show up in almost every interview.</p><h3>A faster way to build interview instincts</h3><p>I built <a href="https://mockingly.ai/trivia"><strong>mockingly.ai</strong></a> for exactly this reason. One feature in particular, <strong>Interview Trivia</strong>, gives you short, high-value quizzes that target the most important fundamentals.</p><p>These quizzes help you:</p><ul><li>Strengthen your understanding of core concepts</li><li>Build the reflexes needed during live interviews</li><li>Learn trade-offs in a practical, memorable way</li><li>Train your brain to respond faster and with more clarity</li></ul><p>Each quiz takes only a minute or two, and covers real topics that candidates struggle with in actual interviews.</p><p>If you want to try it, you can check it out here: <a href="https://mockingly.ai/"><strong>https://mockingly.ai</strong></a></p><h3>Combine fundamentals with real practice</h3><p>Trivia alone is not enough. But it gives you a solid foundation. Once your fundamentals are strong, full mock interviews become far easier.</p><p>At that point, practice full sessions where you:</p><ul><li>Draw a system diagram</li><li>Explain data flow</li><li>Handle follow-up questions</li><li>Discuss trade-offs</li><li>Justify design decisions</li></ul><p>This is where everything clicks.</p><h3>A simple preparation plan you can follow</h3><p>Here is a balanced way to prep without burning out:</p><p><strong>Daily (5 to 10 minutes):</strong> Do a few Interview Trivia quizzes to sharpen fundamentals.</p><p><strong>Weekly (1 or 2 times):</strong> Do a full mock system design session.</p><p><strong>After each session:</strong> Review what confused you and add those topics to your fundamentals practice.</p><p>This creates a cycle of steady improvement.</p><h3>Final takeaway</h3><p>If you want to improve your performance in system design interviews, stop trying to memorize giant architectures. Focus on mastering the core concepts and trade-offs. Build strong instincts. Train them often. Keep your practice light but consistent.</p><p>This one shift separates average candidates from standout ones.</p><p>If you want a structured way to build these instincts, try Interview Trivia and free AI mock interviews at: <a href="https://mockingly.ai/"><strong>https://mockingly.ai</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=406f053ef3af" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[No Bullsh*t Android System Design Interview Preparation Strategy]]></title>
            <link>https://medium.com/@jain.ayusch10/no-bullsh-t-android-system-design-interview-preparation-strategy-b7b89bdd010c?source=rss-6052b8a06387------2</link>
            <guid isPermaLink="false">https://medium.com/p/b7b89bdd010c</guid>
            <category><![CDATA[system-design-interview]]></category>
            <category><![CDATA[leetcode]]></category>
            <category><![CDATA[interview-questions]]></category>
            <category><![CDATA[android-development]]></category>
            <category><![CDATA[coding-interviews]]></category>
            <dc:creator><![CDATA[Ayusch Jain]]></dc:creator>
            <pubDate>Thu, 16 Oct 2025 18:31:02 GMT</pubDate>
            <atom:updated>2025-10-16T18:31:02.376Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y2RXRU59nM4BH49IPbv4Fg.png" /></figure><p>Imagine you have an upcoming interview at Big Tech.</p><p>You see 2 coding rounds, 1 behavioural round, and …. <strong>1 System Design.</strong></p><p>You start to wonder if it’s backend system design, or will it be focused on Android or iOS if you’re an iOS engineer (since I’m an Android Engineer, I’ll use Android more often in this post but all the tips apply to iOS devs too).</p><p>Most of us mobile devs have gone through this dilemma, and it’s not invalid. I’ve had interviews for an Android engineer role, where I was asked backend system design questions.</p><p><strong>Because the interviewer was not an Android dev</strong>. For them, and for the general audience, system design equals backend system design.</p><p>But Android system design rounds are becoming more popular and are a focus point in big tech.</p><p>More so if you’re a Senior since that’s a level decider for your role. Your total comp depends on how well you do in your System Design and Behavioural rounds.</p><p>If you’re a junior, then prepping for system design rounds will help you cement your place. With the bar set so high nowadays, it never hurts to have all bases covered.</p><h4><strong>No BS Preparation for Android System Design</strong></h4><p>It doesn’t have to be complicated. And the good news is, there are fewer moving parts in Android System Design than backend. Here’s a simple step-by-step preparation strategy for your next Android system design interview:</p><ol><li><strong>Prepare a list of questions:</strong> Research online, or get <a href="https://mockingly.ai/"><strong>Mockingly Pro</strong></a> to get a list of previously asked system design questions for Android.</li><li><strong>Solve one question and analyse:</strong> We need to understand the baseline. What are your strengths and weaknesses, and are you able to think in blocks?</li><li><strong>Once you’ve identified areas where you go blank</strong>: Next up, you should check out a solution for that same problem. Look online and I’m sure you’ll find some good solution. Or try <a href="https://github.com/weeeBox/mobile-system-design">weebox</a> on GitHub.</li><li><strong>Solve the question again</strong>, now that you have had a look at the solution. It’s important to solve the same question again, to internalise whatever you learnt.</li><li><strong>Do this</strong> for three to four questions, and you’ll already start feeling confident.</li></ol><h4><strong><em>Next up, let’s prepare for trivia.</em></strong></h4><p>The interviewer, more often than not, will grill you on your decisions, <strong>for example</strong>:</p><ol><li>Why did you choose SQL over a No-SQL db?</li><li>Did you consider Shared Preferences? Why/why not?</li><li>Web Socket vs REST vs GQL, which one would you choose and why?</li><li>What’s REST? And how does it work?</li><li>Difference between HTTP and HTTPS (very common question).</li><li>Some Android/iOS specific trivia like lifecycle management, memory leaks, perf optimisations.</li></ol><p>Having this trivia at the back of your head will help you when the interviewer tries to grill you on your decisions. Once you’re done with these, it’s time to put what you’ve learnt to the test.</p><h4><strong>Mock interviews are the key:</strong></h4><p>There’s little substitute for mocks as they resemble the real interview most closely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zrOxtPX1hDFciDv6cpoDxg.png" /><figcaption><a href="https://mockingly.ai/">Mockingly.AI</a>’s interface has a whiteboard to draw and get it reviewed by AI</figcaption></figure><p><strong>Use </strong><a href="https://mockingly.ai/"><strong>mockingly.ai</strong></a><strong> to prepare for system design. <em>Especially Android system design as it has mobile-focused questions and some of them are questions asked in real interviews.</em></strong></p><p>Other mock providers are way too expensive for what they are. I feel mockingly is a good substitute at a fair price. Even though it sometimes can ask repetitive questions, if you steer the interview in the right direction, then it’s good enough to practice mocks.</p><h4><strong>Last minute:</strong></h4><p>Use the “real interview questions” section on mockingly, Weebox to read about system design questions and their solutions. You’ll be in luck if you get one of those already asked questions.</p><p>If you follow these steps thoroughly, I feel 1–2 months should be enough to put you in a good spot for your Android system design interview. This is based on my experience prepping for big tech interviews. Feel free to share your thoughts in the comments.</p><h4><strong>Resources used:</strong></h4><ol><li><a href="https://github.com/weeeBox/mobile-system-design">WeeBox</a></li><li>proAndroidDev on Medium</li><li><a href="https://mockingly.ai/">Mockingly Pro</a></li><li>Trivia on various websites</li></ol><p>Good luck on your android system design journey. I hope this post will be of some help to anyone looking to prepare.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b7b89bdd010c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Mobile System Design Interview: My FAANG Prep Journey + Free Practice Resource]]></title>
            <link>https://medium.com/@jain.ayusch10/the-mobile-system-design-interview-my-faang-prep-journey-free-practice-resource-96afce1f9583?source=rss-6052b8a06387------2</link>
            <guid isPermaLink="false">https://medium.com/p/96afce1f9583</guid>
            <category><![CDATA[system-design-interview]]></category>
            <category><![CDATA[android-system-design]]></category>
            <category><![CDATA[mobile-design-system]]></category>
            <dc:creator><![CDATA[Ayusch Jain]]></dc:creator>
            <pubDate>Tue, 09 Sep 2025 19:00:29 GMT</pubDate>
            <atom:updated>2026-05-15T15:15:54.603Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ynYsM34Siz0IXfK3bxSO0A.png" /></figure><p>When talking about System Design, most resources, experiences written online focus heavily on backend system designs.</p><blockquote><strong>Check out: </strong><a href="https://mockingly.ai/"><strong>https://mockingly.ai</strong></a><strong> as it’s one of the BEST TOOLS for System Design Interview preparation and Practice</strong></blockquote><p>But if you’re aspiring to be a mobile (Android, iOS) engineer at one of the FAANGs, you’ll have to go through a rigorous mobile system design interview.</p><p>I’ve interviewed<em> at 3/5 FAANG </em>companies, and have cleared their system design rounds. And after about 6 years as a mobile engineer, I feel I have a fairly good experience about what consists of a system design round at these companies.</p><p>But there’s a dearth of mobile focused system design preparation material. So in this blog, I’ll share my experience interviewing at these companies, and a few tips on how to prep for one. I hope this will help any aspiring mobile devs who have an upcoming interview.</p><h3><strong>My Experience</strong></h3><p>The interview at FAANG consists of 3 main components:</p><ol><li>Coding interviews: can range from 2–3 rounds of Data Structure and Algorithms focused interview.</li><li>System Design interview: While mostly 1, recently there’s been a push for 2 rounds of system design interviews. I’ve experienced it at one of the big techs.</li><li>Behavioural Interview: These are interviews focused on your past experiences. Questions are situation based and the best way to answer these is using the STAR method.</li></ol><p>So let’s talk about System Design.</p><p>Here’s some of system design questions I’ve encountered so far in my interviews:</p><ol><li>Design an image caching library like glide.</li><li>Design a 1 to 1 Chat application which can also send images, videos.</li><li>Design a App Store.</li><li>Design an e-commerce app’s homepage.</li><li>Design a stock market app’s ticker page. The page which displays the prices of stocks.</li></ol><p>These are some of the major ones that I remember.</p><p>And while you can find answers to most of them online, just mugging up is never the solution. When I tried mugging up initially, it made me anxious as the interview day got closer. I became anxious that I might forget to draw a component.</p><p>After failing a few interviews, I realised I wasn’t failing because I lacked knowledge, I was failing because I obsessed over details instead of thinking like an architect.</p><p>See, for system design interviews, you can direct them in any way you want. It’s up to you how you steer the interview. You can go down the rabbit hole of discussing very specific details, or you can focus on the building blocks of the design and if need be, explain the block which you’re most confident about. Let the interviewer grill you on a component. Don’t make it hard yourself.</p><h3><strong>My Preparation</strong></h3><p>As a mobile (android, react native) engineer, I couldn’t find many resources to prepare for the interviews. There were questions sprinkled here and there, but nothing like Grokking the system design interview which was heavily backend focused.</p><p>I tried doing some mock interviews with my friends, but they weren’t necessarily helpful. Most of my friends were backend engineers + it was hard to schedule time with them due to our heavy workload. Weekend plans never materialised.</p><p>I came across some websites which offered system design interviews with engineer from FAANGs but it was too costly for me.</p><blockquote><strong>Plug:</strong> I created <a href="http://mockingly.ai/">mockingly.ai</a> to solve for this problem. The first mock interview platform with mobile-specific system design questions, instant AI feedback, and on-demand practice. It’s like having a FAANG engineer available 24/7 to mock interview you. Right now, the first session is free!</blockquote><p>Next up, <a href="https://github.com/weeeBox/mobile-system-design">weebox’s github </a>repository was the first resource that was actually helpful for me. It had mobile focused system design questions.</p><p>Then I did the worst thing possible, I tried mugging up all the answers. As I said, design interviews are very subjective and mugging never helps. I failed miserably at a design interview for a job I desperately wanted. I was disheartened. I had been fairly confident that I could clear the design round as I had all the answers in my head, so I couldn’t believe I screwed up the interview.</p><p>I had screwed up some sys design interviews before, but those weren’t for jobs that I was desperately aiming for, this time it hit different. Something had to change.</p><p>And that change was my preparation strategy. I realised that mugging up won’t help. I needed to really understand how system design worked, what are the components to focus on and the concepts. Also, my approach to interviews had to change.</p><p>Here’s what I did:</p><ol><li>I looked at weebox’s mobile system design questions not as an Android, iOS engineer. But as an architect.</li><li>I started thinking in terms of Screens, presentation layer, data layer. I read how repository pattern works.</li><li>Actively tried not to think in terms of Android concepts like work manager, foreground services, etc…I wanted to think high level, like an architect.</li><li>Picked up 1 question from Weebox, and tried to solve it myself.</li><li>Reviewed my diagrams comparing it to Weebox’s answers.</li><li>Next, pick up some concepts which I wanted to learn such as http vs https, rest vs WebSocket vs GraphQL.</li><li>Started actively critiquing my design choices. eg. why did I choose REST and not WebSocket? What’s the difference, how do they both work.</li><li>I tried mock interviewing, but couldn’t find people for it. Moreover, our timings never matched. <a href="http://mockingly.ai/">mockingly.ai</a> would have been really helpful for preparing for system design interviews. I could do the mocks on demand.</li><li>Designing libraries was no different. Even though they have no screens, they have an entry point. for example: CacheManager for a caching library, which would talk to other components like repository, file cache, sqlite etc…</li></ol><p>It took me almost 4–5 months to get my head around system design interviews. The major change was my thought process. I started to think like an architect instead of a domain expert (like android engineer, iOS engineer).</p><p>Then I scheduled some interviews.</p><blockquote><em>Want to see how Instagram, YouTube, Uber, and WhatsApp are designed from scratch? System Design Handbook walks through each system end-to-end — requirements, architecture, trade-offs, and scaling — exactly the way interviewers expect you to think. </em><a href="https://www.systemdesignhandbook.com/"><em>https://www.systemdesignhandbook.com/</em></a></blockquote><h3><strong>Interview experience</strong></h3><p>Once I got done with my prep, I decided to appear for some interviews, and luckily got a chance at one of the FAANGs.</p><p>This time I wasn’t anxious. At least not about my system design interview. I knew I had the concepts in my head, I knew I had prepared well. And if only I could communicate what I was doing and thinking and explain my decisions, it’d be a breeze!</p><p>And it was, I got the feedback, and even though I didn’t make it (due to a coding round), I had cleared the system design interview and it was s STRONG hire. Yay! I was overjoyed, I had overcome the only obstacle I had in my interview preparations.</p><p>System design had always been a mistery to me. And I had finally solved it.</p><p>I still need to prep for system design rounds, just as I need to do for coding rounds, but it’s not daunting to me anymore. I now have my resources that I can pick up just a month before the interview and be ready.</p><h4><strong>Preparation tips:</strong></h4><p>Here I’ll collate all the things that you’ll find helpful for your system design interview prep. I’ll keep it mobile focused (sorry backend engineers):</p><ol><li><a href="http://mockingly.ai/">mockingly.ai</a> for practicing system design interviews whenever you like.</li><li>Weebox’s <a href="https://github.com/weeeBox/mobile-system-design">Github</a> repository for reading up on the questions and answers. It’s like a question bank.</li><li>Alex Lementuev’s youtube channel. Some interviews are helpful. I would not take the answers on face value, but watch the flow of the interview and the candidate’s thought process.</li><li>Speak. Speak a lot! Practice thinking out loud. You’ll need this to direct the interview.</li><li>Understand how things like http, rest, GraphQL, WebSocket work and why would you pick one over the other.</li><li>Think like an architect and not a XYZ engineer.</li><li>Practice…</li></ol><p>Next up, a step-by-step framework for any system design interview:</p><ol><li>Clarify requirements.</li><li>Identify users and flows.</li><li>Break down into layers (UI, data, networking).</li><li>Highlight trade-offs.</li><li>Deep-dive into one component.</li></ol><p>Let me know if you found this blog helpful. I wished a guide existed for mobile engineers to prepare for mobile system design interviews. Here’s my attempt at creating one :)</p><p>If you’re prepping for mobile interviews, give <a href="https://mockingly.ai/">mockingly.ai</a> a try and tell me what you think. I’d love your feedback — and maybe your success story will be the next one featured here.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=96afce1f9583" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[It’s Android Rewind Time !!]]></title>
            <link>https://medium.com/@jain.ayusch10/its-android-rewind-time-594248bf5aff?source=rss-6052b8a06387------2</link>
            <guid isPermaLink="false">https://medium.com/p/594248bf5aff</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Ayusch Jain]]></dc:creator>
            <pubDate>Mon, 13 Jan 2020 05:04:41 GMT</pubDate>
            <atom:updated>2020-01-13T05:04:41.554Z</atom:updated>
            <content:encoded><![CDATA[<h3>It’s Android Rewind Time !</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*A2NUY507r7y192aQ5cTpkA.gif" /></figure><p>There’s no dull year in the world of Android and 2019 was no different. Many APIs got deprecated, many new APIs hit stable release.</p><p>So, in this article, I’ll try to incorporate all the major events in the world of Android in 2019. Let me know if you want something to be added in the comments.</p><h3>10. Android Studio is a lot Cooler!</h3><p>With updates such as Preview for Compose, Visual Editor for Motion Layout, Apply Changes android has surpassed the definition of IDE.</p><p>It has made complex processes such as connecting to Firebase, adding ML Kit etc…just a single click process! This year the Android Studio team focused on fixing performance issues and evident bugs with Android Studio and I can say that they indeed pulled off a really good job.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mF_9eIm8repS6rUj.png" /></figure><h3>9. Code Search with Cross References for the Android Open Source Project</h3><p>This was yet another big announcement in 2019. Android repository is a collection of multiple repositories and it was difficult for developers to search code references to different repositories.</p><p>Well, this has gotten easier with Code Search where developers can click a reference to another project and they’ll be redirected to that specific piece of code. I think this would be extremely useful for framework engineers who deal with AOSP on a regular basis.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dja24Ctk3pObTHSH.png" /></figure><h3>8. Huawei Ban</h3><p>In May 2019, due to to US-China trade war, Google was forced to pull Huawei’s license for Android OS.</p><p>This meant that the new Huawei phones such as Mate 30 Pro would not have the latest Android OS. However, existing Huawei devices will continue to receive security updates.</p><p>This article will give you more clarity about the whole situation: <a href="https://timesofindia.indiatimes.com/gadgets-news/heres-how-huawei-wants-to-fight-back-google-ban-for-its-android-phones/articleshow/72270853.cms">Huawei Ban</a></p><h3>7. No More 32-bit ONLY apps</h3><p>After 1st August Play Store has stopped accepting apps which support 32-bit architecture only. Developers will have 2 years to update their apps to support 32-bit Architectures as after that their 32-bit only apps wouldn’t be available for download.</p><p>However this is relaxed for games built on Unity engine 5.6 as it can be costly for game developers to upgrade. You can read more about how to upgrade <a href="https://developer.android.com/distribute/best-practices/develop/64-bit">here.</a></p><h3>6. Work Manager hits Stable Release</h3><p>Work Manager is one of the most brilliant APIs Google has released for android in a long time. It hit stable release on 9th March 2019.</p><p>It is a Scheduler API to schedule deferrable tasks on a worker thread. In fact, I’ve written a series of articles on Work Manager which you should definitely check out:</p><ul><li><a href="https://ayusch.com/work-manager-in-android/"><strong>Making Work Manager Work For You</strong></a></li><li><a href="https://ayusch.com/implementing-work-manager-in-android/"><strong>Implementing Work Manager in Android</strong></a></li></ul><h3>5. Android Supports Dark Theme</h3><p>Android Q now officially supports dark theme. It was long due and finally was announced at Google IO 2019.</p><p>And it’s as easy as creating a new theme in styles.xml extending from <strong>Theme.AppCompat.DayNight</strong>. Have a look at this article to know more about how to add dark theme to your android app.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*mz1aDfX79wTkNhFB.png" /></figure><h3>4. Flutter Web Support moves to Beta</h3><p><a href="https://ayusch.com/getting-started-with-flutter-app-development/"><strong>Flutter</strong></a> hit stable release in December 2018 and just a year later, it has moved it’s web support to Beta. It is a toolkit by Google to enable developers to build apps for Mobile, Web and Desktop with a single codebase.</p><h3>3. JetPack Compose hits Developer Preview</h3><p>Jetpack Compose recently moved from alpha to developer preview. And though I was vary of using it at first, but it grew upon me as I built a small application with it. If you want to know about JetPack Compose, I’d suggest giving this article a read.</p><ul><li><a href="https://ayusch.com/android-jetpack-compose/"><strong>Jetpack Compose Once and For All!</strong></a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VaqlL-ihDNz3-LGL.png" /></figure><h3>2. Goodbye AsyncTasks</h3><p>For many Android Developers, AsyncTask was their first API for networking/offloading tasks from UI threads. And to be honest, they worked really well if used properly.</p><p>But with the advent of Volley, Retrofit, RxJava and now Coroutines, it was eventually time for <a href="https://www.techyourchance.com/asynctask-deprecated/">AsyncTask to be deprecated</a>. AsyncTasks will be deprecated from Android 11.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/783/0*IM110NYvg19PDpK-.jpeg" /></figure><h3>1. No More Deserts!</h3><p>This was probably the biggest announcement of 2019 when Google dropped the tradition of naming new android releases based on deserts with Android 10.</p><p>Reason given by Google was that desert names don’t resonate with everyone around the world and numbers were probably the way to go for Android OS to be recognised internationally.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KtlS60Fwy65_X__8.png" /></figure><p>These were the 10 major announcements from the Android world in 2019. Next year we have a lot to look forward to especially with things such as Jetpack compose, Camera X stable release, Flutter stable release for web.</p><p>If you want something to be added to the list, let me know in the comments section below.</p><blockquote><strong><em>*Important*</em></strong><em>: Join the </em><strong><em>AndroidVille</em></strong><em> </em><a href="https://rebrand.ly/73lbl3"><strong><em>SLACK</em></strong><em> </em></a><em>workspace for mobile developers where people share their learnings about everything latest in Tech, especially in </em><strong><em>Android Development, RxJava, Kotlin, Flutter, and mobile development in general</em></strong><em>.</em></blockquote><blockquote><a href="https://rebrand.ly/73lbl3"><strong><em>Click on this link to join the workspace. It’s absolutely free!</em></strong></a></blockquote><p><em>Like what you read? Don’t forget to share this post on </em><a href="https://www.facebook.com/AndroidVille"><strong><em>Facebook</em></strong></a><em>, </em><strong><em>Whatsapp</em></strong><em>, and </em><a href="https://www.linkedin.com/"><strong><em>LinkedIn</em></strong></a><em>.</em></p><p><em>You can follow me on </em><a href="https://www.linkedin.com/in/ayuschjain"><em>LinkedIn</em></a><em>, </em><a href="https://www.quora.com/profile/Ayusch-Jain"><em>Quora</em></a><em>, </em><a href="https://twitter.com/ayuschjain"><em>Twitter</em></a><em>, and </em><a href="https://www.instagram.com/androidville/"><em>Instagram</em></a><em> where I </em><strong><em>answer</em></strong><em> questions related to </em><strong><em>Mobile Development, especially Android and Flutter</em></strong><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=594248bf5aff" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>