<?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 Sanchit Gera on Medium]]></title>
        <description><![CDATA[Stories by Sanchit Gera on Medium]]></description>
        <link>https://medium.com/@sanchit-gera?source=rss-90200d77cc66------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*EaBu1itFWV2pOJo6CyMZAg@2x.jpeg</url>
            <title>Stories by Sanchit Gera on Medium</title>
            <link>https://medium.com/@sanchit-gera?source=rss-90200d77cc66------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 00:33:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sanchit-gera/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[Understanding Spark Caching]]></title>
            <link>https://sanchit-gera.medium.com/understanding-spark-caching-cf3b8e537e96?source=rss-90200d77cc66------2</link>
            <guid isPermaLink="false">https://medium.com/p/cf3b8e537e96</guid>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[spark]]></category>
            <dc:creator><![CDATA[Sanchit Gera]]></dc:creator>
            <pubDate>Tue, 20 Jan 2026 01:06:22 GMT</pubDate>
            <atom:updated>2026-01-20T01:06:22.317Z</atom:updated>
            <content:encoded><![CDATA[<p>In my <a href="https://medium.com/@sanchit-gera/understanding-spark-shuffles-e23d1085bea8">previous post on Spark Shuffles</a>, I explored why data movement across the network is the most expensive part of a distributed system. But there is a second, silent performance killer that often sneaks into production pipelines: Redundant Recomputation. To understand why this happens, let’s first take a look at the core of Spark’s execution model: Lazy Evaluation.</p><h3>Transformation vs. Actions</h3><p>At a high level, every Spark statement you write can be classified into two types:</p><ul><li>Transformation (Lazy): Statements like .select, .map, .filteror .joindon’t actually evaluate the data. They simply help Spark build up its logical plan for how it wants to process the data. These statements can be chained without triggering anything.</li><li>Actions (Eager): Statements like .show, .count, or .writeare eager. They force evaluating the data (Spark can’t tell you how many records a dataset has without first computing it).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_qzW574C7btLAvENl2GnLA.png" /></figure><p>Once an action is finished, Spark discards the materialized results of that computation unless explicitly told to keep them. The logical plan (lineage) still exists — but it will be replayed from the source the next time an action is triggered.</p><h3>The Branching Problem</h3><p>In the real world, processing is rarely linear. A common pattern involves performing an expensive operation — like joining large tables or calling an external API — and then branching that result into “success” and “failed” subsets for different downstream actions.</p><p><strong>The Variable Trap</strong>: A common misconception is that saving a DataFrame to a variable (e.g., final_df = raw_df.join(..))physically stores the data. <strong>It does not</strong>.</p><p>In Spark, a variable is simply a pointer to a lineage (DAG), not a container for data. If final_df is used in two different actions, Spark doesn’t “remember” the result from the first time. Because it is lazy, it follows the pointer back to the source and re-executes the entire plan for every single action.</p><p>Without caching, every terminal action triggers the DAG from scratch. In the example below, where we load data, apply a heavy join, and split the paths, the DAG is triggered 4 separate times. We pay for that “Expensive Computation” over and over again.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*73YBk9FEm9w7yphZQIWvSg.png" /></figure><h3>The Solution: Caching Intermediate Datasets</h3><p>Fortunately, Spark has a simple solution. By calling .cacheimmediately after an expensive step, you tell Spark to store those intermediate materialized partitions in memory so they can be reused for future actions. The next time an action requests that data, Spark intercepts the request at the cache layer and pulls the results directly from memory, skipping the upstream lineage entirely. It’s important to note that .cacheitself is lazy. Spark only materializes the cache the first time an action runs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1PqPS_E5HKFREk5zf4TJaA.png" /></figure><h3>The Cost of Caching</h3><ul><li><strong>The Memory Tax</strong>: By default, datasets are cached in memory. Executor memory is a shared resource split between cached datasets (Storage) and Spark operations (Execution). If the cached datasets become too large, they “squeeze” the space available for shuffles and joins. This forces Spark to either evict the cache or spill operation data to disk, significantly slowing down the job.</li><li><strong>The CPU Cost</strong>: By default, Spark data is stored as raw Java objects (unserialized). While there is minimal CPU overhead to read these objects, the memory consumption is huge — often 2–5x the serialized form. If you choose to reduce the memory footprint by serializing the data, you pay back that “saved” memory in CPU overhead, as Spark must serialize/deserialize the data every time it is accessed.</li></ul><h3>Choosing the Right Storage Level</h3><p>Because of these trade-offs, Spark offers granular control over how you choose to cache your datasets using its persist API:</p><ul><li>MEMORY_ONLY Data is stored in memory only, in an unserialized form. When executor memory is under pressure, the data is evicted from the cache and recomputed when needed.</li><li>MEMORY_ONLY_SER Data is stored in memory only, but in a serialized form. The memory consumption is significantly lower than the non-serialized version but requires additional CPU overhead to deserialize the data back when accessed.</li><li>MEMORY_AND_DISK Data is stored in memory first. If memory is under pressure, the cached data is “spilled” to disk. The data is re-read from disk if needed later.</li></ul><h3>Caching Strategy</h3><p>While there is no universal “best” caching strategy, I like to apply a few rules of thumb when deciding how to cache:</p><ul><li><strong>The Rule of Two</strong>: Only cache a dataset if it is going to be used by more than one action or across multiple branches of your DAG. Caching a DataFrame that is only used once adds storage overhead without any recomputation benefit.</li><li><strong>Cost to Compute vs. Cost to Read</strong>: Don’t cache a dataset if it is massive and recomputing it is faster than reading spilled data. If your transformation is a simple .filter, the time Spark spends writing that data to a local disk (and reading it back) often exceeds the time it takes to just re-run the filter from the source.</li><li><strong>Prefer Serialization</strong>: If you are operating in a memory-constrained environment, always default to MEMORY_ONLY_SER. It is better to pay a small CPU tax for serialization than to risk a job failure due to Garbage Collection pressure or Out-of-Memory errors.</li><li><strong>Clean up Aggressively</strong>: Always call .unpersistonce downstream actions are complete. Forgotten caches are one of the most common causes of executor OOMs in long-running pipelines.</li></ul><h3>Final Thoughts</h3><p>Caching is a powerful construct that can (literally) save your job hours in execution time and a ton of hardware cost. But caches are not a silver bullet, and used incorrectly caches are just as likely to bloat your jobs. Mastery of Spark isn’t just about knowing which functions to call; it’s about knowing exactly what those calls cost the cluster under the hood. Hopefully this post helped you understand the mechanics enough to use it intentionally and effectively.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cf3b8e537e96" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding Spark Shuffles]]></title>
            <link>https://sanchit-gera.medium.com/understanding-spark-shuffles-e23d1085bea8?source=rss-90200d77cc66------2</link>
            <guid isPermaLink="false">https://medium.com/p/e23d1085bea8</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[spark]]></category>
            <category><![CDATA[big-data]]></category>
            <dc:creator><![CDATA[Sanchit Gera]]></dc:creator>
            <pubDate>Mon, 12 Jan 2026 01:20:09 GMT</pubDate>
            <atom:updated>2026-01-12T01:20:09.370Z</atom:updated>
            <content:encoded><![CDATA[<p>One of the hardest Spark concepts to grasp is that of a Spark shuffle, but it is also usually the biggest performance killer. Conversely, a good understanding of shuffles can help you optimize your biggest bottlenecks. This post focuses on how to reason about shuffles and their performance impact.</p><h3>Partitions</h3><p>A partition is a logical chunk of a large dataset. Since Spark is a distributed engine, it breaks data into these chunks so different nodes (Executors/Cores) can work on them in parallel. By default, Spark <em>targets</em> partitions of around <strong>128MB</strong> when reading files, controlled by spark.sql.files.maxPartitionBytes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*qqFCUU7FvG3M7jdFvtk6JA.png" /></figure><p>For instance, when reading a large file of 1GB, Spark may split it into 7–8 partitions of ~128MB each. Conversely, when reading thousands of small files, Spark may choose to “coalesce” them into bigger partitions until it hits the target.</p><p>The key points to remember are:</p><ul><li>A partition is the <strong>logical unit</strong> of data processing.</li><li>Each partition corresponds to <strong>one task</strong> in the Spark UI, which is why partition counts directly translate to task counts.</li><li>All data within a partition is processed by a <strong>single task on a single executor</strong> at any given time.</li></ul><h3>Wide vs. Narrow Transformations</h3><p>When writing Spark code, you’ll typically encounter two kinds of operations:</p><h4>Narrow Transformations (Fast)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/931/1*EhfcuzVzEfsj5gdk__Hayg.png" /></figure><p>In a Narrow Transformation, each input partition contributes to exactly one output partition, meaning data stays on the same machine. Examples include map(), filter(), withColumn(), and select(). These operations are fast because the data never has to leave the executor. The operation doesn’t depend on other rows in the dataset; for example, Spark can independently map a record to a new value in memory.</p><h4>Wide Transformations (Slow)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/879/1*jfHljAPwo-_n1majj_qccw.png" /></figure><p>Wide Transformations are those where the output may depend on multiple input partitions. For instance, when performing aggregations by a key, Spark needs to know what records exist for a given key in <em>all</em> the partitions of the dataset. As a result, data from one partition will need to move to another partition either between different cores on the same JVM, or in the worst case, over the network between executors. Wide transformations introduce a <strong>stage boundary</strong>, meaning Spark must finish one set of tasks before starting the next.</p><h3>The Cost: Why Shuffle Kills Performance</h3><p>A shuffle is essentially <em>how</em> Spark performs a wide transformation. While necessary, a shuffle comes with a few downsides:</p><h4>I/O and Serialization Overhead</h4><p>During a shuffle, Spark cannot simply move data in memory. To efficiently move data between executors, it must first serialize it and store it on local disk (the Shuffle Write). Similarly, the receiving executor must then deserialize the data before it can be processed (the Shuffle Read). Both operations are CPU intensive and consume network bandwidth. This combination of disk I/O and network transfer is orders of magnitude slower than RAM-based processing.</p><h4>Skewed Data</h4><p>While shuffles are slow by themselves, they become especially problematic when data is highly skewed. In real-world datasets, data is often dominated by a single key — for example, a handful of users responsible for the majority of activity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*vCjLzBtq59pmTE3U0cJ8KQ.png" /></figure><p>In these cases, Spark tries to pull all data for that skewed entity into a single partition, creating a bottleneck where one executor works on a massive task while others sit idle. This single “straggler” task determines the execution time for the entire job. In Spark UI, this typically shows up as one task in a shuffle stage running far longer than the rest, often with much higher shuffle read bytes.</p><p>Importantly, increasing the number of executors does <strong>not</strong> fix skew — because the skewed partition is still processed by a single task.</p><h4>Memory Contention</h4><p>As noted in the previous post, Spark divides executor memory into two main pools: <strong>Storage</strong> (for cached data) and <strong>Execution</strong> (for shuffles and joins), which can borrow from each other under pressure. If a shuffle requires more memory than is available in the Execution pool, it will start “evicting” cached data from the Storage pool. If it still needs more, Spark will <strong>“</strong>spill<strong>”</strong> the shuffle data to disk, which slows down the operation significantly because disk access is much slower than RAM. In Spark UI, this often coincides with frequent spill events and erratic task durations.</p><h3>What can you change?</h3><p>Shuffles are inevitable in data processing. Computing aggregates and joins are all necessary operations and cannot be completely avoided. However, a few simple strategies mitigate the impact:</p><h4>Reduce the data being shuffled</h4><p>Shuffling is expensive because of the volume of data moving across the network. Always filter() rows and select() only the columns you truly need <strong>before</strong> a wide transformation. This minimizes the payload written to disk and sent over the wire. Reducing row <em>width</em> is often just as important as reducing row <em>count</em>.</p><h4>Broadcast joins</h4><p>If you are joining a large table with a small one, use a broadcast() <a href="https://spark.apache.org/docs/latest/sql-performance-tuning.html#optimizing-the-join-strategy">hint</a>. This sends a copy of the small table to every executor, allowing the join to happen locally within each partition. This effectively turns a wide join into a narrow one and skips the shuffle entirely. Broadcast joins work best when the broadcasted table comfortably fits in executor memory.</p><h4>Tune Shuffle Partitions</h4><p>The configuration spark.sql.shuffle.partitions defaults to <strong>200</strong>. This is rarely the right number. If your data is tiny, 200 tasks create massive scheduling overhead; if your data is massive, 200 tasks may create partitions so large they cause OOM errors. Tune this number so that your post-shuffle partitions are roughly 128MB to 200MB each. The goal is to balance parallelism against per-task overhead.</p><h4>Apply Salting (Advanced)</h4><p>For severe data skew, you can implement “<a href="https://medium.com/towards-data-engineering/taming-skewness-in-spark-salting-revisited-4a36388e6e24">Salting</a>”. This involves adding a random integer (the “salt”) to your join or grouping key. This forces Spark to distribute a single “hot” key across multiple partitions rather than cramming it into one. While this requires an extra step to aggregate the results back together, it is often the only way to bypass a “straggler” task. Salting trades additional computation for improved parallelism.</p><h3>Final Thoughts</h3><p>Shuffles aren’t bad — but they are expensive. Understanding when they happen, why they hurt, and how to mitigate them is the key to writing performant Spark jobs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e23d1085bea8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Anatomy of a Spark Executor]]></title>
            <link>https://sanchit-gera.medium.com/the-anatomy-of-a-spark-executor-40798a4e6b00?source=rss-90200d77cc66------2</link>
            <guid isPermaLink="false">https://medium.com/p/40798a4e6b00</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[apache-spark]]></category>
            <dc:creator><![CDATA[Sanchit Gera]]></dc:creator>
            <pubDate>Mon, 05 Jan 2026 01:03:41 GMT</pubDate>
            <atom:updated>2026-01-05T01:03:41.800Z</atom:updated>
            <content:encoded><![CDATA[<p>One of the most crucial aspects of Spark is its executor/core architecture. Tuning Spark jobs often involves trial and error. Fudging numbers can often feel like magic unless you truly understand what’s happening under the hood.</p><p>This post walks through the internal constructs Spark uses to manage and allocate memory, and how those constructs map to real-world environments like AWS EMR.</p><h3><strong>Inside the JVM</strong></h3><p>A Spark executor is allocated a fixed amount of memory (controlled by spark.executor.memory). This is the total heap memory available to Spark for all its computation and storage requirements. Functionally, Spark splits this memory into logical regions each serving a different purpose.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uzGoi9dHvoeueo7Ugy3xow.png" /></figure><h4><strong>Reserved Memory</strong></h4><p>Before Spark allocates memory for processing, it reserves a small fixed portion of the executor heap for itself. This reserved memory (typically ~300 MB) is used for internal bookkeeping and metadata and is not available for execution or caching.</p><h4><strong>Unified Memory (Spark-Managed)</strong></h4><p>From the remaining heap, Spark allocates a portion for its core execution needs — this is known as Spark-managed (or unified) memory. This is controlled by spark.memory.fraction, which defaults to 0.6, meaning Spark intentionally limits itself to 60% of the usable heap.</p><p>Spark-managed memory serves two purposes:</p><ul><li><strong>Execution memory</strong>: used for computation such as shuffles, joins, aggregations, and sorts.</li><li><strong>Storage memory</strong>: used to cache or persist datasets via .cache() or .persist().</li></ul><p>The boundary between execution and storage is fluid. Storage memory can be reclaimed at any time to satisfy execution needs, since Spark prefers recomputing cached data over stalling job progress. This is often seen as cache evictions or spills to disk.</p><h4><strong>User Memory</strong></h4><p>The remainder of the executor heap is user (unmanaged) memory. This is where application-level objects live, including UDF state, user-defined data structures, deserialized objects, and other JVM allocations Spark does not control directly. By default, this accounts for the remaining ~40% of usable heap, indirectly determined by spark.memory.fraction.</p><h4><strong>The Container Layer (Memory Overhead)</strong></h4><p>In addition to the JVM heap, Spark allocates off-heap memory per executor to support components that do not live on the heap, such as native libraries, JVM thread stacks, network (Netty) buffers, and (for PySpark) Python worker processes. This is configured via spark.executor.memoryOverhead and defaults to ~10% of the executor heap, meaning a 16 GB executor typically requires an additional ~1.6 GB of memory beyond the heap to run safely.##</p><h3><strong>Physical Mapping: The EC2 Instance</strong></h3><p>Executors ultimately run on physical hardware. A single EC2 instance (for example, 8 vCPUs and 256 GB RAM) is typically divided into multiple executors to balance parallelism, memory usage, and fault isolation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a3dL5iLEF-mxF1upDkf_Sw.png" /></figure><p>Each executor is assigned a fixed number of cores via spark.executor.cores which map directly to vCPU slots on the EC2 instance. For example, an 8-vCPU node might be split into four executors, each configured with 2 cores.</p><p>This physical mapping introduces two hard constraints:</p><ul><li><strong>Memory Limits</strong>: The sum of executor heaps + overhead must fit within the node’s physical RAM, leaving a buffer for the Linux kernel and system daemons.</li><li><strong>CPU Limits</strong>: Assigning more executor cores than available vCPUs oversubscribes the CPU, leading to increased context switching and reduced performance. Ideally, each executor core should map <strong>1:1</strong> to a vCPU core.</li></ul><p>Executor sizing is ultimately constrained by what fits on a single node, not the total capacity available on the cluster. This is where cluster managers like YARN and Kubernetes come in, acting as schedulers that assign these executor containers to the available physical nodes</p><h3><strong>Concurrency and Contention</strong></h3><p>Because an executor is a single JVM, all memory — execution, storage, and user memory — is shared across its cores. Increasing spark.executor.cores increases the number of concurrent tasks contending for the same heap. Under higher concurrency, execution memory pressure rises, leading to more frequent cache eviction and elevated garbage collection (GC) overhead, often degrading performance instead of improving it.</p><h3><strong>Final Thoughts</strong></h3><p>Understanding executors and their relationship with the physical hardware explains many of Spark’s counterintuitive performance behaviors. Shuffles, skew, caching, and garbage collection become easier to reason about once the executor model is clear.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=40798a4e6b00" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Content, Curation, and the Paradox of Choice]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">How elevating quality content can be a competitive strength</p><p class="medium-feed-link"><a href="https://sanchit-gera.medium.com/content-curation-and-the-paradox-of-choice-41263156143e?source=rss-90200d77cc66------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://sanchit-gera.medium.com/content-curation-and-the-paradox-of-choice-41263156143e?source=rss-90200d77cc66------2</link>
            <guid isPermaLink="false">https://medium.com/p/41263156143e</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[business]]></category>
            <category><![CDATA[ux]]></category>
            <dc:creator><![CDATA[Sanchit Gera]]></dc:creator>
            <pubDate>Mon, 28 Nov 2022 04:53:51 GMT</pubDate>
            <atom:updated>2022-11-28T04:53:51.672Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[How Good Good Processes Create Stro]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://sanchit-gera.medium.com/how-good-good-processes-create-stro-79305190f274?source=rss-90200d77cc66------2"><img src="https://cdn-images-1.medium.com/max/1179/1*0LlFWwOcv0T4-imnNGcUMA.jpeg" width="1179"></a></p><p class="medium-feed-snippet">I&#x2019;ve always had a strong disdain for the word &#x201C;process&#x201D;. It invokes deep dread and my brain automatically conjures an image of myself&#x2026;</p><p class="medium-feed-link"><a href="https://sanchit-gera.medium.com/how-good-good-processes-create-stro-79305190f274?source=rss-90200d77cc66------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://sanchit-gera.medium.com/how-good-good-processes-create-stro-79305190f274?source=rss-90200d77cc66------2</link>
            <guid isPermaLink="false">https://medium.com/p/79305190f274</guid>
            <category><![CDATA[business]]></category>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[tech]]></category>
            <dc:creator><![CDATA[Sanchit Gera]]></dc:creator>
            <pubDate>Sat, 13 Aug 2022 17:04:42 GMT</pubDate>
            <atom:updated>2022-08-13T17:04:52.210Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Why Every Company is Now a Tech Company]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://sanchit-gera.medium.com/why-every-company-is-now-a-tech-company-87a388537321?source=rss-90200d77cc66------2"><img src="https://cdn-images-1.medium.com/max/2600/1*YQWj7qfCS1K9MVk9lfrCaQ.jpeg" width="5000"></a></p><p class="medium-feed-snippet">Around 10 years ago, Marc Andreseen published a famous article on how tech companies were disrupting traditional industries that once&#x2026;</p><p class="medium-feed-link"><a href="https://sanchit-gera.medium.com/why-every-company-is-now-a-tech-company-87a388537321?source=rss-90200d77cc66------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://sanchit-gera.medium.com/why-every-company-is-now-a-tech-company-87a388537321?source=rss-90200d77cc66------2</link>
            <guid isPermaLink="false">https://medium.com/p/87a388537321</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[business]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[startup]]></category>
            <dc:creator><![CDATA[Sanchit Gera]]></dc:creator>
            <pubDate>Sun, 15 May 2022 04:40:18 GMT</pubDate>
            <atom:updated>2022-05-15T04:40:18.763Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Building an Information Diet]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://sanchit-gera.medium.com/building-an-information-diet-a8143d08837e?source=rss-90200d77cc66------2"><img src="https://cdn-images-1.medium.com/max/2600/1*xFtb3iNi8nunY4jyvaO76g.jpeg" width="5134"></a></p><p class="medium-feed-link"><a href="https://sanchit-gera.medium.com/building-an-information-diet-a8143d08837e?source=rss-90200d77cc66------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://sanchit-gera.medium.com/building-an-information-diet-a8143d08837e?source=rss-90200d77cc66------2</link>
            <guid isPermaLink="false">https://medium.com/p/a8143d08837e</guid>
            <category><![CDATA[personal-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[journalism]]></category>
            <dc:creator><![CDATA[Sanchit Gera]]></dc:creator>
            <pubDate>Sun, 13 Feb 2022 19:35:20 GMT</pubDate>
            <atom:updated>2022-02-13T19:35:20.471Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The Role of an Engineer]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://sanchit-gera.medium.com/the-role-of-an-engineer-d658d81edee1?source=rss-90200d77cc66------2"><img src="https://cdn-images-1.medium.com/max/2600/1*lULk2sqK-ziK3o6g1zD-1w.jpeg" width="5719"></a></p><p class="medium-feed-snippet">Why engineers thrive in a customer obsessed culture</p><p class="medium-feed-link"><a href="https://sanchit-gera.medium.com/the-role-of-an-engineer-d658d81edee1?source=rss-90200d77cc66------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://sanchit-gera.medium.com/the-role-of-an-engineer-d658d81edee1?source=rss-90200d77cc66------2</link>
            <guid isPermaLink="false">https://medium.com/p/d658d81edee1</guid>
            <category><![CDATA[engineering]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Sanchit Gera]]></dc:creator>
            <pubDate>Fri, 24 Sep 2021 04:16:46 GMT</pubDate>
            <atom:updated>2021-09-24T04:16:46.736Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Everything I Have Learned from Working Remotely for a Year]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/swlh/everything-i-have-learned-from-working-remotely-for-a-year-7dfa3ce9c721?source=rss-90200d77cc66------2"><img src="https://cdn-images-1.medium.com/max/2600/1*ZyPFqxMMmh5__8y8aKdj1A.jpeg" width="5243"></a></p><p class="medium-feed-snippet">We are closing in on an entire year since the pandemic induced lock-downs started. With that, it&#x2019;s also going to be a full year since a&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/swlh/everything-i-have-learned-from-working-remotely-for-a-year-7dfa3ce9c721?source=rss-90200d77cc66------2">Continue reading on The Startup »</a></p></div>]]></description>
            <link>https://medium.com/swlh/everything-i-have-learned-from-working-remotely-for-a-year-7dfa3ce9c721?source=rss-90200d77cc66------2</link>
            <guid isPermaLink="false">https://medium.com/p/7dfa3ce9c721</guid>
            <category><![CDATA[covid19]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[remote-working]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Sanchit Gera]]></dc:creator>
            <pubDate>Tue, 16 Feb 2021 03:33:34 GMT</pubDate>
            <atom:updated>2021-02-22T20:38:18.587Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The Digital Detox]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://sanchit-gera.medium.com/the-digital-detox-449470a8ee74?source=rss-90200d77cc66------2"><img src="https://cdn-images-1.medium.com/max/2600/1*PYRApva0MvUcj6bUv8cEww.jpeg" width="3828"></a></p><p class="medium-feed-snippet">How to rethink  your relationship with the technology around you</p><p class="medium-feed-link"><a href="https://sanchit-gera.medium.com/the-digital-detox-449470a8ee74?source=rss-90200d77cc66------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://sanchit-gera.medium.com/the-digital-detox-449470a8ee74?source=rss-90200d77cc66------2</link>
            <guid isPermaLink="false">https://medium.com/p/449470a8ee74</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[business]]></category>
            <category><![CDATA[mental-health]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Sanchit Gera]]></dc:creator>
            <pubDate>Mon, 25 Jan 2021 16:33:36 GMT</pubDate>
            <atom:updated>2021-01-25T16:33:36.696Z</atom:updated>
        </item>
    </channel>
</rss>