What is Antler?

For those unfamiliar, Antler is a global early-stage venture capital firm that identifies, invests in, and challenges exceptional people to build the defining companies of tomorrow. Unlike traditional accelerators, Antler focuses on the pre-idea, pre-team stage, helping individuals find the right co-founders and validate business ideas before making investments. What makes Antler unique is its dual emphasis on founder matching and idea validation. The program is structured as a 12-week residency that takes participants through a carefully designed journey from introduction to investment readiness.

The Application Process

The journey began with a multi-stage application process that tested both my vision and resilience. It started with an online application requiring a detailed resume, a video pitch outlining my entrepreneurial aspirations, and a written submission on my motivation for joining Antler. This was followed by two rounds of virtual interviews with the Antler India team. The interviews focused on my ability to translate complex AI solutions into scalable products, which resonated with Antler’s mission to back high-impact founders. What stood out was their emphasis on adaptability and founder potential over a fully formed idea — questions probed how I’d pivot under market shifts and collaborate with diverse co-founders, setting the stage for the program’s collaborative ethos.

The Cohort Experience - a 12 Week Journey

The program lasted for 12 intensive weeks, each with a specific focus and purpose. Here’s how my journey unfolded:

Week 1: Introduction and Building Connections
The cohort kicked off with introductions and in-person social events designed to help us get to know each other. Highlights included:

• A FounderSpeak session with Zepto, offering insights from one of India’s fastest-growing startups.
• Workshops focused on finding compatible co-founders.
• Sessions on understanding venture scalability, which helped frame our thinking from day one.
• A two-day Breakout event that fostered deeper connections among participants.

The first week set the tone — intense, collaborative, and focused on relationships as much as ideas. For Loopdesk AI, these connections sparked early discussions with potential co-founders who shared my passion for AI-driven creative tools.

Week 2: Idea Validation & Customer Discovery
By the second week, we were diving deep into validation methodologies:

• A session with Boris Wertz from Version One Ventures gave us a global perspective.
• The Idea Validation Workshop provided a structured approach to testing assumptions.
• The “Billion Touchpoints” exercise pushed us to think at scale.
• Sector-specific jam sessions in Fintech, Mobility, and Digital Public Infrastructure.
• An inspiring FounderSpeak session with Sumit from Instawork.
• AMA with Antler India Residency (AIR) alumni from Kubo Care.
• A Pickleball evening for informal networking.

I began testing Loopdesk AI’s core hypothesis — streamlining video editing workflows — through customer discovery, connecting with creators who validated the need for AI automation.

Week 3: Sector Deep Dives
Week three focused on industry-specific knowledge:

• Deep dives into SaaS + AI, revealing trends in enterprise AI solutions.
• Antler & AU Bank’s session on founder support resources.
• Fintech sector exploration, valuable for understanding adjacent markets.
• A workshop on decision-making for early-stage founders.
• Sector deep dives into ConsumerTech and HealthTech.

The ConsumerTech dive was particularly relevant, as I refined Loopdesk AI’s positioning as a creator-focused platform addressing global content creation demands.

Week 4: Market Validation, Legal & Finance, and MVP Development
This week was content-rich:

• Speak sessions on market sizing and competition analysis.
• Presentations applying market sizing techniques.
• User research training based on “The Mom Test” principles.
• Finance 101 and Legal 101 sessions with Kant.
• Practical MVP development insights from Dodo Payments and Cricinshots founders.
• A FounderSpeak session featuring Jar.

I applied “The Mom Test” to Loopdesk AI, interviewing video editors to uncover pain points in pacing and transitions, shaping our MVP’s feature set.

Week 5: Product Development and Storytelling
By now, teams were forming, and concepts were taking shape:

• An impactful session on storytelling transformed how I communicated Loopdesk AI’s vision. I learned to frame our AI-first platform as a tool that empowers creators to focus on storytelling, not technicalities. This shift made my pitches to potential co-founders and early adopters more compelling, emphasizing how Loopdesk AI removes editing barriers to unlock creative freedom.
• Focused work sprints with selected co-founders, where Loopdesk AI’s prototype began integrating AI-driven transitions and formatting.

