A Curated List of Coding Projects and Resources to Become a Better Developer
Hello, Hope you are doing great. I am Shivang. I have set up this site to list down genuinely helpful resources that'll help us become better engineers. This includes coding projects (in the form of guided blog tutorials, project ideas, coding challenges, courses, and more) and upskilling resources that'll deepen your understanding of the software engineering domain.
If you find the content helpful, don't forget to share it with your friends — it really helps with reach. I also write about systems architecture on my newsletter (whenever I find time!) and actively share engineering insights and curated reads on LinkedIn. Feel free to subscribe and follow along.
Coding Projects
Data Structures
Coding Challenge #1:
Write an algorithm for a scalable leaderboard system
Picture a popular online multiplayer game or a gamified app where users move up or down the ranking board after performing certain activities. This could be anything from winning a challenge against another user, completing a quest, or finishing a mission.
The idea is that whenever they perform an activity, their score changes — and so does their rank. Now, imagine a couple of million users on the platform, all performing actions concurrently and instantly checking their updated ranks. For every event, the system needs to recalculate and update the leaderboard.
At time t, there are n users with specific scores. At time t+1, their scores may change based on the activities they've performed.
Your challenge: Write an algorithm that calculates user ranks in real-time and keeps the leaderboard updated — at scale.
Thinking out loud
A no-brainer brute-force solution to this is to pick one user (assuming the users are stored in a List) and then compare them with the scores of all the other users and update the rankings. This is more like running a bubble sort algorithm having a worst-case time complexity of O(n^2). This is clearly not scalable. We can do better.
The idea is to:
- Avoid scanning the entire list of users every time.
- Maintain a sorted view of users as scores change.
- Query the rank like "How many users have a score higher than a certain user?" quickly.
What are our options? What data structures can we leverage to bring down the time complexity?
We have self-balancing binary search trees that can be used to construct and maintain ordered lists.
Heap is helpful if we want to find out the top K ranks in a large dataset. We can leverage it, but it's not ideal if we want to know the rank of every user in the dataset.
Segment tree is good for range queries like, "How many users have a higher score than X?"
Redis sorted sets, which is a combination of Skip List and Hash Table, are a top choice in implementing leaderboards in production systems. Skip List data structure is leveraged to order the elements for fast rank and range queries and Hash Table facilitates fast lookups.
You can write a similar solution from scratch or use a mix of other data structures to come up with a scalable solution. The idea of this challenge is to deepen your understanding of data structures, helping you understand how they are leveraged to build real-world scalable systems.
This will help you sharpen your systems thinking. Efficient systems rely on thoughtful use of the right data structures. By working through this challenge, you will understand how different data structures perform at scale and why brute force approaches fall apart when the systems are hit with millions of concurrent users.
You can extend this challenge further by building a web-based leaderboard to deepen your understanding of systems architecture. Real-world systems have different requirements based on the business use case:
- Some may operate totally out of memory.
- Some may implement a hybrid solution of the database and cache for their leaderboards.
- Some may not immediately display the rankings but have a time window to show the rankings with materialized views and cron jobs.
- Some may shard the leaderboards by region, tier or game mode, so as opposed to a single, you may have to maintain a number of smaller leaderboards and so on. There can be any number of possibilities based on the business requirements, as mentioned before.
Researching the web service implementation and the algorithmic solution will give you good talking points for your interviews as well.
Coding Challenge #2:
Code a lightweight key-value store with pluggable backends (HashMap and OrderedMap)
Build a key-value store with two different backends and with a config flag to switch between them at runtime:
- HashMap backend (for fast, unordered lookups)
- OrderedMap backend (for sorted keys and range queries)
The cache should:
- Quickly retrieve values by key.
- Allow adding new keys and removing them.
- Support querying sorted keys when needed.
Both backends must implement the below Cache interface:
set(key, value) : Inserts or updates the value for a key
get(key) : Returns the value for a key or null if not found
delete(key) : Removes the key from the store
list_keys() : Returns a list of all keys in the store, sorted by key
OrderedMap
An OrderedMap is a data structure that stores key-value pairs just like a regular map but keeps the keys sorted. Most implementations of ordered maps use a balanced tree such as a red-black tree, B-tree, or AVL tree.
These trees automatically rearrange themselves after insertions and deletions to keep everything sorted and balanced for performance.
The Need for An OrderedMap Backend
An OrderedMap is helpful in scenarios where the ordering of keys or range queries is essential and can't be handled efficiently by a plain HashMap, such as:
Time-series event storage (key: timestamp, value: event data), where we often need to get events between T1 and T2, iterate events in chronological order, fetch the latest N events, and so on.
Price index or stock ticker (key: price, value: stockID or price data), where we quickly need to find all items in a price range or sort by price. This is standard functionality in Ecomm platforms, Fintech apps, and such.
Leaderboards (key: score, value: userID), where we want to fetch top N players based on the score, find users within a certain range, insert while maintaining sorted ranking and more.
You can implement the common key-value store operations (set, get, delete, scan, etc.) and then benchmark how each backend behaves under different workloads.
Key Learning:
With this coding challenge, you'll :
- Understand the trade-offs between using different data structures in a service based on the data access patterns.
- Learn how to measure the performance of different algorithms running micro-benchmarks.
- Develop an understanding of how in-memory caches work and how different types of caches optimize for speed and memory efficiency.
✨ Featured: CodeCrafters
If you enjoy building systems from scratch, CodeCrafters is something you'll love.
It offers hands-on programming challenges where you implement systems like Redis, Git, Kafka, and more — all from the ground up. It's one of the best ways to truly understand how systems work under the hood, exploring real-world architecture and internals one step at a time.
I genuinely recommend it. They offer free starter challenges you can try right away. And if you decide to dive deeper, you can use the same referral link to get 40% off (affiliate).
Backend
Tags: Backend, Fullstack, GraphQL
Level: Intermediate
A free and open-source tutorial to help us create a GraphQL app from zero to production, following best practices and using the programming language and framework of our choice.
Tags: Backend, Python, FastAPI, ScyllaDB
Level: Intermediate
The blog post discusses building a shopping cart app with ScyllaDB, Python and the FastAPI framework. You'll also learn how to use ScyllaDB's change data capture feature to query and export the history of all changes made to the tables.
Build a Rust RPG application that tracks Bluesky user experiences and events
Tags: Backend, REST API, Rust, ScyllaDB
Level: Intermediate
Build an RPG application with Rust and ScyllaDB that can:
- Fetch and process public events from the Bluesky platform.
- Track user events and experiences.
- Implement a leveling system with experience points (XP).
- Display user levels and progress based on XP via a REST API
Build a low-latency video streaming app with NextJS, TypeScript and ScyllaDB
Tags: Backend, NextJS, TypeScript, ScyllaDB
Level: Intermediate
You'll learn coding a video streaming application with features like listing all videos sorted by date, listing videos that the user has started watching along with the progress bar, and more, in addition to learning the data modeling process.
Build a solar power monitoring app with Redis
Tags: Backend, Fullstack, Redis, Java, Python, JavaScript, VueJS
Level: Intermediate
Links to language-specific pages: Java, Python, JavaScript
Gain hands-on experience with Java/Python/JavaScript and Redis by building a solar power monitoring app. You'll develop a command-line data loader, a REST API with Dropwizard, and a Vue.js frontend while working with key Redis data structures like hashes, sets, geospatial indexes, and streams.
Learning Objectives:
- Build a command-line app to load data into Redis using Java/Python/JavaScript.
- Create a REST API backend with Dropwizard to handle data storage and retrieval with Redis.
- Use Redis data structures like hashes, sets, and geospatial indexes in your app.
- Add rate-limiting using Redis to control API call frequency.
- Design and deploy a Vue.js front end that interfaces with Redis through the developed REST API.
Systems Programming
Tags: Go, systems programming
Level: Beginner, Intermediate
The tutorial guides us through creating a basic load balancer using the Go programming language.
Tags: Nginx, Lua, Prometheus, Grafana, systems programming
Level: Intermediate, Advanced
This GitHub repository offers a guide to building a Content Delivery Network (CDN) from scratch, leveraging technologies such as Nginx, Lua, Docker, Prometheus, and Grafana.
The project begins with creating a single backend service and expands from there to a multi-node, latency-simulated, observable, and testable CDN. Throughout the process, it discusses the challenges and trade-offs involved in building, managing, and operating a CDN, making it a valuable resource for those looking to deepen their knowledge in this area.
Data Engineering
Tags: Database, data analytics, SQL, DuckDB
Level: Beginner, Intermediate
DuckDB is an in-memory analytical database designed for fast, efficient querying of structured data. Run analytical SQL queries on a real-world Dutch railway network dataset with the linked tutorial.
Tags: Data analytics, DuckDB, AWS
Level: Advanced
The project uses DuckDB as a stateless query engine on a data lake using AWS Lambda. Instead of maintaining a traditional database server, queries are executed on-demand in a serverless environment, making it highly cost-effective and scalable.
It's a good project for learning data processing, query engines, and serverless.
Exploring StarCraft 2 data with Airflow, DuckDB, and Streamlit
Tags: Data analytics, DuckDB, Airflow
Level: Intermediate, Advanced
A project that fetches data from the StarCraft II API, stores the results in DuckDB orchestrated via Airflow, and creates a Streamlit app to visualize the data.
Tags: Database, data analytics, DuckDB, Python
Level: Intermediate
Extract analytics from Bluesky querying its open APIs and streams with DuckDB to build your own dashboards, tools and visualizations.
Tags: Database, data analytics, DuckDB, SQL
Level: Intermediate
The project demonstrates how to build a real-time data pipeline using DuckDB to process environmental data from the UK's Environment Agency. The data is available on a public REST API, providing information about measures such as rainfall and river levels reported from various stations around the UK.
The project reads data from REST APIs and processes and stores it to be queried with various visualization tools.
More projects are on the way—stay tuned! Meanwhile, check out these learning resources.