Beginner roadmap • updated July 14, 2026

Learn coding and technology basics with AI tools, even if you are starting from zero.

This page is for people in other industries who have an app idea, a workflow problem, or a pile of repetitive tasks and are starting to realize that tools like ChatGPT and Codex can help them build useful things themselves.

Jump to the roadmap See the first hour

You do not need

A CS degree, years of math, or perfect terminology before you begin.

Paid access helps

Free plans are fine for trying things, but paid access makes serious Codex and automation work much more practical.

Your first win

It might be a one-page website running on localhost, not a billion dollar startup.

01

Start here

The goal is not to become an expert first. The goal is to get your first tiny project running.

A good beginner path in 2026 is different from the old path. You still need to learn the basics, but AI lets you get hands-on much earlier. That means you can learn concepts while building things that matter to you.

  • Start with one tiny build, not a giant app idea.
  • Use AI to explain terms while you work.
  • Keep the first project to one folder and one page.
  • The first milestone is seeing localhost:3000 load.

If you want the clearest possible first hour, do this

  1. Install the ChatGPT desktop app. Sign in with your ChatGPT account, ideally the same Plus account you just set up.
  2. Create one empty folder for the project. Name it something simple like my-first-site, then add that folder in ChatGPT as a local project so Codex can read and change files there.
  3. Start a new Codex task in that local project. Do not begin with React, databases, authentication, or mobile. Begin with one plain web page.
  4. Paste a tiny first prompt. 
    Build me a simple HTML website that displays the current local time.
Use plain HTML, CSS, and JavaScript.
Create the files in this folder.
When you are done, tell me exactly how to run it locally on port 3000.
  5. Run a local web server and open the page. After Codex creates the files, open Terminal in that same folder and run: 
    python3 -m http.server 3000
    Then open http://localhost:3000 in your browser. Leave that terminal window open while the site is running. Press Ctrl + C when you want to stop the server.

Beginner rule: do not start with frameworks or startups. First make one index.html load at http://localhost:3000.

Best first clicks

02

OpenAI setup and billing

For most new users, the happy path is simple: sign up for ChatGPT Plus.

If you are new to this, do not overthink the pricing menu. In 99% of cases, the right starting point is ChatGPT Plus at $20/month. It is the simple default, it avoids most of the limits that make the free tier frustrating, and it is enough for nearly everyone getting started with ChatGPT and Codex.

  • Create a ChatGPT account and upgrade to Plus.
  • Use API billing only if you start using scripts, apps, or developer tools that charge by usage.
  • Think of ChatGPT billing and API billing as two separate buckets.
  • Only look at Pro or other higher plans if you use it heavily and keep hitting limits.

Only the links most people need

03

Everyday wins

You do not need an app idea yet. ChatGPT and Codex can already save you time.

Many beginners think the only valid use of AI coding tools is to launch a startup. That is too narrow. A much better starting point is solving boring work: rewriting documents, extracting patterns from data, generating formulas, or writing a one-off Python script to transform text files.

  • Turn messy notes into structured plans.
  • Clean CSV, JSON, or plain-text files with small scripts.
  • Ask Codex to explain code line by line while you learn.
  • Use ChatGPT for brainstorming, summarizing, and decision support.

A good first project: “I have a text file I hate editing by hand. Can AI help me write a script that fixes it every time?”

Good entry points

  • Codex overview to understand where coding help fits inside ChatGPT.
  • ChatGPT docs for current product capabilities, workflows, and terminology.
04

Problem finding

Look for recurring pain, not flashy ideas.

The best beginner app ideas are usually close to your own work. If you work in operations, sales, healthcare, education, logistics, law, construction, or real estate, you probably already touch repetitive forms, checklists, scheduling problems, or messy data. That is fertile ground.

  • List the tasks you repeat every week.
  • Notice where copy-paste and spreadsheet pain show up.
  • Prefer “one painful workflow” over “an app for everyone.”
  • Start with a web app before jumping to native mobile.

Prompts worth trying

  • Ask ChatGPT: “Help me find three automations hiding inside my current job.”
  • Ask Codex: “Turn this manual process into the smallest possible internal tool.”
  • Ask either: “What would the MVP version of this idea look like in one weekend?”
05

Terminal

The terminal is not magic. It is just a text-based control panel for your computer.

You do not need to memorize dozens of commands on day one. You need comfort moving through folders, opening files, running programs, and reading errors without panicking.

  • Learn `pwd`, `ls`, `cd`, `mkdir`, `cp`, and `mv` first.
  • Get used to reading command output slowly.
  • Understand that errors are clues, not judgment.
  • Practice on harmless files until the fear drops.

