Track
A powerful, statically typed language designed for simplicity and efficiency. Master Go’s concurrency model and build scalable, high-performance applications.
Start here
A command-line interface (CLI) application for managing your daily tasks. Users can add, list, complete, and delete tasks. The task list is persisted to a local file (e.g., JSON), so your tasks are saved between sessions.
Sign in to track progress
Basic
4 projectsA command-line interface (CLI) application for managing your daily tasks. Users can add, list, complete, and delete tasks. The task list is persisted to a local file (e.g., JSON), so your tasks are saved between sessions.
Create a CLI tool that fetches and displays the current weather for a specified location. The tool will make an HTTP request to a free weather API (like OpenWeatherMap), parse the JSON response, and display a clean, human-readable summary.
Build a command-line tool that scans a specified directory and organizes files into subdirectories based on their file extension (e.g., images, documents, videos).
Create a tool that fetches the HTML content of a given URL and extracts specific information, like all the links or headlines, printing them to the console.
Intermediate
5 projectsImplement a configurable rate limiter as an HTTP middleware for a web service. This middleware will intercept incoming requests and enforce limits based on a client's IP address, preventing abuse. You can implement a classic algorithm like the Token Bucket.
Build a background service that acts like a simplified version of Filebeat or Logstash. The service will 'tail' a log file, parse new lines as they are written, and 'ship' them to a destination (e.g., standard output, a TCP endpoint, or an HTTP server that you also build). The service must be resilient to log file rotations.
Develop a command-line tool or a simple web service that takes a Markdown file as input and generates a corresponding HTML file.
Build a web crawler that starts from a seed URL, fetches pages, extracts links, and concurrently crawls those links up to a specified depth or number of pages. Avoid revisiting URLs.
Create a web service that accepts a long URL, generates a unique short code, stores the mapping persistently (e.g., in SQLite, BoltDB, or PostgreSQL), and redirects users from the short URL to the original long URL.
Advanced
4 projectsCreate a background job processing system. It will consist of an API server to enqueue jobs, a persistent queue backend (using Redis or BoltDB), and a separate pool of worker processes/goroutines that pull jobs from the queue and execute them. The system should support job retries with exponential backoff.
Build a system of two microservices (e.g., a `Users` service and a `Posts` service) that communicate using gRPC. Instead of hardcoding service addresses, implement a simple service discovery mechanism where services register themselves with a central registry you build, and then query that registry to find other services.
Implement a basic distributed key-value store where data is replicated across multiple nodes. Use a simplified consensus algorithm (like leader election or a basic Raft implementation) to ensure consistency for write operations.
Develop a backend service using WebSockets that allows multiple users to edit the same document simultaneously. Changes made by one user should be broadcast in real-time to all other users editing the same document.
Expert
5 projectsImplement a simplified relational database that can parse and execute a subset of SQL. This involves building a SQL parser, a query planner, and an execution engine that operates on data stored in a custom page-based file format. This is a massive undertaking that touches on many areas of computer science.
Build a basic container runtime from scratch that can execute a process in an isolated environment on Linux. This involves using low-level Linux features like namespaces (to isolate PIDs, networks, etc.) and cgroups (to limit resource usage) to create a container-like environment, similar to how Docker works at its core.
Build a decentralized file-sharing application (CLI or basic GUI) where users can discover each other on a local network (or using a tracker) and transfer files directly between peers, potentially splitting files into chunks.
Design and implement a system composed of several small, independent microservices (e.g., Order, Payment, Inventory, Notification) that communicate asynchronously using an event bus (like NATS or Kafka) following the choreography pattern (no central orchestrator).
Design and implement the core engine for a time-series database (TSDB) optimized for high write throughput and efficient range queries over time. Focus on the storage format and indexing.