100 Days of Code — Structured Challenge

In this tutorial, you'll learn about 100 days of code. We cover key concepts, practical examples, and best practices.

The 100 Days of Code challenge is a structured commitment to code for at least one hour daily for 100 consecutive days — this roadmap provides daily project ideas, data structure practice, real-world application builds, and portfolio development.

What You'll Learn

Why It Matters

Consistency is the single most important factor in becoming a professional developer. Most beginners quit after a few weeks because they lack structure. This 100-day plan eliminates decision fatigue by telling you exactly what to build each day, building from simple exercises to a complete production-ready project that you can show employers.

Who This Is For

Beginner programmers who have completed an introductory course and want structured daily practice, self-taught developers building a portfolio, and career changers who need a clear daily plan. You should know basic syntax in at least one programming language.

timeline
    title 100 Days of Code Structure
    Days 1-20 : Python/JS warmup : Data structures : Algorithms
    Days 21-40 : APIs & scraping : Databases : CLI tools
    Days 41-60 : Web framework : Frontend intro : Full-stack app
    Days 61-80 : Testing : Deployment : Portfolio project
    Days 81-100 : Advanced features : Performance : Submission

Daily Breakdown

Phase 1: Foundations and Warmup (Days 1-20)

Build fundamental programming skills with daily exercises. Focus on data structures (arrays, linked lists, stacks, queues, hash tables, trees, graphs) and algorithms (sorting, searching, recursion, dynamic programming).

Days 1-5: Python or JavaScript Warmup

Write 10 small programs each day: fizzbuzz, palindrome checker, fibonacci, prime number generator, anagram detector, string reversal, array rotation, and basic calculator. Get comfortable writing code without tutorials.

# Day 5 challenge: Anagram detector
def are_anagrams(s1: str, s2: str) -> bool:
    s1_clean = s1.lower().replace(' ', '')
    s2_clean = s2.lower().replace(' ', '')
    return sorted(s1_clean) == sorted(s2_clean)

# Test cases
print(are_anagrams("listen", "silent"))     # True
print(are_anagrams("hello", "world"))       # False
print(are_anagrams("a gentleman", "elegant man"))  # True

Days 6-10: Data Structures

Implement each data structure from scratch: singly linked list, doubly linked list, stack using array and linked list, queue using array and linked list, binary search tree with insert/search/delete, and hash table with collision handling.

Days 11-15: Sorting and Searching

Implement bubble sort, selection sort, insertion sort, merge sort, quick sort, and binary search. Compare time complexity. Count comparisons and swaps. Visualize the sorting process.

Days 16-20: Recursion and Dynamic Programming

Solve recursion problems: factorial, towers of Hanoi, generate all subsets, permutations, N-queens. Learn memoization and bottom-up DP: fibonacci with memoization, coin change, longest common subsequence, knapsack problem.

Phase 2: Real-World Tools (Days 21-40)

Days 21-25: API Integration

Build programs that interact with public APIs. Fetch weather data, cryptocurrency prices, GitHub user stats, and news headlines. Save results to JSON files. Handle rate limiting, pagination, and authentication.

# Weather API client
import requests
from datetime import datetime

def get_weather(city: str, api_key: str) -> dict:
    url = "https://api.openweathermap.org/data/2.5/weather"
    params = {
        "q": city,
        "appid": api_key,
        "units": "metric"
    }
    
    response = requests.get(url, params=params)
    response.raise_for_status()
    
    data = response.json()
    return {
        "city": data["name"],
        "temperature": data["main"]["temp"],
        "humidity": data["main"]["humidity"],
        "description": data["weather"][0]["description"],
        "timestamp": datetime.utcnow().isoformat()
    }

# Usage
weather = get_weather("London", "your-api-key")
print(f"{weather['city']}: {weather['temperature']}C, {weather['description']}")

Days 26-30: File Processing and CSV/JSON

Build a CSV parser, JSON validator, log file analyzer that counts error levels, a duplicate file finder, and a directory tree generator. Process real datasets from Kaggle or government open data portals.

Days 31-35: Database Practice

Learn SQLite first, then PostgreSQL. Create tables, insert data from CSV files, write queries with JOINs and aggregations, create indexes, and analyze query performance with EXPLAIN.

