SkillverseHub / Paths

Career Paths

Four routes, with a career at the end of each. The steps are listed in the order you should follow them, not by displayed difficulty: each step explains why it sits where it does. The lesson count shown is the number of lessons actually published, tallied when this page is generated — not a promise.

Three of the four paths start with a free course. Take it, see whether the work suits you, and then decide what the rest is worth to you.

Filter:

No path matches . Reset filters.

  1. 01

    Full-stack web developer

    Full-Stack Web

    You can read HTML and you want to ship a complete application, not just pages.

    76 lessons written

    9 of 9 courses available

    Nine courses and 76 lessons, all fully written. We start with the language itself, make it safe with TypeScript, build the interface with React and Tailwind, write the server by hand before letting Next.js abstract it away, put everything under test, then plug in a language model and a coding agent — the two additions clients are asking for today.

    1. Step 1

      The language, before the tools

      React, Next.js, and TypeScript are just organized JavaScript. Starting with a framework without knowing the language catches up with you later, on every bug you can’t read.

      • Modern JavaScript

        Modules, async, destructuring: the syntax everything else assumes you already know.

        9 published lessons

    2. Step 2

      Typing, so the code holds up

      TypeScript comes before React, not after: writing a typed component from the start is simpler than retrofitting types onto a codebase that grew without them.

      • TypeScript

        Types, interfaces, generics — and what the compiler catches before your users do.

        7 published lessons

    3. Step 3

      Building the interface

      The component model and state management are the core of browser-side work. This is also the longest stage of the path.

      • React

        Components, state, effects, and the rendering pitfalls you only see in production.

        13 published lessons

    4. Step 4

      Styling without debt

      It comes right after React because Tailwind is written inside the component: learning the two together avoids the parallel stylesheet that ends up contradicting your components.

      • Tailwind CSS

        Utility classes, responsive design, dark mode, and knowing when to extract a component.

        7 published lessons

    5. Step 5

      The server, in JavaScript

      Placed before Next.js, and deliberately so: Next.js hides the HTTP request behind its conventions. Having written a server by hand once makes those conventions readable instead of magical.

      • Node.js and Express

        Routes, middleware, database, authentication: a backend where you master every layer.

        8 published lessons

    6. Step 6

      Going to production

      React alone handles neither routing, nor server-side rendering, nor SEO. Next.js provides what separates a demo from a live site.

      • Next.js

        Routing, server-side rendering, data, and deploying a real application.

        7 published lessons

    7. Step 7

      Shipping without holding your breath

      Tests come once there is an application to break. Writing them earlier in the path means testing course examples; writing them later means never writing them.

    8. Step 8

      Plugging in a language model

      This is the most frequent request on an existing web application. It presupposes an application to integrate it into, hence its late placement.

      • ChatGPT APIs

        Calls, costs, streaming, and handling unexpected responses.

        10 published lessons

    9. Step 9

      Programming with an agent

      Last, for a fundamental reason: an agent amplifies the judgment of whoever uses it, it doesn’t replace it. This course only has value once the eight previous stages are under your belt — otherwise you’re reviewing code you can’t judge.

      • Claude Code

        Scoping a task, reviewing the output, staying in control of a real codebase.

        8 published lessons

    Coming to this path

    Courses in preparation. They will be unlocked at no extra cost for anyone who has already purchased the path.

    • PostgreSQL and SQL Query and model data without an ORM making the decisions for you.
    • Web accessibility and performance The two criteria a site is judged on before its code.
  2. 02

    AI developer

    AI & Machine Learning

    You want to ship AI features that work, before knowing how to train a model.

    81 lessons written

    9 of 9 courses available

    The order is deliberately reversed compared to academic curricula: you first learn to get value from an existing model — API calls, RAG over your documents, tool-using agents — which is most of the real-world work, before opening the hood with NLP and deep learning. Nine courses, 81 lessons, all written.

    1. Step 1

      Get the lay of the land before coding

      Half a day to know what we’re talking about: what AI does, what it doesn’t, and which kind of problem deserves a model rather than a simple rule. Free, with no prerequisites.

      • Introduction to AI

        Vocabulary, model families, and good judgment about use cases.

        6 published lessons

    2. Step 2

      Python, the basic tool

      The entire AI ecosystem is in Python. This course is free and requires nothing before it.

      • Python

        Syntax, data structures, files, and libraries: enough to write useful scripts.

        11 published lessons

    3. Step 3

      Call a model before training one

      A well-used API solves most real needs. Knowing how to plug it in, control its cost, and handle its aberrant responses is worth more, as a first step, than the theory of training.

      • ChatGPT APIs

        Integrate a model into an application, and keep its cost under control.

        10 published lessons

    4. Step 4

      Understanding language models

      Once you’ve used them, understand what they do: tokens, context window, prompts, limits. This is what lets you diagnose a disappointing result instead of just putting up with it.

    5. Step 5

      Answering from your own documents

      The most frequent request in business, and the one most often botched. It comes right after language models because it requires no training: it’s a document retrieval problem before it’s an AI problem.

      • RAG in Production

        Chunking, embeddings, vector database, hybrid search, and the evaluation that tells you whether it works.

        8 published lessons

    6. Step 6

      Giving the model tools

      A model that acts on your systems rather than just producing text. Placed after RAG: reading documents is a less risky capability than writing to a database, and serves as a training ground.

      • Agents and MCP

        Agent loop, tool descriptions, MCP protocol, guardrails, and cost control.

        7 published lessons

    7. Step 7

      Programming with an agent

      The day-to-day application of everything that precedes to your own job. It assumes you’ve already developed judgment about what a model produces — otherwise you’re reviewing code you can’t evaluate.

      • Claude Code

        Scoping a task, reviewing a diff, verifying with tests, recognizing a failure.

        8 published lessons

    8. Step 8

      Language processing

      The historical foundation of the field, useful whenever you need to classify, extract, or compare text without calling a large model on every request. This is where we start opening the hood.

    9. Step 9

      Neural networks

      The most demanding stage, and the last: training your own model only makes sense once you know what an existing model can’t do.

      • Deep Learning

        Architectures, training, and the real cost of an in-house model.

        10 published lessons

    Coming to this path

    Courses in preparation. They will be unlocked at no extra cost for anyone who has already purchased the path.

    • Model fine-tuning Specialize an open model when prompting and RAG are no longer enough.
    • Computer vision Classify, detect, segment — the other half of the field.
    • MLOps Put a model into service and monitor its drift over time.
  3. 03

    Infrastructure and security engineer

    DevOps & Cybersecurity

    You administer machines, or want to, and you want to understand how they get attacked.

    136 lessons written

    8 of 8 courses available

    The most extensive path in the catalog: eight courses and 134 written lessons, including a 65-lesson Windows administration course with no equivalent elsewhere on the site. From the command line to infrastructure described as code, by way of containers, automated delivery, and observability. We finish with offensive security, because you can only properly defend an infrastructure you’ve attacked yourself.

    1. Step 1

      The command line

      Nothing that follows is done with a mouse. This course is free and serves as the foundation for the next two stages.

      • Linux

        File system, permissions, processes, services: enough to get by on a server.

        12 published lessons

    2. Step 2

      Administering at scale

      Most companies’ fleets run on Windows and Active Directory. Automating its administration is the daily work, and it is also the surface attackers target first.

    3. Step 3

      Package and orchestrate

      A hand-administered server can’t be replicated. The container makes a deployment reproducible, the orchestrator makes it survivable: this is the step up between “it runs on my machine” and “it runs in production.”

      • Docker

        Images, volumes, networks, and Compose: ship an identical environment everywhere.

        6 published lessons

      • Kubernetes

        Pods, services, deployments, and scaling across multiple machines.

        6 published lessons

    4. Step 4

      Automating delivery

      A deployment done by hand is a deployment you no longer dare to redo. The integration pipeline comes right after containers, because the built image is what it exists to produce and publish.

      • GitHub Actions

        Triggers, matrices, caching, secrets, and deployment: build, test, and ship with no manual intervention.

        7 published lessons

    5. Step 5

      Describe the infrastructure instead of clicking it together

      A web console leaves no trace of who changed what, and no way to rebuild identically. Terraform comes after the delivery pipeline: the pipeline is what will apply the plans, once they’ve been reviewed.

      • Terraform

        Resources, state, variables, modules, environments — and reviewing the plan before applying.

        7 published lessons

    6. Step 6

      Knowing what is happening in production

      Deploying fast without measuring anything just means breaking things faster. This course closes the operations part: four signals, alerts that wake you up for the right reasons, and what you need to explain an incident after the fact.

      • Observability

        Prometheus, PromQL, Grafana dashboards, useful alerts, logs, and traces.

        7 published lessons

    7. Step 7

      Attack to learn to defend

      Fifteen weeks of a penetration testing engagement, from legal scoping to the final report. Placed last: you can only usefully attack what you know how to administer, deploy, and monitor.

    Coming to this path

    Courses in preparation. They will be unlocked at no extra cost for anyone who has already purchased the path.

    • Cloud security Identities, networks, and permissions: where most recent leaks happen.
    • Incident response What to do in the hour following detection, and in what order.
  4. 04

    Java backend developer

    Backend Java

    You’re aiming at enterprise APIs, where Java remains the standard.

    71 lessons written

    8 of 8 courses available

    Eight courses and 71 lessons that follow the order in which a service is actually built: the language brought up to date, enterprise foundations, the web, persistence, the API, security, tests against a real database, then splitting into services. Each stage assumes the previous one is mastered — it’s the most linear path in the catalog, and the one where skipping a step costs the most.

    1. Step 1

      The language, up to date

      Many Java developers still write Java 8 on version 21. Records, pattern matching, and virtual threads change how you write the rest of the path: seeing them first avoids learning the frameworks with outdated syntax.

      • Modern Java (17 to 21)

        Records, sealed classes, pattern matching, text blocks, Optional, virtual threads.

        7 published lessons

    2. Step 2

      Enterprise foundations

      Servlets, container, request lifecycle: the layer Spring itself is built on. Knowing it keeps you from treating the framework as a black box at the first incident.

      • Java EE

        The enterprise foundations still in place in many systems.

        7 published lessons

    3. Step 3

      The web, Spring-style

      The model-view-controller pattern, dependency injection, and input validation. Everything that follows in the path depends directly on it.

      • Spring MVC

        The controller and view model that everything else rests on.

        8 published lessons

    4. Step 4

      Talking to the database

      Object-relational mapping saves time until the day it costs an enormous amount. This course focuses on what produces slow queries: lazy loading, N+1, poorly scoped transactions.

      • Hibernate and JPA

        Object-relational mapping, and its hidden costs.

        8 published lessons

    5. Step 5

      Exposing an API that others consume

      An internal API can be fixed; a published API has to be maintained for years. Resource design, status codes, versioning, documentation, and consistent error handling.

    6. Step 6

      Authentication and authorization

      Placed after the API rather than before: you secure something that exists. It’s the part most often botched, in interviews as in production.

      • Spring Security

        Authentication, authorization, tokens — the part most often botched.

        9 published lessons

    7. Step 7

      Testing against a real database

      Before splitting into services, not after: a test suite that runs against a real database is what makes a split reversible. Without it, every service extraction is a gamble.

    8. Step 8

      Splitting into services

      The last stage, and the most debatable: splitting too early costs more than not splitting. The course covers the when as much as the how.

    Coming to this path

    Courses in preparation. They will be unlocked at no extra cost for anyone who has already purchased the path.

    • Kafka and asynchronous messaging Decouple services without making them dependent on each other’s availability.
    • JVM performance Memory, garbage collection, profiling: diagnose instead of guessing.

Standalone courses

Two courses don’t follow the progression of any route. Attaching them to a path for convenience would have been misleading.

Another way to approach the catalog

A path bundles the courses for a career at a reduced price. If you’d rather go course by course, the individual courses page lists them with their prices. And if you want to unlock everything at once, the subscription plans include the entire catalog, upcoming courses included.