18.3.1 Web development

Understanding Web Development as a Specialization

Web development is about building things people can use in a web browser: websites, web apps (e.g., Trello, Gmail), APIs, and dashboards. As a Python developer, you typically focus on the backend (server side), but you should understand how it connects to the frontend (HTML, CSS, JavaScript).

Choosing web development as a specialization means:

• You enjoy building things people interact with online.
• You like turning ideas into working websites or web apps.
• You’re okay mixing Python (backend) with browser technologies (frontend).

This section focuses on what web development with Python looks like in practice and how to move forward in this path.

What Web Developers Do (Python-Focused)

A Python web developer typically:

• Builds and maintains web servers that respond to browser or app requests.
• Works with databases (storing users, posts, orders, etc.).
• Exposes APIs that mobile apps or frontends can call.
• Implements business logic (e.g., “if user paid, activate subscription”).
• Integrates external services (payment gateways, email providers, etc.).
• Ensures the app is secure, fast, and reliable.

You don’t need to know how to do all of this on day one. But this is the direction you’ll grow toward if you pick web development.

Backend vs Frontend vs Full-Stack

To decide how deep you go in each area:

Backend (where Python shines)

• Runs on the server.
• Handles requests like “log in”, “save this blog post”, “show my orders”.
• Talks to the database.
• Sends back HTML pages, JSON data, or files.

Python is mainly used here. Frameworks like Flask, Django, and FastAPI are the most common tools.

Frontend

• Runs in the browser.
• Uses HTML (structure), CSS (style), JavaScript (interactivity).
• Controls what the user sees and interacts with: forms, buttons, layouts, animations.

Even as a backend developer, you should be comfortable reading and writing basic HTML and CSS, and understanding where JavaScript fits in.

Full-Stack

• Combines backend and frontend.
• You handle everything from the database to the browser UI.

Early on, you’ll likely be backend-leaning but pick up enough frontend to build simple, complete projects.

Core Skills for Python Web Development

If you choose web development, these become your main learning pillars.

1. HTTP and Routing

You need a mental model of how a web request works:

• Browser sends an HTTP request (e.g., GET /home, POST /login).
• Your Python app receives it and decides how to respond.
• Your app returns a response (HTML, JSON, etc.) with a status code (200, 404, etc.).

In Python web frameworks, you create routes that map URLs to Python functions.

Example (Flask-style idea):

@app.route("/hello")
def say_hello():
    return "Hello from the server!"

This route means: “When someone visits /hello, run this function and send its return value back to the browser.”

2. Templates (Dynamic HTML)

Most web apps need dynamic pages:

• Show a list of blog posts from a database.
• Display a user’s profile info.
• Render search results.

Frameworks use templates: HTML files with placeholders that Python fills in.

Conceptually:

# Python side
user_name = "Alex"
render_template("hello.html", name=user_name)

<!-- hello.html -->
<h1>Hello, {{ name }}!</h1>

The browser ends up seeing:

<h1>Hello, Alex!</h1>

You don’t need to master a specific templating language right now, just understand that templates connect HTML with Python variables.

3. Forms and User Input

Web apps often need to:

• Let users sign up / log in.
• Submit comments, messages, orders, etc.

This involves:

• An HTML form (fields and a submit button).
• A Python route that receives the form data (usually via an HTTP POST request).
• Validating the data and saving it (e.g., to a database).

Example idea (Flask-style pseudocode):

@app.route("/contact", methods=["GET", "POST"])
def contact():
    if request.method == "POST":
        message = request.form["message"]
        # process and save message
        return "Thanks!"
    return render_template("contact.html")

This pattern (show form on GET, process form on POST) appears constantly in web development.

4. Databases and Models

Very few real web apps work without persistent data. As a web developer, you need to:

• Understand basic database concepts: tables, rows, columns, primary keys.
• Use Python code to create, read, update, and delete (CRUD) data.
• Avoid putting everything in memory or text files for serious apps.

You’ll often use:

• Relational databases: SQLite, PostgreSQL, MySQL.
• An ORM (Object–Relational Mapper) that lets you work with Python classes instead of raw SQL.

Concept idea:

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(50))
# Creating a user
new_user = User(name="Sam")
db.session.add(new_user)
db.session.commit()

The details depend on the framework, but thinking in “models” (Python classes representing database tables) is central to backend work.

5. Basic Security Awareness

You don’t need to become a security expert immediately, but you cannot ignore it in web work.

As a beginner, focus on:

