Country or region and language

    Choose your country or region and your language.

    Suggested for you

      All countries and regions

        Choose your character

        It shows in the top bar and on your profile. Change it any time.

        Python full stack developer roadmap

        Follow a Python full stack developer roadmap with clear skill checkpoints, a working inventory app, and portfolio evidence connecting the browser to the database.

        A person practicing on a laptop in a quiet workspace

        Follow this Python full stack developer roadmap by learning Python and Git, then HTML, CSS, JavaScript, and HTTP, followed by a Python web framework and SQL. Build and test one browser-to-database feature before adding authentication, deployment, or a separate front-end framework. Move forward when you can demonstrate each skill, not when you've finished watching a course.

        The learning route

        Full stack development connects the browser interface, the server-side application, and the database that stores information. Python usually handles server-side work; JavaScript handles behaviour inside the browser.

        Use one inventory application throughout your learning. Your everyday tasks mirror development work: clarify a stock rule, build a form, update stored quantities, investigate errors, review changes, and release the application.

        Your first integration checkpoint is specific: reserving a notebook must change both the stored quantity and the browser display. When stock reaches zero, the server must reject another reservation. A page that only changes a displayed number doesn't meet that checkpoint.

        Programming and browser foundations

        Build programming foundations first, then learn how a browser sends work to a server. Learn these skills in order so each one supports the next.

        • Python: learn variables, collections, conditions, loops, functions, exceptions, and modules. Write a reservation function that accepts stock and requested quantity, rejects invalid inputs, and returns the remaining stock.
        • Project isolation: use a virtual environment, an isolated place for a project's Python packages. Explain why separate projects shouldn't depend on one shared package installation.
        • Git: record small changes and inspect differences before committing. Keep a readable commit history and a short account of a corrected bug.
        • Browser structure: use semantic HTML, meaning elements chosen for their purpose, plus CSS for presentation. Give form fields labels and use a real button for submission.
        • Browser behaviour: learn JavaScript variables, functions, events, and document updates. You don't need a front-end framework to submit your first form.
        • HTTP: learn the request-and-response protocol connecting browser and server. GET retrieves a representation; POST submits an action. Status codes describe the response outcome.

        If Python functions or exceptions are still difficult, repeat those skills with the Python course before adding web requests.

        Open your browser's Network panel before submitting a form. Your checkpoint is to identify the request method, destination, response status, and returned content, then explain which server code handled the request.

        Practice what this post teaches

        Server and database skills

        Choose one Python web framework and learn enough SQL to store a complete feature. The example uses Flask, a Python web framework; Django is another Python web framework, not a second track you need to study simultaneously.

        Learn tables, primary keys that identify rows, and constraints that restrict stored values. Practice SQL statements for reading, inserting, and updating records. A transaction groups database work so it can be committed together or rolled back when an error occurs.

        The stock rule belongs in the database operation: subtract only when enough stock exists. Reading stock first and later writing a separately calculated value can lose changes when requests overlap. A conditional update checks availability as part of the update itself.

        A browser-to-database slice

        Build a local notebook reservation for a fictional stationery supplier to connect a form, a Python route, and SQLite, a database stored in a local file. Follow the complete exercise from an empty folder; an existing database would change the starting results.

        Fictional exercise: reserve a notebook
        Platform: macOS or Linux with Python 3 installed
        Target: each successful reservation removes one notebook;
        stock must never fall below zero.
        Starting state: a new empty folder, no stock.db file,
        one notebook record with stock = 2.
        Scope: local learning only; no login or cross-site request
        forgery protection.
        
        Setup commands:
        mkdir notebook-demo
        cd notebook-demo
        python3 -m venv .venv
        source .venv/bin/activate
        python -m pip install Flask
        
        Create app.py in notebook-demo with exactly these contents:
        
        import sqlite3
        from flask import Flask, render_template_string, request
        
        app = Flask(__name__)
        
        with sqlite3.connect('stock.db') as db:
            db.execute('CREATE TABLE IF NOT EXISTS stock '
                       '(id INTEGER PRIMARY KEY, quantity INTEGER NOT NULL '
                       'CHECK (quantity >= 0))')
            db.execute('INSERT OR IGNORE INTO stock VALUES (1, 2)')
        
        @app.route('/', methods=['GET', 'POST'])
        def inventory():
            message = 'Ready'
            with sqlite3.connect('stock.db') as db:
                if request.method == 'POST':
                    result = db.execute(
                        'UPDATE stock SET quantity = quantity - 1 '
                        'WHERE id = 1 AND quantity >= 1'
                    )
                    message = 'Reserved' if result.rowcount == 1 else 'Out of stock'
                quantity = db.execute(
                    'SELECT quantity FROM stock WHERE id = 1'
                ).fetchone()[0]
            return render_template_string(
                '<h1>Notebook stock: {{ quantity }}</h1>'
                '<p>{{ message }}</p>'
                '<form method="post">'
                '<button type="submit">Reserve one</button>'
                '</form>',
                quantity=quantity, message=message
            )
        
        if __name__ == '__main__':
            app.run()
        
        Run from notebook-demo:
        python app.py
        
        Open http://127.0.0.1:5000/ in your browser.
        Expected display: Notebook stock: 2 | Ready
        
        Click Reserve one once.
        Calculation: 2 - 1 = 1
        Expected display: Notebook stock: 1 | Reserved
        
        Click Reserve one a second time.
        Calculation: 1 - 1 = 0
        Expected display: Notebook stock: 0 | Reserved
        
        Click Reserve one a third time.
        Rule check: 0 is below the required quantity of 1.
        Expected display: Notebook stock: 0 | Out of stock
        
        Enter http://127.0.0.1:5000/ in the address bar again.
        This sends a GET rather than resubmitting the form.
        Expected display: Notebook stock: 0 | Ready
        
        Verify storage in a second terminal, from notebook-demo:
        python3 -c "import sqlite3; db = sqlite3.connect('stock.db'); print(db.execute('SELECT quantity FROM stock WHERE id = 1').fetchone()[0]); db.close()"
        Expected output:
        0
        

        The conditional update matches a row only when stock is at least one. The affected-row count determines whether the page reports success or rejection. The database connection's context manager commits the successful transaction before the response is returned.

        The form sends POST to the current address. The Python route runs the update, reads the stored quantity, and inserts that quantity into returned HTML. JavaScript isn't required for this server-rendered flow.

        Don't publish this demonstration as a public application. It omits authentication and cross-site request forgery protection, which helps prevent another site from causing unwanted actions through a user's browser.

        Testing and release readiness

        Prove the stock rule with automated tests before adding security and deployment work. Give each test a fresh database so earlier reservations don't affect later results.

        • Test normal stock, the last available notebook, and empty stock. Check both the response and the stored quantity.
        • Test that GET doesn't change stock and a rejected POST leaves the database unchanged.
        • Add authentication to identify users and authorisation to decide which actions each user may perform.
        • Validate submitted values on the server. Use parameterised SQL, which passes values separately from SQL text, when accepting variable inputs.
        • Add cross-site request forgery protection before exposing browser-based actions to users.

        Repeat weak testing or project-structure skills with the Python for software engineers course before expanding the application.

        Next, learn environment-based configuration, dependency recording, database migrations that track schema changes, logs, HTTPS, and production serving. Write repeatable release instructions. Flask's development server isn't a production release method.

        Only then consider a separate front end. Learn JSON, a text format for structured data, and an application programming interface, a defined way for software components to communicate. Keep the same stock rule when replacing form submissions with JavaScript requests.

        Portfolio evidence and next steps

        Package evidence that another developer can inspect and reproduce: setup instructions, a request-flow diagram, test results, screenshots, and the bug your conditional update prevents. State what you implemented and what remains unfinished.

        Use milestones rather than a promised completion date: explain a request, build a persistent feature, prove an edge case, secure the workflow, and reproduce a release. Revisit Python, Git, Front end, or Application security practice when a milestone exposes a gap.

        The Work Gym provides browser-based practice with automatic checks and hints that name mistakes. Finished projects and courses can produce shareable practice records. Keep those records alongside your own project evidence, not instead of explaining your decisions.

        When you can trace the request and justify the stock rule aloud, use Python for software engineers interview practice to rehearse discussing your work.

        In an interview, describe the request path, a test that exposed an error, and a production limitation. Don't present this local demonstration as evidence that you've operated a production service.

        Common questions

        Should I learn Python or front-end development first? Start with enough Python to write and test small functions, then learn HTML, CSS, and basic JavaScript. Connect those skills through one working form rather than studying each subject indefinitely.

        Do I need React for Python full stack development? No. You can build a complete browser-to-database feature with server-rendered HTML, then consider a separate front-end framework when the interface needs more client-side behaviour.

        Should I start with Flask or Django? Choose one Python web framework and finish a complete feature before switching. This roadmap uses Flask, so following the example with Flask avoids learning two sets of conventions at once.

        How do I know when a full stack project is ready for my portfolio? Include the project when another person can follow its setup instructions, reproduce the main feature, and inspect its tests. Label missing security and deployment work clearly rather than presenting the project as production-ready.

        How can I plan the roadmap around college or a full-time job? Choose one observable milestone for each study block, such as testing empty stock or tracing a POST request. If a milestone takes longer than expected, reduce the feature scope instead of skipping the verification.

        Practice what this post teaches

        Your Work Gym account

        Save your progress and pick up on another device. Your browser's progress comes with you.

        or

        You can keep practicing without an account.

        Help and feedback

        Ask a question, tell us what is not working, or share an idea. We reply by email.

        What is it about?

        We use it only to reply to you.