Top 25 Python Flask Interview Questions & Answers
Flask is one of the most popular Python web frameworks, known for its simplicity, flexibility, and lightweight nature. Whether you’re preparing for a Flask developer interview or brushing up on your skills, mastering key Flask concepts is essential.
In this guide, we’ll cover the top 25 Flask interview questions with detailed explanations and code examples. From routing and templates to database integration, REST APIs, and deployment, this post will help you confidently answer technical questions in Flask job interviews.
Let’s dive in and explore the most frequently asked Flask interview questions!
1. What is Flask?
Flask is a micro web framework for Python that is lightweight, modular, and easy to use. It is called a “micro” framework because it does not include built-in tools for database abstraction, form validation, or authentication, but these can be added via extensions.
Example:
from flask import Flask
app = Flask(__name__)
@app.route(‘/’)
def home():
return “Hello, Flask!”
if __name__ == ‘__main__’:
app.run(debug=True)
2. How does Flask compare to Django?
Feature | Flask | Django |
Type | Micro-framework | Full-stack framework |
Flexibility | More flexible | More opinionated |
ORM | Not built-in (can use SQLAlchemy) | Built-in ORM |
Admin Panel | No built-in admin panel | Has built-in admin panel |
Use Case | Small to medium apps, APIs | Large apps |
3. What are the key features of Flask?
- Lightweight and minimalistic
- Built-in development server and debugger
- RESTful request handling
- Support for Jinja2 templating
- Extension support (Flask-SQLAlchemy, Flask-RESTful, etc.)
- URL routing
4. What is the use of @app.route() in Flask?
The @app.route() decorator is used to bind a function to a specific URL.
Example:
@app.route(‘/about’)
def about():
return “This is the About page”
5. How can you define dynamic routes in Flask?
You can define dynamic routes using angle brackets <variable>.
Example:
@app.route(‘/user/<name>’)
def user(name):
return f”Hello, {name}!”
6. How do you handle HTTP methods in Flask?
Use the methods parameter in @app.route().
Example:
@app.route(‘/submit’, methods=[‘GET’, ‘POST’])
def submit():
if request.method == ‘POST’:
return “Form Submitted”
return “Submit Form”
7. How do you render an HTML template in Flask?
Use the render_template() function.
Example:
from flask import render_template
@app.route(‘/welcome’)
def welcome():
return render_template(‘welcome.html’)
Template file (templates/welcome.html):
<!DOCTYPE html>
<html>
<body>
<h1>Welcome to Flask!</h1>
</body>
</html>
8. What is Jinja2 templating in Flask?
Jinja2 is Flask’s template engine that supports dynamic HTML generation using placeholders, loops, and conditions.
Example: Template file:
<ul>
{% for user in users %}
<li>{{ user }}</li>
{% endfor %}
</ul>
9. How can you access form data in Flask?
Use request.form.
Example:
from flask import request
@app.route(‘/login’, methods=[‘POST’])
def login():
username = request.form[‘username’]
password = request.form[‘password’]
return f”Logged in as {username}”
10. How do you handle JSON data in Flask?
Use request.get_json().
Example:
@app.route(‘/api/data’, methods=[‘POST’])
def api_data():
data = request.get_json()
return {“message”: “Received”, “data”: data}
11. How do you use sessions in Flask?
Use session from flask.
Example:
from flask import session
app.secret_key = ‘secret123’
@app.route(‘/set_session’)
def set_session():
session[‘username’] = ‘JohnDoe’
return “Session set!”
@app.route(‘/get_session’)
def get_session():
return session.get(‘username’, ‘No session set’)
12. How do you set and get cookies in Flask?
Use response.set_cookie() and request.cookies.
Example:
@app.route(‘/set_cookie’)
def set_cookie():
resp = make_response(“Cookie is set”)
resp.set_cookie(‘user’, ‘John’)
return resp
@app.route(‘/get_cookie’)
def get_cookie():
user = request.cookies.get(‘user’)
return f’User: {user}’
13. How do you integrate a database in Flask?
Use Flask-SQLAlchemy.
Example:
from flask_sqlalchemy import SQLAlchemy
app.config[‘SQLALCHEMY_DATABASE_URI’] = ‘sqlite:///users.db’
db = SQLAlchemy(app)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
db.create_all()
14. How do you perform CRUD operations using SQLAlchemy?
Example:
# Create
new_user = User(name=’Alice’)
db.session.add(new_user)
db.session.commit()
# Read
user = User.query.filter_by(name=’Alice’).first()
# Update
user.name = ‘Alicia’
db.session.commit()
# Delete
db.session.delete(user)
db.session.commit()
15. How do you handle 404 errors in Flask?
Use @app.errorhandler(404).
Example:
@app.errorhandler(404)
def page_not_found(e):
return “Page not found!”, 404
16. How do you create a REST API in Flask?
Example:
from flask import jsonify
@app.route(‘/api/user/<int:id>’)
def get_user(id):
return jsonify({“id”: id, “name”: “John”})
17. What are Flask Blueprints?
Blueprints help organize a large Flask app into modules.
Example:
from flask import Blueprint
auth = Blueprint(‘auth’, __name__)
@auth.route(‘/login’)
def login():
return “Login Page”
Register Blueprint:
app.register_blueprint(auth, url_prefix=’/auth’)
18. What is Flask Middleware?
Middleware is a function that executes before processing requests.
Example:
@app.before_request
def before_request():
print(“Before request executed”)
19. What is Flask CORS?
Flask-CORS enables cross-origin requests.
from flask_cors import CORS
CORS(app)
20. How do you deploy a Flask app?
You can deploy Flask using:
- Gunicorn (gunicorn app:app)
- NGINX + uWSGI
- Heroku (heroku create && git push heroku main)
- Docker (docker run -p 5000:5000 flask-app)
21. What is the difference between Flask and FastAPI?
Flask and FastAPI are both Python web frameworks, but they have key differences:
Feature | Flask | FastAPI |
Performance | Slower (based on WSGI) | Faster (ASGI, async support) |
Asynchronous Support | Limited (via gevent or asyncio) | Built-in async/await support |
Type Checking | No built-in type hints | Enforces type hints (via Pydantic) |
Speed | Comparatively slower | Up to 3-5x faster |
API Docs | No built-in docs | Auto-generates Swagger and Redoc |
Use Cases | General web apps, APIs | High-performance APIs, microservices |
Example:
Flask API
from flask import Flask, jsonify
app = Flask(__name__)
@app.route(‘/user/<int:id>’)
def get_user(id):
return jsonify({“id”: id, “name”: “John”})
if __name__ == ‘__main__’:
app.run(debug=True)
FastAPI Equivalent
from fastapi import FastAPI
app = FastAPI()
@app.get(“/user/{id}”)
async def get_user(id: int):
return {“id”: id, “name”: “John”}
When to use Flask vs. FastAPI?
- Use Flask for traditional web apps, monoliths, and simple APIs.
- Use FastAPI for high-performance APIs and async applications.
22. How do you scale a Flask application?
Scaling a Flask app means handling more requests efficiently. Here are some strategies:
- Use a Production Server (Gunicorn)
Flask’s built-in server is not production-ready. Use Gunicorn:
gunicorn -w 4 app:app
- -w 4: Spawns 4 worker processes.
- Use Caching (Redis, Memcached)
Flask-Cache or Redis can improve performance by storing frequently accessed data.
Example:
from flask_caching import Cache
app.config[‘CACHE_TYPE’] = ‘simple’
cache = Cache(app)
@app.route(‘/data’)
@cache.cached(timeout=50)
def cached_data():
return “This data is cached!”
- Load Balancing (NGINX, AWS ALB)
Deploy multiple Flask instances and balance the load using NGINX:
upstream flaskapp {
server 127.0.0.1:5000;
server 127.0.0.1:5001;
}
server {
location / {
proxy_pass http://flaskapp;
}
}
- Use a Message Queue (Celery for Async Tasks)
Instead of handling long-running tasks in Flask, offload them using Celery:
from celery import Celery
celery = Celery(‘tasks’, broker=’redis://localhost:6379′)
@celery.task
def long_task():
return “Task Completed”
- Use a Cloud Service (AWS, GCP, Azure)
- Deploy Flask as serverless using AWS Lambda (Zappa).
- Use Kubernetes for microservices deployment.
23. What are Flask Extensions?
Flask doesn’t include built-in features for things like databases, authentication, or caching. Instead, we use Flask extensions.
Popular Flask Extensions
Extension | Purpose |
Flask-SQLAlchemy | Database ORM |
Flask-WTF | Forms & validation |
Flask-Login | Authentication |
Flask-Mail | Email sending |
Flask-RESTful | REST API support |
Flask-CORS | Cross-Origin Resource Sharing |
Example: Flask-SQLAlchemy
from flask_sqlalchemy import SQLAlchemy
app.config[‘SQLALCHEMY_DATABASE_URI’] = ‘sqlite:///db.sqlite3’
db = SQLAlchemy(app)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
24. How to enable Debug Mode in Flask?
Debug mode allows for automatic reloading and interactive debugging.
Enable Debug Mode in Code
if __name__ == ‘__main__’:
app.run(debug=True)
or using environment variables:
export FLASK_ENV=development
export FLASK_DEBUG=1
flask run
25. How do you test a Flask app using PyTest?
Flask supports testing using PyTest and the test_client().
Install PyTest
pip install pytest
Example: Testing a Flask App
import pytest
from app import app # Import your Flask app
@pytest.fixture
def client():
return app.test_client()
def test_homepage(client):
response = client.get(‘/’)
assert response.status_code == 200
assert b”Hello, Flask!” in response.data
Run Tests
pytest test_app.py
Flask is a powerful and flexible web framework that enables developers to build scalable and efficient web applications. In this guide, we covered 25 essential Flask interview questions, ranging from basic concepts to advanced topics like database handling, REST APIs, and performance optimization.
By mastering these concepts and practicing with real-world examples, you’ll be well-prepared to ace any Flask developer interview. Keep exploring Flask, experiment with projects, and stay updated with the latest best practices to strengthen your web development skills.
Good luck with your Flask interview, and happy coding!