• Never storing plain-text passwords (always hashed).
• Being careful with user input; don’t blindly run or print it in unsafe ways.
• Using your framework’s built-in tools:
• CSRF protection for forms.
• Proper session handling (logins).
• Escaping values in templates by default.

As you grow, you’ll learn about common web security issues (like SQL injection, XSS, CSRF), but at the start, rely on frameworks and follow tutorials that mention security practices.

Popular Python Web Frameworks

You don’t need all of these. Start with one and stick with it for a while.

Flask

• Minimal, flexible, and beginner-friendly.
• Good for small to medium apps, APIs, and learning how the web works.
• You add features (database, forms, login) with extensions as needed.

Flask is an excellent first framework if you want to understand the building blocks.

Django

• “Batteries included”: comes with admin panel, ORM, auth system, and more.
• Great for large, content-heavy, or database-driven apps.
• Encourages a clear structure and “Django way” of doing things.

Django is a solid choice if you like having strong guidance and lots of built-in tools.

FastAPI

• Modern framework focused on APIs, speed, and type hints.
• Popular for building backend services used by frontends or mobile apps.
• Good fit if you’re interested in APIs and microservices.

You can pick any of these and build a career, but as a first step:

• If you want to understand fundamentals clearly: Flask.
• If you want a structured ecosystem quickly: Django.

Typical Beginner Web Projects

When choosing web development, you’ll learn best by building small, real projects. Here are some increasing steps:

1. Static + Minimal Dynamic Site

• A small personal site with HTML/CSS.
• One route returning simple HTML from Python.
• A dynamic greeting, like “Hello, [name]”.

This gets you comfortable with routing and templates.

2. Guestbook / Simple Message Board

• A form where users can submit a short message.
• Store messages in memory at first, then in a database.
• Display them on a page.

Concepts: forms, POST requests, reading data, showing data back.

3. Simple CRUD App

Examples:

• A to-do list (create, view, update, delete tasks).
• A small notes app.

Concepts: database models, CRUD operations, more advanced templates, basic validation.

4. User Accounts

• Allow users to register, log in, and log out.
• Each user sees their own data (e.g., their own notes).

Concepts: sessions, authentication, authorization basics.

5. Simple API

• A JSON-based API for tasks, notes, or messages.
• No HTML, just routes that send and receive JSON.

Concepts: API design (endpoints, methods, request/response format), useful if you later work with frontend frameworks or mobile apps.

Learning Path for Python Web Development

Here’s a practical sequence if you choose this specialization:

1. Strengthen core Python
   Make sure you’re comfortable with:
• Variables, functions, conditions, loops.
• Working with files and basic data structures.
  These are reused constantly in web code.
2. Learn basic web fundamentals
• HTML: headings, paragraphs, links, forms.
• CSS: basic layout, fonts, colors.
• Understand what happens when you type a URL in a browser.
3. Pick one Python web framework
• Start with Flask or Django.
• Follow an up-to-date, beginner-focused tutorial from start to finish.
4. Build 2–3 small projects
• At least one with forms and a database.
• At least one that includes user login, or an API.
5. Learn a bit of deployment
• Understand what it means to host your app on:
• A platform like Render, PythonAnywhere, or Railway.
• Or a cloud platform (Heroku’s alternatives, etc.).
• Focus on following a simple deployment guide for your chosen framework.
6. Deepen your knowledge
• For Flask/Django: forms, models, authentication, structure for larger apps.
• For FastAPI: path operations, pydantic models, error handling.
• Basics of web security and performance.

Signs Web Development Is a Good Fit for You

Web development might be a strong choice if:

• You like seeing immediate visual results in a browser.
• You enjoy building things other people can easily access and use.
• You don’t mind dealing with “many moving parts” (frontend, backend, database, deployment).
• You’re interested in both technical and user-facing aspects.

If you prefer working mainly with data, analysis, and charts, you may lean more toward data science. If you like running scripts to manage files or systems, automation might appeal more. For products like desktop apps, games, or complex software systems, software development is another path.

Next Concrete Steps (If You Choose Web)

If you decide to specialize in web development:

1. Finish learning the Python fundamentals in this course.
2. Learn basic HTML & CSS (enough to build simple pages and forms).
3. Choose either Flask or Django and:
• Follow one complete beginner tutorial.
• Deploy that tutorial project once.
4. Build a small personal project:
• Example: a simple blog or notes app with user accounts.
5. Keep a list of “mini-features” you want to add:
• Search, pagination, profile pages, file uploads, etc.
• Implement them one by one as you learn.

Over time, you’ll move from “I followed a tutorial” to “I can design and build my own small web apps,” which is exactly where a web development specialization starts to feel real and useful.