<?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 Simran Sachdeva on Medium]]></title>
        <description><![CDATA[Stories by Simran Sachdeva on Medium]]></description>
        <link>https://medium.com/@dotslashsimran?source=rss-a9edd1162ca1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ZlJ6fQ-bYBHoH9RM3yXGDg.jpeg</url>
            <title>Stories by Simran Sachdeva on Medium</title>
            <link>https://medium.com/@dotslashsimran?source=rss-a9edd1162ca1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 23:02:48 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dotslashsimran/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[Caching for dummies (Redis Edition)]]></title>
            <link>https://medium.com/@dotslashsimran/caching-for-dummies-redis-edition-b65a20656259?source=rss-a9edd1162ca1------2</link>
            <guid isPermaLink="false">https://medium.com/p/b65a20656259</guid>
            <category><![CDATA[database]]></category>
            <category><![CDATA[caching]]></category>
            <category><![CDATA[scalability]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[backend-development]]></category>
            <dc:creator><![CDATA[Simran Sachdeva]]></dc:creator>
            <pubDate>Fri, 21 Nov 2025 09:37:41 GMT</pubDate>
            <atom:updated>2025-11-21T09:37:41.350Z</atom:updated>
            <content:encoded><![CDATA[<h3>What the hell is caching?</h3><p>Caching = <strong>remembering things so you don’t have to do the slow thing again</strong>.<br>Basically, Instead of recalculating or refetching data, we store it in a <strong>super-fast memory DB</strong> like Redis.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*eIeh-Kv9nJpy6y0l5R-cIA.webp" /></figure><h3>Why is Caching Necessary?</h3><p>Every backend performs the same expensive tasks repeatedly:</p><ul><li>Fetching from a relational database (slow I/O)</li><li>Talking to third-party APIs (failure-prone)</li><li>Doing CPU-heavy computations (money money money)</li><li>Re-serialising and re-formatting responses</li></ul><p><strong>Without caching:</strong></p><blockquote><em>High traffic = High latency → angry users → angry PMs → sad devs.</em></blockquote><p><strong>With caching:</strong></p><blockquote><em>Same traffic, faster responses, lower cost.</em></blockquote><p>Speed = engagement.<br> Speed = conversions.<br> Speed = revenue.</p><p>This is why <strong>Redis is everywhere, </strong>from Netflix to Instagram to Discord.</p><h3>Different Layers of Cache (and When to Use Them)</h3><p>Caching can exist at multiple layers:</p><ol><li><strong>Client-side cache</strong></li></ol><p>Browser localStorage, mobile app storage<br>Good for: JWT tokens, UI state<br>Bad for: Anything sensitive</p><p><strong>2. CDN / Edge cache</strong></p><p>Cloudflare, Akamai, Fastly<br> Good for: Static pages, images, videos<br> Massive scale, worldwide</p><p><strong>3. Server-side cache (Redis)</strong></p><p>The majority of caching lives here<br> Good for: Query results, API responses, user sessions<br> (The star of this article)</p><p><strong>4. Database-level cache</strong></p><p>Query caching built into DB engines<br> Good for: Repeated SELECTs<br> You don’t control behaviour fully</p><p>Redis buffers your database like a bouncer buffers at a nightclub:</p><blockquote><em>Only real VIP queries are allowed in. The rest are handled at the door.</em></blockquote><h3>TTL — Time to Live (Forget)</h3><p>Caches should <strong>forget</strong>.</p><p>TTL (Time To Live) means each cached item expires after a duration:</p><p>Example</p><p>Suggested TTL</p><p><strong>Home feed</strong> 1–5 minutes</p><p><strong>Weather updates</strong> 30–90 seconds</p><p><strong>Product inventory count</strong> &lt; 10 seconds</p><p><strong>User login session</strong> Hours to days</p><p>Why TTL matters:</p><ul><li>Prevents stale data</li><li>Frees up space automatically</li><li>Avoids breaking real-world expectations</li></ul><p>If users expect data to change, don’t cache forever.</p><h3>Redis Trash Management</h3><p>RAM is limited. Redis must throw things out when full.</p><p>Common eviction strategies:</p><ul><li><strong>LRU</strong> — Least Recently Used<br> Default in many setups</li><li><strong>LFU</strong> — Least Frequently Used<br> Great when popularity matters</li><li><strong>FIFO</strong> — First In First Out<br> Simple but not very smart</li><li><strong>Noeviction</strong> — Errors instead of removal<br> Aka “chaos mode”</li></ul><p>In most production systems:<br> <strong>Use LRU or LFU.</strong></p><h3>Session Storage</h3><p>Servers crash, autoscale, redeploy.<br>User sessions shouldn’t vanish.</p><p>Redis enables:</p><ul><li>Centralised session storage</li><li>Durable login state</li><li>Shopping carts that survive page refreshes</li></ul><p>This makes backend servers <strong>stateless</strong>, which helps horizontal scaling.</p><h3>Rate Limiting</h3><p>Redis can atomically update counters at insane speeds.</p><p>Example: limit user to 100 requests per minute</p><pre>INCR req:user:42<br>EXPIRE req:user:42 60<br>If value &gt; 100 → block</pre><p>Protects against:</p><ul><li>DDoS attacks</li><li>Bots abusing endpoints</li><li>OTP spamming</li><li>Brute-force login attempts</li></ul><p>Simple logic, strong protection.</p><h3>Redis Data Structures (for Humans)</h3><p>Redis isn’t just a key-value store.<br>It offers structures designed for speed:</p><p><strong>String </strong>Simple values: tokens, counters</p><p><strong>Hash </strong>User profiles, product info</p><p><strong>List </strong>Activity feeds, queues</p><p><strong>Set </strong>Unique elements: likes, followers</p><p><strong>Sorted Set (ZSet) </strong>Leaderboards, ranked posts</p><p><strong>Bitmaps/Bloom Filters </strong>Large-scale boolean checks</p><p>Using the right structure results in big performance gains.</p><h3>Caching Patterns for Fast APIs</h3><p>There isn’t just one caching strategy. Choose based on safety and performance:</p><h3>Cache Aside (Lazy Loading)</h3><ul><li>App checks Redis → if miss, fetch DB → store → return</li><li>Most widely used</li><li>Great balance of speed + consistency</li></ul><h3>Write Through</h3><ul><li>Write to Redis + DB together</li><li>Safer but slower writes</li></ul><h3>Read Through</h3><ul><li>App only talks to Redis</li><li>Redis auto-fetches from DB if needed</li><li>Needs special tooling</li></ul><h3>Write Back (Write Behind)</h3><ul><li>Write only to Redis, sync DB later</li><li>Fastest writes</li><li>Risky during failure</li></ul><p>Trade-offs:</p><blockquote><em>Faster writes = more risk.<br> Safer writes = more latency.</em></blockquote><h3>Cache Invalidation</h3><p>Caches must reflect <strong>truth</strong> eventually. Strategies:</p><ul><li>Invalidate on write (delete after DB update)</li><li>Background refresh using workers/queues</li><li>Versioning keys (e.g., user:42:v2)</li></ul><p>Pro tip:</p><blockquote><em>Deleting a key is better than storing stale lies.</em></blockquote><h3>When to Cache vs When to Not</h3><h3>Yes, Cache It:</h3><p>✔ Heavy DB queries<br> ✔ Mostly-read, rarely-updated data<br> ✔ Repeated API responses<br> ✔ Rate limits, counters, flags<br> ✔ GraphQL + aggregated responses</p><h3>No, Don’t Cache:</h3><p>✘ Sensitive credentials<br> ✘ Data with real-time critical accuracy<br> ✘ Massive datasets better suited for DB indexing</p><p>Caching is enhancement, not replacement.</p><p>In the next part for this, i’ll try to make it a lil more hands on and beginner friendly so you can try and implement this for your very own web apps :)</p><p>Toodles !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b65a20656259" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FastAPI for dummies]]></title>
            <link>https://medium.com/@dotslashsimran/fastapi-for-dummies-420d5ffdd9a4?source=rss-a9edd1162ca1------2</link>
            <guid isPermaLink="false">https://medium.com/p/420d5ffdd9a4</guid>
            <category><![CDATA[api]]></category>
            <category><![CDATA[crud]]></category>
            <category><![CDATA[restful-api]]></category>
            <category><![CDATA[fastapi]]></category>
            <dc:creator><![CDATA[Simran Sachdeva]]></dc:creator>
            <pubDate>Wed, 24 Sep 2025 15:58:06 GMT</pubDate>
            <atom:updated>2025-09-24T15:58:06.677Z</atom:updated>
            <content:encoded><![CDATA[<p>The goal isn’t just to show syntax, but to help you <strong>think in FastAPI</strong>.</p><h3>What is an API?</h3><p>Before we dive into FastAPI, let’s break the word <strong>API</strong>. An API (Application Programming Interface) is nothing more than a contract between two systems.</p><p>For web APIs, that contract usually looks like:</p><ul><li>A <strong>request</strong>: client sends data (via URL, headers, or body).</li><li>A <strong>response</strong>: server sends back structured data (often JSON).</li></ul><p>FastAPI. It knows how to listen for requests, validate them, pass them into your code, and return clean JSON responses.</p><h3>Why FastAPI and Not Flask/Django?</h3><ul><li><strong>Flask</strong> is minimal and flexible, but validation and docs require external libraries.</li><li><strong>Django</strong> is powerful, but heavy and not async-native.</li><li><strong>FastAPI</strong> hits the sweet spot:</li><li>Async-first, modern Python.</li><li>Auto-generated docs.</li><li>Built-in validation with <strong>Pydantic</strong>. (which is why it is fast asf)</li><li>Performance on par with Node.js and Go frameworks.</li></ul><h3>Installation</h3><p>We’ll set up a fresh project:</p><pre>mkdir fastapi-tutorial &amp;&amp; cd fastapi-tutorial<br>python -m venv .venv<br>source .venv/bin/activate   # Windows: .venv\Scripts\activate<br>pip install &quot;fastapi[all]&quot;</pre><p>This installs FastAPI and uvicorn (an ASGI server).</p><h3>Hello World in FastAPI</h3><pre># main.py<br>from fastapi import FastAPI</pre><pre>app = FastAPI()</pre><pre>@app.get(&quot;/&quot;)<br>def home():<br>    return {&quot;message&quot;: &quot;Hello, World!&quot;}</pre><p>Run it:</p><pre>uvicorn main:app --reload</pre><p>Visit:</p><ul><li><a href="http://127.0.0.1:8000/">http://127.0.0.1:8000</a> → JSON output</li><li><a href="http://127.0.0.1:8000/docs">http://127.0.0.1:8000/docs</a> → Swagger UI docs</li><li><a href="http://127.0.0.1:8000/redoc">http://127.0.0.1:8000/redoc</a> → alternative docs</li></ul><p><strong>Why this matters:</strong> With Flask or Django, you’d need extra work for documentation. In FastAPI, docs are free.</p><h3>The Core Concepts</h3><h3>Path and Query Parameters</h3><p>FastAPI makes it effortless to capture input.</p><pre>@app.get(&quot;/square/{number}&quot;)<br>def square(number: int):<br>    return {&quot;result&quot;: number * number}</pre><pre>@app.get(&quot;/search&quot;)<br>def search(q: str = None, limit: int = 10):<br>    return {&quot;query&quot;: q, &quot;limit&quot;: limit}</pre><ul><li>/square/5 → {&quot;result&quot;: 25}</li><li>/square/banana → error (invalid input)</li><li>/search?q=fastapi&amp;limit=2 → works with defaults and optional params</li></ul><p>Notice: type hints aren’t just hints anymore. FastAPI enforces them.</p><h3>Request Bodies with Pydantic</h3><p>In real APIs, you’ll accept structured data. Enter <strong>Pydantic models</strong>:</p><pre>from pydantic import BaseModel</pre><pre>class User(BaseModel):<br>    name: str<br>    age: int<br>    email: str</pre><pre>@app.post(&quot;/users/&quot;)<br>def create_user(user: User):<br>    return {&quot;hello&quot;: user.name, &quot;age&quot;: user.age}</pre><p>Send JSON:</p><pre>{<br>  &quot;name&quot;: &quot;Simran&quot;,<br>  &quot;age&quot;: 21,<br>  &quot;email&quot;: &quot;simransachdeva@example.com&quot;<br>}</pre><p>If the payload is missing fields or has wrong types, FastAPI returns a <strong>422 error</strong> with details.</p><h3>Response Models</h3><p>Explicit responses keep APIs predictable.</p><pre>from typing import List</pre><pre>class Item(BaseModel):<br>    id: int<br>    name: str</pre><pre>@app.get(&quot;/items/&quot;, response_model=List[Item])<br>def get_items():<br>    return [<br>        {&quot;id&quot;: 1, &quot;name&quot;: &quot;Laptop&quot;},<br>        {&quot;id&quot;: 2, &quot;name&quot;: &quot;Phone&quot;}<br>    ]</pre><p>Clients now know exactly what to expect.</p><h3>Let’s notch it up abit.</h3><h3>Dependency Injection</h3><p>FastAPI’s <strong>dependency injection (DI)</strong> system prevents global spaghetti code.</p><pre>from fastapi import Depends</pre><pre>def get_settings():<br>    return {&quot;app_name&quot;: &quot;FastAPI Tutorial&quot;}</pre><pre>@app.get(&quot;/config/&quot;)<br>def config(settings=Depends(get_settings)):<br>    return settings</pre><p>Think of dependencies as reusable building blocks. This is how you’ll handle DB connections, authentication, and caching.</p><h3>Async Endpoints</h3><p>Most real APIs wait on external resources. Async solves that.</p><pre>import httpx</pre><pre>@app.get(&quot;/joke/&quot;)<br>async def joke():<br>    async with httpx.AsyncClient() as client:<br>        r = await client.get(&quot;https://api.chucknorris.io/jokes/random&quot;)<br>        return r.json()</pre><p>One endpoint can now handle thousands of concurrent requests efficiently.</p><h3>Background Tasks</h3><p>Not every task should block a client. For side work (logging, sending emails, analytics), use background tasks:</p><pre>from fastapi import BackgroundTasks</pre><pre>def log_event(msg: str):<br>    print(&quot;LOG:&quot;, msg)</pre><pre>@app.post(&quot;/notify/&quot;)<br>def notify(background_tasks: BackgroundTasks, email: str):<br>    background_tasks.add_task(log_event, f&quot;Sent email to {email}&quot;)<br>    return {&quot;status&quot;: &quot;queued&quot;}</pre><h3>Real Project (Users and Database)</h3><p>Let’s build a real <strong>CRUD API with SQLite</strong>.</p><h3>Setup Database (SQLAlchemy)</h3><pre>pip install sqlalchemy</pre><pre># db.py<br>from sqlalchemy import Column, Integer, String, create_engine<br>from sqlalchemy.ext.declarative import declarative_base<br>from sqlalchemy.orm import sessionmaker</pre><pre>DATABASE_URL = &quot;sqlite:///./test.db&quot;<br>engine = create_engine(DATABASE_URL, connect_args={&quot;check_same_thread&quot;: False})<br>SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)</pre><pre>Base = declarative_base()</pre><h3>Define a Model</h3><pre># models.py<br>from db import Base<br>from sqlalchemy import Column, Integer, String</pre><pre>class User(Base):<br>    __tablename__ = &quot;users&quot;<br>    id = Column(Integer, primary_key=True, index=True)<br>    name = Column(String, index=True)<br>    email = Column(String, unique=True, index=True)</pre><h3>Create Tables</h3><pre># init_db.py<br>from db import Base, engine<br>from models import User</pre><pre>Base.metadata.create_all(bind=engine)</pre><h3>CRUD Routes</h3><pre># main.py (extending)<br>from sqlalchemy.orm import Session<br>from db import SessionLocal<br>from models import User<br>from pydantic import BaseModel</pre><pre>class UserCreate(BaseModel):<br>    name: str<br>    email: str</pre><pre>def get_db():<br>    db = SessionLocal()<br>    try:<br>        yield db<br>    finally:<br>        db.close()</pre><pre>@app.post(&quot;/users/&quot;)<br>def create_user(user: UserCreate, db: Session = Depends(get_db)):<br>    db_user = User(name=user.name, email=user.email)<br>    db.add(db_user)<br>    db.commit()<br>    db.refresh(db_user)<br>    return db_user</pre><pre>@app.get(&quot;/users/{user_id}&quot;)<br>def read_user(user_id: int, db: Session = Depends(get_db)):<br>    return db.query(User).filter(User.id == user_id).first()</pre><p>Now you’ve got persistent users in a database.</p><h3>Middleware</h3><p>Global hooks for logging, security, and headers.</p><pre>@app.middleware(&quot;http&quot;)<br>async def add_header(request, call_next):<br>    response = await call_next(request)<br>    response.headers[&quot;X-App&quot;] = &quot;FastAPI&quot;<br>    return response</pre><h3>Authentication with JWT</h3><pre>pip install python-jose passlib[bcrypt]</pre><p>Example:</p><pre>from fastapi.security import OAuth2PasswordBearer<br>from jose import jwt</pre><pre>oauth2_scheme = OAuth2PasswordBearer(tokenUrl=&quot;token&quot;)</pre><pre>@app.get(&quot;/me&quot;)<br>def read_me(token: str = Depends(oauth2_scheme)):<br>    payload = jwt.decode(token, &quot;SECRET&quot;, algorithms=[&quot;HS256&quot;])<br>    return {&quot;user&quot;: payload.get(&quot;sub&quot;)}</pre><p>In practice, you’d integrate with databases and hash passwords with passlib.</p><h3>Testing FastAPI</h3><pre>pip install pytest</pre><pre>from fastapi.testclient import TestClient<br>from main import app</pre><pre>client = TestClient(app)</pre><pre>def test_home():<br>    response = client.get(&quot;/&quot;)<br>    assert response.status_code == 200<br>    assert response.json() == {&quot;message&quot;: &quot;Hello, World!&quot;}</pre><p>FastAPI is designed with testing in mind — dependencies can be overridden in tests.</p><h3>Deployment</h3><h3>Run in Production</h3><pre>uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4</pre><h3>Dockerfile</h3><pre>FROM python:3.11<br>WORKDIR /app<br>COPY . .<br>RUN pip install &quot;fastapi[all]&quot; sqlalchemy<br>CMD [&quot;uvicorn&quot;, &quot;main:app&quot;, &quot;--host&quot;, &quot;0.0.0.0&quot;, &quot;--port&quot;, &quot;8000&quot;]</pre><h3>Options for Deployment</h3><ul><li><strong>Docker Compose</strong> → great for local dev.</li><li><strong>Kubernetes</strong> → scalable in production.</li><li><strong>Serverless</strong> → Google Cloud Run, AWS Lambda, Azure Functions.</li></ul><p>Declare your data, write your logic, let the framework handle the plumbing.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=420d5ffdd9a4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kubernetes for Dummies]]></title>
            <link>https://medium.com/@dotslashsimran/kubernetes-for-dummies-ff8a2400f094?source=rss-a9edd1162ca1------2</link>
            <guid isPermaLink="false">https://medium.com/p/ff8a2400f094</guid>
            <category><![CDATA[cloud-native]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[system]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Simran Sachdeva]]></dc:creator>
            <pubDate>Thu, 18 Sep 2025 10:50:47 GMT</pubDate>
            <atom:updated>2025-09-18T10:50:47.135Z</atom:updated>
            <content:encoded><![CDATA[<p>Kubernetes is everywhere. It powers startups, Fortune 500s, and even hobby projects. Yet for many, it feels like a maze of YAML and abstractions. What is Kubernetes, why does it matter, and how do you actually use it?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zlK4GqfJs55oGkl3IyrLDg.png" /></figure><h3>The Why</h3><p>Before Kubernetes:</p><ul><li>Apps were tied to machines. If a server died, so did your app.</li><li>Scaling meant manual labor. New servers, reconfigured load balancers, hope nothing broke.</li></ul><p>Docker solved packaging. Containers made apps portable. But containers alone don’t orchestrate themselves. If you have 100 containers across 10 servers, who decides where they run? Who restarts them when they fail? Who makes them reachable?</p><p>Kubernetes answers all that. Born at Google, open-sourced in 2014, it is the industry standard for container orchestration.</p><h3>Core Idea</h3><p><strong>Kubernetes is a declarative system for running containerized apps across a cluster of machines.</strong></p><p>You describe your desired state in YAML : number of replicas, configuration, networking. Kubernetes compares desired vs actual, and reconciles them continuously.</p><p>This reconciliation loop is its magic.</p><h3>Your First Cluster</h3><p>Spin up Kubernetes locally with <strong>kind</strong> (Kubernetes in Docker):</p><pre>brew install kind<br>kind create cluster --name demo<br>kubectl get nodes</pre><p>You now have a working cluster.</p><h3>Step 1: Pods</h3><p>The smallest deployable unit is a <strong>Pod</strong>.</p><pre>apiVersion: v1<br>kind: Pod<br>metadata:<br>  name: hello-pod<br>spec:<br>  containers:<br>  - name: hello<br>    image: nginx</pre><p>Apply:</p><pre>kubectl apply -f pod.yaml<br>kubectl get pods</pre><p>Delete it, and it disappears forever meaning Pods are ephemeral. That’s why we need controllers.</p><h3>Step 2: Deployments</h3><p>A <strong>Deployment</strong> ensures Pods stay alive and updates happen safely.</p><pre>apiVersion: apps/v1<br>kind: Deployment<br>metadata:<br>  name: web-deploy<br>spec:<br>  replicas: 3<br>  selector:<br>    matchLabels:<br>      app: web<br>  template:<br>    metadata:<br>      labels:<br>        app: web<br>    spec:<br>      containers:<br>      - name: nginx<br>        image: nginx:1.21</pre><pre>kubectl apply -f deployment.yaml<br>kubectl get pods</pre><p>You now have 3 NGINX Pods. Kill one, Kubernetes creates a replacement. Update the image, Kubernetes rolls out changes gradually.</p><p>Rollback if needed:</p><pre>kubectl rollout undo deployment web-deploy</pre><h3>Step 3: Services</h3><p>Pods get replaced often. Their IPs change. You need a stable entry point.</p><pre>apiVersion: v1<br>kind: Service<br>metadata:<br>  name: web-service<br>spec:<br>  selector:<br>    app: web<br>  ports:<br>  - port: 80<br>    targetPort: 80<br>  type: NodePort</pre><p>Apply:</p><pre>kubectl apply -f service.yaml<br>kubectl get service web-service</pre><p>Access via http://localhost:&lt;nodeport&gt;. Kubernetes load balances across replicas.</p><h3>Step 4: Config and Secrets</h3><p>Stop hardcoding configuration.</p><pre>apiVersion: v1<br>kind: ConfigMap<br>metadata:<br>  name: app-config<br>data:<br>  WELCOME_MSG: &quot;Hello from Kubernetes&quot;</pre><p>Mount into a Pod as an environment variable. For sensitive data, use <strong>Secrets</strong>:</p><pre>kubectl create secret generic db-credentials \<br>  --from-literal=username=admin \<br>  --from-literal=password=secret123</pre><p>This is how production apps inject configuration securely.</p><h3>Step 5: Autoscaling</h3><p>Enable metrics server:</p><pre>kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml</pre><p>Scale automatically with HPA:</p><pre>kubectl autoscale deployment web-deploy --cpu-percent=50 --min=3 --max=10</pre><p>If load rises, Kubernetes adds Pods. If load drops, it shrinks back.</p><h3>Step 6: Observability</h3><p>Clusters without visibility are disasters waiting to happen. Install Prometheus + Grafana with Helm:</p><pre>helm repo add prometheus-community https://prometheus-community.github.io/helm-charts<br>helm install monitoring prometheus-community/kube-prometheus-stack</pre><p>Dashboards now show CPU, memory, and cluster health.</p><h3>Oh well, well, beyond the BASICS</h3><p>Once you master Deployments, Services, ConfigMaps, Secrets, and HPA, you can climb into advanced workloads:</p><ul><li><strong>StatefulSets</strong> → Keep identity for Pods that store data (databases, queues).</li><li><strong>DaemonSets</strong> → Ensure one Pod per Node (logging, monitoring).</li><li><strong>Ingress</strong> → Route external traffic with TLS.</li><li><strong>Namespaces</strong> → Partition resources across teams.</li><li><strong>RBAC</strong> → Fine-grained permissions.</li><li><strong>Network Policies</strong> → Control Pod-to-Pod communication.</li><li><strong>Operators</strong> → Automate complex apps like Postgres or Kafka.</li></ul><h3>Common Pitfalls</h3><ul><li>YAML sprawl → Use Helm or Kustomize.</li><li>Over-engineering → Don’t start with Istio.</li><li>Ignoring limits → Leads to cost overruns.</li><li>No monitoring → You’ll fly blind.</li><li>Weak security → Enforce RBAC, scan images, rotate secrets.</li></ul><h3>Hands-On Challenge (30 Minutes)</h3><p>Try this full stack mini-project on your local cluster:</p><ol><li><strong>Frontend</strong> → Deploy an NGINX container serving static HTML.</li><li><strong>Backend</strong> → Deploy a Python/Flask API with /hello endpoint.</li><li><strong>Database</strong> → Deploy Postgres via StatefulSet + PersistentVolume.</li><li><strong>Config</strong> → Store DB credentials in a Secret, inject into backend.</li><li><strong>Service</strong> → Expose frontend + backend via Services.</li><li><strong>Ingress</strong> → Route / → frontend, /api → backend.</li><li><strong>Autoscale</strong> → Apply HPA on backend.</li><li><strong>Monitor</strong> → Install Prometheus, watch metrics as load tests run.</li></ol><p>With this, you’ve deployed a full application stack — frontend, backend, DB, config, scaling, monitoring — entirely in Kubernetes.</p><p>Kubernetes is not just “containers at scale.” It’s a mindset shift:</p><ul><li>From <strong>imperative</strong> (“run this here”) → <strong>declarative</strong> (“make sure this is always running”).</li><li>From <strong>servers</strong> → <strong>systems</strong>.</li></ul><p>Start with Pods. Move to Deployments, Services, and ConfigMaps. Add autoscaling and monitoring. Then explore StatefulSets, Operators, GitOps, and service meshes.</p><p>The learning curve is steep, but the reward is obv clear:</p><p>resilient, portable, scalable infrastructure that adapts to change.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ff8a2400f094" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Docker for Dummies]]></title>
            <link>https://medium.com/@dotslashsimran/docker-for-dummies-f9dae0b756ba?source=rss-a9edd1162ca1------2</link>
            <guid isPermaLink="false">https://medium.com/p/f9dae0b756ba</guid>
            <category><![CDATA[containerized-application]]></category>
            <category><![CDATA[dockerization]]></category>
            <category><![CDATA[containerization]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Simran Sachdeva]]></dc:creator>
            <pubDate>Sat, 06 Sep 2025 06:55:06 GMT</pubDate>
            <atom:updated>2025-09-06T06:55:06.103Z</atom:updated>
            <content:encoded><![CDATA[<p>Every dev has lived through this drama.</p><p>You test locally. It works. QA runs the same code. It breaks. Ops deploys it. It explodes.</p><p>Different OS, different libraries, different configs. Classic “environment drift.”</p><p><strong>Docker solves this by standardising environments.</strong> You build an image once and run it anywhere: Mac, Windows, Linux, cloud, your Raspberry Pi. Same bits, same behavior.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3r1RqgDwvpNpq7xxb44kBw.png" /></figure><h3>The Basics:</h3><ul><li><strong>Image</strong> → Immutable snapshot. It’s your app + its runtime + dependencies. like. a <strong>movie DVD, </strong>you can make many copies, right, all identical.</li><li><strong>Container</strong> → A live instance of an image. It’s isolated from the host but shares the host’s kernel. like, pressing <em>play</em> on the DVD player. Multiple players = multiple containers.</li><li><strong>Dockerfile</strong> → Text file with instructions to build an image.<br> Example:</li></ul><pre>FROM python:3.11-slim WORKDIR /app COPY requirements.txt . RUN pip install -r requirements.txt COPY . . CMD [&quot;python&quot;, &quot;main.py&quot;]</pre><ul><li><strong>Registry</strong> → Central repo for images.</li><li><strong>Docker Hub</strong> (public).</li><li><strong>Private registries</strong> (e.g., AWS ECR, GCP Artifact Registry).</li></ul><p>Quick sanity check:</p><pre>docker run hello-world</pre><p>This pulls an image from Docker Hub, spins a container, runs it, exits. Done.</p><h3>Okay i think it’s time for a Deeper Dive</h3><p><strong>Layers</strong></p><ul><li>Each line in your Dockerfile adds a layer.</li><li>Layers are cached → rebuilds are faster.</li><li>Shared layers save space (multiple images reusing Ubuntu base).</li></ul><p><strong>Volumes</strong></p><ul><li>Containers are ephemeral: stop one, data is gone.</li><li>Volumes let you persist data outside the container.</li><li>Example:</li></ul><pre>docker run -v mydb:/var/lib/postgresql/data postgres</pre><p><strong>Networks</strong></p><ul><li>Containers run in isolated namespaces.</li><li>Docker creates a virtual network (bridge by default).</li><li>You can attach containers to the same network so they “see” each other by name.</li><li>Example with Compose:</li></ul><pre>services:   web:     build: .     ports: [&quot;8080:80&quot;]   db:     image: postgres</pre><ul><li>Here web can connect to db:5432 by service name.</li></ul><h3>Okay some relatable examples and stuff</h3><h3>1. Running a Web App in Docker</h3><p>Say you’ve got a Flask API:</p><pre>docker build -t my-flask-api .<br>docker run -p 5000:5000 my-flask-api</pre><p>No Python installed locally, no dependencies, it just works.</p><h3>2. Local Dev Environments</h3><p>Before Docker: “Install Node, Mongo, Redis, RabbitMQ, oh and the right versions.”<br> After Docker:</p><pre>docker run -d -p 27017:27017 mongo<br>docker run -d -p 6379:6379 redis</pre><p>One line per service. No system pollution.</p><h3>3. Real Companies Using Docker</h3><ul><li><strong>Netflix</strong>: Runs containerised micro services at insane scale.</li><li><strong>Spotify</strong>: Containers for dev environments so engineers spin up identical stacks in minutes.</li></ul><h3>Advanced Angle</h3><p><strong>Docker Compose</strong></p><ul><li>Define multiple services in one YAML file.</li><li>docker-compose up brings them all up with networks/volumes wired automatically.</li><li>Great for dev/test environments.</li></ul><p><strong>Orchestration</strong></p><ul><li>One container? Cool.</li><li>Thousands of containers across hundreds of servers? Nightmare without orchestration.</li><li><strong>Kubernetes</strong>: Handles scaling, service discovery, self-healing. Industry standard.</li><li><strong>Docker Swarm</strong>: Built-in, simpler, but less popular today.</li></ul><h3>Common Pitfalls</h3><p><strong>Bloated Images</strong></p><ul><li>Bad: FROM ubuntu → adds ~70 MB.</li><li>Better: FROM ubuntu:20.04 (pinned version).</li><li>Best: FROM alpine (~5 MB, but minimal).</li></ul><p><strong>Debugging Containers</strong></p><ul><li>Containers don’t log to files by default.</li><li>Use:</li></ul><pre>docker logs &lt;container&gt; docker exec -it &lt;container&gt; sh</pre><p><strong>Security</strong></p><ul><li>Don’t run everything as root inside the container.</li><li>Keep base images updated.</li><li>Never trust random Docker Hub images (check Dockerfile/source).</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f9dae0b756ba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[APIs for Dummies]]></title>
            <link>https://medium.com/@dotslashsimran/apis-for-dummies-12e16aa8fb81?source=rss-a9edd1162ca1------2</link>
            <guid isPermaLink="false">https://medium.com/p/12e16aa8fb81</guid>
            <category><![CDATA[graphql]]></category>
            <category><![CDATA[api-development]]></category>
            <category><![CDATA[grpc]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[rest-api]]></category>
            <dc:creator><![CDATA[Simran Sachdeva]]></dc:creator>
            <pubDate>Thu, 04 Sep 2025 13:56:07 GMT</pubDate>
            <atom:updated>2025-09-04T13:56:07.438Z</atom:updated>
            <content:encoded><![CDATA[<p>APIs are the invisible wiring of the internet. Without them, your apps couldn’t talk to each other, your devices couldn’t sync, and half the web services you rely on wouldn’t work.</p><p>At its core, an <strong>API (Application Programming Interface)</strong> is a <strong>contract</strong>:</p><ul><li>A client sends a <strong>request</strong> (usually over HTTP).</li><li>A server sends back a <strong>response</strong> (usually JSON, XML, or Protocol Buffers).</li></ul><p>This contract defines <em>what</em> you can ask for, <em>how</em> you should ask for it, and <em>what format</em> you’ll get in return.</p><h3>The Basics of API Communication</h3><p>When you hit an API, three things happen:</p><ol><li><strong>Endpoint</strong> — A URL that represents a resource. Example: /users/123.</li><li><strong>Method</strong> — The action you want to perform. Common HTTP methods:</li></ol><ul><li>GET → Read data</li><li>POST → Create new data</li><li>PUT/PATCH → Update existing data</li><li>DELETE → Remove data</li></ul><p><strong>3. Response</strong> — The server sends back structured data.</p><ul><li>Example:</li></ul><pre>{   &quot;id&quot;: 123,   &quot;name&quot;: &quot;Simran&quot;,   &quot;email&quot;: &quot;simran@example.com&quot; }</pre><p>This pattern (request → response) is the foundation of nearly every API out there.</p><h3>The Three Big API Styles</h3><h3>1. REST (Representational State Transfer)</h3><p>REST is the workhorse of the web.</p><ul><li><strong>Structure</strong>: Resources exposed as URLs.</li><li><strong>Example</strong>:</li><li>GET /products → list products</li><li>POST /products → create product</li><li><strong>Format</strong>: Typically JSON over HTTP.</li></ul><p><strong>Strengths</strong>:</p><ul><li>Simple, human-readable.</li><li>Works in browsers and mobile apps easily.</li><li>Huge ecosystem (Postman, Swagger/OpenAPI).</li></ul><p><strong>Weaknesses</strong>:</p><ul><li>Can be “chatty.” For example, fetching a user and their posts might need two separate requests.</li><li>No strict schema — clients can get unexpected data if APIs change.</li></ul><h3>2. GraphQL</h3><p>Created at Facebook, GraphQL fixes REST’s “too much data / too little data” problem.</p><ul><li><strong>Query Language</strong>: Clients specify exactly what fields they need.</li><li><strong>Example</strong>:</li></ul><pre>{   user(id: 123) {     name     posts {       title     }   } }</pre><ul><li><strong>Response</strong>:</li></ul><pre>{   &quot;user&quot;: {     &quot;name&quot;: &quot;Simran&quot;,     &quot;posts&quot;: [       { &quot;title&quot;: &quot;APIs for Dummies&quot; },       { &quot;title&quot;: &quot;CDNs Explained&quot; }     ]   } }</pre><p><strong>Strengths</strong>:</p><ul><li>No over-fetching or under-fetching.</li><li>One endpoint for everything (/graphql).</li><li>Strong developer tooling (playgrounds, schema introspection).</li></ul><p><strong>Weaknesses</strong>:</p><ul><li>Harder caching because requests are dynamic.</li><li>Can encourage complex queries that overload servers.</li></ul><h3>3. gRPC (Google Remote Procedure Call)</h3><p>gRPC is designed for <strong>speed</strong> and <strong>machine-to-machine communication</strong>.</p><ul><li><strong>Protocol</strong>: Uses Protocol Buffers (protobufs) instead of JSON.</li><li><strong>Transport</strong>: Uses HTTP/2 for multiplexing and streaming.</li><li><strong>Example</strong>: Instead of hitting /users/123, you call a method:</li></ul><pre>service UserService {   rpc GetUser(UserRequest) returns (UserResponse); }</pre><p><strong>Strengths</strong>:</p><ul><li>Extremely fast and efficient.</li><li>Strong typing via protobuf schemas.</li><li>Supports bi-directional streaming.</li></ul><p><strong>Weaknesses</strong>:</p><ul><li>Not human-readable (binary data).</li><li>Requires client libraries (not as easy as plain HTTP).</li><li>Best suited for internal microservices, not public APIs.</li></ul><h3>okay let’s take it up a notch</h3><h3>Rate Limiting</h3><p>Prevents clients from overloading servers.</p><ul><li>Example: GitHub API allows 5,000 requests per hour.</li></ul><p>Techniques:</p><ul><li><strong>Token bucket</strong> — Clients “spend” tokens to make requests.</li><li><strong>Leaky bucket</strong> — Requests flow at a steady rate.</li></ul><h3>Versioning</h3><p>APIs change, but old clients can’t break overnight.</p><ul><li><strong>URI versioning</strong>: /api/v1/users, /api/v2/users.</li><li><strong>Header versioning</strong>: Accept: application/vnd.api+json;version=2.</li><li><strong>Best practice</strong>: Minimise breaking changes, use semantic versioning.</li></ul><h3>Authentication &amp; Authorization</h3><ul><li><strong>API Keys</strong> — Simple, like passwords.</li><li><strong>OAuth 2.0</strong> — For delegated access (e.g., login with Google).</li><li><strong>JWTs (JSON Web Tokens)</strong> — Encoded tokens with claims about the user.</li></ul><h3>Error Handling</h3><ul><li><strong>2xx</strong> → Success (200 OK, 201 Created)</li><li><strong>4xx</strong> → Client errors (400 Bad Request, 401 Unauthorized, 404 Not Found)</li><li><strong>5xx</strong> → Server errors (500 Internal Server Error)</li></ul><p>Good APIs return <strong>helpful error messages</strong> with context.</p><h3>Real-World SWE Scenarios</h3><ul><li><strong>Mobile Apps</strong>:</li><li>E-commerce app calling APIs for products, cart, checkout.</li><li><strong>Microservices</strong>:</li><li>At Netflix, dozens of microservices talk via gRPC to serve your video.</li><li><strong>Third-Party Integrations</strong>:</li><li>Travel site aggregating APIs from airlines, hotels, and car rentals.</li><li><strong>Scaling Challenges</strong>:</li><li>Rate limiting to prevent DDoS attacks.</li><li>API gateways (like Kong, Apigee, AWS API Gateway) to enforce policies, caching, and analytics.</li></ul><h3>How Engineers Choose</h3><ul><li><strong>REST</strong> → Public APIs, CRUD operations, simple web/mobile apps.</li><li><strong>GraphQL</strong> → Complex client apps (dashboards, mobile apps with varying needs).</li><li><strong>gRPC</strong> → Internal high-performance systems, microservices, streaming data.</li></ul><p>In practice, companies often mix them:</p><ul><li>REST for external developers.</li><li>GraphQL for mobile/web apps.</li><li>gRPC for internal communication</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=12e16aa8fb81" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CDNs (for Dummies) Why Netflix and TikTok Never Buffer ?]]></title>
            <link>https://medium.com/@dotslashsimran/cdns-for-dummies-why-netflix-and-tiktok-never-buffer-bc4ab7025b30?source=rss-a9edd1162ca1------2</link>
            <guid isPermaLink="false">https://medium.com/p/bc4ab7025b30</guid>
            <category><![CDATA[latency]]></category>
            <category><![CDATA[caching]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[cdn]]></category>
            <category><![CDATA[web-performance]]></category>
            <dc:creator><![CDATA[Simran Sachdeva]]></dc:creator>
            <pubDate>Thu, 28 Aug 2025 12:30:49 GMT</pubDate>
            <atom:updated>2025-08-28T12:30:49.788Z</atom:updated>
            <content:encoded><![CDATA[<h3>CDNs (for Dummies) Why Netflix and TikTok Never Buffer ?</h3><p>The internet is fast, but physics is rude. Light in fiber travels at ~200,000 km/s sounds quick, but if your request has to cross oceans, the round trip adds up.</p><p>Example:</p><ul><li>Delhi ↔ Virginia (a common AWS region) is ~12,000 km.</li><li>One round-trip TCP handshake = ~150 ms minimum latency.</li><li>Add TLS handshake + fetching the video + congestion → hello, buffering wheel.</li></ul><p>That’s why your TikTok can’t come straight from “the origin.” It would be like ordering pizza from New York when you live in Bangalore.</p><h3>the CDN</h3><p>A <strong>Content Delivery Network (CDN)</strong> is a set of geographically distributed servers (called Points of Presence, or PoPs). These servers cache and serve static or semi-static content (videos, images, JS bundles).</p><p>Key idea is to put the content <strong>closer to users</strong>, so data only travels tens of kilometres, not thousands.</p><p>Think of it like Domino’s: one recipe (the origin), many local kitchens (the PoPs).</p><h3>How It Actually Works (Nitty Gritty)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zGO-n-YOSPvPNGOSJTFhqQ.png" /></figure><h3>Step 1: DNS Resolution Magic</h3><ul><li>You request video.tiktokcdn.com.</li><li>Your DNS resolver asks the authoritative DNS server.</li><li>Instead of one fixed IP, CDNs return the IP of the <strong>closest PoP</strong> (using GeoDNS, Anycast routing, or both).</li><li>Result: your device thinks it’s just talking to “TikTok,” but in reality it’s hitting a CDN edge server 20 km away.</li></ul><h3>Step 2: Cache Behaviour</h3><ul><li>CDN edges store content in caches (memory/disk).</li><li>Popular stuff is always hot in cache.</li><li>Cache policy is controlled by headers:</li><li>Cache-Control: max-age=3600 → keep for an hour</li><li>ETag → unique fingerprint of file, used for validation</li><li>Vary → tell CDN that response depends on certain headers (like language or device type)</li></ul><h3>Step 3: Smart Transport Optimisations</h3><ul><li><strong>TCP termination</strong>: Long-haul connections are handled between PoP ↔ origin. The user just connects locally, cutting handshake latency.</li><li><strong>QUIC/HTTP3</strong>: Newer CDNs use UDP instead of TCP for faster handshakes and less head-of-line blocking.</li><li><strong>Range Requests</strong>: Netflix doesn’t stream the whole 2-hour movie at once your client requests byte ranges (Range: bytes=500000-999999). CDNs serve just that slice.</li></ul><h3>Step 4: Prefetching and Prediction</h3><ul><li>TikTok preloads the next 1–2 videos before you swipe.</li><li>Netflix prefetches next segments during playback.</li><li>All of this leans on the CDN so the origin isn’t overloaded.</li></ul><h3>okay now the literal Netflix vs TikTok (so you don’t get a clickbait title)</h3><p><strong>Netflix (Open Connect)</strong></p><ul><li>They literally ship custom CDN appliances to ISPs worldwide.</li><li>Popular shows are pre-loaded onto ISP servers.</li><li>Result: when you hit play, packets don’t even leave your ISP’s network.</li><li>That’s why ISPs love/hate Netflix — it saves bandwidth, but Netflix controls the pipeline.</li></ul><p><strong>TikTok (Latency-Obsessed)</strong></p><ul><li>Short videos = zero tolerance for buffering.</li><li>Uses aggressive caching and chunked delivery.</li><li>Invests in peering agreements with ISPs so data never travels far.</li><li>Employs AI-driven prefetch: it guesses the next video you’ll swipe to and caches it before you even realise.</li></ul><h3>Debugging Reality</h3><p>When something feels “slow,” here’s how engineers peek under the hood:</p><ol><li><strong>Check DNS Resolution</strong></li></ol><p>dig video.tiktokcdn.com</p><p>→ See which PoP IP you’re resolving to. If it’s another continent, that’s the problem.</p><p><strong>2. Check Cache Headers</strong></p><p>curl -I <a href="https://video.tiktokcdn.com/somefile.mp4">https://video.tiktokcdn.com/somefile.mp4</a></p><p>Look for:</p><ul><li>x-cache: HIT → served from edge (fast)</li><li>x-cache: MISS → fetched from origin (slower)</li><li>age: 123 → how long it’s been cached in seconds</li></ul><p><strong>3. Trace Latency</strong></p><p>traceroute video.tiktokcdn.com</p><p>→ If hops stay local, CDN is working. If you see packets crossing oceans, something’s misconfigured.</p><p><strong>4. Chrome DevTools</strong></p><ul><li>Look at Timing tab on requests.</li><li>Long DNS or TCP connection times = you’re hitting a far PoP.</li></ul><h3>Why This Matters in Real Life</h3><ul><li>Your site’s “slow in India” but fine in the U.S.? Probably CDN misconfig, not your code.</li><li>Mis-set cache headers → CDN constantly refetches → user sees lag.</li><li>No CDN at all → you’re paying in both latency and cloud egress $$$.</li><li>Debugging CDN behaviour is often the difference between an app people binge on (TikTok, Netflix) and one they abandon after the loading spinner.</li></ul><p>CDNs are the <strong>secret sauce of the modern internet</strong>. They hide latency, mask origin weakness, and make the web feel instant. Netflix wouldn’t scale without Open Connect. TikTok wouldn’t dominate without their edge strategy.</p><p>Without CDNs, the internet would still be buffering like a 2008 YouTube video.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc4ab7025b30" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How the Internet Actually Works (for Dummies)]]></title>
            <link>https://medium.com/@dotslashsimran/how-the-internet-actually-works-for-dummies-8bc7431de1e9?source=rss-a9edd1162ca1------2</link>
            <guid isPermaLink="false">https://medium.com/p/8bc7431de1e9</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[system-design-interview]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[internet]]></category>
            <category><![CDATA[computer-science]]></category>
            <dc:creator><![CDATA[Simran Sachdeva]]></dc:creator>
            <pubDate>Tue, 26 Aug 2025 22:11:04 GMT</pubDate>
            <atom:updated>2025-08-26T22:11:04.539Z</atom:updated>
            <content:encoded><![CDATA[<p>We all use the Internet daily while bingeing Netflix, pushing code to GitHub, stalking people on Instagram but very few of us actually stop to ask: <em>how does this thing really work?</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vwKv8ic7LRihNHxlOjW1pQ.jpeg" /></figure><p>Let’s break it down.</p><h3>1. The Internet</h3><p>At its heart, the Internet is a <strong>giant postal service for data</strong>.</p><ul><li>You (your computer) = a house.</li><li>Your IP address = your street address.</li><li>Websites = other houses.</li><li>Routers = post offices and traffic cops.</li><li>Packets = envelopes carrying little pieces of your message.</li></ul><p>You open your browser and type:</p><pre>https://www.google.com/search?q=cat+memes</pre><p>That line already encodes a lot:</p><ul><li>https:// → protocol (HTTP, but over TLS for encryption)</li><li>www.google.com → domain (human-friendly alias for an IP)</li><li>/search → path (resource you want)</li><li>?q=cat+memes → query string (parameters for the request)</li></ul><p>The browser now says: <em>“Cool, I need to find where google.com lives.”</em>Your browser is now like, “Cool, I need to find where example.com lives.”</p><h3>2. IP Addresses</h3><p>Every device connected to the Internet has an <strong>IP address</strong> like a home address.</p><ul><li>IPv4 (most common): 192.168.1.1 (limited, about 4 billion addresses total).</li><li>IPv6 (newer): 2401:db00:2110:3003::1 (basically infinite).</li></ul><p>Problem: humans don’t remember numbers well. You wouldn’t say, <em>“I’ll meet you at 142.250.190.46”</em>. That’s why we have…</p><h3>3. DNS</h3><p>DNS (Domain Name System) is like a global phonebook.</p><p>Computers don’t understand google.com; they need an IP. So your OS kicks off a DNS resolution sequence:</p><ol><li><strong>Browser cache</strong> → Did I resolve this recently?</li><li><strong>OS cache</strong> → Maybe the system already knows.</li><li><strong>Router cache</strong> → Your Wi-Fi router might have the answer.</li><li><strong>Recursive resolver</strong> (usually ISP or Google’s 8.8.8.8) → If no one knows, this resolver does the legwork:</li></ol><ul><li>Ask the <strong>root servers</strong>: “Where’s .com?”</li><li>Ask the <strong>.com TLD servers</strong>: “Where’s google.com?”</li><li>Ask the <strong>authoritative Google DNS servers</strong> → They return multiple IPs, like 142.250.190.100.</li></ul><p>Now the browser knows where to connect. (Fun fact: Google returns different IPs depending on your geography/load balancing.)</p><p>This chain is why sometimes your site works on one computer but not another caches might be stale.</p><h3>4. Packets</h3><p>When you send data (say a photo), it doesn’t go as one giant blob. It gets chopped into <strong>packets (</strong>small envelopes) with:</p><ul><li><strong>Source address</strong> (your IP).</li><li><strong>Destination address</strong> (Google’s IP).</li><li><strong>Payload</strong> (the actual chunk of data).</li><li><strong>Sequence number</strong> (so the receiver can reassemble).</li></ul><p>Think of sending a novel by mailing each page separately. Even if pages take different routes, the receiver can reorder them.</p><h3>5. Routers</h3><p>Packets don’t know the entire path to their destination. They just know <em>where they need to go next</em>.</p><p>Routers are like post offices. Each one looks at the packet’s destination and decides the next hop using <strong>routing tables</strong>.</p><ul><li>At a global level, routing between big networks is handled by <strong>BGP (Border Gateway Protocol)</strong>.</li><li>Each large network (ISP, cloud provider, university) is an <strong>Autonomous System (AS)</strong> with its own number.</li><li>BGP is how the Internet’s backbone decides “this IP range can be reached through me.”</li></ul><p>This is why if BGP is misconfigured, entire parts of the Internet can go down (looking at you, Facebook outage of 2021).</p><h3>6. TCP/IP</h3><p>Okay, packets are flying around. But how do we make sure they:</p><ul><li>Arrive in order.</li><li>Don’t get lost.</li><li>Aren’t duplicated.</li></ul><p>That’s <strong>TCP (Transmission Control Protocol)</strong>’s job.</p><h3>The Three-Way Handshake</h3><p>Before sending actual data, TCP establishes a connection:</p><ol><li>Client → Server: SYN (let’s talk).</li><li>Server → Client: SYN-ACK (cool, I’m ready).</li><li>Client → Server: ACK (great, let’s go).</li></ol><p>Now both sides know they’re ready.</p><h3>Reliability</h3><ul><li>If a packet is missing, TCP asks for a resend.</li><li>It controls speed (so a fast sender doesn’t overwhelm a slow receiver).</li><li>It adapts to congestion by adjusting window sizes.</li></ul><p>Sometimes TCP is <em>too careful</em>. That’s why we also have <strong>UDP (User Datagram Protocol) </strong>which is<strong> </strong>faster, but unreliable. Used for games, video calls, live streams (where “fast but a bit lossy” is better than “perfect but late”).</p><h3>7. HTTPS</h3><p>Now that we have reliable pipes, let’s talk security.</p><p>HTTP is the language browsers and servers use to talk (“GET this page”, “POST this form”).<br> But plain HTTP is insecure — anyone can read your packets.</p><p>That’s why we have <strong>HTTPS (HTTP + TLS encryption)</strong>.</p><ul><li>Your browser and the server exchange cryptographic keys.</li><li>They agree on a secret shared key.</li><li>All communication after that is encrypted.</li></ul><p>With TLS done, the browser makes its first HTTP request:</p><pre>GET /search?q=cat+memes HTTP/1.1<br>Host: www.google.com<br>User-Agent: Chrome/119.0<br>Accept: text/html,application/xhtml+xml<br>Cookie: 1P_JAR=abcd1234; NID=xyz...</pre><ul><li>GET → HTTP method (retrieve data, don’t change anything)</li><li>/search?q=cat+memes → Path + query</li><li>Headers → Browser metadata (UA, accepted formats, cookies for personalization/ads/etc.)</li></ul><p>TLS uses asymmetric cryptography (public/private keys) to exchange a symmetric session key (faster for bulk data). Certificates ensure authenticity (yes, this <em>really</em> is Google).</p><h3>8. Servers &amp; CDNs</h3><p>When your request finally reaches the right IP, it lands at a <strong>server</strong> (a computer in a datacenter).</p><p>But serving the entire planet from one server would be slow. Enter <strong>CDNs (Content Delivery Networks)</strong>:</p><ul><li>Distributed servers keep copies of popular content.</li><li>Instead of fetching Netflix from California, you fetch it from a server in Mumbai.</li></ul><p>CDNs use <strong>anycast routing</strong> (same IP advertised from multiple places). The network routes you to the “nearest” copy.</p><h3>9. The Physical Internet</h3><p>Let’s not forget: the Internet isn’t floating in the air. It’s <strong>very physical</strong>.</p><ul><li>Your device → WiFi → home router.</li><li>Router → ISP via fiber/cable/4G tower.</li><li>ISP → regional hubs.</li><li>Regional hubs → undersea fiber cables.</li></ul><p>~99% of intercontinental Internet traffic runs through submarine cables. Satellites are used, but mostly for backup or remote regions (latency is high: ~600ms vs ~50ms on fiber).</p><h3>10. Debugging Scenarios</h3><p>Now let’s connect this knowledge to real life.</p><p><strong>Ping works, but website doesn’t.</strong></p><p>You ping google.com and get replies. Great the network path and IP routing work.</p><p>But the browser just spins forever? Likely <strong>DNS</strong> or <strong>HTTP layer</strong> issue.</p><ul><li>Maybe DNS gave you the wrong IP (misconfigured DNS server).</li><li>Maybe HTTP(S) handshake is failing (cert issues, firewall, TLS mismatch).</li></ul><p>Ping only checks IP reachability, not whether the higher layers are happy.</p><p><strong>DNS resolves, but site is painfully slow.</strong></p><p>dig example.com works instantly. So DNS is fine.</p><p>But the page crawls. This could mean:</p><ul><li>Routing detour (packets taking the “scenic route” due to BGP or ISP peering).</li><li>Network congestion somewhere along the path.</li><li>TCP retransmissions because of packet loss.</li></ul><p>Use traceroute or mtr to see where latency spikes.</p><p><strong>Streaming video keeps buffering.</strong></p><p>TCP is designed to <em>slow down</em> when it detects congestion (via packet loss or high latency).</p><p>If your ISP doesn’t like you bingeing 4K Netflix, they might throttle traffic on port 443 for known video CDNs.</p><p>Or your Wi-Fi router just sucks at handling high throughput.<br> <br>Check if other sites stream fine. Try a VPN (if it works better, your ISP is shaping traffic).</p><p><strong>One site doesn’t load, but others do.</strong></p><p>Gmail works. Twitter works. But that random dev blog is dead.</p><ul><li>This screams <strong>routing issue</strong>. Maybe a <strong>BGP route leak </strong>some ISP is announcing bad paths.</li><li>Or the site’s firewall blocks your ISP’s IP ranges.</li></ul><p>Use curl -v to see where the request dies. If DNS resolves but TCP connection won’t establish, the issue is beyond your local machine.</p><h3>11. Recap</h3><ul><li><strong>Physical Layer</strong>: Cables, WiFi, fiber, satellites.</li><li><strong>Network Layer (IP)</strong>: Addressing and routing.</li><li><strong>Transport Layer (TCP/UDP)</strong>: Reliability and flow control.</li><li><strong>Application Layer (HTTP, DNS, etc.)</strong>: Human-usable services.</li></ul><p>Every time you open Instagram, this entire stack springs into action billions of packets flying around the planet just to show you a cat meme.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8bc7431de1e9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Git, Github and all about version control (for dummies)]]></title>
            <link>https://medium.com/@dotslashsimran/git-github-and-all-about-version-control-for-dummies-c65941abf0c8?source=rss-a9edd1162ca1------2</link>
            <guid isPermaLink="false">https://medium.com/p/c65941abf0c8</guid>
            <category><![CDATA[git]]></category>
            <category><![CDATA[version-control]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[version-control-system]]></category>
            <category><![CDATA[git-version-control]]></category>
            <dc:creator><![CDATA[Simran Sachdeva]]></dc:creator>
            <pubDate>Mon, 25 Aug 2025 14:59:28 GMT</pubDate>
            <atom:updated>2025-08-25T15:00:30.294Z</atom:updated>
            <content:encoded><![CDATA[<p>Version control is how developers avoid the jazz of final.doc, final2.doc, and final_really_final.doc. Instead of renaming files endlessly, we use <strong>Git (</strong>a system that remembers every change) and <strong>GitHub (</strong>the online home where projects live, grow, and involve entire teams)</p><p>Let’s walk through the <strong>lifecycle of a Git project</strong>:</p><h3>Starting a Project</h3><p>When you begin, you either:</p><ul><li><strong>Create a new repo</strong> for a fresh project:</li></ul><pre>git init</pre><ul><li><strong>Clone an existing repo</strong> (from GitHub, GitLab, etc.):</li></ul><pre>git clone &lt;url&gt;</pre><p>Now Git is tracking your project. Every file change can be saved into history.</p><h3>Understanding Git’s Three Areas</h3><p>Think of Git as three “layers”:</p><ol><li><strong>Working Directory</strong> → where you edit files.</li><li><strong>Staging Area (Index)</strong> → a prep zone where you choose what to save.</li><li><strong>Repository (History)</strong> → permanent, committed snapshots.</li></ol><h3>Making Changes</h3><p>The daily loop is always: <strong>edit → add → commit</strong>.</p><pre>git status              # what’s changed?<br>git diff                # see unstaged changes<br>git add &lt;file&gt;          # stage a file<br>git add .               # stage everything<br>git diff --staged       # review staged changes<br>git commit -m &quot;Message&quot; # save a snapshot</pre><p>Pro tip: commit messages should explain <em>why</em>, not just <em>what</em>.<br> Bad: git commit -m &quot;update file&quot;<br> Good: git commit -m &quot;Fix bug where login failed on empty password&quot;</p><h3>Branching (Work Without Breaking Main)</h3><p>Branches let you experiment safely.</p><pre>git branch feature/login       # create branch<br>git switch feature/login       # move to it<br># (older command: git checkout -b feature/login)</pre><p>Now you’re working in your own lane.</p><p>When you’re done:</p><pre>git switch main<br>git merge feature/login        # merge work into main</pre><h3>Merge vs Rebase</h3><p>Here’s where Git gets opinionated.</p><ul><li><strong>Merge</strong>: brings another branch’s history into yours. Keeps all commit history visible.</li></ul><pre>git merge feature/login</pre><p>Result: a “merge commit.” History is <strong>non-linear</strong>, but full.</p><ul><li><strong>Rebase</strong>: reapplies your branch commits <em>on top of</em> the target branch.</li></ul><pre>git switch feature/login<br>git rebase main</pre><p>Result: a <strong>linear history </strong>as if your branch was built after the latest main.</p><p><strong>Rule of thumb:</strong></p><ul><li>Use <strong>merge</strong> when you want full context (team work).</li><li>Use <strong>rebase</strong> to keep your personal branch tidy before merging.</li><li>Never rebase <em>shared history</em> (branches teammates already pulled).</li></ul><h3>Collaborating with GitHub</h3><p>Local commits are great, but you’ll want your work online.</p><ul><li>Connect to GitHub:</li></ul><pre>git remote add origin &lt;url&gt;</pre><ul><li>Push your branch:</li></ul><pre>git push -u origin main</pre><ul><li>Next time, just:</li></ul><pre>git push</pre><ul><li>To get teammates’ work:</li></ul><pre>git pull         # fetch + merge<br>git pull --rebase # fetch + rebase instead of merge</pre><p>On GitHub, the standard process is:</p><ol><li>Push your branch.</li><li>Open a <strong>Pull Request (PR)</strong>.</li><li>Teammates review your changes.</li><li>Merge into main.</li></ol><p>This is how modern software teams avoid chaos.</p><h3>Fixing Mistakes</h3><p>Git has an “undo” button for almost everything:</p><pre>git restore &lt;file&gt;            # undo changes in working directory<br>git restore --staged &lt;file&gt;   # unstage a file<br>git commit --amend            # fix last commit (msg or staged files)<br>git reset --hard &lt;sha&gt;        # reset branch to a commit (dangerous!)<br>git checkout &lt;sha&gt; -- &lt;file&gt;  # restore a file from history</pre><p>Think of Git as a safety net: you’ll break things, but rarely lose work.</p><h3>The Lifecycle in Practice</h3><p>Here’s the flow most developers live in:</p><ol><li><strong>Clone / init</strong> the project.</li><li><strong>Branch</strong> off main for your work.</li><li><strong>Edit → add → commit</strong> in small chunks.</li><li><strong>Rebase</strong> on top of the latest main to keep your branch fresh.</li><li><strong>Push</strong> to GitHub and open a <strong>Pull Request</strong>.</li><li><strong>Merge</strong> back into main once reviewed.</li><li>Repeat.</li></ol><h3>The Core Commands to Know</h3><ul><li><strong>Start:</strong> git init, git clone</li><li><strong>Status &amp; history:</strong> git status, git log --oneline, git diff</li><li><strong>Save work:</strong> git add, git commit</li><li><strong>Branching:</strong> git branch, git switch, git merge, git rebase</li><li><strong>Collaboration:</strong> git push, git pull, git pull --rebase</li><li><strong>Fixes:</strong> git restore, git commit --amend, git reset</li></ul><p>Master these, and you’re fluent in Git’s lifecycle</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*dK0Ujk5nhwvzgvxbi6rigA.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c65941abf0c8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Agents, everything you need to know (for dummies version)]]></title>
            <link>https://medium.com/@dotslashsimran/ai-agents-everything-you-need-to-know-for-dummies-version-371add03cfe6?source=rss-a9edd1162ca1------2</link>
            <guid isPermaLink="false">https://medium.com/p/371add03cfe6</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai-agents-review]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Simran Sachdeva]]></dc:creator>
            <pubDate>Thu, 24 Apr 2025 07:35:42 GMT</pubDate>
            <atom:updated>2025-04-24T07:35:42.359Z</atom:updated>
            <content:encoded><![CDATA[<p>You missed Bitcoin in 2010. That’s okay. But if you’re ignoring AI, you might not recover from this one.</p><p>And no — AI isn’t here to take your job.</p><p>But someone who knows how to use it? They might.</p><p>This is the start of a series I’ve been meaning to write for a while. Something simple, useful, and not annoying. There’s too much noise around AI right now — too many big words, just too much of everything.</p><p>It’s okay even if you do not know how to code. I’ll try to keep this as simple as possible.</p><p>I’ve automated pretty much everything in my life — from boring work tasks to Bumble chats. I’ve built AI agents for friends, clients, random people oh and also Microsoft.</p><p>I’ve been in this space, I’ve done the work, and now I’m sharing what I know. No hype. No condescension. Just things that make sense — and make your life easier.</p><p>Soooooo, <strong>what even is an AI agent?</strong></p><p>an AI agent is just a piece of software that <em>does things for you</em>.</p><p>It can <em>think a little</em>, plan, and act in your place. Like a really, really competent intern who never sleeps and doesn’t need coffee breaks.</p><p>also, cheaper.</p><p>It can:</p><ul><li>Read your emails and reply to them</li><li>Book your flights and schedule meetings</li><li>Do research and summarise findings</li><li>Write code, test it, fix bugs</li><li>Even have conversations on your behalf (seriously)</li></ul><p>Here’s some stuff you should prob know of:</p><h3>LLMs (Large Language Models)</h3><p>At the core of most AI agents is a foundation model: ChatGPT, Claude, Mistral, LLaMA, whatever flavour you like.</p><p>These models are built using transformers (the architecture, not the robots), trained on trillions of tokens from books, websites, codebases, Reddit rants, and more.</p><p>They’re not conscious.</p><p>They don’t <em>understand</em> in the way humans do.</p><p>What they do best is <strong>contextualize</strong>. Probabilistic next-token prediction — which, when scaled up, weirdly feels like “intelligence.”</p><p>LLMs really excel at is <strong>pattern recognition</strong>. That’s how they generate ideas that seem like intelligent responses. They can infer, hypothesize, and create structure out of chaos, but it’s important to know <strong>they’re not truly “thinking”</strong> — they’re just really good at predicting the best possible next step based on massive datasets.</p><h3><strong>Memory</strong></h3><p>Memory in AI is the ability of an agent to <strong>retain context</strong> over time. This isn’t just the agent forgetting everything after each task; <strong>it remembers</strong>. It can look back at past interactions, and it can keep track of things you’ve said across sessions.</p><p>But memory isn’t just about storing information like a database.</p><p>It’s about <strong>contextual memory</strong> — remembering what’s important for decision-making.</p><p>Let’s say you tell your AI agent, “I prefer meetings in the morning,” and next time it checks your schedule, it prioritizes meetings in the morning.</p><ul><li><strong>Short-term memory</strong> can get easily overwritten because LLMs have <strong>context windows</strong> (like 8k tokens in GPT-4).</li><li><strong>Long-term memory</strong> needs a more sophisticated approach — think <strong>vector embeddings</strong> stored in something like FAISS or Weaviate.</li></ul><p>Embeddings turn your data into vectors, which can be searched more efficiently than just raw text. It’s like your agent has a way of “remembering” your preferences, while also being <strong>selective</strong> about what it keeps for future use.</p><h3>🧠 + 🧠 ≠ Agent</h3><p>A model alone is <em>not</em> an agent. A lot of people miss this.</p><p>An agent is when you combine:</p><ol><li><strong>Reasoning (LLM)</strong></li><li><strong>Memory (short-term + long-term)</strong></li><li><strong>Tools (APIs, code execution, file systems, web access)</strong></li><li><strong>Autonomy (goal-oriented loops, not just single-shot prompts)</strong></li></ol><p>That last part is where things get spicy. The loop, it is what makes agents <em>actually</em> smart.</p><p>It helps an agent evaluate its choices and continuously adjust to find the best possible outcomes over time.</p><p>Most real world agents operate in a goal-oriented feedback loop:</p><ol><li><strong>Observe</strong> — What’s the current state?</li><li><strong>Think</strong> — What should I do next?</li><li><strong>Act</strong> — Call a function, hit an API, update a file, whatever.</li><li><strong>Repeat</strong> — Based on the outcome, go again.</li></ol><p>This is what frameworks like <strong>LangChain</strong>, <strong>Autogen</strong>, <strong>CrewAI</strong>, and <strong>AutoGPT</strong> try to orchestrate. Some better than others.</p><p>You can also roll your own — and honestly, you <em>should</em>, at least once.</p><p>It teaches you a ton about prompt engineering, tool abstraction, and execution orchestration.</p><p>Mathematically, this is akin to <strong>reinforcement learning</strong> (RL), where the agent gets feedback (rewards or penalties) based on its actions. The agent continuously updates its <strong>policy</strong> to maximize the cumulative reward.</p><p>Google Q learning approach to dig in more math if needed.</p><h3>How do these agents with the newfound goals exactly work?</h3><p>This is where agents level up. Instead of just doing <em>what you say</em>, they start working toward <em>what you want.</em></p><p>Let’s say your goal is:<br> <strong>“Find me a remote software job in Europe that matches my resume, and apply to the top 5.”</strong></p><p>This is too complex for a single LLM prompt. But an agent can break it down:</p><ol><li>Search for remote job listings.</li><li>Filter by location and job type.</li><li>Compare JD keywords with your resume (using embeddings or keyword matching).</li><li>Auto-fill applications or generate tailored cover letters.</li><li>Track which ones it’s applied to (memory!) so it doesn’t repeat itself.</li></ol><p>You didn’t tell it how to do all that. You just gave it a goal. And they figure out <em>how</em> to get there.</p><p>In the next part of this series, we’ll build your <em>first</em> AI agent — step-by-step.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=371add03cfe6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Landed Offers from Fortune 500 Companies at 19 with Cold Emails (includes a template)]]></title>
            <link>https://medium.com/@dotslashsimran/how-i-landed-offers-from-fortune-500-companies-at-19-with-cold-emails-a6549f2e7d8d?source=rss-a9edd1162ca1------2</link>
            <guid isPermaLink="false">https://medium.com/p/a6549f2e7d8d</guid>
            <category><![CDATA[undergraduate]]></category>
            <category><![CDATA[hiring]]></category>
            <category><![CDATA[cold-emails]]></category>
            <category><![CDATA[referrals]]></category>
            <category><![CDATA[internships]]></category>
            <dc:creator><![CDATA[Simran Sachdeva]]></dc:creator>
            <pubDate>Sun, 21 Apr 2024 15:22:35 GMT</pubDate>
            <atom:updated>2024-04-21T15:23:15.134Z</atom:updated>
            <content:encoded><![CDATA[<p>Let me share a little story about how a few thoughtfully crafted cold emails helped me, at just 19, secure opportunities with some of the world’s leading companies. It’s not just about sending emails — it’s about making a connection, and yes, it can actually be pretty enjoyable.</p><p>Cold emails are more than just shots in the dark; they’re strategic, purposeful, and surprisingly effective when done right. They’re your way of saying, “Hello, I’m here and I have something valuable to offer.” But how do you craft an email that gets you noticed without sounding like every other pitch in the inbox?</p><p>• Directly Visit the Company’s Website<br>• Navigate to the Footer<br>• Find the ‘About Us’ or ‘Team’ sections.<br>• Find their CEOs or managers’ emails/linkedin (or ask employees for referrals, they often get a bonus for referring someone)<br>• Send a Cold Email or DM<br>• Articulate Your Value</p><p>You want to be respectful yet relatable, professional yet personable. The key is to strike a balance that not only respects the recipient’s time but also highlights your unique attributes.</p><p>Here’s a template to get you started:</p><blockquote>Subject: 3 pointers on why you should hire me</blockquote><blockquote>Hi [Recipient’s Name],</blockquote><blockquote>I hope this email finds you well. I am [Your Name], currently pursuing [your major] student at [Your University]. I am very interested in exploring internship opportunities with [Recipient’s Company], especially because of your work in [specific project or area you admire].</blockquote><blockquote>I have attached my resume for your review, but here are a few key points about my background:</blockquote><blockquote>• I have worked on a project about [briefly describe a relevant project or coursework].</blockquote><blockquote>• I am skilled in using [list any important tools or software relevant to the job].</blockquote><blockquote>• I have been part of [mention any team or leadership experience or previous internships].</blockquote><blockquote>I would really appreciate the chance to talk with you for a few minutes about how I might be able to contribute to your team/company.</blockquote><blockquote>Thank you for your time. I am looking forward to the opportunity to learn and contribute at [Recipient’s Company].</blockquote><blockquote>Best wishes,</blockquote><blockquote>[Your Full Name]</blockquote><blockquote>[Your Contact Information]</blockquote><blockquote>[Your LinkedIn Profile] (optional)</blockquote><h4>Why This Approach Works</h4><ol><li><strong>It’s Personal: </strong>It starts with a direct address and a personal connection to their work. It shows you’re informed and engaged.</li><li><strong>It’s you:</strong> The email is concise yet reflects your personality. It’s professional, but not stiff — think of it as chatting with a mentor, not submitting an essay.</li><li><strong>It’s Clear and Direct:</strong> The email outlines your skills briefly and ends with a clear call to action. It’s about setting the stage for a future conversation, not closing a deal on the spot.</li><li><strong>It Calls to Action:</strong> The gentle nudge for a follow-up chat isn’t pushy. It’s about mutual discovery, seeing how you might fit into their world.</li></ol><p>Remember, cold emailing is about building relationships, not just sending out applications. Each email is a step towards a conversation that could lead anywhere. Keep it light, make it personal, and show them why you’d be a great addition to their team. Who knows where your next email might lead? Happy emailing!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a6549f2e7d8d" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>