Week 6: Dedicated Build Time
The sixth week was a valuable pause for building. My team made significant progress on Loopdesk AI’s MVP, incorporating creator feedback to enhance automation features, condensing months of development into days of focused effort.

Week 7: Pitch Days with the Antler Team
This was our first major milestone, presenting Loopdesk AI’s progress to the Antler team. Feedback on our pitch — particularly on clarifying our enterprise value proposition — helped refine our narrative for investor audiences.

Weeks 8–10: Development and Refinement
These weeks focused on iterative development and investor prep. We ran pilot tests with 15 video creators, iterating Loopdesk AI’s MVP based on their feedback. Mentor sessions with Antler’s ConsumerTech experts helped us sharpen our go-to-market strategy, targeting both creators and enterprises.

Week 11: Go-to-Market Strategy
As we approached the end:

• A session on B2C Go-to-Market strategy with Ankur Saxena provided insights for Loopdesk AI’s creator-focused rollout.

We developed a dual strategy: direct-to-creator subscriptions and enterprise partnerships for scalable adoption.

Week 12: Entering the Cohort Finale

As we enter the final week of the program, we’re gearing up for the culminating presentations. Loopdesk AI’s pitch is set to showcase our AI platform’s potential to transform video editing, aiming to impress the Antler team and lay a strong foundation for upcoming investor pitches.

The Antler Network and Resources

Antler’s global network was a game-changer:

• Industry experts guided us during sector deep dives, particularly in ConsumerTech and AI.
• Former founders from Zepto, Instawork, Jar, Dodo Payments, and Cricinshots shared battle-tested advice.
• A global community spanning 30+ cities.
• Technical resources and mentor connections in AI and ConsumerTech.
• Strategic partnerships with AU Bank.

The FounderSpeak session with Zepto was memorable, as their hypergrowth story inspired Loopdesk AI’s ambition to scale globally from India.

The People Who Made It Special

The cohort’s diversity was a highlight:

• Experienced corporate professionals.
• Serial entrepreneurs.
• Technical specialists.
• Young innovators.

Life After the Program

Post-Antler, Loopdesk AI is preparing to pitch to the Antler Investment Committee for pre-seed funding to accelerate our MVP development and market entry. We’ve attracted significant interest, with 17 US investors and 5 Indian investors reaching out to explore opportunities. The stronger US interest aligns with the global demand for enterprise AI solutions, and we’re tailoring our pitch to highlight Loopdesk AI’s scalability and creator empowerment. The Antler network continues to support us, providing introductions to ConsumerTech mentors and investor prep sessions. As we refine our pitch, the program’s lessons in validation and storytelling are proving invaluable in navigating the fundraising landscape.

Key Learnings and Takeaways

My biggest takeaways from the 12-week Antler experience:

• Founder-Market Fit Matters: The ConsumerTech deep dives validated the demand for AI-driven creative tools, reinforcing Loopdesk AI’s mission to empower creators.
• Speed of Execution: The build weeks showed how focus can condense months of progress into days.
• The Power of a Curated Network: From pickleball evenings to jam sessions, informal connections were as valuable as structured programming.
• Validation Before Investment: The “Mom Test” session in Week 4 changed how I approach customer interviews. For Loopdesk AI, shifting from “Do you like this tool?” to “What’s the biggest challenge in your editing workflow?” uncovered critical insights about pacing and transitions, shaping our AI features to address real pain points.
• Storytelling is Everything: The storytelling session transformed Loopdesk AI’s pitch, framing it as a platform that frees creators from technical hurdles, making it resonate with investors and users.

Advice for Future Applicants

My advice for Antler India applicants:

