In this chapter we’ll build a new Django project that says “Hello, World” on the homepage. This is the traditional way to start a new programming language or framework. We’ll also work with git for the first time which is a version control system and deploy our code to Bitbucket, a remote code repository.

Initial Setup

To start navigate to a new directory on your computer. For example, we can create a helloworld folder on the Desktop with the following commands.

$ cd ~/Desktop
$ mkdir helloworld
$ cd helloworld

Make sure you’re not already in an existing virtual environment at this point. If you see text in parentheses () before the dollar sign $ then you are. To exit it, type exit and hit Return. The parentheses should disappear which means that virtual environment is no longer active.

We’ll use pipenv to create a new virtual environment, install Django and then activate it.

$ pipenv install django==2.1
$ pipenv shell

If you are on a Mac you should see parentheses now at the beginning of your command line prompt in the form (helloworld-XXX) where XXX represents random characters. On my computer I see (helloworld-415ivvZC). I’ll display (helloworld) here in the text but you will see something slightly different on your computer. If you are on Windows you will not see a visual prompt at this time.

Create a new Django project called helloworld_project making sure to include the period . at the end of the command so that it is installed in our current directory.

(helloworld) $ django-admin startproject helloworld_project .

If you use the tree command you can see what our Django project structure now looks like. (Note: If tree doesn’t work for you, install it with Homebrew: brew install tree.)

(helloworld) $ tree
├── Pipfile
├── Pipfile.lock
├── helloworld_project
│   ├──
│   ├──
│   ├──
│   └──

1 directory, 7 files

The file controls our project’s settings, tells Django which pages to build in response to a browser or url request, and, which stands for web server gateway interface, helps Django serve our eventual web pages. The last file is used to execute various Django commands such as running the local web server or creating a new app.

Django comes with a built-in web server for local development purposes. We can start it with the runserver command.

(helloworld) $ python runserver

If you visit you should see our familiar Django welcome page.

Django welcome page

Create an app

Django uses the concept of projects and apps to keep code clean and readable. A single Django project contains one or more apps within it that all work together to power a web application. This is why the command for a new Django project is startproject! For example, a real-world Django e-commerce site might have one app for user authentication, another app for payments, and a third app to power item listing details. Each focuses on an isolated piece of functionality.

We need to create our first app which we’ll call pages. From the command line, quit the server with Control+c. Then use the startapp command.

(helloworld) $ python startapp pages

If you look again inside the directory with the tree command you’ll see Django has created a pages directory with the following files:

(helloworld) $ tree
├── pages
│   ├──
│   ├──
│   ├──
│   ├── migrations
│   │   └──
│   ├──
│   ├──
│   └──

Let’s review what each new pages app file does:

  • is a configuration file for the built-in Django Admin app
  • is a configuration file for the app itself
  • migrations/ keeps track of any changes to our file so our database and stay in sync
  • is where we define our database models, which Django automatically translates into database tables
  • is for our app-specific tests
  • is where we handle the request/response logic for our web app

Even though our new app exists within the Django project, Django doesn’t “know” about it until we explicitly add it. In your text editor open the file and scroll down to INSTALLED_APPS where you’ll see six built-in Django apps already there. Add our new pages app at the bottom:

# helloworld_project/
    'pages.apps.PagesConfig', # new

We should always add our own local apps at the bottom because Django will read our INSTALLED_APPS in top down order. Therefore the internal admin app is loaded first, then auth, and so on. We want the core Django apps to be available since it’s quite likely our own apps will rely on their functionality.

Another thing to note is you might be wondering why we can’t just list the app name pages here instead of the much longer pages.apps.PagesConfig? The answer is that Django creates an file with each new application and it’s possible to add additional information there, especially with the Signals framework which is an advanced technique. For our relatively basic application using pages instead would still work, but we’d miss out on additional options and so as a best practice, always use the full app config name like pages.apps.PagesConfig.

We’ll build and add many more apps to our Django projects in later chapters so this pattern will become familiar with time.

Views and URLConfs

In Django, Views determine what content is displayed on a given page while URLConfs determine where that content is going.

When a user requests a specific page, like the homepage, the URLConf uses a regular expression to map that request to the appropriate view function which then returns the correct data.

In other words, our view will output the text “Hello, World” while our url will ensure that when the user visits the homepage they are redirected to the correct view.

This interaction is frequently very confusing to newcomers so let’s map out the order of a given HTTP request/response cycle. When you type in a URL, such as the first thing that happens within our Django project is a URLpattern is found that matches the homepage. The URLpattern specifies a view which then determines the content for the page (usually from the database) and a template for styling. The end result is sent back to the user as an HTTP response.

URL -> View -> Model (typically) -> Template

Let’s start by updating the file in our pages app to look as follows:

# pages/
from django.http import HttpResponse

