A lot of developers learn new concepts, tools or languages, by following a course, watching tutorials or reading documentation, and then building project, but nobody talks about the hardest parts: applying what you learned into real projects.
It usually goes like this:
- You learn a new tool, language or framework
- You want to build something to apply what you learned into a real project
- You don't know what to build and you struggle to find ideas
After a while you lose motivation and end up building nothing or you start following tutorials and what happens is:
- You watch someone build something.
- You understand it.
- You feel productive.
Or you get stuck in tutorial hell.
And then... you try building something on you own.
Suddenly you brain goes blank.
I've realized the biggest gap between learning programming and becoming a professional engineer is not knowledge, it's experience. So I decided to fix that.
I started a 100 Projects Challenge.
The name suggests 100 projects in 100 days, but realistically it might take longer. Some projects may take a day, others up to a week. The important part isn't the calendar, it's the consistent building and showing up.
The goal is simple:
Build 100 meaningful coding projects that force me to explore different technologies, tools, and fields in computer science and engineering.
Why I started this challenge
As a junior developer and being a beginner myself, I realized that most beginner projects looks like this:
- To-Do List
- Calculator
- Weather App
- Blog CRUD
- E-Commerce clone
Those projects were useful... in 2018.
While those projects are great starting point to teach you the fundamentals of software development. In an era where LLMs can generate boilerplate CRUD code in seconds, the value of a developer shifts from writing code to understanding systems.
So I wanted something different...
Something that would:
- Force me to research, read documentation and know how to learn
- Expose me to new technologies and tools I would have never touched
- Help me gain real skill
- Make actual project worth documenting and showing on my resume
- Learn how things actually work which is something rarely touched in modern courses and tutorials
This challenge is designed to build system-thinking.
The Rules of the Challenge
To make the challenge meaningful, I created a few rules.
1. Every project must teach something meaningful
Basic beginner projects don’t count.
- No todo lists.
- No simple CRUD dashboards.
- No tutorial clones.
Every project must introduce a real concept or skill.
For example:
- Building a feature flag engine
- Writing a small network protocol
- Experimenting with computer graphics
- Creating a simple embedded system
- Integrating AI into real tools
The goal is learning something valuable each time.
2. Projects must explore different technologies
This challenge isn’t about mastering one language.
It’s about exploring the ecosystem of computer engineering.
Projects may involve:
- Web development
- System programming
- Embedded systems
- IoT
- AI engineering
- Game development
- Computer graphic
- Networking
- Open source tooling
- Or anything else you're interesting in and want to learn
Different languages and environments are encouraged. You don't have to learn 10 languages, but you should know how to read documentation and research when you need.
3. Each project must provide real value
Every project should give the challenger something tangible:
- A reusable library
- A useful tool
- A deeper understanding of a field
- Or anything you can show off and be proud that you built it
- experience with real engineering concepts
The goal isn’t just “finishing projects”.
It’s gaining skills you can carry forward.
4. Projects must be small but meaningful
Each project should take:
- Minimum: 1 day
- Maximum: 1 week
The challenge is designed to encourage focused exploration, not multi-month builds.
You also cannot start a new project until the current one is finished.
No half-built graveyards of abandoned repos.
5. Every project must be documented
Finishing a project is only half the job.
Every project must be documented as either:
- A DEV article
- A blog post
- An open-source repository with proper documentation
Documenting forces you to:
- Organize your thoughts
- Explain your decisions
- Share knowledge with others
And it builds a public record of your progress.
What Kinds of Projects Will Be Included?
The challenge spans multiple areas of computer science and engineering.
Some examples of topics I plan to explore:
- Web development tools and libraries
- AI-powered applications
- Embedded systems experiments
- IoT devices
- 3D computer graphics (OpenGL / Vulkan etc.)
- Low-level system programming
- Networking tools
- Developer utilities
- Open source contributions
- Game development experiments
Each project focuses on one meaningful concept.
For example:
- Building a feature flag engine
- Implementing a mini task scheduler
- Creating a simple TCP protocol
- Writing a CLI tool that solves a real problem
- Integrating an AI agent into an application
Small projects, but real engineering ideas.
You can adjust those to align with your preferences and interests.
Why This Challenge Is Powerful
This approach solves several problems developers face:
- Tutorial Hell: You stop watching tutorials and start building things yourself.
- Fear of New Technologies: Instead of committing months to something new, you try it in a one-week experiment.
-
Lack of Portfolio Projects,
after 100 projects, you’ll have:
- dozens of repositories
- many documented experiments
- experience across multiple domains
- That’s far more interesting than another CRUD app.
-
Real Engineering Experience. Each project teaches something concrete, in my case:
- networking fundamentals
- secure coding practices
- graphics pipelines
- embedded development
- AI integration patterns
Over time, the knowledge compounds.
How the challenge works
Coming up with project ideas sucks, and it is the reason many beginners feel overwhelmed or clueless, so you don't have to do it, I wrote this prompt which you can edit according to your preferences and paste it into your AI assistant
# 100 projects in 100 days challenge.
The goal of this challenge is to build 100 meaningful coding projects in a short time period (may be more than 100 days in total) where I get to research, learn and experience with different languages, concepts, fields and tools. The project is going to consist of 100 different coding projects that are short and sweet, completable in the minimum of 1 day and the maximum of 1 week, with every project providing a real value I can take out. The rules consist of the following:
- Every project should touch something meaningful I can learn from, basic things like To-Do lists, Crud Apps, ECommerce websites etc.
- Projects should not be a single language, they should force exploration and working in different languages and environment, while being welcoming if the challenger is new to the language
- Each project should leverage one tool or topic that would benefit the challenger with a real value
- Each project can be completed in the minimum of 1 day and the maximum of 1 week, and the challenger can NOT start a new project before confirming they finished the current one.
- Project topics include to web and application development, embedded systems, IoT software, Low level system programming, AI engineering (integrating AI into real projects using agentic systems or APIs), game development, open source, computer graphics (preferably Vulkan, could go with OpenGL if the entry barrier for Vulkan is not beginner friendly), computer networks etc. The projects should not be too unrelated or teach a skill that is unrelated, the goal is to build something real and get real skills and get into that field.
- Projects should be welcomed to new comers, and should be doable if the challenger has 0 experience in the field.
- Every Project should teach the challenger something about the field it's related to, the challenger should finish a project with a related skill they can take home (e.g. a minimal http server, if the project is related to systems and computer networks)
- Every project idea will be generated by you with a section mentioning prerequisites, key skills, background assumptions and a quick guide to get started with resource and references. The challenger can request a reroll if they feel the project is too hard or too easy.
- Every project should be documented whether it's a short article on a platform like DEV.to or a personal blog, or an open source repository with well written documentation The project aims to give the challenger a chance to get into the provided fields, by having real skills and meaningful experience to go further and expand in these topics and fields.
<You can add any other custom instructions here>
Paste this to your AI assistant and update it every time you finish a project.
For each project:
- The idea is generated.
- The project includes:
- prerequisites
- key skills
- a quick guide to get started
The project is built.
The results are documented publicly.
If a project turns out to be too difficult or too trivial, it can be rerolled.
The goal isn’t punishment, the goal is learning.
The Real Goal
The purpose of this challenge isn’t just completing 100 projects.
It’s about becoming comfortable building things in unfamiliar territory.
By the end of the challenge I hope to have:
- explored many areas of computer engineering
- developed practical skills in multiple domains
- built a large collection of real projects
- documented the entire journey
And hopefully helped others start their own challenges too.
If you’ve ever felt stuck in tutorial hell or unsure how to explore new technologies…
Try building 100 small, meaningful projects.
You might be surprised how much you learn.
Top comments (0)