• Be clear about your motivation but flexible on ideas.
• Engage fully in sector deep dives, even outside your focus.
• Actively participate in founder matching early on.
• Come with an open mind about co-founders.
• Embrace the intensity — the 12 weeks are designed to push you.
• Don’t skip social events; your co-founder connection may happen over pickleball.
• Use Pitch days for real feedback.

Conclusion

Twelve weeks ago, I entered Antler with a vision for Loopdesk AI but uncertain about scaling it. Today, I’m a founder with a refined MVP, a co-founder, and a global network propelling us toward investor pitches. For those serious about entrepreneurship, Antler’s residency offers a unique launchpad. The structured programming — from FounderSpeak to deep dives to pitch practice — builds a strong foundation. But the curated cohort and Antler’s network, which continues post-program, are what make it transformative. The 6th cohort wasn’t just about building Loopdesk AI — it was about becoming a founder ready to shape the future of AI-driven creativity.

Anil Pai is the CTO and Co-founder of Loopdesk AI, and was part of Antler India’s 6th cohort. Connect with him on LinkedIn.

The Pacific Ocean, known for its expansive reach, is dotted with numerous islands, each with its unique geography. While some islands boast freshwater lakes, others are devoid of such water bodies. Imagine representing this vast marine tapestry as a 2D matrix, where ‘0’ signifies water and ‘1’ indicates land. Now consider an algorithmic challenge: given the coordinates of a land piece within this matrix, can we devise a function that accurately counts the number of freshwater lakes present on that particular island?

To unravel the mystery of lake counts on an island, our approach unfolds in two strategic phases. Initially, we employ Breadth-First Search (BFS) to chart out the island’s contours, expanding our search in all eight possible directions. Subsequently, we harness Depth-First Search (DFS) to delve into the island’s terrain, probing in four cardinal directions to enumerate the lakes. Here, a ‘lake’ is identified as a cluster of ‘0’s fully encapsulated within the island’s bounds, ensuring that no part of the lake touches the matrix’s periphery.

Time & Space complexity

The time complexity of the countNumberOfLakes function is O(m*n), where m is the number of rows and n is the number of columns in the island matrix. This is because in the worst-case scenario, the function will need to visit every cell in the island matrix once.

The space complexity of the countNumberOfLakes function is also O(m-1*n-1), where m is the number of rows and n is the number of columns in the island matrix. This is because in the worst-case scenario, every cell in the island matrix could be part of a lake, and thus every cell could be added to the visited set.

Conclusion

Our journey to discern the number of lakes nestled within an island’s embrace concludes with the methodology delineated above. Yet, this beckons us to reflect on several intriguing considerations: Could there be a more streamlined method, perhaps a singular function that negates the need for constructing an island matrix? Is it feasible to pinpoint lakes amidst an island that’s ensconced by the ocean on all sides? How do we distinguish between the ocean’s saline embrace and the freshwater kiss of lakes when both are denoted by ‘0’s? And what if our starting coordinate is itself a watery enclave — will our function still perform reliably? Might there exist an alternative solution, maybe through leveraging an innovative data structure like a disjoint set? I invite you to ponder these questions and share your insights in the comments below.

Freshwater lakes on an island was originally published in Mind-boggling Algorithms on Medium, where people are continuing the conversation by highlighting and responding to this story.

In the realm of social networks, it’s crucial to grasp the interconnections among nodes. Nodes with a direct link—termed edges in graph theory—are akin to friends, or zero-degree connections. Conversely, nodes linked through an intermediary node are known as mutual acquaintances or first-degree connections, colloquially referred to as friends of friends. From a programming perspective, we aim to identify both friends and mutual acquaintances within a social network.

Separated by one degree

Wonderful! Having identified a node’s immediate friends and their mutual acquaintances, we can now explore how to extend this approach to ascertain the connections at the “N”th degree for a given node.

The time complexity of the Breadth-First Search (BFS) algorithm is O(V + E), where V is the number of vertices (nodes) and E is the number of edges in the graph. This is because every vertex and every edge will be explored in the worst case.