def homePageView(request):
    return HttpResponse('Hello, World!')

Basically we’re saying whenever the view function homePageView is called, return the text “Hello, World!” More specifically, we’ve imported the built-in HttpResponse method so we can return a response object to the user. Our function homePageView accepts the request object and returns a response with the string Hello, World!.

Now we need to configure our urls. Within the pages app, create a new file.

(helloworld) $ touch pages/

Then update it with the following code:

# pages/
from django.urls import path

from .views import homePageView

urlpatterns = [
    path('', homePageView, name='home')

On the top line we import path from Django to power our urlpattern and on the next line we import our views. The period used here from . import views means reference the current directory, which is our pages app containing both and Our urlpattern has three parts:

  • a Python regular expression for the empty string ''
  • specify the view which is called homePageView
  • add an optional url name of 'home'

In other words, if the user requests the homepage, represented by the empty string '' then use the view called homePageView.

We’re almost done. The last step is to configure our project-level file too. Remember that it’s common to have multiple apps within a single Django project, so they each need their own route.

Update the existing helloworld_project/ file as follows:

# helloworld_project/
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('', include('pages.urls')),

We’ve imported include on the second line next to path and then created a new urlpattern for our pages app. Now whenever a user visits the homepage at / they will first be routed to the pages app and then to the homePageView view.

It’s often confusing to beginners that we don’t need to import the pages app here, yet we refer to it in our urlpattern as pages.urls. The reason we do it this way is that the method django.urls.include() expects us to pass in a module, or app, as the first argument. So without using include we would need to import our pages app, but since we do use include we don’t have to at the project level!

Hello, world!

We have all the code we need now! To confirm everything works as expected, restart our Django server:

(helloworld) $ python runserver

If you refresh the browser for it now displays the text “Hello, world!”

Hello world homepage


In the previous chapter we also installed git which is a version control system. Let’s use it here. The first step is to initialize (or add) git to our repository.

(helloworld) $ git init

If you then type git status you’ll see a list of changes since the last git commit. Since this is our first commit, this list is all of our changes so far.

(helloworld) $ git status
On branch master

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)


nothing added to commit but untracked files present (use "git add" to track)

We next want to add all changes by using the command add -A and then commit the changes along with a message describing what has changed.

(helloworld) $ git add -A
(helloworld) $ git commit -m 'initial commit'

Please note Windows users may receive an error git commit error: pathspec ‘commit’ did not match any file(s) known to git which appears to be related to using single quotes '' as opposed to double quotes "". If you see this error, using double quotes for all commit messages going forward.


It’s a good habit to create a remote repository of your code for each project. This way you have a backup in case anything happens to your computer and more importantly, it allows for collaboration with other software developers. The two most popular choices are Bitbucket and Github.

In this book we will use Bitbucket because it allows private repositories for free. Github charges a fee. Public repositories are available for anyone on the internet to use; private repositories are not. When you’re learning web development, it’s best to stick to private repositories so you don’t inadvertently post critical information such as passwords online.

To get started on Bitbucket, sign up for a free account. After confirming your account via email you’ll be sent a page to create a unique username for your Bitbucket Cloud.

Bitbucket unique username

Next we can start our first code repository. Click on the button for “Create repository” since we want to add our existing local code to Bitbucket.

Bitbucket create repo

Then on the “Create a new repository” page enter in the name of your repository: “hello-world”. Also–and this is important–click on the dropdown menu next to “Include a README” and select “No” rather than the default “Yes, with a tutorial (for beginners)” button. Then click the blue “Create repository” button:

Bitbucket new repo

Since we already have local code we want to add to Bitbucket, look at the instructions on the page for “Get your local Git repository on Bitbucket.”

Bitbucket repo homepage

We’re already in the directory for our repo so skip Step 1. In Step 2, we’ll use two commands to add our project to Bitbucket. Note that your command will differ from mine since you have a different username. The general format is the below where <USER> is your Bitbucket username. Mine happens to be wsvincent.

(helloworld) $ git remote add origin<USER>/hello-world.git

After running this command to configure git with this Bitbucket repository, we must “push” our code into it.

(helloworld) $ git push -u origin master

Now if you go back to your Bitbucket page and refresh it, you’ll see the code is now online!

Bitbucket overview

Since we’re done, go ahead and exit our virtual environment with the exit command.

(helloworld) $ exit

You should now see no parentheses on your command line, indicating the virtual environment is no longer active.


Congratulations! We’ve covered a lot of fundamental concepts in this chapter. We built our first Django application and learned about Django’s project/app structure. We started to learn about views, urls, and the internal web server. And we worked with git to track our changes and pushed our code into a private repo on Bitbucket.

Continue on to Chapter 3: Pages app where we’ll build and deploy a more complex Django application using templates and class-based views.

Buy the Book