Introduction
Django is one of the most popular web frameworks for building applications with Python. It provides developers with a structured way to create websites, REST APIs, admin panels, authentication systems, and database-driven applications.
If you’re new to Django, the first step is setting up a proper development environment on your Windows computer.
The good news is that installing Django on Windows is straightforward. You mainly need Python, a virtual environment, and Django itself.
In this guide, we’ll walk through how to install and set up Django on Windows, from installing Python to creating and running your first Django project.
What Is Django?
Django is a high-level, open-source web framework built with Python.
It follows the principle of “Don’t Repeat Yourself” (DRY) and provides many features out of the box, including:
- URL routing
- Database integration
- Authentication
- Forms
- Security features
- Template rendering
- Django Admin
- Middleware
- Session management
- Static file handling
Instead of building these features from scratch, developers can use Django’s built-in tools and focus on application-specific functionality.
Prerequisites for Installing Django on Windows
Before installing Django, you need a few basic tools.
1. Windows Computer
You can install Django on supported versions of Windows using Python.
2. Python
Django is a Python framework, so Python must be installed before Django.
3. Command Prompt or PowerShell
You’ll use either Command Prompt, PowerShell, or another terminal to install packages and run Django commands.
4. Code Editor
A code editor is not technically required for installing Django, but it makes development much easier.
Popular choices include:
- Visual Studio Code
- PyCharm
- Sublime Text
Step 1: Check Whether Python Is Installed
Before installing Python, check whether it is already available on your computer.
Open Command Prompt or PowerShell and run:
python --version
You may also try:
py --version
If Python is installed, you’ll see its version.
For example:
Python 3.x.x
If Windows says that Python is not recognized, you’ll need to install it.
Step 2: Install Python on Windows
Download Python from the official Python website and install a current supported version.
During installation, pay attention to the option:
Add Python to PATH
Make sure this option is selected before continuing.
Adding Python to PATH allows you to run Python commands directly from Command Prompt or PowerShell.
After installation, close and reopen your terminal.
Then verify the installation:
python --version
You should now see the installed Python version.
Step 3: Check pip
pip is Python’s package manager. Django can be installed using pip.
Check whether pip is available:
pip --version
You should see information about the installed pip version and its Python environment.
If pip isn’t recognized, you can usually use:
python -m pip --version
Using python -m pip is also a reliable way to make sure pip is associated with the Python installation you’re using.
Step 4: Create a Project Directory
It’s a good practice to keep your Django projects organized in a dedicated folder.
For example, you might create a folder called:
django-projects
You can then navigate to that folder from your terminal.
Keeping projects organized becomes especially useful when you’re working on multiple Django applications.
Step 5: Create a Virtual Environment
One of the most important steps when setting up Django is creating a Python virtual environment.
A virtual environment creates an isolated Python environment for your project.
This means each project can have its own dependencies and package versions without affecting other projects.
For example:
Project A
- Django version A
- Package version A
Project B
- Django version B
- Package version B
Without virtual environments, managing different project dependencies can become difficult.
Why Use a Django Virtual Environment?
Suppose you have two Django projects.
One project requires an older Django version while another uses a newer version.
Installing Django globally could create dependency conflicts.
With virtual environments, each project has its own isolated dependencies.
This is why using a virtual environment is considered a standard practice for Python and Django development.
Step 6: Create the Virtual Environment
Inside your project directory, create a virtual environment.
A common name is:
venv
Once created, you’ll have a separate environment for your Django project.
You should generally avoid committing the virtual environment folder to Git because it contains installed packages specific to your local machine.
Step 7: Activate the Virtual Environment on Windows
After creating the virtual environment, activate it.
For Command Prompt, you can use the appropriate activation command.
For PowerShell, the activation command is slightly different.
Once activated, your terminal typically displays the virtual environment name before the command prompt.
For example:
(venv)
This indicates that commands such as python and pip are now operating inside your project’s virtual environment.
Common PowerShell Execution Policy Issue
Some Windows users may encounter an error when trying to activate a virtual environment in PowerShell.
The error is usually related to PowerShell’s script execution policy.
If this happens, you may need to adjust the execution policy according to your organization’s security requirements or use Command Prompt instead.
Avoid changing system security settings blindly, especially on managed work computers.
Step 8: Install Django
Once your virtual environment is activated, you can install Django using pip.
The installation is straightforward.
After installation, verify Django:
django-admin --version
You can also check Django through Python:
python -m django --version
If the version is displayed successfully, Django has been installed correctly.
Step 9: Create Your First Django Project
Now that Django is installed, you can create a project.
Django provides a command-line utility that generates the basic project structure.
For example, you can create a project named:
myproject
Django will create several important files and directories for your application.
A typical Django project contains files such as:
manage.pysettings.pyurls.pyasgi.pywsgi.py
These files have different responsibilities within the Django project.
Understanding manage.py
The manage.py file is one of the most frequently used files in a Django project.
It provides a command-line interface for performing common Django operations.
You can use it to:
- Start the development server
- Create applications
- Run database migrations
- Create superusers
- Run tests
- Open the Django shell
For example, many Django commands are run using:
python manage.py
Step 10: Run the Django Development Server
After creating your Django project, navigate into the project directory and start the development server.
Django provides a built-in development server that allows you to test your application locally.
The command is:
python manage.py runserver
You should see output indicating that Django’s development server is running.
The default address is generally:
http://127.0.0.1:8000/
Open that address in your browser.
If everything is configured correctly, you’ll see Django’s default welcome page.
What Is 127.0.0.1:8000?
When you run Django’s development server, it normally listens on:
127.0.0.1:8000
Here:
127.0.0.1refers to your local computer.8000is the default development server port.
This means your Django application is accessible locally and is not automatically available to everyone on the internet.
Step 11: Create a Django App
A Django project and a Django app are different concepts.
A project represents the overall website or application configuration.
An app usually represents a specific feature or area of functionality.
For example, an e-commerce project could contain apps such as:
- Products
- Orders
- Customers
- Payments
You can create an app using Django’s command-line tools.
For example:
python manage.py startapp products
This creates the basic structure for the products application.
Django Project vs Django App
Understanding this difference is important for beginners.
| Django Project | Django App |
|---|---|
| Contains overall configuration | Handles a specific feature |
| Manages project settings | Contains application logic |
| Contains main URL configuration | Can have its own URLs |
| Can contain multiple apps | Belongs to a project |
A single Django project can contain multiple Django apps.
Step 12: Configure the Django App
After creating an app, you generally need to add it to the project’s Django settings.
Django uses an application registry to keep track of installed applications.
Your application should be included in the appropriate configuration before you start using its models, templates, and other components.
This is an important step that beginners sometimes forget.
Step 13: Set Up the Database
Django supports multiple database systems, including:
- SQLite
- PostgreSQL
- MySQL
- MariaDB
- Oracle
For a new Django project, SQLite is commonly used during development because it requires minimal configuration.
Django creates the database structure through its migration system.
You can run migrations using:
python manage.py migrate
This creates the database tables required by Django’s built-in applications.
Step 14: Create a Django Superuser
Django includes a powerful administration interface.
To access the admin panel, you can create a superuser account.
The command is:
python manage.py createsuperuser
Django will ask for information such as:
- Username
- Email address
- Password
Once the account is created, start the development server and visit the Django admin URL.
The default admin path is usually:
/admin/
Step 15: Open Django Admin
Django Admin is one of Django’s most useful built-in features.
It provides an interface for managing application data without requiring you to build an administration dashboard from scratch.
You can use it to manage things such as:
- Users
- Groups
- Database records
- Products
- Orders
- Blog posts
- Other registered models
Once you understand Django models and the admin site, this feature can significantly speed up development.
Step 16: Choose a Code Editor
Once Django is installed, you’ll spend most of your time writing and organizing code.
Visual Studio Code is a popular choice for Django development because it provides:
- Python support
- Syntax highlighting
- Debugging
- Integrated terminal
- Git integration
- Extensions
- Code navigation
Other editors such as PyCharm are also excellent options.
The important thing is to use an editor that supports Python development comfortably.
Recommended Django Project Structure
A basic Django project may look similar to:
myproject/
│
├── manage.py
│
├── myproject/
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ ├── asgi.py
│ └── wsgi.py
│
└── products/
├── migrations/
├── __init__.py
├── admin.py
├── apps.py
├── models.py
├── tests.py
└── views.py
As your project grows, you may add templates, static files, URLs, services, forms, APIs, and other components.
Common Django Installation Problems on Windows
Python Is Not Recognized
If you see an error saying that Python is not recognized, check whether Python was installed correctly and whether it was added to PATH.
Restarting Command Prompt after installation can also help.
pip Is Not Recognized
Try using:
python -m pip
instead of directly using pip.
Django Is Not Recognized
Make sure your virtual environment is activated and Django is installed inside that environment.
You can verify the installation with:
python -m django --version
Virtual Environment Won’t Activate
If PowerShell blocks the activation script, check the PowerShell execution policy or use Command Prompt.
Port 8000 Is Already in Use
Another application may already be using port 8000.
Django allows you to run the development server on another available port.
For example:
python manage.py runserver 8080
Django Development Environment Best Practices
A good Django development setup should follow a few basic practices.
Always Use Virtual Environments
Avoid installing project dependencies globally whenever possible.
Keep Dependencies Organized
Use a dependency file such as requirements.txt so other developers can reproduce the project environment.
Use Git
Version control helps you track changes and collaborate with other developers.
Keep Secrets Out of Source Code
Database passwords, API keys, and other sensitive configuration values should not be committed to your repository.
Use Separate Development and Production Settings
Development environments and production servers have different requirements.
Avoid treating the Django development server as a production server.
Is Django Ready for Production After Installation?
No.
The Django development server is designed for development and testing.
A production Django deployment typically requires additional components such as:
- A production-ready web server
- WSGI or ASGI server
- Production database
- Static file configuration
- HTTPS
- Environment variables
- Security configuration
- Logging
- Monitoring
- Proper server infrastructure
The local Django setup is simply the first step toward building and deploying a production application.
Django Installation Checklist
After completing the setup, you should have:
- Python installed
- pip available
- A project directory
- A virtual environment
- Django installed
- A Django project created
- A Django app created
- Database migrations applied
- A superuser created
- Development server running
- A code editor configured
If these steps are working, your Windows machine is ready for Django development.
Conclusion
Learning how to install Django on Windows is the first step toward building Python-powered web applications with Django.
The basic process is simple:
Install Python → Create Virtual Environment → Install Django → Create Project → Run Server
Once your development environment is ready, you can start learning Django’s core concepts, including models, views, templates, URLs, forms, authentication, Django REST Framework, and database management.
The most important habit to develop early is using a virtual environment for every Django project. It keeps dependencies isolated and makes your projects easier to maintain.
With your Windows Django development environment properly configured, you’re ready to start building real-world web applications.
Frequently Asked Questions
Can I install Django on Windows?
Yes. Django can be installed on Windows using Python and pip.
Do I need Python to install Django?
Yes. Django is a Python web framework, so Python is required.
Is a virtual environment necessary for Django?
While not technically mandatory, using a virtual environment is strongly recommended because it isolates project dependencies.
Which Python version should I use for Django?
Use a currently supported Python version that is compatible with the Django version you plan to install.
Can I use VS Code for Django development?
Yes. VS Code is a popular code editor for Django and Python development.
Can I use Django with MySQL or PostgreSQL?
Yes. Django supports several relational database systems, including PostgreSQL, MySQL, MariaDB, SQLite, and Oracle.
Is Django free?
Yes. Django is free and open-source software.
