Route decorator (@app.route) in Flask - Step-by-Step Execution

Concept Flow - Route decorator (@app.route)

Define function

↓

Apply @app.route decorator

↓

Register URL path with function

↓

Start Flask server

↓

Browser sends HTTP request to URL

↓

Flask matches URL to function

↓

Function runs and returns response

↓

Response sent back to browser

This flow shows how a function is linked to a URL path using @app.route, so when a browser visits that URL, Flask runs the function and sends back the response.

Execution Sample

Flask

from flask import Flask
app = Flask(__name__)

@app.route('/')
def home():
    return 'Hello, world!'

This code sets up a Flask app and uses @app.route('/') to link the home() function to the root URL, returning a greeting.

Execution Table

Step	Action	Details	Result
1	Define function home()	Function created but not linked yet	home() exists
2	Apply @app.route('/') decorator	Link '/' URL path to home()	Route '/' registered to home()
3	Start Flask server	App ready to receive requests	Server running
4	Browser sends GET request to '/'	Request received by Flask	Request matched to home()
5	Run home() function	Function executes return statement	Returns 'Hello, world!'
6	Send response to browser	Response contains 'Hello, world!'	Browser displays greeting
7	End	Request handled successfully	Waiting for next request

💡 Request handled and response sent; server waits for next request

Variable Tracker

Variable	Start	After Step 2	After Step 5	Final
app	Flask instance created	Route '/' linked to home()	No change	No change
home	Function defined	Linked to route '/'	Executed, returns string	No change
request	No request	No request	GET '/' received	No request (after response)

Key Moments - 3 Insights

Why does the function run only when the URL is visited?

Because @app.route('/') registers the function to that URL path, Flask calls it only when a matching request arrives, as shown in execution_table step 4 and 5.

What happens if we define a function without @app.route?

The function exists but is not linked to any URL, so Flask never runs it on requests. This is shown in execution_table step 1 where the function is defined but not registered.

Can multiple URLs use the same function?

Yes, by applying multiple @app.route decorators or listing multiple paths in one decorator, Flask registers all those URLs to the same function.

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 4?

A Flask starts the server

B Browser sends GET request to '/'

C Function home() is defined

D Response is sent to browser

💡 Hint

Check the 'Action' and 'Details' columns at step 4 in the execution_table

At which step does Flask link the URL '/' to the function home()?

A Step 2

B Step 5

C Step 1

D Step 6

💡 Hint

Look for when @app.route('/') is applied in the execution_table

If we remove @app.route decorator, what changes in the execution flow?

A Server fails to start

B Function runs automatically on server start

C Function never runs on HTTP requests

D Browser shows an error immediately

💡 Hint

Refer to key_moments about function without @app.route and execution_table step 1 vs step 2

Concept Snapshot

Use @app.route('path') above a function to link that URL path to the function.
When a browser visits that path, Flask runs the function and sends its return value as response.
Without @app.route, the function is not connected to any URL and won't run on requests.
This is how Flask maps URLs to code simply and clearly.

Full Transcript

The @app.route decorator in Flask connects a URL path to a Python function. When you write @app.route('/') above a function, you tell Flask to run that function whenever someone visits the root URL. The flow starts by defining the function, then applying the decorator which registers the URL. When the Flask server runs and a browser sends a request to '/', Flask matches the URL to the function and runs it. The function returns a response string, which Flask sends back to the browser to display. If the decorator is missing, the function exists but Flask never calls it on requests. This simple pattern lets you build web pages by linking URLs to Python code.