The space complexity of BFS is O (V). In the worst-case scenario, the queue will store all the vertices of the graph. This happens when the input graph is a tree (or a forest), where there is no cycle and the last level of the tree (or forest) contains n/2 nodes.

So, for the Nth-degree node function given above:

• Time Complexity: O(V + E)
• Space Complexity: O (V)

"One degree apart" typically refers to the relationship between two people created by a third party, commonly a mutual friend. This idea is frequently mentioned when discussing social networks and the six degrees of separation’ theory. This theory proposes that everyone on the planet can be connected through a maximum of six steps, with each step involving an acquaintance.

Degrees of separation was originally published in Mind-boggling Algorithms on Medium, where people are continuing the conversation by highlighting and responding to this story.

A list of time intervals are given representing start/end times of various car trips. All times are positive 64-bit integer timestamps, and the ranges are inclusive on left and exclusive on right.

The goal is to generate a time series (list of time and count, sorted by time) of the number of active trips over time.

Input :(0,5), (2,3), (4,6), (7,10)

Output:

(0,2) => 1
(2,3) => 2
(3,4) => 1
(4,5) => 2
(5,6) => 1
(6,7) => 1
(7,10) => 2

As shown above, the output should provide the time slots followed by number of trips active during that period.

This is a problem of generating time series data plots for the graph with time intervals on the x-axis and active trips on the y-axis.

Heaps (Priority Queue) data structure can be used here to build a min-heap (sorted values in ascending order) to check for start times of new trip with already active end times of previous trips.

import heapq as hq


def generate_time_series(trips):
  trips.sort(key=lambda x: (x[0], x[1]))
  series = {}
  minStartTime = []

  for trip in trips:
    if minStartTime and minStartTime[0] <= trip[0]:
      # start time of incoming trip is lesser than the earliest end time ( AKA minimum start time)
      end = hq.heappop(minStartTime)
      series[end] = len(minStartTime)
    # push current trip end time to a heap
    hq.heappush(minStartTime, trip[1])
    series[trip[0]] = len(minStartTime)

  # Ending all the active trips
  while minStartTime:
    end = hq.heappop(minStartTime)
    series[end] = len(minStartTime)
  
  # Print the active trips as a time series
  sorted_series = dict(sorted(series.items()))
  prev_item = None
  for item in sorted_series.items():
    if prev_item is None:
      prev_item = item
    else:
      print(f"({prev_item[0]},{item[0]}) ====> {prev_item[1]} active trip(s)")
      prev_item = item
  return ''

trips = [[2, 3], [4, 6], [7, 10], [0, 5]]
print(generate_time_series(trips))

trips2 = [[1, 9], [3, 10], [2, 6], [7, 8]]
print(generate_time_series(trips2))

Once the map (dictionary in python) is ready, sort them by key and print them to represent plots on a time series.

Generating Time Series was originally published in Mind-boggling Algorithms on Medium, where people are continuing the conversation by highlighting and responding to this story.

A stream of numbers are flowing in and we need to find out the rank of the number. The first number flowing in is ranked 1, and next numbers to follow will have a rank based on previous stream of numbers we have seen.

A = [4, 6, 2, 3, 5, 1, 10]

4 (Rank →1)

6 (Rank →2)

2 (Rank →1)

3 (Rank →2)

5 (Rank →4)

1 (Rank →1)

10 (Rank →7)

One way to solve the problem is to build a Binary Search Tree (BST) using the stream of numbers. All the values less than the node, goes to the left and all the values greater than the node, goes to the right. Let's also assume, all the numbers in the stream are unique.

Note that every node should store an additional variable left_size which increments everytime we traverse to the left of a node.

A variation of this problem is to consume the entire stream of numbers and provide ranks. This involves a 2 step process of :

1. insert every value and build the BST.
2. traverse the entire tree and return their ranks.

Reference : https://www.geeksforgeeks.org/rank-element-stream

