Start Here: Choose Your Path
Welcome to Journey to Code.
This blog isn't a course with one correct beginning or a checklist you're supposed to complete from top to bottom.
It's a collection of things I've learned by writing code, building projects, breaking things, fixing them, and occasionally figuring out why they broke in the first place.
So if you're new here, don't worry about starting with the oldest article.
Pick a path that sounds interesting and start there.
Learn Git and work with code more confidently
Commit to Success: Mastering Git From Init to Push
Git starts out feeling like a handful of commands you have to memorize.
Then you start working on larger projects or with other developers and realize it's really about managing change.
This series works through Git from the fundamentals toward the workflows that make version control useful in real development: repositories, commits, branches, merging, remotes, collaboration, and the tools that help you recover when things don't go quite according to plan.
Start here if: you're learning Git, working with branches and pull requests, collaborating with other developers, or trying to get beyond simply memorizing add, commit, and push.
Go from web fundamentals to Web Components
Journey to Web Components: From Fundamentals to Advanced UI Architecture
This is one of the biggest learning paths on Journey to Code.
It doesn't begin with Custom Elements.
It starts lower in the stack with the pieces they're built on: semantic HTML, accessibility, responsive CSS, JavaScript, and the DOM.
From there, the series moves into Web Components themselves: Custom Elements, Shadow DOM, templates and slots, styling, lifecycle callbacks, communication between components, accessibility, real-world patterns, framework integration, and larger UI architecture.
Start here if: you want to understand the browser platform more deeply, build reusable interfaces without depending entirely on a framework, or strengthen the fundamentals underneath technologies like React.
Explore the Web Components series →
Work with APIs, browser data, and offline applications
Mastering the Fetch API and Browser Storage
Getting data from an API is one thing.
Building an application that handles that data reliably is another.
This series begins with the Fetch API, moves into browser storage and client-side persistence, and then brings those ideas together in offline-first and resilient web applications.
You'll encounter things like network requests, responses, authentication patterns, LocalStorage, SessionStorage, IndexedDB, the Cache API, service workers, synchronization, and strategies for keeping an application useful when the network isn't.
Start here if: you're building applications that communicate with APIs, store data in the browser, or need to keep working when connectivity becomes unreliable.
Explore Fetch & Browser Storage →
Make the browser do something different
Mastering the Web Audio API: From Fundamentals to Advanced Applications
Browsers aren't limited to forms, buttons, and API requests.
They can also synthesize, process, analyze, visualize, and spatialize sound.
This series starts with the foundations of the Web Audio API and works toward more advanced audio processing, synthesis, spatial audio, visualization, music systems, and browser-based production tools.
It's one of the more experimental corners of Journey to Code—and that's exactly why I like it.
Start here if: you're interested in creative coding, game development, interactive experiences, music, audio visualization, or browser APIs that don't show up in the average CRUD application.
Explore the Web Audio series →
Prefer building things over following a series?
Good.
That's increasingly a big part of what Journey to Code is about.
Tutorials are useful, but some of the best lessons don't appear until an application becomes large enough to disagree with you.
You'll also find articles here about:
- React and Node.js
- Full-stack applications
- APIs and authentication
- Testing with Jest, Vitest, React Testing Library, and Playwright
- Accessibility
- Application architecture
- Git workflows and team development
- CI/CD and GitHub Actions
- Debugging the bugs that only appear under exactly the wrong conditions
- Web Components and native browser APIs
- Rust and WebAssembly experiments
- Open source
- The lessons that come from actually trying to ship software
A good introduction to that side of the blog is What a Long, Strange Trip...
It's where I picked the story back up after more than a year away from writing and looked at what happened while I was still building: React, Node.js, Code the Dream, team development, testing, CI, architecture, debugging, and helping build a full-stack financial literacy application called Sprout.
Read What a Long, Strange Trip... →
Not sure which path to choose?
If Git still feels mysterious, start with Commit to Success.
If you want stronger web fundamentals, follow the Web Components path from the beginning.
If you're comfortable with JavaScript and want to build applications that work with real data, try Fetch & Browser Storage.
If you want to make the browser do something you probably haven't tried before, experiment with the Web Audio API.
And if you're less interested in following a curriculum and more interested in what happens while building real software, jump into the newer project and engineering articles.
There isn't a correct order.
That's kind of the point.
What Journey to Code is becoming
Journey to Code started as a place for me to document what I was learning.
It still is.
The difference is that learning now happens just as often through building applications, collaborating with other developers, testing systems, making architectural decisions, debugging failures, and revisiting things I thought I already understood.
So you'll still find tutorials here.
You'll also find the messier part in between the tutorials and the finished product.
That's usually where the interesting lessons are anyway.
Looking for my projects?
Journey to Code is where I write about the process.
mnix.dev is where you'll find a more traditional developer portfolio and the projects I've built.
Here, I'd rather talk about what happened while building them.
Pick a path and see where it goes.
Learn something. Build something. Break something. Figure out why. Repeat.