<?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 Alok on Medium]]></title>
        <description><![CDATA[Stories by Alok on Medium]]></description>
        <link>https://medium.com/@zerion0?source=rss-d85eba17769f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*bl_X_lmLF81c-BYhCJ3Cnw.jpeg</url>
            <title>Stories by Alok on Medium</title>
            <link>https://medium.com/@zerion0?source=rss-d85eba17769f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 10:38:27 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@zerion0/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[Why Fast Shipping and Good Product Rarely Coexist]]></title>
            <link>https://zerion0.medium.com/why-fast-shipping-and-good-product-rarely-coexist-3fca0e2d0425?source=rss-d85eba17769f------2</link>
            <guid isPermaLink="false">https://medium.com/p/3fca0e2d0425</guid>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Alok]]></dc:creator>
            <pubDate>Fri, 26 Jun 2026 03:31:01 GMT</pubDate>
            <atom:updated>2026-07-24T17:58:28.100Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5RvQzuIdhBxkeHval8_Gmg.png" /></figure><h3>Current problem of developers</h3><p>Over the past 2 to 3 months, I have been observing many projects, whether they are open-source projects or company projects. The use of AI has become so high that people have almost stopped using their own brain cells.</p><p>There is no doubt that AI can ship great-quality code, but there is a quote that perfectly fits these new developers: “<strong>Bandar kya jaane adrak ka swad,</strong>” or in English, “<strong>Casting pearls before swine</strong>.”</p><p>Just ask yourself: do you really know the basic syntax of the code you are shipping? Without even knowing the basic syntax, you are shipping production-level code. Just ask yourself, how can you really design a production system with that level of understanding?</p><p>Let me give you an example.</p><p>At my workplace, I was assigned to a new project where people earning 2x or 3x more than me were working. They were facing a DB timeout issue, and when I looked at the code, I easily found the problem.</p><p>Instead of running a long task in Lambda or a proper background job, they were directly running that task on the server. When I asked them about that code, they told me, “It was written by AI.”</p><p>Really, dude?</p><p>If my seniors are writing that kind of code and shipping it to production, then what do you expect from juniors?</p><h3>Why it Require to know the basic CS Fundamental</h3><p>To be honest, if you think that in this AI era you do not need to learn the basic fundamentals of CN, DBMS, programming, and a basic level of <strong>DSA</strong>, then you are on the wrong path.</p><p>Whether you know it or not, there are three levels of vibe coding. These are my own terms, and I am referring to prompt engineering here:</p><ol><li><em>Cracked people vibe coding</em></li><li><em>Senior-level vibe coding</em></li><li><em>Tab monkey</em></li></ol><p>Let me give you an example.</p><ol><li>Suppose <em>Andrej Karpathy</em> wants to build a feature. He knows all the details: how to build it, the best way to build it, and what precautions he needs to take while developing it.</li></ol><p>When he does vibe coding, he will still review the code, make changes, add his own logic if required, test it properly, and then ship it.</p><ol><li>Suppose a <em>senior</em> developer starts vibe coding. He may not know every tiny detail, and he may miss some edge cases, but he will still understand the basic structure of the feature. He will try to cover the important test cases, check the flow, think about performance, and then ship it.</li><li>Now comes the <strong><em>tab monke</em></strong>y.</li></ol><p>Suppose a developer does not know basic CS fundamentals and starts shipping features without understanding load, performance, testing, edge cases, or maintainability.</p><p>Just imagine what kind of feature he will ship.</p><p>Because of that, the whole project slowly becomes unmaintainable.</p><h3>The Effect of Short Attention Spans on Developers</h3><p>To be honest, this is the biggest enemy of any developer, or any person nowadays.</p><p>Developers using AI have developed such a low attention span that they cannot even bother to learn something new. They just write a prompt and keep prompting without knowing what they are doing, without understanding the basic code flow, and without caring about the reusability or maintainability of the code.</p><p>Let me give my own example.</p><p>Previously, I designed my portfolio in TanStack Start. Initially, I thought, “I know React, so why would I need to write all the code from scratch?” That was my biggest mistake.</p><p>I used Claude Opus 4.8, and it built the whole portfolio for me. I kept going, kept using different models, kept adding routes, and eventually I started facing small issues. Those issues were fixable, but when I looked at my code, it had become a complete mess.</p><p>There was no reusability in the code. Even a single small change required changes in two or three different places. That was when I realized that even if I published that portfolio and it looked beautiful, it was still a hollow project that I was not ready to show anyone.</p><p>So I rewrote the whole portfolio in Next.js from scratch, with less use of AI. Now I understand each flow and each line of code.</p><p>Even if I ask you, “What is the most recent thing you have learned so far?” do you have an answer for it?</p><p>I asked the same question to my senior: “Besides CRUD, what else have you done, and what have you learned?”</p><p>She had no answer.</p><p>People do not want to learn. People only want to build things, but they forget that building real things requires learning.</p><p>Just ask ourselves: when did you last read the last documentation of any website or any technologies that you are currently learning?</p><p>What we are doing now, we are directly going to the chatbot or the cloud and just telling them, “Give me the syntax of that thing, or I am not able to make that logic. Give me the correct logic, all these things.” Even I am doing that, and that is the best, the worst thing that you can do in the coding arena. If you are doing this or if you are liking me, then probably we both need to work on that.</p><h3>A Hollow Heart developer</h3><p>The term I made for these people is “<strong>jumpers</strong>.”</p><p>These are people who keep learning different things, but never stick to one thing long enough. One month they start learning Golang, next month they move to Rust, after 15 days they start Figma design, and the next day they call themselves React developers.</p><p>I would place myself in that category too.</p><p>After realizing this, I wrote this blog. People think that if you know everything, you become irreplaceable and everyone will praise you. But in reality, you know nothing deeply. You do not even know the basics of one language properly. You are not capable of building a project that requires designing a complex system or making good architectural decisions.</p><p>Sometimes, you have to stick to one thing and extend your knowledge in that area instead of jumping from one language or technology to another.</p><p>I have seen many people on X who only focus on UI, but they keep extending their knowledge inside that area. They learn math, WebGL, font design, animation, and other things that actually help them become better.</p><p>The best line for this is: “Do not try to ride two horses at once. Pick one path.”</p><h3>The Hall of Shame</h3><p>Nowadays, if you tell any people that you are not using an AI agent to generate the coding, then they will probably tell you that you are going to get replaced and other things. Nowadays, it has become very seamless to say the same thing, even if you are not using any AI agent, even in your company, or whether you are a working professional. There will, of course, be pressure on you to directly use the Chatbot’s Claude code or anything to ship any product. Without knowing the product, without getting the architecture, why you are building, and without performing any unit test, you are directly shipping on that, without knowing what you can expect from that type of product.</p><p>Apart from that, I know that if you are shipping like that, then this means that your product is going to fail. You are going to get more bugs, and you will consume much more AI tokens than expected. You are just becoming a tab monkey man.</p><p>Just ask yourself some basic questions about OS, DBMS, or any other CS fundamentals. When was the last time you revised all these things? Are you just tabbing through suggestions, accepting them, or generating responses from ChatGPT or any chatbot and directly pasting them? Whether you believe it or not, you should not do that unless you actually understand these things.</p><p>Let me give you an example. Last month, I did more vibe coding than expected. I was just accepting whatever Cursor generated. Because of that, I started forgetting basic things, like how to use useEffect, how to use useCallback, and even the syntax of useState.</p><p>Just think about it. If I go into an interview and the interviewer asks me to write the syntax of useEffect, and I am not able to write it, that would be a serious problem. The same thing can happen to you.</p><p>For example, if you are doing vibe coding all the time and the interviewer asks you to write code without using AI, or manipulate data without AI, you may not be able to do it. You may not clearly understand the difference between filter, reduce, and other JavaScript methods, even if you are a JavaScript developer.</p><p>The same applies to C++. If someone asks you to write code without using bits/stdc++.h, and you are not able to do it, that means your basics are weak. This applies to competitive programming as well. The same goes for Java and other developers too.</p><p>AI is useful, but you should not let it replace your fundamentals.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3fca0e2d0425" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Must-Take Precautions While Designing Your Backend]]></title>
            <link>https://zerion0.medium.com/must-take-precautions-while-designing-your-backend-5feae108bada?source=rss-d85eba17769f------2</link>
            <guid isPermaLink="false">https://medium.com/p/5feae108bada</guid>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Alok]]></dc:creator>
            <pubDate>Fri, 13 Mar 2026 19:51:06 GMT</pubDate>
            <atom:updated>2026-03-13T19:52:00.414Z</atom:updated>
            <content:encoded><![CDATA[<p>Most backend systems don’t fail because of bad logic. They fail because of bad structure, blind trust, and decisions made in a hurry that nobody wants to touch six months later. Whether you’re starting fresh or scaling something existing, there are a handful of things that will save you enormous pain down the road. This is not a beginner’s tutorial. These are lessons learned from real projects that either held up or fell apart.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/796/1*tyKLWp3lKqvUIm8Ye6zLtQ.png" /><figcaption>Backend checklist</figcaption></figure><h3>1. Structure Your Folders by Feature, Not by Function</h3><p>No doubt you learn this structure while learning from online toturial or making any project following this classing service, controller, routes</p><p>The classic mistake looks like this:</p><pre>/controllers<br>  authController.js<br>  userController.js<br>/services<br>  authService.js<br>  userService.js<br>/routes<br>  authRoute.js<br>  userRoute.js</pre><p>At first glance it feels organized. But every time you work on the auth feature, you&#39;re jumping across three folders. Your mental model of &quot;auth&quot; is scattered across your entire codebase.</p><p>Instead, group by feature:</p><pre>/auth<br>  auth.controller.js<br>  auth.service.js<br>  auth.route.js<br>/user<br>  user.controller.js<br>  user.service.js<br>  user.route.js<br>/order<br>  order.controller.js<br>  order.service.js<br>  order.route.js</pre><p>Now when a new developer joins and needs to touch auth, they go to /auth and everything they need is right there. Deleting a feature becomes a single folder deletion. Testing becomes easier. Ownership is clear.</p><p>This pattern becomes non-negotiable once your codebase grows past a certain size.</p><h3>2. Never Trust the Client</h3><p>Your frontend is not your security layer. It never was. Anyone with a browser devtools window or a curl command can send whatever they want to your API. Input that looks clean in your UI can arrive at your server completely malformed, malicious, or just plain wrong.</p><p>Add validation on the server side. Always. Use <strong>Zod</strong> or a similar schema library:</p><pre>import { z } from &quot;zod&quot;;</pre><pre>const registerSchema = z.object({<br>  email: z.string().email(),<br>  password: z.string().min(8),<br>  username: z.string().min(3).max(20),<br>});</pre><pre>// In your route handler<br>const result = registerSchema.safeParse(req.body);<br>if (!result.success) {<br>  return res.status(400).json({ errors: result.error.flatten() });<br>}</pre><p>The rule is simple: validate the shape, type, and constraints of every incoming request before it touches your business logic or your database. No exceptions.</p><h3>3. Add a Rate Limiter</h3><p>Without rate limiting, a single user can hammer your API thousands of times per minute. That might be someone trying to brute force a login, scrape your data, or just a bug in their client making infinite retry loops.</p><p>Rate limiting is a one-time setup with a large payoff. Using Express? express-rate-limit is simple and effective:</p><pre>import rateLimit from &quot;express-rate-limit&quot;;</pre><pre>const limiter = rateLimit({<br>  windowMs: 15 * 60 * 1000, // 15 minutes<br>  max: 100,<br>  message: &quot;Too many requests, please try again later.&quot;,<br>});</pre><pre>app.use(&quot;/api&quot;, limiter);</pre><p>For auth routes specifically, make it stricter. A login endpoint should not allow 100 attempts in 15 minutes from the same IP. Drop that to 5 or 10 and lock it down.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1005/1*vLR5iafW0D01KMSWOU_0Sw.png" /><figcaption>how rate limiter protect you</figcaption></figure><h3>4. Cache Frequently Accessed Data with Redis</h3><p>If your app is reading the same data from the database on every request, you’re leaving a lot of performance on the table. User profiles, product catalogs, configuration settings, dashboard summaries. These don’t change on every request, yet many backends query the database every single time.</p><p>Redis fixes this:</p><pre>import redis from &quot;ioredis&quot;;<br>const client = new redis();</pre><pre>async function getUserProfile(userId) {<br>  const cached = await client.get(`user:${userId}`);<br>  if (cached) return JSON.parse(cached);</pre><pre>  const user = await db.users.findById(userId);<br>  await client.setex(`user:${userId}`, 3600, JSON.stringify(user));<br>  return user;<br>}</pre><p>The pattern is straightforward: check the cache first, hit the database only on a miss, and write the result back to cache with an expiry. Your database will thank you when traffic spikes.</p><h3>5. Stop Reaching for External Packages for Small Tasks</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/867/1*uIe-64ljVc5HKqkLPdq1Og.png" /><figcaption>the blackhole theory of node modules</figcaption></figure><p>This one is a slow leak. You add a package to check if a string is a palindrome. Another one to capitalize a word. Another for deep equality checks. Before long, your node_modules is 400MB and half of it is solving problems that are two lines of JavaScript.</p><p>Every external dependency is a maintenance burden, a potential security vulnerability, and a source of supply chain risk. The npm ecosystem has had multiple incidents where a small, widely used package was compromised or simply deleted, breaking thousands of projects overnight. Before installing anything, ask yourself: can I write this in under 20 lines?</p><p>That said, there are cases where the logic is genuinely complex. Temporary email detection is one of them. If you’re building anything with user accounts, people will sign up with throwaway emails from services like Mailinator or Guerrilla Mail to skip your onboarding flow, bypass paywalls, or just avoid getting any follow-up.</p><p>Here is the thing though: you don’t need a package for this either. There is a GitHub repo called disposable-email-domains that maintains a list of over 3000 known throwaway email domains. Just copy that list into your own project as a local file:</p><pre>import { validate } from &quot;deep-email-validator&quot;;</pre><pre>const result = await validate(&quot;user@mailinator.com&quot;);<br>if (!result.valid) {<br>  return res.status(400).json({ error: &quot;Disposable emails are not allowed.&quot; });<br>}</pre><p>The rule is: be picky. Add dependencies that solve genuinely hard problems. Don’t add them because you don’t want to write a for loop.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RyrOLR_23n16nqlaQ8KJ7w.png" /></figure><h3>6. Design Before You Code</h3><p>This one gets skipped the most and causes the most regret.</p><p>Before you write a single route, sit down with a tool like Excalidraw and sketch out how your system actually works. Draw the entities. Draw the data flow. Map out which service calls which. Decide where authentication sits. Figure out where caching makes sense. Think about what happens when things fail.</p><p>A design-first approach forces you to catch bad ideas before they become bad code. Changing a box in a diagram takes ten seconds. Refactoring a tightly coupled service takes three days. The investment pays for itself before you’ve written a single line.</p><p>You don’t need a fancy tool. Excalidraw is free, fast, and runs in the browser. The habit matters more than the tool.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/993/1*wVuoiirtc1d0VS4LA6Q9pQ.png" /></figure><h3>Wrapping Up</h3><p>None of these things are exotic. They’re all well-known practices, but the gap between knowing them and actually doing them is where most backend problems are born. Structure your folders so a new developer can navigate them. Validate everything that comes from the outside. Protect your endpoints with rate limiting. Cache data that doesn’t need to be fetched fresh every time. Be deliberate about your dependencies. And before you write any of it, think it through on paper first.</p><p>Get these six things right and you’ll spend a lot less time firefighting and a lot more time building.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5feae108bada" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Button That Sells Your Identity: What Really Happens When You 'Login with Google']]></title>
            <link>https://zerion0.medium.com/the-button-that-sells-your-identity-what-really-happens-when-you-login-with-google-4d6cb08e02d0?source=rss-d85eba17769f------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d6cb08e02d0</guid>
            <category><![CDATA[google]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[security]]></category>
            <category><![CDATA[privacy]]></category>
            <category><![CDATA[oauth]]></category>
            <dc:creator><![CDATA[Alok]]></dc:creator>
            <pubDate>Sat, 07 Mar 2026 20:45:47 GMT</pubDate>
            <atom:updated>2026-03-07T20:46:35.816Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Button That Sells Your Identity: What Really Happens When You ‘Login with Google’</h3><blockquote><strong><em>OAuth is destroying your privacy and most people have no idea.</em></strong></blockquote><p>Every time you click that blue button, a quiet transaction happens and you are the product, not the customer.</p><p>OAuth 2.0 powers almost every “Login with ___” button on the internet. It was designed to be secure. It is, technically. But <strong>security and privacy are not the same thing.</strong> OAuth can protect your password while simultaneously exposing everything else about you to a constellation of third parties — most of whom you’ve never heard of and will never meet.</p><p>This article is about what actually happens when you press that button.</p><h3>The OAuth Flow — Step by Step</h3><p>OAuth is an authorization protocol, not an authentication one — though it’s commonly used for both. Here’s what happens in the roughly 800 milliseconds after you click “Login with Google”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3VoEGKg1JPwLXVIoRva9bQ.png" /><figcaption><em>The OAuth 2.0 Authorization Code Flow</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*VY0VYmblqKXwsw0uJyEJMw.png" /></figure><p>Notice step 9: <strong>Google also logs this authorization event.</strong> Every app you’ve ever connected to your Google account appears in your security dashboard. Google knows you use Spotify, Notion, Slack, every newsletter tool you signed up for, and every productivity app you tried once and forgot about.</p><p>This is not a flaw. This is how the protocol works by design.</p><blockquote>“OAuth doesn’t just let an app see your data. It creates a permanent record — held by Google, held by the app, and potentially sold to a dozen ad networks — of the fact that you exist.”</blockquote><h3>Who Learns What About You</h3><p>There are three parties in every OAuth transaction. Each learns something different.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fAgy8v5xrCaZ8w37gJFppg.png" /><figcaption><em>The Three-Party Data Exposure Map</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/722/1*uLBEQM7zLDaXGeQSKSH_lg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/737/1*Z4iKvErLAcBHufjWCjqJPg.png" /></figure><h3>What Google (Identity Provider) Learns</h3><p>Data Point Risk Level Which app you just authorized Medium Exact timestamp of authorization Medium Your IP address and device fingerprint High Which scopes (permissions) you granted High How often the app calls the API on your behalf Medium Whether you later revoke access Low Cross-referenced with your Gmail, Maps, Search history <strong>Critical</strong></p><h3>What the Third-Party App Learns</h3><p>Data Point Notes Your full name From Google profile Primary email address Can be sold to data brokers Profile photo URL Permanent link Google Account ID (sub) <strong>Permanent. Never changes. Links all activity.</strong> Locale and language settings Reveals region and language Email verification status Tells them Google trusts your email Access Token Valid for 1 hour, used to make API calls Refresh Token (if requested) <strong>Never expires. Silent, permanent access.</strong></p><p>That sub field in the token is particularly dangerous. It is a permanent, unique identifier for your Google account. Every app you have ever authorized has this number. They can use it to cross-reference you across services, build profiles, and identify you even if you change your email address.</p><h3>Scopes — The Permission System Most People Ignore</h3><p>When Google shows you the consent screen, it lists “scopes” — specific data the app is requesting. Most people glance at this screen for approximately 0.8 seconds before clicking Allow.</p><p>Here is what those scopes actually mean:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/780/1*dFTdQKwzLJ2B8SNoF5uQtg.png" /></figure><p><strong>The alarming part:</strong> many apps request far more than they need. A recipe app has no legitimate use for your Gmail. A to-do list tool doesn’t need calendar write access. But you granted it — and now they have it, permanently.</p><blockquote><strong><em>Real Case (2018):</em></strong><em> It emerged that hundreds of third-party apps had been granted Gmail read access through OAuth — including data analytics firms that employed actual humans to read users’ private emails for product training. This was all technically permitted under Google’s policies at the time.</em></blockquote><h3>What’s Inside That Access Token</h3><p>Google issues a JWT (JSON Web Token) as part of the OAuth response. When decoded, the payload reveals far more than most users ever consciously consent to sharing.</p><p><strong>Example decoded JWT payload:</strong></p><pre>{<br>  &quot;iss&quot;: &quot;https://accounts.google.com&quot;,<br>  &quot;sub&quot;: &quot;110169484474387970369&quot;,<br>  &quot;email&quot;: &quot;you@gmail.com&quot;,<br>  &quot;email_verified&quot;: true,<br>  &quot;name&quot;: &quot;Your Full Name&quot;,<br>  &quot;picture&quot;: &quot;https://photo.url/your-photo.jpg&quot;,<br>  &quot;locale&quot;: &quot;en-IN&quot;,<br>  &quot;iat&quot;: 1730000000,<br>  &quot;exp&quot;: 1730036000,<br>  &quot;azp&quot;: &quot;243262207867.apps.googleusercontent.com&quot;<br>}</pre><h3>The Refresh Token Problem</h3><p>Access tokens expire after about one hour. Refresh tokens do not.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VIfNqUtj-8S3DP8FyPBniw.png" /><figcaption><em>The Refresh Token Problem</em></figcaption></figure><p>When an app requests offline_access — which many do — they receive a refresh token that lets them generate new access tokens indefinitely, <strong>without you ever logging in again.</strong></p><p>Token Type Lifespan What It Does Access Token ~1 hour Makes live API calls. Expires and becomes useless. Refresh Token <strong>Forever</strong> (unless revoked) Silently generates new access tokens in the background. ID Token (JWT) Session Snapshot of your identity. Often stored permanently in the app’s database.</p><p>This means an app you authorized in 2021 may still be actively querying your Google profile today. You don’t know. There’s no notification. You’ve long since forgotten you gave them access.</p><p><strong>How to check:</strong> Go to <a href="https://myaccount.google.com/permissions">myaccount.google.com/permissions</a> — you will almost certainly find apps you don’t recognize.</p><h3>The 12-Month Privacy Erosion Timeline</h3><p>It doesn’t happen all at once. Your data exposure compounds over time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KZ5ifUwuDjsgEGC1yaC-ww.png" /><figcaption><em>12-Month Privacy Erosion Timeline</em></figcaption></figure><p>Time Event Impact Day 1 Sign up for productivity app App gets name, email, Google ID. Google logs the event. Week 2 Log into news aggregator Requests profile + email. Your email added to 3 partner marketing lists. Month 2 Authorize a calendar tool Requests calendar.readonly. App now knows your work schedule, travel plans, doctor appointments — indefinitely. Month 4 Productivity app is acquired Your data transfers to new owner with a very different privacy policy. Month 7 Calendar app is breached Stolen access token lets attacker read your calendar silently until you revoke it. Month 12 You have 40+ active OAuth tokens Most forgotten. You have no idea who has access to what.</p><h3>What Google Builds From Your OAuth Activity</h3><p>Every authorization event feeds Google’s data graph. Google doesn’t just know which apps you use — it knows what those apps reveal about you.</p><p>Signal What Google Infers Fitness apps authorized Health interests, possible medical conditions Finance apps authorized Income bracket, investment behavior Dating apps authorized Relationship status, sexual orientation App usage timestamps Work patterns, sleep schedule, mental state IP address history Where you live, travel patterns, routines Contacts-scope granted Social graph — who you know and how important they are Competitor app signed up for Active purchase intent — advertising gold</p><p>Google’s privacy policy explicitly states that they use data from third-party sites and apps to improve their services and deliver targeted ads. OAuth activity is data. It is collected. It is used.</p><blockquote>“The ‘Login with Google’ button isn’t just a convenience feature. It is Google’s distributed surveillance network — running on someone else’s app, paid for by that app’s users.”</blockquote><h3>What You Can Actually Do About It</h3><h3>1. Audit Your Connected Apps</h3><p>Go to <strong>myaccount.google.com/permissions</strong>. Revoke everything you don’t actively use. This won’t delete data already collected, but it stops future access and invalidates refresh tokens.</p><h3>2. Use a Dedicated or Alias Email Instead</h3><p>For apps you’re not sure about, create a real account with a password and a separate email address. The trade-off is convenience for privacy. Sometimes that’s worth it.</p><h3>3. Read the Scope Screen</h3><p>When an app asks for Gmail access to “improve your experience” — deny it. Legitimate apps that don’t need email access won’t break if you refuse. If they do break, that tells you something important about what they were actually doing.</p><h3>4. Prefer Apps That Request Minimal Scopes</h3><p>A well-designed, privacy-respecting app only asks for what it needs. If a simple to-do app wants your Google Contacts, that’s a red flag.</p><h3>5. Check Privacy Policies for Data-Sharing Language</h3><p>Look specifically for phrases like “partners,” “affiliates,” and “service providers.” These are the entities you’ve never heard of who will eventually have your data.</p><h3>Comparing OAuth Providers</h3><p>Not all OAuth providers handle data the same way:</p><p>Provider Data Collected Ad Business Revocation URL Google Extensive — links to Gmail, Maps, Search Yes — core business myaccount.google.com/permissions Apple Minimal — hides your real email by default No appleid.apple.com Facebook Extensive — social graph, behavior Yes — core business facebook.com/settings/apps GitHub Account info, repos (if scoped) No github.com/settings/applications Microsoft Profile, email Partial myaccount.microsoft.com</p><p><strong>Apple’s “Sign in with Apple”</strong> is the most privacy-respecting mainstream option. It generates a random relay email address that forwards to your real one, so the app never learns your actual email.</p><h3>The Uncomfortable Conclusion</h3><p>OAuth 2.0 is a well-designed protocol. The engineers who built it thought carefully about security. In that narrow sense, it works: your password stays with Google, not with random apps.</p><p>But privacy is not the same as security. You can have perfect security and zero privacy simultaneously. OAuth achieves exactly this for most users.</p><p>The button that says “Login with Google” should really say:</p><blockquote>“Allow Google to know you use this app, allow this app to have your profile data forever, allow this app’s future acquirers to have it too, and allow the entire chain of data partners to enrich their profiles of you with this new signal.”</blockquote><p>It’s a lot to put on a button. Which is probably why they went with “Login with Google.”</p><p><strong>Before you click “Allow” next time, ask yourself:</strong> Do I trust this app enough to give them my Google profile data forever? Do I trust their future owners? Do I trust their data partners? Do I trust their security practices?</p><p>If the answer to any of these is <em>“I don’t know”</em> — that is probably reason enough to use a password instead.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d6cb08e02d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Do Progressive Blur Matters in your website]]></title>
            <link>https://zerion0.medium.com/do-progressive-blur-matters-in-your-website-2f7826e6494e?source=rss-d85eba17769f------2</link>
            <guid isPermaLink="false">https://medium.com/p/2f7826e6494e</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[full-stack-developer]]></category>
            <dc:creator><![CDATA[Alok]]></dc:creator>
            <pubDate>Sun, 15 Feb 2026 17:23:13 GMT</pubDate>
            <atom:updated>2026-02-15T17:23:13.632Z</atom:updated>
            <content:encoded><![CDATA[<p>So hello guys, are you tired of trying backdrop-blur-sm, backdrop-blur-xl, etc., and still not satisfied with the blur? Sometimes it looks awful.</p><p>Let me give you an example of two types of blur:</p><ol><li><strong>Normal backdrop blur</strong></li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/807/1*xW61Ytw2uhrKnJDCeNdqDA.png" /></figure><p>Here you can clearly see an edge. There is a visible line that separates the blurred area.</p><p>2. <strong>Progressive blur</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tAKJUPeTyhyHf6ANXS3RGg.png" /></figure><p>In the second picture, you can see that the separating line is gone. The blur looks much more professional while still keeping the header distinct from the rest of the content.</p><p>So the question is: how can you build this?</p><p>There are two ways to build this. I’ll show you from the easiest to the hardest.</p><p>→ First, using a gradient mask image.</p><p>You can create a gradually blurred SVG in Figma and use it directly in your project. The downside is that it may not produce the exact result you want. You’ll also have limited customization over the blur and how you apply it in your project.</p><p>→ Using pure CSS with some math.</p><p>You can look at examples like <a href="https://magicui.design/docs/components/progressive-blur">MagicUI</a> or <a href="https://reactbits.dev/animations/gradual-blur">ReactBits</a>. I found ReactBits to be complex, with external dependencies and heavy math.</p><p>Then I found a simpler <a href="https://codepen.io/silas/pen/rNYqZoz">CodePen</a> example that was easier to understand.</p><p>After spending an hour studying it, I was finally able to build my own progressive dynamic blur component with no external libraries and much simpler logic.</p><p>progressiveblur.tsx <a href="https://ray.so/9UNs5WB">code Link</a></p><p><strong>How the Progressive Blur Work</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aGTH5pHfvrgDPpiRtXc1mw.png" /></figure><p>This picture shows how a progressive blur works.</p><p>Instead of applying the same blur everywhere, the blur is divided into multiple horizontal layers. Each layer has a different intensity.</p><p>At the bottom, the blur is very light. As you move upward, the blur slowly increases. By the time you reach the top, the blur is much stronger.</p><p>The idea is simple: stack several sections on top of each other and gradually increase the blur value. This creates a smooth transition. It removes the harsh visible line you usually get with a single backdrop blur and makes the header feel naturally separated from the rest of the content</p><p><strong>Where does progressive blur shine?</strong></p><ul><li>It works especially well in card components where you want to show text on top of an image. The gradual blur keeps the image visible while making the text readable.</li><li>It’s also great for headers and footers. It helps separate sections without using harsh borders or solid backgrounds.</li></ul><p>This type of blur adds a clean, premium feel to the UI and improves the overall user experience.</p><p><strong><em>Some Example of Progressive from Internet</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-KNPOoX0Fvmg0mmx" /></figure><p>Some Portfolio that uses Progressive blur</p><ol><li><a href="https://zerion0.site/">Zerion</a></li><li><a href="https://legions.dev/">legion dev</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2f7826e6494e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>