Days 36-40: CLI Tools

Build command-line tools: a to-do list manager (add, list, complete, delete tasks stored in JSON), a password generator, a file encryption/decryption tool using cryptography libraries, and a system health checker (CPU, memory, disk usage).

Phase 3: Web Development (Days 41-60)

Days 41-45: Web Framework

Choose Flask (Python), Express (Node.js), or FastAPI. Build a REST API with CRUD endpoints for a blog or notes app. Include proper error handling, input validation, and status codes.

# Flask notes API
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///notes.db'
db = SQLAlchemy(app)

class Note(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)
    created_at = db.Column(db.DateTime, default=db.func.current_timestamp())

@app.route('/api/notes', methods=['GET'])
def get_notes():
    notes = Note.query.order_by(Note.created_at.desc()).all()
    return jsonify([{
        'id': n.id,
        'title': n.title,
        'content': n.content,
        'created_at': n.created_at.isoformat()
    } for n in notes])

@app.route('/api/notes', methods=['POST'])
def create_note():
    data = request.get_json()
    if not data or 'title' not in data:
        return jsonify({'error': 'Title is required'}), 400
    
    note = Note(title=data['title'], content=data.get('content', ''))
    db.session.add(note)
    db.session.commit()
    
    return jsonify({'id': note.id}), 201

Days 46-55: Frontend Basics

Build a minimal frontend with HTML, CSS, and vanilla JavaScript that consumes your API. Display a list of notes, add new notes with a form, and delete notes. No frameworks yet — understand how the browser communicates with the server.

Days 56-60: Connect Frontend and Backend

Deploy both frontend and backend locally with proper CORS configuration. Add basic authentication (JWT tokens). Store hashed passwords. Create protected routes that require authentication.

Phase 4: Portfolio Project (Days 61-100)

Days 61-70: Plan and Build Core Features

Design and build a complete application: a markdown blog, a URL shortener, a habit tracker, or a price tracker. Plan the database schema, build the API, and create the frontend. Write automated tests for critical paths.

Days 71-80: Testing and Polish

Write unit tests with pytest or Vitest. Add integration tests for API endpoints. Implement error handling for all failure modes. Add input validation, loading states, and empty states. Profile and optimize slow queries.

Days 81-90: Deployment

Containerize the application with Docker. Write a Dockerfile and docker-compose.yml. Deploy to a free tier (Railway, Fly.io, Render). Set up a PostgreSQL database in production. Configure environment variables and CI/CD.

# Dockerfile for portfolio project
FROM node:20-alpine AS build

WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=build /app/build /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf

EXPOSE 80

HEALTHCHECK --interval=30s --timeout=3s \
  CMD wget --no-verbose --tries=1 --spider http://localhost:80/ || exit 1

Days 91-100: Portfolio and Documentation

Write a README with screenshots, installation instructions, and architecture diagram. Add a live demo URL. Prepare a project walkthrough video. Update your resume and LinkedIn with the project. Write a blog post about what you built and what you learned.

Common Mistakes

1. Missing a day and abandoning the challenge entirely — if you miss a day, just continue the next
2. Working on the same type of problem every day — rotate between algorithms, projects, and design
3. Copying code without understanding it — write every line yourself and experiment with changes
4. Perfectionism — build something that works first, then improve it
5. Not committing code to GitHub daily — your commit history is proof of consistency for employers
6. Choosing a project that is too large — finish a small project completely before starting a big one
7. Not sharing your progress publicly — posting daily updates builds accountability and networking

Progress Checklist

Learning Resources

• LeetCode — Daily algorithm practice with categorized problems
• Project Euler — Mathematical programming challenges
• roadmap.sh — Visual roadmaps for every developer path
• Hacker News — Build projects inspired by real startup ideas
• GitHub Explore — Discover open source projects to contribute to

Next Steps

After completing 100 Days of Code, follow the Full-Stack Developer Roadmap for structured depth. Explore Open Source Contribution to work on real-world projects. Consider the System Design Interview roadmap for preparation for technical interviews at top companies.

Built by the developers of Doda Browser, DodaZIP, and Durga Antivirus Pro.