The Application Factory Pattern (create_app)0%
Building JSON APIs with jsonify & Status Codes

The Application Factory Pattern (create_app)

Beginner12 min read•Updated: Jul 11, 2026
Study MaterialsCheatsheet

The Application Factory Pattern (create_app)

In simple Flask tutorials, the application instance is created as a global variable at module level: app = Flask(__name__). While fine for prototypes, global application objects cause severe architectural issues in production:

  1. 1
    Circular Import Nightmares: Views import db from app.py, while app.py imports views.
  2. 2
    Testing Limitations: You cannot create isolated app instances with different configurations (e.g. SQLite for tests, PostgreSQL for production).
  3. 3
    Multiple Instances: Running multiple instances of the same app in a single process is impossible.

The Application Factory Pattern resolves all of these issues by encapsulating app creation inside a factory function, conventionally named create_app().

1. Decoupling Extension Initialization

When using the factory pattern, extensions (like SQLAlchemy, LoginManager, Migrate) are instantiated globally without an app argument. Later, they are bound to the app instance inside create_app() via their .init_app() method:

Python
# app/extensions.py
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from flask_migrate import Migrate
from flask_wtf.csrf import CSRFProtect
 
# Instantiate unattached extensions
db = SQLAlchemy()
login_manager = LoginManager()
migrate = Migrate()
csrf = CSRFProtect()

2. Implementing the create_app() Factory Function

Python
# app/__init__.py
from flask import Flask
from config import config
from app.extensions import db, login_manager, migrate, csrf
 
def create_app(config_name="default"):
# 1. Instantiate application
app = Flask(__name__)
# 2. Load configuration from object
app.config.from_object(config[config_name])
# 3. Initialize extensions with the active app
db.init_app(app)
login_manager.init_app(app)
migrate.init_app(app, db)
csrf.init_app(app)
# Configure login manager
login_manager.login_view = "auth.login"
login_manager.login_message_category = "warning"
# 4. Register Blueprints (delayed imports prevent circular import errors!)
from app.main.routes import main_bp
from app.auth.routes import auth_bp
from app.api.routes import api_bp
app.register_blueprint(main_bp)
app.register_blueprint(auth_bp, url_prefix="/auth")
app.register_blueprint(api_bp, url_prefix="/api/v1")
# 5. Register custom error handlers or context processors
from app.errors import register_error_handlers
register_error_handlers(app)
return app

3. The Entry Point (run.py / wsgi.py)

Now the entry point is clean and minimal:

Python
# wsgi.py
import os
from app import create_app
 
# Read environment (development, production, testing)
env = os.environ.get("FLASK_ENV", "default")
app = create_app(env)
 
if __name__ == "__main__":
app.run()

4. Why This Pattern Revolutionizes Testing

With the Application Factory, automated tests can instantiate fresh, disposable app instances backed by an in-memory SQLite database:

Python
# tests/conftest.py
import pytest
from app import create_app
from app.extensions import db
 
@pytest.fixture
def app():
# Instantiate app with isolated testing config
test_app = create_app("testing")
with test_app.app_context():
db.create_all()
yield test_app
db.session.remove()
db.drop_all()
 
@pytest.fixture
def client(app):
return app.test_client()
Interactive Quiz

Practice Quiz

Question 1
What is the primary benefit of the Application Factory pattern (create_app)?
Question 2
How are Flask extensions bound to an app when using the Application Factory pattern?
Question 3
Why are blueprint imports placed inside create_app() rather than at the top of the file?
Question 4
How does the Flask CLI discover an application when using a factory function?
Question 5
What does test_app.app_context() provide during unit tests?
Next Lesson

Building JSON APIs with jsonify & Status Codes

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous LessonNext Lesson
Modular Routing with Flask BlueprintsBuilding JSON APIs with jsonify & Status Codes

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

PreviousNext
PrevNext