Streaming Algorithms : Computing current rank of a value in a stream was originally published in Mind-boggling Algorithms on Medium, where people are continuing the conversation by highlighting and responding to this story.

This is my first post under my new publication titled “Mind-boggling algorithms”. In this post I will be discussing a way to calculate running medians of an array.

To understand this problem, you need to imagine an array which grows over time.

The Python Standard Library provides a min-heap implementation using heapq module. A min-heap always has the lowest element as the root element. In some cases, we need to use the max-heap. Though not documented by heapq docs, there is an internal function _heapify_max which can be used. For a min-heap, using heappush will push a element to the heap & internally calls the heapify function. For a max-heap, heappush must follow _heapify_max .

The approach involves maintaining a max-heap & min-heap at all times. If the new streaming value is less than current median then add the value to max-heap otherwise min-heap.

Before we jump to process of calculating the median, make sure the length of difference between max_heap and min_heap is not more than 1.

The median calculation is based on the size of the heaps. If both heaps are of same size, median is the average of topmost element of both heaps. Otherwise the topmost element of larger heap becomes the median.

Reference:

heapq - Heap queue algorithm - Python 3.8.5 documentation

Streaming Algorithms — running median of an array using two heaps was originally published in Mind-boggling Algorithms on Medium, where people are continuing the conversation by highlighting and responding to this story.

Graph problems are always interesting and currency arbitrage is one of the standard graph problems from CLRS book (Introduction to Algorithms).

Few weeks ago, I stumbled upon this problem when I was reading about forex trading & transaction costs.

Arbitrage is defined as near simultaneous purchase and sale of securities or foreign exchange in different markets in order to profit from price discrepancies.

Forex arbitrage is a risk-free trading strategy that allows forex traders to make a profit with no open currency exposure. The strategy involves acting on opportunities presented by pricing inefficiencies in the short window they exist. This type of arbitrage trading involves the buying and selling of different currency pairs to exploit any pricing inefficiencies. The act of exploiting the pricing inefficiencies will correct the problem so traders must be ready to act quickly with arbitrage strategies. For this reason, these opportunities are often around for a very short time.

Suppose we are given a table of currency exchange rates, represented as a 2D array. Determine whether there is a possible arbitrage, i.e, whether there are certain sequence of trades you can make, starting with some amount A of any currency, such that you can end up with some amount greater than A of same currency.

Let’s say, 1 U.S. dollar bought 0.82 Euro, 1 Euro bought 129.7 Japanese Yen, 1 Japanese Yen bought 12 Turkish Lira, and 1 Turkish Lira bought 0.0008 U.S. dollars. Then, by converting currencies, a trader can start with 1 U.S. dollar and buy U.S. dollars, thus turning a 0.82*129.7*12*0.008 =1.02 US dollars, thus making a 2% profit.

For the sake of simplicity, let’s assume there are no transaction costs and you can trade any currency amount in fractional quantities.

How do we solve this?

Graph data structure

Weighted directed graphs can be represented as an adjacency matrix. For a graph with |V| X |V| vertices, an adjacency matrix is a |V| times |V| matrix of values, where the entry in row i & column j is a non-zero integer if and only if the edge (i, j) is in the graph. If you want to indicate an edge weight, put it in the row i, column j entry, and reserve a special value (perhaps None) to indicate an absent edge.

Finding arbitrage

Arbitrage opportunities arise when a cycle is determined such that the edge weights satisfy the following expression

w1 * w2 * w3 * … * wn > 1

The above constraint of finding the cycles is harder in graphs. Instead we must transform the edge weights of the graph such that the standard graph algorithms can be applied.

Let’s take the logarithm on both sides, such that

log(w1) + log(w2) + log(w3) + … + log(wn) > 0

Taking the negative log, this becomes

(-log(w1)) + (-log(w2)) + (-log(w3)) + … + (-log(wn)) < 0

Therefore we can conclude that if we can find a cycle of vertices such that the sum of their weights if negative, then we can conclude there exists an opportunity for currency arbitrage. Luckily, Bellman-Ford algorithm is a standard graph algorithm that can be used to easily detect negative weight cycles in O(|V*E|) time.

