+49 (0) 30 5201 4923
info@orb-experts.com
An intensive advanced course on developing professional QGIS extensions with Python and PyQGIS. Participants create robust plugins with graphical user interfaces, integrate databases and external Python libraries, and automate testing, versioning, and deployment.
You will deepen your knowledge of PyQGIS and set up a professional development environment for efficient plugin development. You will create custom extensions with Qt-based dialog windows, use QGIS-specific widgets, and manage user interactions through signals and slots.
You will also develop responsive applications with background processing, integrate libraries such as Pandas, NumPy, and SciPy, and access PostGIS databases through SQL. The course also covers server-side plugin development and professional approaches to testing, versioning, and deployment.
By the end of the course, you will be able to design, implement, test, and distribute independent QGIS plugins according to professional development standards.
• Set up a professional development environment for PyQGIS
• Develop custom QGIS plugins with Plugin Builder
• Create graphical user interfaces with Qt Designer
• Use QGIS widgets, signals, and slots
• Control user interactions and application states
• Move time-consuming calculations into background tasks
• Integrate external Python libraries into QGIS projects
• Use PostGIS databases and Spatial SQL from plugins
• Develop server-side QGIS extensions
• Create automated unit tests for plugins
• Build a custom plugin repository
• Version, package, and deploy plugins
• Confident fundamental knowledge of QGIS
• Basic Python programming knowledge
• Experience with layers, attribute tables, geoprocessing, and QGIS projects
• A basic understanding of object-oriented programming is helpful
• Previous experience with PyQGIS or the QGIS Python Console is beneficial
*We customize the course outline and content to your specific needs and relevant use cases.
Module 1: A Professional PyQGIS Development Environment
• Requirements for a structured QGIS development environment
• Understanding QGIS, Python, and PyQGIS versions
• Configuring PyCharm for PyQGIS development
• Setting up the Python interpreter, library paths, and environment variables
• Enabling code completion and type information
• Organising projects, source code, and resources clearly
• Identifying and resolving common configuration issues
Module 2: Remote Development with QGIS
• Separating the development environment from the running QGIS instance
• Benefits of a dedicated IDE for larger projects
• Synchronising code between development and plugin directories
• Preparing debugging and testing processes
• Creating portable paths and configurations
• Managing multiple development environments and QGIS versions
Module 3: Efficient Development with Plugin Reloader
• Reloading plugins during development
• Avoiding unnecessary QGIS restarts
• Testing changes to Python code and interfaces quickly
• Controlling plugin initialisation and clean-up
• Recognising problems caused by stale module states
• Automating and accelerating development cycles
Module 4: Structure and Architecture of a QGIS Plugin
• Structure and lifecycle of a QGIS plugin
• Metadata, entry points, and essential plugin files
• Understanding plugin classes and initialisation
• Integrating actions, menus, and toolbars
• Managing resources, icons, and translation files
• Separating business logic, interface code, and data access
• Developing maintainable structures for larger plugins
Module 5: Creating Plugins with Plugin Builder
• Installing and configuring Plugin Builder
• Selecting a suitable plugin template
• Generating the basic plugin structure
• Understanding generated files and classes
• Adjusting metadata and plugin properties
• Loading and testing the plugin in QGIS
• Extending generated structures for specific requirements
Module 6: User Interfaces with Qt Designer
• Fundamentals of Qt interface development
• Creating dialog windows and dock widgets
• Structuring forms with layouts
• Using buttons, input fields, lists, and tables
• Integrating resources and icons
• Loading interface files into Python
• Designing responsive and uncluttered dialogs
• Validating input and providing clear feedback
Module 7: QGIS-Specific Widgets
• Benefits of QGIS widgets over general Qt elements
• Using layer and field selection widgets
• Applying coordinate, file-path, and projection controls
• Managing map and database references through widgets
• Updating widgets dynamically from available layers
• Converting user input into QGIS-compatible parameters
• Developing forms with GIS-specific functionality
Module 8: Signals, Slots, and User Interaction
• Event-driven programming with Qt
• Connecting signals and slots
• Responding to buttons, selection changes, and text input
• Defining and emitting custom signals
• Processing user actions in a controlled manner
• Implementing dependencies between interface elements
• Displaying progress indicators, messages, and errors
• Avoiding unintended repeated execution
Module 9: Accessing QGIS Projects and Layers
• Accessing the current QGIS project through PyQGIS
• Finding, selecting, and adding layers
• Distinguishing vector and raster layers
• Examining data sources and layer properties
• Reading attribute fields and features
• Creating and changing selections
• Controlling editing sessions
• Saving or rolling back changes safely
Module 10: Geoprocessing in Custom Plugins
• Using the QGIS Processing Framework from Python
• Finding and calling algorithms
• Generating input parameters dynamically
• Managing temporary and permanent outputs
• Combining multiple algorithms into workflows
• Developing custom Processing algorithms
• Integrating geoprocessing into graphical plugin interfaces
• Evaluating messages and errors from processing tasks
Module 11: Plugin Architecture and Clean Code Structures
• Dividing responsibilities between components
• Understanding Model–View–Controller and comparable patterns
• Decoupling the interface from business logic
• Developing reusable classes and utility functions
• Managing configurations and settings
• Providing dependencies in a controlled way
• Integrating logging and traceable error messages
• Preparing code for testing and future extension
Module 12: Background Processing and Multithreading
• Effects of long-running calculations on the QGIS interface
• Moving operations into the background with QGIS Tasks
• Reporting progress and task status
• Cancelling processes and handling errors
• Returning results safely to the interface
• Considering thread safety and restrictions of the QGIS API
• Coordinating multiple tasks
• Identifying suitable applications for background processing
Module 13: Integrating External Python Libraries
• Applications of Pandas, NumPy, and SciPy in GIS projects
• Checking dependencies and Python environments
• Processing tabular data with Pandas
• Conducting numerical calculations with NumPy
• Using scientific functions from SciPy
• Transferring data between QGIS structures and external libraries
• Packaging libraries or documenting them as requirements
• Considering compatibility and licensing
Module 14: Introduction to PostGIS
• Purpose and benefits of spatial databases
• Structure of a PostgreSQL/PostGIS database
• Understanding spatial tables and geometry types
• Configuring database connections in QGIS
• Adding tables and views as layers
• Querying database information through PyQGIS
• Understanding transactions and multi-user access
Module 15: SQL Integration and Spatial SQL
• Running SQL queries from Python
• Using parameterised queries safely
• Filtering, aggregating, and updating attribute data
• Applying PostGIS spatial functions
• Calculating distances, buffers, and intersections
• Displaying the results of spatial SQL queries in QGIS
• Processing query results as layers or tables
• Controlling errors and transactions
Module 16: QGIS Server and Server-Side Extensions
• Purpose and architecture of QGIS Server
• Differences between desktop and server plugins
• Server-side processing without a graphical interface
• Understanding requests, responses, and filters
• Introduction to server-plugin entry points
• Extending web services and incoming requests
• Developing structured server-side logic
• Deploying server plugins in a suitable test environment
Module 17: Interfaces and Access Restrictions
• Providing custom functionality through server-side interfaces
• Reading and validating request parameters
• Producing structured responses
• Defining error codes and messages
• Checking user- and role-based access
• Considering authentication information
• Protecting data and functions from unauthorised access
• Logging security-related events
Module 18: Automated Testing
• Importance of automated testing for professional plugins
• Creating unit tests for business logic
• Structuring interfaces and data access for testability
• Initialising QGIS test environments
• Using test data and mock objects
• Testing successful, invalid, and boundary cases
• Running tests automatically
• Detecting breaking changes early
Module 19: Version Control and Collaborative Development
• Managing source code with Git
• Using sensible commit and branching strategies
• Marking releases and versions
• Documenting changes clearly
• Coordinating several developers
• Separating sensitive configuration from source code
• Identifying and resolving conflicts safely
Module 20: Creating a Custom Plugin Repository
• Understanding the structure of a QGIS plugin repository
• Packaging plugins correctly
• Maintaining metadata and version information
• Creating repository files and download structures
• Providing an internal plugin repository
• Configuring the repository in QGIS
• Publishing new plugin versions
• Organising access rights and internal distribution
Module 21: Deployment and Publication
• Conducting technical checks before publication
• Reviewing dependencies, resources, and metadata
• Documenting compatibility with supported QGIS versions
• Providing the plugin as a ZIP package
• Publishing updates and migration guidance
• Creating installation and user documentation
• Preparing issue-reporting and support processes
• Planning maintenance and future development
Module 22: Practical Project – A Professional QGIS Plugin
• Defining requirements for a custom plugin
• Setting up the development environment and project structure
• Creating the plugin foundation with Plugin Builder
• Developing a Qt-based user interface
• Integrating QGIS layers, Processing, or PostGIS
• Running a time-consuming task in the background
• Adding error handling and logging
• Creating unit tests
• Versioning, packaging, and distributing the plugin through a repository
Hands-on learning with expert instructors at your location for organizations.
Master new skills guided by experienced instructors from anywhere.
