Building a backend with Python

Internet of Things (IoT)

From GeoJSON to API: A Scalable Backend with Python, Docker, and PostGIS

A three-day course in which you’ll learn to build a Python backend that makes geodata accessible via an API. You’ll work with Docker, FastAPI, and PostgreSQL/PostGIS to develop, step by step, a self-hosted backend that stores GeoJSON data and makes it available via an API.

This course complements our courses on IoT, microcontrollers, and sensor data, but can also be taken as a standalone course. The input data is in GeoJSON format and can therefore come from a variety of sources: sensors, GIS systems, scripts, or external datasets.

Prerequisites: basic knowledge of Python.

Course duration: 3 days

Taught by:

Joram van der Vlist

Nederlands

Introduction to Python Backends and Modern API Architectures

Many modern geospatial applications consist of multiple components: sensors or datasets that provide data, a backend that processes and stores the data, and applications that use the data in maps, dashboards, or analyses.

The backend is the central component in this setup. This is where data is received, validated, stored, and made available via an API.

In this course, you’ll learn how to build such a backend yourself using Python and FastAPI, a modern framework specifically designed for building fast and scalable APIs.

We host the backend in Docker, making the application easy to run and deploy. This allows the backend to run consistently across different systems and environments.

The backend stores data in PostgreSQL with PostGIS, a widely used database for geodata. GeoJSON data is received via the API and stored as geometries in the database.

You will learn how a modern geodata architecture works:

GeoJSON → API → backend → database → application

The course complements our courses on IoT and microcontrollers, in which sensors collect data. In this backend course, we build the system that receives, stores, and makes that data available.

However, the course can also be taken independently. The GeoJSON data can come from sensors, scripts, GIS software, or external datasets.

Since the course lasts three days, the pace is relatively fast, and we focus on building a working backend architecture, not on in-depth DevOps or database administration.

What you’ll learn in this course

During this three-day course, you will learn how to develop a Python backend for processing and making geodata accessible.

Among other things, you will learn:

how a backend architecture for data applications works
how to use Docker to run a backend environment
how to build an API with FastAPI
how to receive and validate GeoJSON data
how to store geodata in PostgreSQL/PostGIS
how a backend communicates with other applications
how an API is structured and documented

By the end of the course, you will have developed a working backend that stores GeoJSON data in a PostGIS database via an API.

Why choose this course

Many programming courses cover individual topics such as Python, databases, or Docker. In this course, we combine these technologies into a single cohesive system.

You’ll learn not only how to write code, but also how to set up a modern backend architecture.

The course complements our courses on:

IoT and microcontrollers
sensor data and data collection
geo-data infrastructures

But it’s also suitable for anyone who wants to develop a backend for data or geo-applications.

Who is this course for

This course is intended for professionals and students who want to learn how to make data available to applications via a backend.

The course is suitable for:

GIS specialists
geo-data analysts
Python developers
data engineers
researchers who work with data applications

Basic knowledge of Python is required. No prior knowledge of Docker, FastAPI, or databases is necessary.

Enroll

€1795,- (VAT included)

Course duration: 3 days

Register for this course

Need help?

Contact us

Daily schedule

Day 1 — Setting up the backend environment

On the first day, we’ll set up the entire backend environment.

We’ll use Docker to create a development environment where the Python backend and database run together. This will teach you how modern applications are built from multiple services.

Day 1 Topics

Introduction to containerization
What is Docker and why do we use it
Working with Docker images and containers
Using Docker Compose for multiple services
Setting up a backend development environment
Introduction to PostgreSQL and PostGIS
Connecting the backend to the database

By the end of this day, you will have a working backend environment running Python and PostGIS in Docker.

Day 2 — Building an API with FastAPI

On the second day, we’ll build the Python backend ourselves.

We’ll use FastAPI to create an API that allows applications to send and retrieve data.

Topics for Day 2

Introduction to FastAPI
Structure of a Python backend
Building endpoints for an API
Working with request and response models
Data validation
Automatic API documentation
Testing API endpoints

By the end of this day, you will have a working API that can receive and return data.

Day 3 — Processing GeoJSON and Saving Data

On the final day, we’ll integrate all the components.

The backend receives GeoJSON data via the API and stores it in a PostGIS database.

Topics for Day 3

Working with GeoJSON in an API
Storing geodata in PostgreSQL/PostGIS
API endpoints for data storage
Retrieving data via the API
Testing the backend
Structure and expansion of a backend project

The final result of the course is a self-hosted Python backend that stores GeoJSON data in a PostGIS database via an API.

Leerdoelen

By the end of this course, you will be able to:

explain how a modern backend architecture with APIs, services, and databases is structured.
develop a REST API using Python and FastAPI.
define API endpoints and process and validate HTTP requests.
containerize and run an application with Docker.
Connect a backend to a PostgreSQL/PostGIS database.
Store, retrieve, and expose GeoJSON data via an API for use in GIS and web applications.

Want to know more?

Do you have questions about the course content? Or are you unsure whether the course aligns with your learning goals or preferences? Would you prefer an in-house or private course? We’d be happy to help.

Other courses

Building a backend with Python Internet of Things (IoT)

Certified
3 dagen

€1795,-

Building WebGIS Applications with Django Internet of Things (IoT)

Certified
3 dagen

€1795,-

From sensors to map Internet of Things (IoT)

Certified
2 dagen

€1195,-

Sensor Networks with Arduino ESP32 and Python Internet of Things (IoT)

Certified
2 dagen

€1195,-

Frequently Asked Questions About Building Backends with Python

FastAPI is a modern Python framework designed specifically for building fast and well-structured APIs. The framework uses Python type hints for automatic data validation and automatically generates interactive API documentation via OpenAPI and Swagger. This makes FastAPI highly suitable for developing data APIs and microservices. Compared to frameworks like Flask, FastAPI offers more built-in functionality for API development, while being lighter and simpler than a full-stack framework like Django.

Docker allows you to package applications along with all their dependencies into a container. As a result, the application runs the same way in any environment, regardless of the operating system or server configuration. This prevents common issues such as discrepancies between development, testing, and production environments. In addition, Docker makes it easy to run multiple services, such as a backend and a database, together in a controlled and reproducible environment.

Yes, as long as participants have a basic understanding of Python. During the course, the key concepts of backend development are explained step by step, such as API routes, HTTP requests, and database connections. Containerization with Docker is also covered from the ground up. This allows participants without prior backend experience to still develop a solid understanding of how modern API-based systems work.

The backend developed during the course can be used as a data service for various applications. Because the API can store and expose GeoJSON data via HTTP endpoints, it can, for example, be integrated with web maps, dashboards, mobile applications, or GIS systems. This allows the backend to serve as a central data hub for geographic data in applications such as monitoring platforms, smart city projects, or geodata analyses.

GeoJSON is a widely used format for exchanging geographic data via web APIs. On the backend, GeoJSON is typically first received via an API endpoint and then converted into a geometry object that can be stored in a PostGIS column. PostGIS supports various geometric types, such as points, lines, and polygons. By storing GeoJSON data in this way, the database can perform spatial queries, such as distance calculations, intersections, or area analyses.