Bellman Ford Algorithm

Let G(V, E) be a graph with vertices, V, and edges, E.

Let w(x) denote the weight of vertex x.

Let w(i, j) denote the weight of the edge from source vertex i to destination vertex j.

Let p(j) denote the predecessor of vertex j.

The Bellman-Ford algorithm seeks to solve the single-source shortest path problem. It is used in situations where a source vertex is selected and the shortest paths to every other vertex in the graph need to be determined. After applying Bellman-Ford algorithm on a graph, each vertex maintains the weight of the shortest path from the source vertex to itself and the vertex which precedes it in the shortest path. In each iteration, all edges are relaxed if [w(i) + w(i, j) < w(j)] and the weight of each vertex is updated accordingly. After the i-th iteration, the algorithm finds all shortest paths consisting of at most i edges.

Once all shortest paths have been identified, the algorithm loops through all of the edges and looks for edges that can further decrease the value of the shortest path. If we can still relax the edges, then a negative weight cycle has been found since a path can have at most |V-1| edges.

Printing a negative weight cycle is done to show the arbitrage opportunity. We use the predecessor chain to print the cycle. Now that we have an edge which can be further relaxed, we have found the source & destination vertex of such an edge. Let’s start from the source vertex and go backwards until you see the source vertex again or any other vertex that predecessor chain has already shown us while printing the negative weighted cycle.

In the real world scenario, it may be hard to find the arbitrage opportunity. It is advisable to take the negative logarithm of currency value after converting the floating point value with 2 decimal places and multiply that by 100 . This is beneficial such that we can avoid arbitrage opportunities which are less than 1%.

Conclusion

Bellman Ford algorithm can be used to find arbitrage opportunities among a given bunch of currencies represented as a graph. Normally these opportunities exist for a very short period of time, so someone interested in profiting from such a risk free transaction must act quick.

Next Steps ?

1. Visualization: We can make use of visualization libraries to plot the graph and visualize the vertices and edges. This will make understanding the concept easier as we can see the negative weighted cycles consisting of vertices and edges in a different color.
2. Real World Currency Arbitrage: Using dummy values or historical data might be great for learning purposes, but how about using the real time currency value data and finding arbitrage in real time ?

Here is a way to check currency arbitrage in real time: https://gist.github.com/anilpai/08f3cedb60b7a3c9a3b4e27c0c022096

This is my first medium post. I am going to write about a prime question I am asked every time.

“How do you stay updated with the industry? What books or websites one needs to read to enhance their career and knowledge?”

To begin with, let me speak about myself. I have a Bachelors degree (India) and Masters degree in Computer Science Engineering (USA). I have a great penchant for attending hackathons and won a couple of them. Hackathons are not always about winning, but its more about networking, time management and getting shit done.

“How was the Hack Reactor JavaScript Bootcamp experience?”

I have also attended Coding Bootcamps and aced it. In 2016, I was working at Autodesk and they sponsored 20 candidates for Hack Reactor remote boot camp at their Michigan office. The program begins with 6 basic online courses relating to basic javascript with github submissions for every module, followed by a final interview via google hangout. Majority of them cleared the first hurdle as most candidates had Masters degree in Computer Science, else they have to pay additional fees to pass the interview again. The next step is 6 weeks of rigorous pair programming mentored by a Hack reactor instructor. Each week has 3 full size projects that is assigned to every pair, and a couple of surprise tests, so around 18 projects in total. The bootcamp ends with a 48hrs hackathon project. This is a great way to learn NodeJS and Advanced JS if you want to be a full stack JavaScript developer in future.

Interview Preparation Books

I would like to suggest few books which might help you in building a great career in the field of software development.

Algorithms & Data Structures

#1 Cracking the Coding Interview by Gayle McDowell