Learn the command line

06

Git

Git is version control: a way to track changes, go backward, and collaborate safely.

Beginners often treat Git as a scary ritual. A better mental model is this: Git is your timeline, your save points, and your safety net. It lets you experiment without losing your place.

  • A repository is the project and its history.
  • A commit is a saved checkpoint with a message.
  • A branch is a separate lane for trying changes.
  • GitHub is a hosting and collaboration layer around Git.

Learn Git well enough to move fast

07

Vibe coding

Vibe coding works best when you keep shipping, checking, and tightening the loop.

“Vibe coding” is not refusing to think. It is using AI to move quickly while still checking what the machine produced. The people who get the most from it keep prompts concrete, test small pieces, and ask follow-up questions without pretending to know more than they do.

  • Describe the outcome, inputs, constraints, and edge cases.
  • Ask for the smallest working version first.
  • Run the code and paste back real errors.
  • Keep asking “explain why this works” as you go.

YouTube searches worth opening

08

Web basics

If you want to build a web app, understand the simple stack first: HTML, CSS, and JavaScript.

You do not need to master ten frameworks before building. Start by understanding the browser. HTML gives structure, CSS handles look and layout, and JavaScript makes the page respond to user actions and data.

  • HTML is the skeleton.
  • CSS is the design system.
  • JavaScript is the behavior layer.
  • Frameworks make more sense after the basics click.

Solid learning resources

09

Python

Python is one of the best first languages when your goal is useful automation.

If you want AI to help you write scripts that rename files, edit text, process spreadsheets, call APIs, or scrape simple data, Python is a strong first choice. It is readable, popular, and very well supported by AI tools.

  • Read and write files.
  • Transform text, CSV, and JSON.
  • Install libraries when needed.
  • Keep scripts small and test them on sample data first.

Best Python beginner links

10

Data, APIs, and databases

Apps become more powerful when they can fetch data, store data, and connect systems.

You do not need to become a backend specialist immediately, but you should learn a few core concepts. APIs let software talk to software. JSON is a common data format. Databases store structured information. SQL helps you ask questions of that data.

  • Learn what an API request and response look like.
  • Get comfortable reading JSON.
  • Understand when a spreadsheet stops being enough.
  • Learn simple SQL before chasing big architecture ideas.

Good first resources

11

First web app

Build the smallest version of the thing people can click and use.

Your first web app does not need a complex architecture. A good first version often looks like this: one page, one form, one data flow, one output. Let AI help scaffold it, then keep trimming until the value is obvious.

  • Choose one stack and stick to it for a while.
  • Build one core workflow, not a complete platform.
  • Ship the browser version before worrying about mobile apps.
  • Use feedback from real users to decide what comes next.

Good build-path resources

12

Hosting and domains

Get your simple web app live on a real URL people can visit.

A project does not feel real until someone else can open it in a browser. The basic path is straightforward: push your code, deploy it to a host, get a default URL, then connect a custom domain when you are ready. You do not need to own servers to do this.

  • Static sites can be deployed very cheaply and very fast.
  • Git-connected hosting gives you automatic redeploys on every push.
  • Custom domains make the project feel legitimate and easier to share.
  • DNS records and SSL are normal parts of going live, not advanced magic.

Beginner rule of thumb: if it is mostly HTML, CSS, and JavaScript, GitHub Pages can be enough. If you want preview deploys, environment variables, and an easier path to a real app, look closely at Cloudflare Pages, Vercel, or Netlify.

What to learn and where to deploy

13

Mobile and launch

After the web version proves useful, treat native Swift and Kotlin as the long-term default.

Many people jump to mobile too early, and many people also assume they must use a cross-platform framework forever. A better default in many serious products is: prove the workflow on the web first, then strongly consider native iOS with Swift and native Android with Kotlin for the long run. Flutter and React Native are worth understanding, but they are not automatically the right end state. Codex can generate native code too, which lowers the old barrier to going native.

  • Validate the workflow in a browser first.
  • For long-term products, native Swift and Kotlin are often the best choice.
  • Use Flutter or React Native when their tradeoffs truly fit the job.
  • Watch real users struggle and write down every point of friction.
  • Let a 90-day plan beat endless “research mode.”

Mobile and next-step resources

A practical 90-day path

  1. Week 1-2: set up ChatGPT, Codex, terminal basics, and Git basics.
  2. Week 3-4: build tiny Python and HTML/CSS projects.
  3. Month 2: ship one small web app for a real workflow and get it live on a real URL.
  4. Month 3: improve it with user feedback, data storage, and a native mobile decision only if the web version earns it.