If you are a student and want to prepare for the interviews, then this is the first book to start with. If you are not a Java/C++ programmer, then you can happily discard the solutions code. As the author says, the purpose of the book is to make the reader start thinking in terms of data structures and algorithms for solving the problem. Don’t memorize code !

#2 Intro to Algorithms by Cormen ( C )and 3 others (LRS)

This was the book I read in my second year of Bachelors (famously known as CLRS). Its very vast and extensive with lots of code and mathematical equations. I still read this book sometimes to revise some of the concepts. Its a good reference book to have on your bookshelf.

#3 Algorithms unlocked by Cormen

Same author as before. The content is condensed and part of readers prefer this version. Frankly, I haven’t read this book yet.

#4 Algorithms — 4th Edition by Robert Sedgewick & Kevin Wayne

One of my favorites. This book helped me a lot when I was studying Advanced Data Structures at Syracuse University (Masters). The programming language used is C++. I would recommend this book to anyone who wants to be strong at Data Structures and Algorithms.

#5 Algorithm Design by Jon Kleinberg and Eva Tardos

This book helps you develop the thought process while designing your algorithms. I am yet to finish this book.

#6 The Algorithm Design Manual by Steven S Skiena

Another great book on Algorithms design. I haven’t read this book yet.

#7 Coding Practice

Leetcode — a nice site to practice interview questions. Majority of the companies use similar questions or sometimes copy paste from this site for phone screens. Highly recommend solving as many problems as possible from this site.

Geeks for Geeks — you will find variety of problems with solutions in multiple languages. I see lot of interesting hard problems with great explanations which are easier to understand.

Codewars — if you want to casually practice coding problems, this is my favorite. All problems are crowdsourced and you can choose problems based on how others have rated them. Your solutions are also voted by others.

I would also recommend a youtube video series by Tushar Roy.

Tushar Roy - Coding Made Simple

System Design

System Design knowledge is crucial when you are planning to grow within an organization. If you have interviewed for a senior role, you already know how important it is to come up with great architecture design within minutes to win a job offer.

#1 Grokking Algorithms by Aditya Bhargava

This is a good book to get started with design interviews. I haven’t myself read this book entirely but I liked the initial few chapters. I recommend this book for a beginner, even if you are not planning to interview for a Senior position.

#2 highscalability.com

This is the only site I have been referring to regularly for the last 8 years to read about system design, architecture and everything to do with scalability. I would suggest reading this once a month to catch up with all scalability stuff. Since most companies have their own engineering blogs today, trying subscribing to them.

#3 Github links:

Most of the system design interview prep material is available on github, and here are 3 important github repos which are more than sufficient to prepare.

• GitHub - donnemartin/system-design-primer: Learn how to design large-scale systems. Prep for the system design interview. Includes Anki flashcards.
• GitHub - checkcheckzz/system-design-interview: System design interview for IT companies
• GitHub - theanalyst/awesome-distributed-systems: A curated list to learn about distributed systems

#4 The Architecture of Open Source Applications

Link : http://aosabook.org/en/index.html

Here is a decent list of topics to revise relating to few open source projects. I did not like the way its been structured and you can find most of them online. I wouldn’t recommend buying this book. You can definitely skim through the free chapters.

#5 Design data intensive application by Martin Kleppmann

I have heard very nice reviews about this book. This book is a must read if you are planning software development and data engineering.

More books worth reading….

These books do not fall under algorithms, data structures or system design category, but they are worth reading.

Advanced Architecture for Big Data Applications

Link : https://www.safaribooksonline.com/learning-paths/learning-path-architect/9781491987063/

Google SRE Book

Link : https://landing.google.com/sre/book/index.html

I have heard a lot of nice reviews about this book. Its a free book by Google and will help you get some knowledge relating to operations. I have read few chapters randomly and I liked it.

The Effective Engineer: by Edmond Lau

Coders at Work by Peter Seibel

Joel on Software by Joel Spolsky

I will continue updating this list as I find any interesting books or websites. Until then, do post your comments and suggestions below.