Welcome by the organizers and the QGIS project, followed by practical information about the conference and its schedule.

This is a placeholder for now, we are in discusion with an interesting person

From today’s perspective, the word “map” sounds rather outdated and antiquated, and yet maps and map-related products are more present than ever before in our everyday lives. I’m thinking here about things such as interactive map apps and navigation systems. In view of the global situation and the trend towards simply renaming places at liberty, I believe it is worthwhile pausing briefly and asking ourselves what actually constitutes a map.

This presentation introduces a reproducible QGIS-based workflow designed to address a key challenge in archaeological landscape studies: the analysis of urban organisation in contexts where large-scale excavation is limited or absent. By integrating LiDAR-derived digital elevation models (DEMs) with advanced terrain analysis techniques, the workflow provides a structured approach for extracting spatial patterns from surface morphology alone.
Developed entirely within an open-source QGIS environment, the workflow combines relief visualisation methods (local relief model, sky-view factor, openness), anisotropic least-cost path modelling, and viewshed analysis into a sequential and interoperable analytical process. Rather than applying these methods in isolation, the approach emphasises their integration, enabling the transition from micro-topographic detection to the modelling of movement corridors, visibility patterns, and spatial organisation.
The workflow is demonstrated using a high-resolution UAV-based LiDAR dataset from the ancient city of Parion (Çanakkale, Türkiye), where modern settlement and the limited extent of excavation constrain traditional archaeological interpretation. The approach demonstrates that the integrated use of terrain-based analyses can reveal structured spatial relationships, including movement corridors and visual thresholds. In particular, the results enable the identification of potential city gates, segments of the city’s defensive wall system, the boundaries of funerary landscapes, and the principal urban axes of the Roman city, including the decumanus and cardo. These findings offer a viable framework for interpreting archaeological urban organisation prior to extensive and potentially invasive archaeological excavations.
The primary contribution of this study lies in the design of a transferable and reproducible workflow that can be directly implemented by QGIS users working with DEM data. Furthermore, it contributes to the community by demonstrating how complex terrain analyses can be operationalised within a single platform, moving beyond isolated tool use toward integrated workflow design. By explicitly structuring the analytical sequence, defining parameter choices, and relying exclusively on open-source tools, the approach supports transparency and adaptability across different research contexts. It can be applicable not only to archaeological prospection, but also to environmental modelling, landscape planning, and other domains requiring multi-scalar terrain analysis.

QGIS has long supported coordinate reference systems for bodies other than Earth, but until recently the practical experience of working with planetary data was limited by a number of issues related to use of non-Earth CRS. This talk covers the improvements that arrived with QGIS 4.2, making QGIS a more capable platform for planetary science and non-Earth spatial work.

The changes introduced by this work touch several key parts of QGIS: loading non-Earth data as the project's first dataset, available tools in QGIS, scale calculation and measurements on non-Earth data. The work also included a relatively small fix for QGIS server allowing it to publish WMS service properly for non-Earth data, without defaulting to use WGS 84 improperly.

Hydrodynamic and morphodynamic modeling in the littoral zone remains a key goal of coastal researchers and engineers: recurring needs include understanding past extreme wave, current, and storm surge events; simulating how new construction will impact the coast; and investigating how the shoreline will respond under Sea Level Rise (SLR) scenarios. The free and open source XBeach model from Deltares (https://www.deltares.nl/en/software-and-data/products/xbeach) represents an obvious gateway to the world of coastal hazard numerical modeling, validated through a growing archive of peer-reviewed studies. Still, initial model creation and setup can pose a barrier to entry with a fairly steep learning curve. While many excellent software solutions exist to aid model generation, limitations can include Operating System (OS) specificity, proprietary licenses, or required programming skills. Enter QBeach: this initiative aims to collect existing Python tools into a familiar QGIS (https://qgis.org/) plugin designed to set up XBeach models, impose boundary conditions, generate basic files needed for models to run, and quickly visualize model outputs. The OS agnostic QGIS serves as a near perfect ecosystem to host such a tool with its wide adoption in the scientific community, Graphical User Interface (GUI) accessible through PyQt, and integrated Python scripting. Further, XBeach users likely already rely upon QGIS to assemble model inputs such as bathymetry and topography raster data from various sources. As of April 2026, a rough QBeach prototype lives on Github (https://github.com/JTMelly/QBeach) that, ideally, will be added to the QGIS plugins repository pending further testing, debugging, and usage documentation. The present version (0.1) interpolates bathymetry data to an XBeach model grid; generates input parameter, tide, and wave boundary condition files; and provides basic visualization of NetCDF output files resulting from XBeach model runs. The roadmap for additional features includes treatment of irregular grids, bed roughness coefficients, sediment grain sizes, non-erodible surfaces, and further model output diagnostics. This presentation addresses themes of collaboration on tools to address persistent research questions, Artificial Intelligence (AI) augmenting human programming skills, and free and open source software development.

This is a special moment in the evolution of QGIS. Version 4.0 was released earlier this spring and shortly version 4 will become the next long-term release. It’s been 7 years since we’ve had a new major version of QGIS!
This talk will focus on what users can expect when they upgrade to QGIS 4.x. There were also quite a few notable features released with the last QGIS 3.x release – QGIS 3.44 Solothurn. This talk will include features from 3.44 as they will be new to anyone migrating from the last LTR (3.40 Bratislava).

Each highlighted feature will not simply be described but will be demonstrated with real data. If you want to learn about the latest features in QGIS, this talk is for you!

Likely topics include GUI enhancements * Symbology * Annotations * Point cloud support * Data Providers * Processing * Model builder * 3D * Vector editing * Print compositions

The narrative that the desktop is dying resurfaces regularly – yet the same industry pushing SaaS centralisation is quietly rediscovering local hardware as an "edge node" for computationally expensive AI workloads. This contradiction is worth unpacking: it reveals that the question is not desktop vs. cloud, but rather who controls the compute and for whose benefit.

This talk makes the case for QGIS as a first-class architectural component in modern geodata infrastructure. Using a structured SWOT analysis, it compares QGIS against representative cloud-based GIS platforms across four dimensions: processing performance on large vector and raster datasets, extensibility through the plugin ecosystem, deployment and maintenance overhead, and strategic dependency risk (vendor lock-in, licensing, data sovereignty).

Concrete examples ground the analysis: local processing benchmarks for typical geoprocessing workflows (topology validation, large-scale raster analysis), a comparison of customisation depth between QGIS plugins and SaaS extension models, and two deployment patterns that address common IT administration concerns – managed QGIS profiles and MDM-based rollout.

The talk closes with a practical framing for hybrid architectures: where cloud services add genuine value, and where local compute is not a legacy compromise but the technically and strategically correct choice.

Key Takeaways
- The edge-computing trend inadvertently vindicates the local GIS client – and organisations should exploit this rather than defend against it.
- QGIS's plugin ecosystem enables domain-specific innovation that closed SaaS platforms structurally cannot replicate.
- Efficient desktop deployment is a solved problem; the administrative objections are manageable and concrete mitigations exist.

Pollinators, particularly bees, play a critical role in maintaining biodiversity and supporting agricultural productivity. However, in many regions of Africa, including Rwanda, there is a significant lack of spatial data on bee diversity, distribution, and habitat conditions. This limits the ability to design effective conservation strategies and monitor pollinator populations.

This presentation demonstrates how QGIS is being applied as a practical and accessible tool to support field-based ecological research on bee diversity in Rwanda. The project integrates field data collection, including species observations, habitat characteristics, and GPS coordinates, with geospatial analysis to produce distribution maps and identify key pollinator habitats across different ecosystems such as wetlands, forests, and agricultural landscapes.

The workflow highlights the use of QGIS for data visualization, mapping species occurrence, and analyzing habitat pressures. It also explores how open-source GIS tools can support conservation planning, especially in resource-limited contexts. Challenges encountered during field data integration and mapping are discussed, along with opportunities for improving data quality and scaling up the approach.

This talk is aimed at end users and early-stage practitioners interested in applying QGIS to biodiversity conservation, and it demonstrates how geospatial tools can bridge the gap between field research and actionable environmental management.

At 3Liz, for our internal needs, for our clients, and for deploying QGIS Server plugins on our Lizmap hosting infrastructure, we used a file server, XML files listing the available plugins, and qgis-plugin-manager.

qgis-plugin-manager is a command-line tool for managing installed QGIS plugins. Designed primarily for managing QGIS Server extensions, it also works with QGIS Desktop extensions.

Although functional, the file server and simple XML files for plugin deployment no longer met our needs.
We therefore developed a QGIS plugin deployment server without a user interface to deploy our plugins: the YAPT server. This plugin server features a simple REST API for retrieving the list of available plugins (QGIS-compatible) and for pushing a QGIS plugin archive:
* GET /plugins.xml?qgis=version
* &all=true - to get all available versions
* &pre=true - to get unstable versions
* &tags= - to filter by tag with values separated by comma
* &server=true - to filter only server plugins
* &deprecated=true - to get deprecated plugins
* POST /plugins/?status=[stable|unstable]

We have therefore also developed a plugin packaging tool that uses the YAPT server API: the YAPT package.

Finally, we have also developed a command-line tool that uses the YAPT server API: the YAPT Manager.

All of these developments were built using Rust and are available under an open-source license.

This presentation provides an opportunity to introduce all of these tools to the QGIS community.

Sometimes QGIS is missing a tool or two needed for your own workflows or project-specific capabilities. QGIS plugins can fill that gap: they let you automate repetitive tasks, extend QGIS with entirely new functionality, tailor the interface to your needs, and integrate external data sources — making them one of the most versatile ways to get more out of QGIS. Using Python, you can write these custom extensions yourself. In this workshop, participants will build their own QGIS plugin from scratch and learn the fundamentals of plugin development.

We will start by exploring how to interact with the QGIS API using Python (the PyQGIS library), including how to access layers, trigger actions, and interact with the user interface programatically. From there, we will walk through the core structure of a QGIS plugin and set up a minimal working plugin.

Next, we will convert an existing PyQGIS script into a plugin, then extend it with a basic dialog created in Qt Designer. Along the way, we will discuss practical development patterns such as organizing plugin code, handling user input, and debugging. By the end of the session, participants will have a working plugin they can further adapt for their own projects.

Participants should have basic knowledge of Python and QGIS. Some prior experience with PyQGIS is helpful, though the essential PyQGIS fundamentals will also be briefly introduced.

Imagine sailing in the middle of the Baltic Sea:
What happens when the GNSS signal drops, the chart plotter freezes, or you simply want to practice the art of traditional seamanship without the inaccuracies of a blunt pencil?
In the world of modern offshore sailing, we have become dangerously dependent on a blue dot on our screens. But true navigation starts when the electronics fail.
In the era of ubiquitous GNSS availability, traditional terrestrial navigation is often regarded as a relic of the past. However, recent increases in signal interference, jamming, and the inherent risks of electronic single-points-of-failure have renewed interest in "back-to-basics" navigation. While the methods of the 18th century remain valid, their manual execution on paper charts introduces significant "human error"—where a mere 0.5mm pencil line can represent a 25-meter deviation in reality.
This presentation introduces a specialized, "seaworthy" QGIS plugin designed to digitize and refine the process of nautical position fixing. The tool allows mariners to perform traditional cross bearings and dead reckoning with the geometric precision of a GIS, effectively eliminating the mechanical inaccuracies of manual plotting.

Laax is where QField was born. It's only fitting that we come home to show you what it's grown into.

This session runs through the latest features at full speed: on-the-fly project creation so you can go from zero to field-ready in seconds, COGO tools for precise coordinate geometry straight on your device, NTRIP support for centimeter-level accuracy with your RTK setup, and full 3D data collection and visualization.

No slides full of roadmaps. Just features, live.

Expressions are one of QGIS's key features and a major pillar of its success. Powerful, flexible, and available almost everywhere in the interface, they allow for complete customization of any QGIS project, regardless of the desired level of complexity. Expressions provide a unified language that opens the door to increasingly creative and efficient uses, and are enriched with new features in each new version of QGIS.

This workshop will provide an opportunity to gain a thorough understanding of this language, starting with its fundamentals—expression structure, operators, and essential functions—and gradually progressing to more advanced uses such as conditional expressions, geometry generation, and variable manipulation.

We will cover the use of expressions in several parts of a QGIS project:
• Customizing labels
• Defining dynamic symbologies
• Configuring elements in layouts
• Creating dynamic feature forms
• Advanced use in the field calculator
• Filtering and selecting features (layer filters, expression selection, dynamic subsets)
• Geoprocessing
• etc.

Through concrete examples, participants will learn to fully leverage the potential of expressions. The workshop also aims to be a forum for discussion: everyone will be able to share their ideas, challenges, needs, and tips, contributing to a collective reflection on best practices and the future development of this essential language in QGIS.

Introduction

The QGIS ecosystem offers powerful capabilities for building domain-specific geospatial workflows through plugins and customized projects. However, in professional environments, these workflows rarely rely on a single component. Instead, they typically combine a database schema, configured QGIS projects, and one or more custom plugins. Ensuring that all these elements are consistently deployed and maintained across users and systems remains a major challenge.

Solution

This talk introduces oQtopus as a solution to this problem. For users, oQtopus is a QGIS plugin designed to deploy domain-specific modules that encapsulate not only plugins, but also associated resources such as project configurations and database-related components. Through a centralized and automated approach, users can install and update entire modules with minimal effort, ensuring that all elements remain synchronized.
From a technical perspective, oQtopus relies on a modular architecture in which each package represents a consistent deployment unit. These packages include versioned plugin code, QGIS project files, and conventions for integrating with PostgreSQL schemas and roles. This approach guarantees reproducibility, simplifies maintenance, and allows administrators to retain control over versioning and distribution.

Example with TEKSI

TEKSI is a Swiss community providing open-source modules for public infrastructure management (e.g. wastewater, water supply, and district heating). Within TEKSI, modules are based on three core components: a PostgreSQL data model with predefined roles and permissions, a preconfigured QGIS editing project with translations, and a domain-specific QGIS plugin. Together, these elements form a coherent and reproducible working environment.
However, the TEKSI community faces challenges in distributing reliable stacks, while users struggle to keep their systems up to date and to test upcoming releases. Building on over fifteen years of experience, TEKSI initiated the development of the TEKSI Management Module Tool (TMMT), a dedicated branding of oQtopus.
With TMMT, service providers significantly reduce installation and maintenance time: tasks that previously required half a day can now be completed in 15 to 30 minutes. This also accelerates testing and integration of new developments, reducing overall costs and improving the professional quality of TEKSI deployments.

Conclusion

Although initially developed for TEKSI, this architecture is not domain-specific. It can be applied to any organization relying on database-backed workflows, customized QGIS projects, and internal plugins. Public administrations, engineering firms, and research institutions can use oQtopus to distribute standardized environments, enforce data models, and streamline onboarding.
By presenting both the conceptual architecture and practical implementation of oQtopus, this talk demonstrates how integrating database design, project configuration, and plugin management into a unified deployment strategy improves consistency, scalability, and user experience. Attendees will gain practical insights into managing complete geospatial application stacks within QGIS. Ultimately, oQtopus provides not only a tool, but a reusable framework for building more robust and maintainable QGIS-based solutions.

While working in the municipal government of Tijuana, we conducted a study integrating direct data on the spatial distribution of crime with the city’s urban conditions. By georeferencing five years of case referrals to the Public Prosecutor’s Office, we analyzed environmental, social, and urban factors in high- and low-incidence areas, establishing spatial correlations with crime. Results highlight the direct impact of urban infrastructure, urban land-use issues, certain commercial activities, and social and environmental factors on crime distribution. Additionally, we quantified the minimum public lighting required to significantly reduce nighttime crime, confirming the interrelation between criminal incidence and the urban environment.

The Federal Office of Topography swisstopo has long operated the standard services wms/wmts.geo.admin.ch, where both Swisstopo’s own datasets and around 900 thematic geodatasets from other federal agencies are published. As a supplementary service for internal administrative access by intranet using (Q)GIS clients, Swisstopo operates a PostGIS database containing vector data. This database offers a subset of the datasets from geo.admin.ch, with the difference that they are available in their original vector data structure and accuracy, ready for individual analysis, visualisation and use in GIS. This presentation describes the access options available to users within the federal administration, the system architecture and the tools used in operation, as well as some operational experiences.

In an ideal world, any new feature or bug fix in a QGIS plugin is instantly available to all users of the plugin - of course after having passed the quality checks that the testing framework of the plugin put into place.

In reality, publishing a plugin can be a rather manual and stressful process, but it doesn't have to be. In this talk, we will showcase what is needed to publish a plugin and how this is done manually, and how to automate plugin publication using the QGIS Plugin CI - from the commandline as well as using the CI frameworks of GitHub and GitLab.

AI coding assistants are easy to overhype. In practice, the interesting question is much narrower: where do agentic coding tools actually help when building and maintaining a real QGIS plugin?

This talk presents lessons from developing qfit, a QGIS plugin for importing, analysing, and publishing personal fitness activity data, using OpenClaw as an agentic coding environment. Rather than treating AI as a magic code generator, I will focus on practical workflows: breaking work into small reviewable changes, using agents to explore code, draft implementations, refactor modules, and strengthen tests, while keeping a human firmly responsible for architecture, validation, and release quality.

I will share what worked well, where the approach failed or created extra review burden, and which guardrails mattered most, especially around testing, CI, code review, and incremental design in a PyQGIS codebase. Attendees will leave with concrete patterns for using agentic coding in QGIS plugin development without lowering engineering standards.

This session is aimed at developers and technical QGIS users who are curious about AI-assisted plugin development but want concrete practices rather than hype.

Mergin Maps has grown a lot over the past year. It is no longer just a simple data collection app. In this talk, we will look at the new features in the 2025/26 release. We will cover updates to the mobile app, the QGIS plugin, the server, and our developer tools.
First, we look at high-precision surveying. If you use external GNSS receivers, you will see how the app now handles orthometric heights and geoid separation. We also added support for more Bluetooth devices.
Next, we will show two highly requested features: map sketching and photo sketching. Field workers can now draw freehand directly on the map. They can also draw on photos with color codes. This helps them record exactly what they see on site.
On the server side, we are introducing "Share Maps via URL" and Single Sign-On (SSO) for Enterprise users. We also completely rewrote the sync process in the QGIS plugin and Python API. If you have ever seen timeout errors during bulk uploads or when multiple people sync at the same time, we will explain how the new system fixes this.
Finally, we look at new form features. You can now use HTML and conditional fields. You set these up directly in QGIS, without needing any extra plugins.
Whether you set up projects for field teams or write code using our API, this talk will help you get the most out of Mergin Maps this year.

Geotest AG, an engineering and environmental consultancy with over 200 employees, has been transitioning from Esri ArcMap to a fully open‑source GIS environment built around QGIS. This shift enhances flexibility, reduces licensing dependencies, and enables consistent geodata workflows across the organization.

We deploy QGIS LTR over our enterprise portal using centrally managed profiles that provide predefined settings, templates, and resources. To handle the heterogeneity of cantonal and federal datasets, we maintain curated QLR files and WMS/WFS catalogues for reliable, uniform access to authoritative data. Efficiency is further supported through custom plugins, tailored processing scripts, and automated workflows.

Knowledge sharing is anchored by our internal geo-documentation platform, built on Read the Docs, where tutorials, standards, and best practices are continuously maintained. Combined with our service desk system, a network of power users, and regular half-day user sessions, we ensure scalable and sustainable user support. Our development work relies on Gitea for version control and collaborative enhancement of our QGIS tools.

The shift from the Esri ecosystem to QGIS required significant in‑depth expertise and a geoinformatics team with strong open‑source knowledge. It also demanded a company‑wide willingness to invest in people whose work does not always show an immediate return, but is essential for long‑term stability and innovation.

The QGIS Brazil community has undergone a significant transformation, evolving from a localization-oriented group into a strategic contributor within the global ecosystem. This session analyzes the community’s growth trajectory, illustrating how localized software, documentation, and robust user-support networks acted as catalysts for widespread professional adoption across Brazil.
A pivotal milestone in this journey was the QGIS LATAM 2024 conference, which unified regional efforts and strengthened integration with global QGIS.org structures. This organizational maturity culminates in the 2026 release of QGIS 4.2 LTR "Belém do Pará," a version that serves as both a technical tribute to the community’s contributions and a legacy of hosting major FOSS4G events. The presentation discusses governance models for coordinating thousands of users, strategies for long-term engagement, and the impact of regional LTR naming on the visibility of Latin American geospatial expertise. It provides a blueprint for regional groups transitioning from software consumption to active, strategic contribution.

At the National Land Survey of Finland, a new QGIS-based topographic data production system was introduced last year. The system includes quality assurance tools that enable users to verify the logical consistency of topographic data.

The tools support validation of attribute value domains, geometric consistency, and the correctness of topological relationships among maintained features. Detected quality errors are listed in a QGIS panel and visualized in the map view.

To assess topological consistency, nearly 20 different topological rules have been defined. The rules are applied to relevant pairs formed from approximately 100 different feature classes (points, lines, and polygons), resulting in about 8,000 distinct rule evaluations. Quality checks are performed directly in the PostGIS database whenever edits made in QGIS are saved, and the results are presented to users almost in real time.

In this presentation, I will introduce the operating principles of the quality assurance tool, the adopted custom-made topological rule set, and demonstrate how these rules support the maintenance of topographic data.

The temporal controller is one of the most overlooked aspects of QGIS, yet it acts as a true timeline addition to your QGIS projects. This timeline opens up a new dimension “t” for visualizing data.

Throughout various studies, I've experimented with spatial data and its temporal dimension, then moved beyond strictly temporal data to also enhance methodologies with animations, before finally using the controller to blur the lines between art and geography. This presentation aims to synthesize these experiences all wrapped in pretty cartography

This presentation will break down how the temporal controller, geometry generators, QGIS expressions, and a touch of Python code can be used to create the following animations:

• https://youtu.be/VqZFsCQ5UJ4
• https://youtu.be/R6kVB-uChUg
• As well as other original variations

While not a detailed tutorial, this presentation serves as an introduction to the concepts of animation applied to GIS: keyframing, the different types of interpolations, and several tips and tricks to make an animation more dynamic.

The goal of this presentation is to provide you with the tools to transform QGIS into a veritable mini-video editing software specializing in GIS and add a new dynamic dimension to your projects..

Finally, we will discuss what lessons can be learned from this artistic experiment, from several perspectives.

• As a cartographer/researcher: How do we move from a static GIS to a dynamic GIS capable of conveying a story? How do we make a methodology accessible to a wider audience?

• As an artist-geographer: How do art and GIS mutually fuel each other and push QGIS to its limits?

• As a QGIS developer: Despite QGIS's obvious strengths, practical experience reveals several limitations to make it a credible alternative to proprietary animation software like Adobe After Effects and GEOlayers. What are these limitations, and how can we overcome them in the near future?

Do you finally want to understand what relations and references mean in QGIS and how to work with them?
In this workshop we will give an introduction to the different forms of simple and complex data relationships. We will look at how they are managed in QGIS and how they can be configured and edited in the attribute form with different widgets. We will also take a closer look at cardinalities and relationship strengths.

What you need to rock with us:
+ Current QGIS LTR or later
+ The data below

Lizmap Web Client is an open-source software allowing to publish web map applications based on QGIS projects.
All layers managed in QGIS can be visualized in Lizmap, and vector layers can also contain information that is worth displaying using charts: bar charts, line graphs, pie charts and tables.

The aim of this workshop is to demonstrate how to create and display plots in the Lizmap interface using vector data (PostgreSQL, FGB, CSV, etc.).

A project with ready-made data will be provided to the participants. We will use weather data from the website https://open-meteo.com/ (Free and open-source weather API).

You can view an example of how Lizmap can display graphs at this address:
https://demo.lizmap.com/lizmap/index.php/view/map?repository=features&project=land_use
In this demo, you can for example select another layer in the left panel (such as "
Postes clés") to see other charts, or choose a municipality in the combo box "Localisation" (top right of the map) to filter the visible charts for a specific municipality.

Workshop schedule:

• Get the QGIS project and publish the first map
• Presentation of the data (municipalities, weather)
• The main principles of data visualisation in Lizmap
• The different types of charts available (bar, pie, polar, histogram, HTML, etc.)
• Creating and publishing charts on the web map
• Filtering charts dynamically
• Viewing filtered charts for the queried feature
• Organizing charts with tabs and groups
• HTML charts for greater flexibility
• Printing using the server-side Dataplotly plugin

On GIS projects it is often required to populate certain fields in various layers automatically with data, either from current values, like date and time or user, or fields from other layers, including online and cloud resources. These fields can be populated with some of the processing tools, especially, when a large number of rows need to be updated, or with the expression builder when a new record is added or an existing one updated. Both processes can involve simple calculations, like additions, subtractions, multiplications, divisions or any other mathematical formulas, or complex (spatial) queries of data in other layers or online and cloud resources like digital elevation models or WMS/WMTS, WFS, REST layers hosted on the Internet. While it might be quite easy to automatically update a date field with the integrated “now” function, or a text field with the Plus Code, or a field for the current user with the QGIS variables, it is not a lot more difficult to share data between joined layers, although joins in large QGIS projects could become quite slow. A bit more challenging automated field updates can become between related layers and spatially overlapping or nearby layers, but querying WMS or other online layers can have their own challenges altogether. In some cases database triggers are the most effective way of dealing with field updates, but these need to be configured depending on the database used.

This presentation will provide a short overview of what is possible and demonstrate live field updates directly in QGIS using complex attribute forms and several layers related to each other. The querying of online layers (WMS, WFS and cloud-based DEM) will also be shown and the use of triggers for updating fields explained.

At FOSS4G Europe 2025 in Mostar, a group of teaching enthusiasts from around the world began exploring how to strengthen collaboration among educators in Open‑Source GIS. This presentation introduces the QGIS Trainer Network, a new initiative designed to exchange knowledge, teaching materials, and best practices among QGIS trainers globally.

The network emerged from ongoing conversations revealing the need for shared guidelines and resources in open‑source GIS education. Questions such as “What should be part of a basic GIS course?” and “Which software stacks and file types should be taught?” inspired a community survey distributed across educational institutions and public administrations.

In this session, we will present the survey results, outline the network’s goals, and invite participants to join the growing community of QGIS trainers. The presentation will highlight how the network fosters collaboration, supports curriculum development, and strengthens the global capacity for open‑source geospatial education.

Large organizations have numerous users and a multitude of applications to deploy, update, maintain and adapt. Be it in public organizations or private key accounts, IT services face challenges when deploying applications to large amount of users.

Since QGIS has a wide area of use cases and user typology, it can be complicated to conjugate industrial deployment in an urbanized IT infrastructure, and adaptation of the software to user's needs.

In this presentation, we first detail the challenges faced by large organizations wanting to deploy QGIS for numerous users.

Then we present a strategy to combine efficient automated deployment and configuration management to adapt installed QGIS versions to specific users needs.

This strategy comes with specific opensource tools easing deployments, and incorporated into the toolset of system administrators, especially on windows platforms.

We then talk about future needs and improvements to these tools.

This talk presents practical workflows for using Mergin Maps to support bird monitoring in field conditions. It is aimed at beginner/intermediate users, who want to find new solutions for existing data collection issues or more structured and efficient workflows.
Drawing on real-world use cases, the presentation will demonstrate how Mergin Maps is used for nest monitoring, bird sighting data collection, and maintenance of acoustic monitoring stations. The focus will be on how to design field-ready data collection forms in QGIS, synchronize data between devices and desktop environments, ensure consistency across field teams, and create data-driven visualizations that highlight key information to support planning and decision-making in the field.
The session will highlight lessons learned from deploying these workflows in practice, focusing on how we addressed specific challenges through practical solutions. Attendees will see concrete examples they can adapt to their own ecological or conservation projects.

The National Land Survey of Finland has previously modernized its topographic data management system by developing a QGIS based solution. The next step is to produce cartographic products using QGIS as well. For this purpose, an efficient and flexible method for defining product versions has been developed in collaboration with Gispo, using YAML configuration files and a new plugin.

The map products of the National Land Survey of Finland include the topographic map, background map, and plain map. Each map product is produced at multiple scales, ranging from 1:10 000 to 1:8 million. The topographic map also has separate versions for print and web use.

The YAML files define the data sources used by each product version, the layer order, and one or more cartographic styles for each layer. Using a newly developed QGIS plugin, a QGIS project is automatically generated from the YAML configuration, allowing cartographic styles to be easily edited through the graphical user interface.

Finally, all style changes are exported to version control through a controlled workflow. When the cartographer submits style changes, a CI/CD pipeline automatically builds the QGIS projects for the map products using the newest changes. At a later stage, the maps will be published as web services using QGIS Server.

This presentation demonstrates how QGIS can be extended into a full featured platform for national map production. By showcasing a configuration driven workflow and a custom QGIS plugin, the talk offers practical ideas for improving maintainability, reproducibility, and collaboration in map production. The concepts presented are applicable well beyond national mapping agencies and will be valuable to anyone facing complex cartographic workflows.

Beyond Atlas: Automating Map Production with PyQGIS

Map production is still often a manual step at the end of a GIS analysis workflow. QGIS Atlas and expressions provide powerful tools to automate the printing process. However, there are limits to this approach, for instance when more advanced, data-driven customization is required. This is where we can benefit from using Python and the PyQGIS API to automate printing tasks in QGIS.

We will start with a brief recap of QGIS printing layouts and the Atlas feature. Then, we will explore how to use PyQGIS and QGIS print layout templates to automate the printing process. Using structured data (e.g. from a database or a CSV file), we can configure layouts and run batch printing jobs with a single script.

The session includes a live demo in the QGIS Python console, along with an outline of how to write code that loads different print templates, accesses layout items via their IDs, dynamically modifies content, configures print jobs, and exports maps.

The talk concludes with a discussion of when a PyQGIS based printing approach is preferable to the Atlas feature, and how it can be integrated into a QGIS workflow.

Biodiversity Net Gain (BNG) is a pioneering environmental planning approach that requires development projects in the UK to leave biodiversity in a measurably better state than before development commenced. Introduced in 2021, BNG requires most developments to deliver a minimum 10% increase in biodiversity value, calculated using Natural England’s Statutory Biodiversity Metric.

The legislation represents a significant shift in how ecological impacts are assessed and mitigated within the planning process, moving beyond traditional impact avoidance towards measurable ecological enhancement. The biodiversity metric is gaining attention worldwide, and is helping countries around the globe adopt a measurable, transparent approach to biodiversity restoration.

To conduct a BNG assessment ecologists must undertake detailed habitat surveys, assess current habitat condition, map proposed (post-development) habitats from (landscape) architect CAD plans, and calculate change in biodiversity ‘units’. The process requires robust GIS workflows.

This presentation will provide a practical case study of how QGIS can support efficient, accurate, standardised, and scalable workflows for delivering BNG analysis. It will explore some of the principal technical challenges involved in conducting BNG analyses. It will also explore the suite of tools (including QGIS forms and models), video training courses, and QGIS workflows developed by Maplango/Spatialsesh to support ecologists. Attention will be given to the role of Qfield/Mergin Maps in streamlining ecological survey workflows, reducing duplication, and improving data quality between field and office environments.

By demonstrating how open-source GIS technologies can be configured to deliver complex regulatory ecological workflows, this session will highlight the growing role of QGIS as a professional platform for biodiversity assessment and environmental planning in both national and international contexts.

Enterprise GIS is an organization-wide suite of interoperable GIS software used to manage and process geospatial information. PostGIS, QGIS and QField are often baseline softwares for Enterprise GIS solutions. This presentation will cover best practices to build Enterprise GIS databases for QGIS and QField usage.

Enterprise GIS is always following the basic principles of enterprise software architecture. Its structure is based on three distinct layers: the User Interface, the Application Server, and Data Storage. This presentation will focus on how to build a robust and efficient Data Storage layer with PostGIS database.

Modern Enterprise GIS is nowadays built with FOSS4G softwares. Many organizations are in the middle of transition to build EntrepriseGIS and some organizations are still planning to move from old fashioned closed source software implementations to open source solutions. FOSS4G based Enterprise GIS is commonly built with PostGIS based GIS database, QGIS desktop software, mobile applications (like QField) and web applications servers (like QGIS Server). The most crucial and enduring component of an Enterprise GIS solution is the database. This presentation will cover how to design, build and maintain a GIS database for Enterprise usage.

This presentation will cover the following topics:
- GIS database design and modelling with open source solutions
- Best practices for GIS data modelling and versioning of data models
- Organise and manage the Enterprise GIS database in PostgreSQL cluster
- Best practices for access privileges in Enterprise GIS database
- QGIS and QField related data storage to PostGIS
- Manage database connections and credentials in QGIS

This presentation is essential for GIS database managers, GIS managers, and all users of Enterprise GIS solutions. Attendees will be equipped with the fundamental knowledge and practical best practices — including valuable tips-and-tricks — required to effectively build and maintain a robust Enterprise GIS database.

Strong open source projects do not happen by accident. They are built through sustained effort, shared ownership, and a community of people who understand the power of GIS tools and care about making software like QGIS accessible, reliable, and useful for everyone.
In this talk, we introduce the people behind one part of that work: the documentation team and the project administrative assistant. The documentation team currently includes two full-time writers, and this year QGIS welcomed a new colleague, an administrative assistant supporting the QGIS Project Steering Committee and the wider project. Having dedicated, funded roles like these is still quite new for open source projects, and we see it as an important step toward long-term sustainability. We want to introduce ourselves and share what this work really looks like.
We will walk through our documentation review: what we audited, what we improved, what we rewrote, and what we learned along the way. This includes pull requests and community contributions, new and reworked content sections, progress on translations that bring QGIS closer to more communities worldwide, and workflow improvements that make contributing to documentation easier for everyone.
We will also talk honestly about what full-time open source work feels like in practice - collaborative and rewarding, but also full of real challenges. Keeping pace with a fast-moving codebase, deciding what to prioritise, supporting community contributors, and building a team culture within a volunteer-rooted project all take more effort than they might appear from the outside.
Finally, we will look ahead: expanding coverage, improving the experience for new contributors, strengthening the connection between development and documentation cycles, and making the annual review reports a lasting and useful practice.
If you use QGIS, contribute to it, or are simply curious about what it takes to keep a large open source project well documented and welcoming, this talk is for you.

Geospatial data is an important yet underutilised resource in municipal crisis management. Swedish municipalities face increasing pressure on emergency preparedness due to geopolitical instability and more frequent extreme weather events, while routines and levels of expertise vary widely. In addition, organisational gaps between crisis management functions and geodata departments often lead to fragmented solutions and limited regional situational awareness.

To address these challenges, a collaboration project involving all 26 municipalities in Stockholm County was launched in February 2026. The project aims to develop “KrisGIS paketet”, a QGIS based package that strengthens municipalities’ ability to use geospatial data during crises. The solution includes standardised datasets, symbology, print layouts, workflows, manuals and checklists, and will be ready to use for all municipalities in the County.

The use of QGIS as a common open-source platform has been a crucial decision to provide a method available for everyone while monitoring issues concerning digital sovereignty. Beyond the technical solution, the project seeks to educate through inter municipal exercises and prepare for long term governance and maintenance. Through standardising workflows, routines and data, the project promotes a coordinated and data driven municipal crisis management in Stockholm County.

In this talk, we’ll look at what makes QGIS-Server-Light different and why this might be of interest to you.
We’ll also examine the technical ideas in more detail and see how this approach prioritises scalability and robustness. Proved and explained by numbers and charts.

QGIS-Server-Light is a lightweight Python runtime that processes a queue as a worker. This makes runtime debugging a breeze.
Packaged in a container, such a running worker has a memory footprint of approximately 170 MB. This allows many parallel workers to be deployed, each operating independently of the others. QGIS-Server-Light starts up in under 1 second.
This ensures that, in the event of a crash, a new worker is available before you know it.
QGIS Server Light is configured entirely via the queue it does not need a QGIS project. This makes it the perfect component for scalable cloud environments.

This hands-on workshop introduces how map production can be automated using Python/PyQGIS scripts together with QGIS print layouts. It builds on the preceding talk and focuses on practical implementation.

We start with a short introduction to print layout templates and their main elements, such as maps, legends, text labels, images, and scale bars, as well as a brief introduction to PyQGIS.

In the practical part, participants learn how to prepare a layout for automation by assigning item IDs to its elements. We will then write PyQGIS code to control and modify the print layout. Using PyQGIS, layout elements are accessed via their IDs and dynamically updated—for example by changing text, adjusting map settings, modifying legends, or inserting images. As a first step, a single layout is exported as a PDF.

A prepared example project is then introduced, containing input data (CSV), a GeoPackage, and print layout templates. Participants will extend the provided script step by step and finally run a batch export.

The focus of the workshop is on the interaction between Python/PyQGIS code and QGIS print layouts. To support this, participants work with prepared PyQGIS scripts which are extended.

Participants should have basic knowledge of QGIS and Python. Prior experience with the QGIS Python API is helpful but not required.

While QGIS excels at individual workflows, collaborative editing of shared datasets remains a challenge. Teams often struggle with server-side storage, synchronization between desktop and web environments, resolving editing conflicts, and tracking the history of data changes.

This talk presents an open-source approach for building collaborative QGIS workspaces using NextGIS components.

NextGIS Web (https://github.com/nextgis/nextgisweb) provides a Web GIS framework designed for storing and publishing geospatial data. It includes advanced user permission management and built-in version control for vector datasets, allowing teams to track edits, roll back changes, and manage collaborative workflows. The system uses QGIS as a rendering engine, enabling almost full support for QGIS symbology in web maps.

NextGIS Connect (https://github.com/nextgis/nextgis_connect) is a QGIS plugin that tightly integrates QGIS with NextGIS Web. It allows users to:
- publish QGIS projects as web maps,
- open web maps directly as QGIS projects,
- edit server-side data directly from QGIS,
- resolve editing conflicts interactively.

The latest release of NextGIS Connect introduces full support for feature attachments (photos, documents, and other files), which can now be managed both from QGIS and from web interfaces. Attachments are also included in the dataset version control system.

In this talk we will demonstrate how these tools enable simultaneous multi-user editing of geospatial data from QGIS, show the workflow of publishing and synchronizing projects between desktop and web environments, and explain how the underlying data version control system tracks and manages changes.

The presentation will be useful for QGIS users who want to build collaborative geospatial workflows without leaving the open-source ecosystem.

As an archaeo-geomatician using QGIS on a daily basis, I asked myself while drawing the map for an archaeological protohistoric excavation: what if we could give life to this flat blueprint, digging trenches and elevating walls and postholes into structures we could wander around?

At the same time, I was doing this exact job using well-known game creation systems (GCS) like Unity or Godot for a 3D, browser-based WebGL render. I then decided to give my idea a try. The challenge was to create a lightweight, efficient workflow simple enough for most users to handle. Choices had to be made, from the coordinate reference system (CRS) to the output format of the levels and, more importantly, the HTML5 engine designed to render this data as a 3D, browsable world.

The result is a web-based tool where uploaded GeoJSON files are interpreted on the fly, linking geographical features to 3D assets and table attributes to game triggers and events. On the QGIS side, native functions and dedicated plugins can ease environment generation by distributing vegetation or linking heightmaps for a roamable topography.

This interesting, open-source use case of QGIS aims to merge the best of both the 2D and 3D worlds, making volumetric world creation accessible. This toolkit can come in handy for popularizing work for larger or more specialized audiences, similar to the way Building Information Modeling (BIM) does.

More than 1 billion people are living with mental health disorders, according to the World Health Organization (WHO).

In our opensource communities, this sensible topic is rarely mentioned, and even more rarely taken into account seriously. Meanwhile, a lot of developers or OpenSource maintainers suffer from mental health issues related to their activity. This can lead to well-known situations such as burn-out, maintainer's fatigue, job quit, or sometimes to much worse situations.

OpenSource communities is mostly composed of engineers, who are - let's be honest - usually very bad at dealing with social, human, communication or emotional issues. I am one of them, and was also very bad on these topics.

Communication is key. With this presentation, I intend to put the issue on the table so that we can start discussing the matter openly and find ways to improve our community's well-being.

I will present how OpenSource communities consist in specific environments, especially on communication and human relationships.

Then I will give some examples of situations I have seen in OpenSource communities that can lead to well-being issues.

And I will try to give some ideas to improve the situation in the future, on individual and collective levels.

QField and QField Cloud have become primary tools for mobile data collection at Land Vorarlberg. Because GIS-technicaians are proficient with QGIS, a wide range of departments - from forestry to spatial planning, now rely on QField for tasks that range from quick field checks to comprehensive monitoring projects. The challenge is to keep the set-up straightforward while avoiding unnecessary administrative overhead.
In this presentation I will describe how we have organised QField and QField Cloud to achieve this balance. The talk will cover:
-Streamlined administration within the organisation
-Broad accessibility of resources for personnel with QGIS expertise
-Centralised management and utilisation of large raster datasets
-Cross-departmental knowledge exchange, including project insights and best practices

QField and QFieldCloud - Project setup, team management and best practices

QField and the QFieldCloud ecosystem provide everything you need to take your QGIS projects into the field, collaborate seamlessly, and ensure your spatial data remains consistent. This workshop provides a comprehensive guide to setting up a project for field data collection workflows and synchronization.
Organizations worldwide rely on QField for efficient mobile data collection. QFieldCloud acts as the bridge between desktop QGIS and mobile devices, supporting collaborative editing with GeoPackage and PostGIS layers. However, proper project configuration is essential to prevent data loss, avoid synchronization conflicts, and optimize storage.
In this workshop, we will explain the core concepts of QFieldCloud and guide you through the following workflow:
- Understand the synchronization process (QGIS to Cloud, Cloud to Field, and applying Deltas)
- Choose the correct working mode (Offline Editing vs. Direct Data Access)
- Implement project configuration best practices (managing UUIDs, relative paths, and modular GeoPackages)
- Manage teams, restrict project files, and resolve data conflicts
- Push and synchronize changes seamlessly using the QFieldSync plugin
- This workshop is for GIS professionals, field data managers, and QGIS users looking to deploy reliable mobile data collection campaigns.

Requirements for the Attendees
- QGIS installed on a laptop
- QField app installed on a mobile device (Android or iOS)
- QFieldSync plugin installed in QGIS
- A registered account on QFieldCloud

Beneath our feet lies one of the least explored environments on Earth. While mountains, rivers, and landscapes are well mapped, the subsurface remains largely hidden. Digital soil field data collection offers an efficient way to shed light on this unseen world. This is particularly important because protecting high-quality soils requires knowing where they are. Despite its importance, only about 13% of agriculturally used soils in Switzerland are covered by detailed soil information, and mapping has traditionally been carried out on paper.

Geodata applications now enable direct digital data collection in the field. In search of an open-source solution, I developed a QField project for practical soil mapping. QField is a powerful mobile app based on QGIS that enables efficient field data collection. This presentation outlines design considerations from the development process built on continuous feedback from field workers.

The overall system architecture is defined by QField, but key decisions such as deployment (local or remote) and data management still need to be designed carefully. The identified best practices will be compared in terms of usability, collaboration, and technical complexity. An important consideration is the choice between local and cloud-based setups, as this affects the optimal project size as well as the handling of databases and layers. For editing layers, either GeoPackages or PostgreSQL can be used. Regarding background layers, it is important to distinguish between online Web Map Service (WMS) and offline raster datasets in order to keep the project lightweight.

Other key design considerations presented include closely replicating paper-based workflows in a digital environment, ensuring near real-time performance, and maintaining a clear overview despite the limited screen size of mobile devices.

In conclusion, careful QGIS project preparation has enabled efficient, robust, and practical digital soil data collection with QField. A major benefit is that observations are now collected and stored digitally. The captured information is no longer in heterogeneous handwritten field notes but instead provides structured data and accessible knowledge. The presented best practices can serve as inspiration for other QGIS users aiming to improve the efficiency and usability of their own QField mobile app projects.

QGIS is a successful open-source project built by two main groups. On one side, there are developers who spend a lot of time and energy building and improving the software. On the other side, there are many users who use QGIS in very different contexts. These two groups are both very important, but they do not always work closely together.

Open source is not only about code. It is also about collaboration and exchange between people. QGIS User Groups already show this at a local level, where users meet, share experience, and learn from each other. However, when it comes to influencing how the software evolves, many users feel far from the process.

One reason is that developers and users often think in different ways. Developers focus on algorithms, parameters, technical solutions, QEP and coding style. Users focus on their daily work: making maps, managing data, and solving concrete problems. For example, a user interface is not only a way to show parameters — it should match how users think and work. But sometimes, design decisions are made without enough user feedback. This can lead to tools that are difficult to understand or not adapted to real needs. Another issue is related to contribution itself. Contribution channels often assume familiarity with tools such as GitHub — even though many users do not know what it is or how to use it.

Other open-source projects have worked on similar problems. They have created spaces for discussion, user testing, and easier ways to contribute without technical skills.

In this talk, I will present some ideas to improve the situation: better discussion platforms (like forums), regular user testing sessions, and stronger links between user feedback and development. I will also argue that reporting a problem in a workflow is already an important contribution.

The presentation will end with an open discussion: how can we connect users and developers more effectively? What role can QGIS User Groups play? And how can we build a QGIS that is designed with its users, not only for them?

In the recent months, there has been a lot of progress in the capabilities of the 3D map visualization within QGIS. With support for various 3D data formats, QGIS 3D is moving far beyond the simple viewer when it was first released in QGIS 3.0 in 2018.

This talk summarizes the work that has been done in 2025 and 2026 to make QGIS 3D faster, more powerful and easier to use. We will discuss support for ESRI’s scene layers (I3S / SLPK), improvements to 3D Tiles support, significant performance improvements for handling of vector layers and much more!

The Florida’s Turnpike Enterprise (FTE) has re-architected its statewide travel demand modeling platform, the Turnpike State Model (TSM - NextGen), by embedding the entire modeling workflow within a custom QGIS plugin interface. This transition represents a fundamental shift from traditional, fragmented modeling environments toward a fully integrated, open-source, and GIS-native ecosystem.
At the core of this innovation is the use of QGIS not just as a visualization tool, but as the primary user interface for model configuration, execution, and diagnostics. All stages of TSM from land use editing and network preparation to population synthesis, demand modeling, and assignment are initiated and completed within the QGIS environment. This eliminates the need for external software, file transfers, or manual data handling across disconnected platforms, significantly reducing operational complexity and risk of error.
By leveraging QGIS’s open architecture, TSM has achieved complete independence from proprietary software, aligning with public-sector goals of cost efficiency, transparency, and long-term sustainability. The plugin-based design allows direct interaction with GeoPackage, PostGIS based land use and network data, where users can modify socio-economic attributes (e.g., population, households, employment) using standard QGIS editing tools. These changes dynamically trigger appropriate model components (e.g., population synthesizer, demand model, route choice), all orchestrated through an intuitive graphical interface.
A key advancement is the integration of AI-assisted workflows within the QGIS plugin. Customized GPT-driven user guides are embedded directly into the interface, enabling context-sensitive assistance for each modeling step. These guides are dynamically linked to backend GitHub repositories, providing users with real-time access to source code, documentation, and model logic for each widget or module. This creates a self-service, intelligent help system that reduces onboarding time and enhances user confidence in navigating complex disaggregate models.
The open QGIS platform has also enabled rapid acceleration of development cycles. AI tools have been used to generate, debug, and refine PyQGIS and UI components, allowing iterative improvements that would traditionally take significantly longer. This has resulted in a modern, modular, and extensible interface that can evolve alongside emerging modeling needs.
Ultimately, the TSM QGIS interface transforms how analysts interact with large-scale travel demand models bringing transparency, efficiency, and usability to a domain historically constrained by technical barriers and proprietary dependencies. This presentation will demonstrate the architecture, workflows, and lessons learned from deploying a fully open-source, AI-enhanced modeling platform within a statewide agency.

Through our Lizmap hosting service, we provide and monitor several hundred QGIS Servers. In response to the challenges we encountered, we developed Py-QGIS-Server as an open-source project. It enables efficient management of the QGIS project cache, long-running requests, automatic restart, available QGIS Server processes, and more.

But we needed to go further to create a version of QGIS Server perfectly suited for cloud services. So we developed and released an open-source project: QJazz. It uses a microservices architecture with gRPC (a high-performance open-source Remote Procedure Call framework) to control the various QGIS Server processes that manage OGC services.

QJazz is a suite of QGIS Server-based services, comprising: QGIS Server as a microservice and an OGC Processes server based on the QGIS processing module.

This is a set of modules that enable the deployment of QGIS-based servers and processing services compliant with the OGC API Processes standard. It aims to provide a solution for the scalable deployment of QGIS-based services on medium- to large-scale infrastructures and was developed to address certain challenges associated with processing large numbers of projects. The services are implemented as wrappers around the QGIS Server API and the QGIS Processing API. As a result, they support all the features and options of QGIS Server.

The objective of this presentation is to introduce QJazz, its architecture, and its features.

As QGIS and its plugins evolve rapidly, teams often struggle to verify that critical workflows remain stable and performant across new releases. Manual testing is time-consuming and subjective, yet there is no easy way to automate it directly within QGIS.

This talk presents the Macro plugin, which records mouse and keyboard events as reusable macros, enabling advanced automation without writing a single line of code. These macros can be saved, shared and executed in different environments.

By combining macros with the Profiler plugin, it is possible to monitor these recorded QGIS actions to detect performance regressions issues and anomalies from the QGIS UI down to individual Python function calls.

Practical applications of Macro and Profiler plugins:
* Repeatable test setups for end-to-end testing
* Automating repetitive manual tasks (even digitizing or editing features)
* Comparing rendering speeds and processing times across different environments and QGIS or plugin versions
* Identifying performance bottlenecks in QGIS

The talk includes live demos of both plugins.

How do multiple public agencies jointly own and sustain an open-source project — without it falling apart? The Model Baker QGIS plugin has done exactly this for a decade, and this talk shares how.

INTERLIS, the Swiss standard for geodata exchange, demands robust tooling. Model Baker brings that tooling into QGIS. It handles model-driven data collection and structural validation. But the technical challenge is only half the story. Just as important is governance: how a group of cantons with different priorities, budgets, and timelines could collaborate on a shared product sustainably.

In this talk we will show you what a working collaboration model between multiple public entities actually looks like in practice; the roadmap process, funding structure, and how quality assurance stays community-driven without becoming chaotic. And how this not only benefits the Swiss INTERLIS requirements but also helped QGIS to make a leap forward.

At Lutra Consulting we have been busy improving and extending point cloud workflows in QGIS: From editing of point cloud attributes and processing algorithms for classification and comparison, to advanced styling techniques and virtual point cloud improvements. In this talk we will go through all the features we have introduced in the last couple of QGIS versions that make handling LiDAR data more accessible and intuitive than ever before.

The Geological Survey of Brazil (SGB) has, among its institutional responsibilities, the development of studies aimed at territorial planning, directly related to the country’s geological and geomorphological characteristics. In this context, municipal susceptibility maps for landslides and floods stand out as essential tools for identifying areas prone to natural disasters and supporting risk management.
This work presents a case study describing the implementation of an integrated workflow for the production of these maps, covering stages from the preliminary identification of susceptible areas to field validation and final cartographic outputs. The proposed workflow uses QGIS for office-based activities and QField for field data collection and validation, with data storage and integration through GeoPackage and a PostGIS database.
The research emphasizes the transition from traditional processes—often manual and reliant on proprietary solutions—to an automated model based on free and open-source geospatial tools (FOSS4G). The main objective is to optimize the cost–quality–time balance in the production of cartographic products for geological risk management.
Key methodological innovations include the customization of editable layers in QGIS, using intelligent forms based on Qt widgets, standardization of typologies, and the implementation of automated calculations through virtual layers. These features enable field operators to obtain derived information in real time without the need for auxiliary instruments. Additionally, the use of triggers in the PostGIS database automates the population of spatial attributes, such as municipality and state, after synchronization of collected data. Each record is assigned a UUID, ensuring data integrity and traceability in a decentralized data collection environment.
The adoption of this integrated workflow resulted in an estimated productivity gain of approximately 67%, while also significantly improving the standardization of final products. The incorporation of these routines directly into QField enabled greater consistency in field surveys and data structuring, resulting in more reliable and comparable cartographic outputs.
The results demonstrate that the combined use of QGIS and QField not only accelerates the production of susceptibility maps but also enhances their technical quality and standardization. This methodological advancement has enabled SGB to increase the number of published maps with greater efficiency and reliability.
Finally, the adoption of integrated open-source platforms represents a strategic advancement in natural disaster prevention projects, directly contributing to the generation of critical information for population protection and risk reduction, with a direct impact on saving lives and promoting sustainable territorial planning.

Managing forestry subsidies brings together a diverse set of users and data — not only spatially, but also digitally. Power users need the full flexibility of QGIS for advanced digitizing, while district foresters and private forest owners need simple, guided workflows that help them contribute high-quality data without being overwhelmed.

In the Canton of Zug (Switzerland), the cantonal forestry office developed a central platform that coordinates all access to the shared dataset. The platform is built on Django and exposes data through different endpoints — the web application via Django's own model and admin layer, QGIS via OGC API Features using the django-oapif library — but crucially, both share the same underlying business logic, user management, and permission model. Each user only sees and edits what they are authorized to, regardless of which client they use, and data quality rules are enforced once at the platform level rather than in each client individually.

Users can freely choose between the modern web application and QGIS depending on their needs. Authentication is handled uniformly for all users. Beyond the core workflow, the platform integrates data from surrounding systems and automatically generates PDF reports.

In this talk, we will walk through the architecture, the role QGIS plays as the power-user frontend, and the practical challenges we encountered bridging the gap between desktop GIS and web-based workflows over a shared platform. We will also give an outlook on upcoming improvements: Single Sign-On integration, rendering web forms directly inside QGIS, and our experiments with alternative geometry encodings to improve transfer performance of OGC API Features.

Every time a user opens QGIS, downloads a plugin, or grabs the latest installer, a carefully maintained web of infrastructure quietly does its job in the background. But how does that infrastructure keep running, and what does it actually look like at scale?

In this talk, we pull back the curtain on the systems that power the QGIS ecosystem. With over a petabyte of monthly downloads, over 100k visits and nearly 30k downloads per day on qgis.org alone, and close to 2M plugin downloads monthly through plugins.qgis.org, the scale of what the community relies on is enormous — and largely invisible to its users.

We will walk through the key components of this infrastructure: the main website and download pipeline backed by an S3 bucket and a network of mirrors, the plugin repository serving the global community, the feed analytics that provide the news and quietly registers nearly 1M QGIS launches every day, and the resource-sharing hub at hub.qgis.org. We will also cover supporting services including planet.qgis.org, certification.qgis.org, members.qgis.org, and the emerging user group websites for national communities.

Beyond the architecture, we will share the human side of this work — the decisions, the trade-offs, and the ongoing effort required to keep these services reliable, secure, and scalable for a globally distributed open-source community.

Whether you are a QGIS contributor, a user group organizer, an active user or simply curious about what keeps the ecosystem ticking, this talk offers a behind the scenes look at the foundation everything else is built on.

This talk covers the good, the bad, and the ugly side of AI in the QGIS Ecosystem. From neat new AI plugins to AI slop in the PR queue and the issue of training new users and developers, this talk provides an overview of current challenges and opportunities.

With the model builder you can use all tools in the QGIS toolbox to build your own workflows. It could be anything from fetching, processing, analyzing to storage of data. The purpose of building a model is to easy and fast repeat complicated operations. It will also be a documentation of the work. Another purpose could be to automate tasks such as fetching and processing of data.

The latest versions of QGIS have brought a lot of improvements that make model builder a much more user-friendly and powerful tool.. We are trying out using the model builder to do some common data management tasks.

Bring a computer with QGIS 3.44 (4.0, 4.2?) installed if you want to follow along and do the exercises yourself. It may also work with slightly older versions of QGIS, although not everything works exactly the same. Starts basic. No prior knowledge is required.

Graph models form the basis for flow simulations. In practice, most GIS data are not directly suitable for flow simulations and various steps are necessary to transform grid data into simulation-ready graph models. QGIS provides the ability to create custom toolchains to streamline and automate this transformation process. We (SmartSim GmbH) use QGIS to create simulation models of gas grids for the use of gas quality tracking. The presentation outlines the workflow and the tool library we have developed and how we automate this transformation process with the help of QGIS.

How can initially reluctant beginners become engaged, self-motivated users of QGIS? This presentation introduces a successful, research-informed workflow that uses learner-generated, field-based data as an accessible entry point into GIS thinking.

This QGIS case study presents an effective educational framework to introduce new digital tools to learners who may not be predisposed toward their adoption and to student groups with diverse technical and disciplinary backgrounds. Many students are more familiar with proprietary ecosystems and with the consumption, rather than creation, of data. Under these conditions, conventional tutorials using scaffolded concepts and preconfigured datasets are less engaging and pedagogically ineffective.

To address these challenges, we use a “Findings from the Field” approach that inverts the traditional tutorial model. Rather than beginning with abstract concepts and standardized datasets, students first identify a topic of personal or collective interest and gather geotagged data using mobile photography. Working individually or collaboratively, they document phenomena encountered outside the classroom that interest them, such as public infrastructure, creative works, or commercial artifacts. Students are then introduced to core QGIS functions as they import their geotagged photographs to create point layers and associated attribute tables; they then use the Map Tips feature to display the images interactively. Because the dataset originates from student fieldwork, this process supports deeper reflection on connecting their interests to geocoding practices, spatial representation, analysis, and workflows.

This approach’s relative simplicity makes it an effective entry point for both instructors and novice learners, as well as a foundation for further exploration, while simultaneously reinforcing critical, place-based research skills. Beyond the case study, this presentation contributes to discussions on inclusive and interdisciplinary GIS pedagogy, particularly in contexts with learners initially unaware of or disinterested in geospatial analysis and representation. The workflow we present is grounded in classic learning theories that address motivation and skill acquisition: Self-Determination Theory explains how student-generated data fosters intrinsic motivation through autonomy and relevance (Ryan & Deci, 2000); Cognitive Load Theory informs how simplifying initial technical tasks supports learning (Sweller, Ayres, & Kalyuga, 2011); and the Zone of Proximal Development concept (Vygotsky, 1978) guides the structured introduction of QGIS tools for deeper exploration. At a broader level, the approach aligns with experiential and constructionist learning theories, as students build knowledge through field-based inquiry and the creation of meaningful artifacts (Healey & Jenkins, 2000).

References/resources
Healey, M., & Jenkins, A. (2000). Kolb’s Experiential Learning Theory and Its Application in Geography in Higher Education. Journal of Geography, 99(5), 185–195. https://doi.org/10.1080/00221340008978967
Ryan, R. M., & Deci, E. L. (2000). Intrinsic and extrinsic motivations: Classic definitions and new directions. Contemporary Educational Psychology, 25(1), 54–67. https://doi.org/10.1006/ceps.1999.1020
Sweller, J., Ayres, P., & Kalyuga, S. (2011). Cognitive load theory. Springer.
Vygotsky, L. S. (1978). Mind in society: The development of higher psychological processes. Harvard University Press.

I'd like to spend some time during the (or every) QGIS User Conference on gathering with the QGIS User Groups world wide. The goal is sharing ideas and activities, helping new user groups to start up, communication with members, improve financial funding of QGIS, evaluate the voting process, et cetera.

At BRGM (the French Geological Survey), transitioning from field observations to high-quality published maps requires a seamless digital workflow. This presentation explores how we leverage the synergy between QField and QGIS to build an integrated, industrial-scale production line for geological data.

We will break down our specialized workflow into three strategic phases:

• 1. Upstream Preparation (QGIS to QField): How we prepare complex field projects by integrating multi-source data (satellite imagery, geophysics, legacy vectors) and configuring advanced QField forms (drag-and-drop layouts, 1-N relations, and lookup registers) to ensure structured data entry.
• 2. Field Acquisition (QField): Utilizing rugged tablets to capture geological features in situ, ensuring data consistency and topological integrity right at the outcrop.
• 3. Downstream Production (QGIS & Custom Plugins): Beyond standard GIS tasks, we will showcase our internal suite of Python plugins. These tools automate post-processing and final cartographic rendering according to BRGM’s rigorous scientific standards, transforming raw SIG layers into professional map products.

By sharing our experience, we aim to demonstrate how this 100% Open Source ecosystem—enhanced by bespoke development—not only reduces data entry errors but also significantly accelerates the timeline from "rock to map."

qgis-js brings the QGIS core rendering engine to the browser via WebAssembly — no server-side map rendering required. Since its initial release, the project has matured significantly: all qgis-js patches have been upstreamed into QGIS core, and wasm32-emscripten is now an officially supported build target. This means new qgis-js versions can be built directly alongside QGIS releases, with CI ensuring ongoing compatibility.

In this talk, we will cover the recent project developments — what has changed, what new capabilities are available, and where the remaining challenges lie — before diving into a real-world application: a browser-based cockpit built for the Swiss Federal Office for the Environment (BAFU) as part of their modular warning system SAM. The application supports early warning decisions for spontaneous landslides and debris flows by presenting complex model results — precipitation thresholds, exceedance probabilities, and time series — as interactive, QGIS-styled maps and diagrams directly in the browser. What started as a QGIS desktop prototype with project macros and attribute form plots is now a highly interactive web application powered by qgis-js, accessible to warning officers without any software installation.

We will share the architectural decisions behind the application, the lessons learned integrating qgis-js into a production web app, and our outlook for the project's future.

In the 15 years since the first lines of code for Lizmap Web Client were written, the web has come a long way: JS frameworks, OpenLayers 3 through 10, WASM, Broadcast Channel, Storage API, WebGL, and more.

Over the past 15 years, Lizmap Web Client — an open-source web mapping application that integrates closely with QGIS Server — has had to evolve, and a new major release is on the horizon.

This presentation will provide an opportunity to showcase the latest features of Lizmap Web Client version 3.10: DXF export, map rotation based on the direction provided by geolocation, the ability to copy and paste an object’s geometry from a map layer during the digitization process, portfolio, and more.

But also to introduce the upcoming version 4 of Lizmap Web Client: removing OpenLayers 2, being able to detach the attribute table while maintaining the link to the map, etc.

The City of Zurich is currently conducting a new round of its Habitat Type Mapping (Biotoptypenkartierung – BTK), a long-term monitoring program that assesses the ecological quality of habitats across the city. The survey provides an essential foundation for biodiversity conservation and urban planning and supports the city's goal of increasing the proportion of ecologically valuable habitats in urban areas to 15% by 2040.

This presentation introduces the migration of the mapping workflow from ArcMap to a modern solution based on QGIS, QField and QFieldCloud, developed in close collaboration with OPENGIS.ch.

The session will present the complete workflow, from project preparation in QGIS to field mapping with QField and cloud synchronization through QFieldCloud. It will discuss the technical challenges encountered during the migration, including improving the editing workflow, reducing topological errors, and enabling efficient collaboration between field and office teams.

The presentation will also show how the workflow has been extended with automated quality control. Using FME Form & Flow together with the QFieldCloud REST API, newly synchronized data are validated every night, demonstrating how QGIS-based solutions can integrate seamlessly with existing enterprise systems.

The session aims to provide practical insights for organizations planning similar migrations or developing efficient, scalable workflows for large-scale field data collection.

Centre Scientifique et Technique du Bâtiment (CSTB) has been developing a building energy modeling tool called DIMOSIM for over 10 years. This simulation tool is capable of modeling thermal energy demand, energy systems, occupant behavior associated with electrical appliance loads, thermal and electrical grids connecting buildings. There is also smart grid functionality related to photovoltaic electrical generation and electrical storage management. Currently this tool can be used by project partners through a basic web API but this interface is not very user friendly. This year, the DIMOSIM team has been developing a plugin in QGis to offer a user friendly, geographical interface to improve the user experience and even allow non-technical users to access and use DIMOSIM.
Current functionality of the interface includes building a new project, modifying global or building specific simulation parameters, selecting system types, selecting simulation type, drawing a thermal grid connecting buildings, simulating the thermal energy demand or electrical load of the project. The most challenging part of using the current web API for users is understanding the input parameter files that have a specific format for DIMOSIM. The current QGis plugin uses template files and dialog boxes to explain the meaning of each parameter. There is also the possibility to load building geometry and some building parameters from the open API of the National Building Data Base (BDNB) also produced by CSTB. The user can then manually adjust parameters or use a default value option to fill in missing values.
A thermal network can also be added including district heating or cooling systems. This type of simulation with the current DIMOSIM API is a bit challenging to understand by users. With the QGis interface, some parameters are automatically adjusted to ensure the correct configuration of multiple input files. An initial grid geometry is very easy to draw in QGis which is then optimized by DIMOSIM connecting all applicable buildings to the grid. The user can once again modify parameters and systems configurations before completing the simulation.
Future developments include improving user selection of desired results and results viewing. Currently typical results are provided to the user via a csv file. A selected result of interest is aggregated and loaded as a layer to visualize the building geometries and their aggregated results value. Ideally, a more detailed investigation of the results should be possible allowing for multiple aggregated results to be visualized and a choice of aggregation type for each results type. Exploring options in DataPlotly to plot timeseries graphs for some results would be ideal.

Urban ground deformation is an often overlooked but critical issue in rapidly developing coastal cities, particularly in arid regions where groundwater extraction and land modification are common. While time-series InSAR techniques are widely used in research, their integration into practical geospatial workflows for city-level applications remains limited.
This presentation demonstrates how time-series InSAR results can be effectively integrated into the QGIS environment to support ground deformation monitoring in Dammam, Saudi Arabia. Using Sentinel-1 data from 2017 to 2025, more than 1,500 interferograms were processed through an open-source workflow combining ASF HyP3, ISCE2, and MintPy. The analysis reveals localized subsidence with rates reaching up to −1.7 cm/year, forming a spatially coherent deformation pattern.
The focus of this work is on transforming these advanced remote sensing outputs into actionable geospatial information within QGIS. InSAR-derived products, including cumulative displacement maps, velocity layers, and time-series point data, are imported and managed in QGIS to enable visualization, spatial analysis, and integration with urban datasets. This allows users to identify deformation-prone zones and relate them to infrastructure, land use, and drainage systems.
A validation step using historical optical imagery shows that detected deformation corresponds to real surface changes, including infilled depressions and post-construction consolidation. This highlights the capability of QGIS to serve as a central platform for combining multi-source geospatial data into a coherent monitoring framework.
The presented workflow demonstrates how open-source tools can bridge the gap between advanced satellite analysis and practical urban management. It provides a scalable and cost-effective approach for municipalities and organizations seeking to incorporate ground deformation monitoring into their geospatial decision-making processes using QGIS.

Ramboll operates QGIS at enterprise scale, with 500+ monthly users managed through a centralized governance model alongside a substantial ArcGIS user base. This presentation shares practical lessons from building and running a dual-platform geospatial ecosystem in a global engineering and consultancy firm—covering technical setup, organizational governance, and the strategic drivers that shape adoption and funding.
We will outline our technical approach to maintaining QGIS in a managed IT environment: standardized packaging and deployment, controlled upgrade cadences (LTS vs. latest), profile and plugin management, and configuration baselines that ensure consistency across project teams and regions. We will discuss data access patterns that allow QGIS and ArcGIS to interoperate, emphasizing the importance of leveraging open standards while still supporting proprietary formats such as File Geodatabases.
We will also discuss the internal drivers that inform strategy and funding—total cost of ownership, risk management, compliance, and the growing importance of digital sovereignty. Finally, we will share an outlook on how AI is raising the profile of QGIS and open-source systems in the Architecture, Engineering, and Consultancy sector.

Teaching QGIS effectively requires more than good materials: it requires matching learning modalities to the motivations, constraints, and expectations of different learner groups. In this talk, I reflect on two decades of teaching QGIS to university students, professionals, and self‑motivated learners, and I argue that how we teach matters as much as what we teach.

For highly motivated individuals, those who actively seek out GIS skills for their own projects, self‑paced online learning remains the most efficient and impactful modality. These learners benefit from autonomy, the ability to revisit complex topics, and the flexibility to progress at their own rhythm. Structured online courses, supported by LMS platforms such as Moodle with H5P interactivity, allow them to build strong technical foundations with minimal friction.

In university settings, blended learning consistently outperforms traditional lectures. Students watch theory videos at home, then use classroom time for quizzes, discussions, troubleshooting, and guided exercises that they can complete independently afterward. This model increases engagement, reduces cognitive overload, and frees in‑person time for higher‑order learning (analysis, application, and problem‑solving).

For professionals, however, the picture is different. When courses are paid by employers and squeezed between demanding jobs, full in‑person or live‑online formats remain the default. While these modalities often produce lower learning performance compared to self‑paced or blended approaches, they align with expectations of learners, donors, and colleagues. Insights from my work on capacity development show that synchronous formats are frequently preferred not for pedagogical reasons but because they fit existing incentive structures: they are visible, certificate‑friendly, and compatible with organisational habits. Yet these formats are fragile, especially in low‑resource settings, and often lead to low retention, passive participation, and limited long‑term application.

Recognising this gap between performative and sustainable learning helps QGIS trainers design interventions that genuinely strengthen geospatial capacity. Effective training requires autonomy, continuity, and relevance. These conditions are difficult to achieve in long Zoom marathons but flourish in well‑designed self‑paced or blended environments.

The talk includes practical tips for becoming a strong QGIS trainer: designing modular materials, encourage the development of real‑world skills, scaffolding exercises to build confidence, integrating open‑source values into teaching, and cultivating a classroom culture where experimentation and failure are part of the learning journey.

Ultimately, effective QGIS teaching is not one-size-fits-all. It is a craft that adapts to context, respects learner diversity, and embraces the strengths of open-source communities.

Road traffic crashes remain a persistent global challenge, causing millions of fatalities each year and severely injuring many more. Beyond their human toll, crashes impose significant socio-economic costs worldwide, yet traditional approaches to identifying hazardous locations often rely on simple frequency-based metrics, which fail to capture spatial dependence and variations in crash severity. However, crash events are not spatially random in many urban contexts; instead, they exhibit strong clustering patterns driven by recurring geometric, operational, and behavioural factors.
Identifying the spatial distribution of traffic crash hotspots provides valuable insights into the root causes of crash occurrence over the area under study. This knowledge supports decision-makers in assessing road safety risks and implementing targeted countermeasures to reduce crash rates. Nevertheless, identifying areas with high crash potential remains a complex task.
In this regard and within this study, we aim to address these limitations by developing a comprehensive spatial analytics framework for assessing crash severity patterns. The proposed methodology integrates severity-weighted crash indices and applies a suite of spatial statistical techniques to detect clustering behaviour and identify micro-scale hotspots. Specifically, the framework employs Average Nearest Neighbor Distance (ANND) to evaluate the statistical significance of spatial clustering, Global Moran’s I to assess overall spatial autocorrelation, and Local Moran’s I to identify significant local clusters, including High-High (HH) and Low-Low (LL) severity areas, as well as spatial outliers.
The framework is designed and developed within the QGIS environment as an experimental plugin, offering a user-friendly interface and a streamlined workflow for performing advanced spatial statistical analyses. The solution is scalable and transferable to different geographic contexts, provided that appropriate input data are available. The methodology is demonstrated through a case study in the greater Limassol area in southern Cyprus, where it is used to analyse crash patterns and evaluate spatial risk.
Results reveal strong clustering of crash locations based on ANND analysis, while Global Moran’s I indicates weak or non-significant global spatial autocorrelation of crash severity. This suggests that severe crashes do not form broad regional patterns but instead emerge as highly localized phenomena. Local Moran’s I analysis confirms the presence of small yet significant High-High severity hotspots and several spatial outliers (High-Low and Low-High), typically located along major arterial corridors, network transition points, and mixed-use zones. A comparative analysis of pre- and post-COVID periods shows a substantial reduction in crash frequency and cluster intensity, indicating measurable impacts from altered mobility patterns and the introduction of automated speed enforcement measures. Overall, the findings highlight the importance of localized, severity-aware spatial analysis for modern road safety management. The proposed framework provides actionable insights for black-spot identification, targeted interventions, dangerous goods routing, and integration into digital twin and intelligent transport systems (ITS) decision-support environments, supporting data-driven strategies aligned with Vision Zero objectives.

Messy, overlapping labels are one of the most common challenges in map design - and a major source of time-consuming manual fixes. While QGIS provides a powerful labeling engine, many users only scratch the surface of what it can do.

In this talk, I will present practical techniques for configuring label placement and demonstrate how they perform through a range of real-world examples. I will also share useful tips for working effectively with labels in map layouts.
This presentation is aimed at QGIS users who want to improve their labeling skills and expand their overall understanding of label management.

In the GIS world, database schemas often dictate the layout of data entry screens—at the expense of usability in the field. GIS specialists often lack the UI/UX expertise needed to translate complex data models into intuitive tools. This presentation bridges that gap: We’ll share usability best practices specifically tailored to mobile geodata collection with QField.

Based on the KISS principles, participants will learn how to reduce the cognitive load on users by choosing the right widgets, logical groupings, and visual hierarchies. To facilitate practical application, we introduce the “SmartFormGenerator.” This QGIS plugin automates the design process: It transforms layer metadata and simple tags (#tab, #values) directly into optimized drag-and-drop forms. This turns a rigid schema into a user-centered tool that minimizes errors and increases acceptance in the field.

Key Takeaways

• UX for GIS Admins: A concise introduction to usability principles (Fitts’s Law, error tolerance) without a design degree.
• Form Checklist: A practical guide for configuring QGIS attribute forms for field use.
• SmartFormGenerator: Presentation of a workflow that integrates UX optimization directly into layer design.
• Single Source of Truth: Efficient form control via field comments instead of manual clicking.

KADAS is a standard application used by the Swiss Armed Forces to work with digital maps and geoinformation. KADAS was developed on the basis of QGIS. The source code is publicly available on Github. Swisstopo supports the armed forces and other users within the Federal Administration with the operation and development of this software.

KADAS makes it easier for the armed forces to access a wide range of geoservices, especially those provided by the military spatial data infrastructure. This simplifies the process of analysing the landscape and creating plans for tactical operations. This information and these plans can be exchanged between the various systems.

KADAS also works offline. To make this possible, the application comes with a basic data package of digital maps. This allows the maps to be used offline during tactical operations where there is no network connection. Additional offline data packages are available on request. The integration of symbols and tactical graphics allows KADAS to exchange situational information with the armed forces’ command and control systems. This means that members of the armed forces who do not have access to these systems can use KADAS. This helps them to prepare operations and further training exercises.

This presentation showcases how QGIS can serve as a powerful, central platform for advancing community resilience research through spatial analysis. We demonstrate a novel approach to operationalizing the Community Capitals Framework (CCF) at fine spatial scales, enabling practitioners to move beyond coarse, aggregated assessments and instead uncover meaningful, place-based disparities within rural communities.
While the CCF is traditionally applied across seven domains—built, natural, human, social, political, cultural, and financial capital—this project introduces the concept of spatial capital as a critical, integrative dimension. By leveraging QGIS as the analytical hub, we reveal how geography itself—through proximity, connectivity, and infrastructure—fundamentally shapes access to opportunity. This spatial lens transforms how community assets are understood, shifting the focus from simple presence to real-world accessibility.
Drawing on rural case studies from the Midwestern United States, this work integrates open geospatial data with socioeconomic indicators to build a flexible, customizable and reproducible workflow centered in QGIS. The presentation highlights how QGIS enables the synthesis of diverse data sources and analytical techniques into a cohesive, scalable process. Attendees will see how spatial patterns of access emerge when community assets are analyzed in relation to transportation networks, physical barriers, and the lived realities of rural environments.
This approach positions QGIS not just as a mapping tool, but as a platform for spatial thinking and discovery. Through compelling visualizations and case examples, we illustrate how subtle infrastructural features—such as rail corridors, disconnected street networks, or uneven service distributions—can produce significant inequities in access, even within small communities. These insights underscore the importance of embedding spatial analysis into community development practice.
The session will also reflect on the opportunities and challenges of working with open data, including issues of data quality and consistency, and how QGIS can be used to navigate and mitigate these limitations through user defined configurations and modeling. By emphasizing transparency, adaptability, and accessibility, this workflow is designed to be used by researchers, planners, and community stakeholders alike.
Attendees will leave with a fresh perspective on how QGIS can be leveraged to support informed, data-driven decision-making. This presentation offers an engaging and forward-looking case study that repositions spatial analysis as a core component of community resilience—introducing spatial capital as a compelling new way to understand and map access and resources.

Ideally, any bug fix, feature or refactoring in a QGIS plugin can be made safely, knowing that the quality checks of the testing framework of the plugin will catch any regressions introduced by the new or changed code.

In reality, getting there can be quite hard: How does one even start to write tests? How many tests does my plugin need? How can the interactive parts of the QGIS GUI be tested? And then, once tests are in place, how do I make sure that all PRs are tested? And what makes certain that the code commited to main actually passes all tests?

In this talk, we will showcase how to write tests for a QGIS plugin using pytest and how to automate running tests using the GitHub and GitLab CI.

All this is not done using a toy project, where often everything seems to neatly fall into place.
Instead, we will have a look at a real-world example: the ORSTools QGIS Plugin, showcased at QGIS UC 2025.

One of the main features missing in QGIS, compared to other enterprise GIS, is streamlined web map publishing. Fortunately, there is the QGIS server, which is co-developed with the QGIS desktop app, and a whole ecosystem of tools that provide web map functionality.

This talk aims to review the current state of web map publishing for QGIS and compare the pros and cons of various approaches. We will look at the usual choices, such as Lizmap, QWC2 and G3W-Suite, each with its own distinct philosophy. We will examine the popular qgis2web plugin for simple map publishing, investigate the lesser-known tools such as GIS Quick, and look at the new options like Mergin Maps (which now includes web maps).

Finally, we will contrast the QGIS-native options with non-native approaches - such as using GeoServer or Felt (which offers QGIS integration) - to see their benefits and limitations.

Controlled End-to-End Testing of QGIS Plugins

At Nelen & Schuurmans we build and maintain several QGIS plugins. Because we like to ship improvements and new features quickly, we try to release new versions often.

Frequent releases only work if the quality is consistently maintained. To help with that (and to reduce manual testing), we rely on automated tests. Besides unit tests, that check isolated pieces of code, we also run end-to-end tests that simulate real user workflows. Ideally, these tests closely mimic what the users do: clicking buttons in the plugin interface. From there, the test follows the whole plugin logic, interacting with external services such as API's, and eventually verifying that the expected result actually happened (for example, a file ending up in cloud storage). In other words, we try to test the full chain to make sure all components work together.

Running these kinds of tests for a GUI application like QGIS is not trivial. We wanted our tests to run both automatically in a headless CI/CD environment (such as GitHub Actions), and locally on a developer’s machine. In both cases, we would like to visually inspect failed tests.

By combining Docker and WSL / Linux X11 window system, and limited mocking of the QgisInterface, we ended up with a single setup that suits are needs. In this presentation, we’ll share how we set this up, the challenges we encountered, and the lessons we learned along the way.

Georama is the new stack for seamlessly and securely publishing OGC geoservices from QGIS. Geogirafe is the brand-new front end developed by the Geomapfish community and is particularly feature-rich. Combining these three solutions makes setting up a geodata infrastructure remarkably straightforward. In this presentation, we will guide you through the process of making your spatial data accessible to end users, in a way that is less arduous than in the past.

QGIS’s plugin ecosystem enables accessible workflows that extend beyond traditional mapping. This 90-minute, hands-on workshop presents a streamlined process for creating 3D terrain models suitable for 3D printing using freely available data and core QGIS plugins. Participants will use four widely adopted plugins — QuickMapServices, OpenTopography DEM Downloader, QuickOSM, and Qgis2threejs — in a cohesive, step-by-step workflow. Starting with basemap acquisition, we will retrieve elevation data, enrich it with OpenStreetMap features, and generate a 3D scene suitable for web-based interactive visualization or export to 3D printing software.

Designed for beginners and educators, the session emphasizes reproducibility and accessibility. Participants will leave with a digital 3D model and a reusable workflow for teaching, research, or public engagement.

This hands-on workshop introduces participants to a complete mobile GIS workflow using QField and QGIS, based on a real-world accessibility mapping exercise.

Participants will collaboratively survey the conference venue to identify and document accessibility barriers such as entrances, stairs, ramps, signage, and facilities. Working in small teams, they will collect structured geospatial data directly on-site using QField, including attributes, comments, and photos.

The collected data is synchronized into a shared QGIS project, where results are reviewed, analyzed, and discussed live. This creates a highly interactive learning experience in which participants not only observe but actively contribute to a meaningful dataset.

The workshop demonstrates how mobile GIS can be applied efficiently in spatial planning and accessibility analysis. It covers the full workflow from project setup and field data collection to synchronization and evaluation in QGIS.

Designed for beginners to professional users, the session highlights the power of open-source tools in a practical and engaging context, turning the venue itself into a live GIS learning environment.

QField's built-in form interface covers most data collection needs — but what happens when your project demands something it simply can't deliver? This talk explores how to break free from QField's native form UI using the app-wide QML plugin mechanism: a powerful but largely undocumented capability that puts full control of the data entry experience in your hands.

Most practitioners who discover QML customization in QField start at the layer level. This talk makes the case for thinking bigger. By working at the app-wide plugin level — through main.qml and metadata.txt — you gain the ability to intercept and completely replace QField's native form drawer for any layer in your project, with a single, maintainable plugin.

We'll walk through the key concepts: how QFieldSync exports projects and names GeoPackages, how the app-wide plugin mechanism works and why it differs fundamentally from layer-level customization, and how to use iface.findItemByObjectName("overlayFeatureFormDrawer") to hook into QField's UI at runtime. Along the way, we'll cover the real challenges encountered — including QML/Qt integration quirks and debugging strategies — and the solutions that made it work in production.

Whether you're a QField power user who has hit the limits of the native form, or a developer curious about what's possible beneath QField's surface, this talk will give you a clear mental model and a practical starting point for building custom form experiences that your field teams will actually want to use.

At the Danish Nature Agency, we are delivering large-scale climate and wetland restoration projects covering 45,000–70,000 hectares. These projects are implemented by many project managers, most of whom are not GIS specialists.

To support this, we have developed a standardized QGIS project combined with a custom plugin and toolbar that transforms QGIS into a guided workflow platform. Instead of relying on manual GIS operations, users are guided through predefined processes for creating projects, editing data, running spatial analyses, and generating outputs.

The plugin provides one-click tools for key tasks such as spatial overlap analysis, compensation mapping, nitrogen and CO₂ screening, and automated extraction of land ownership data. Behind the scenes, complex geoprocessing workflows—such as clipping, dissolving, overlay analysis, and reporting—are executed in a consistent and controlled way.

This approach ensures data consistency, reduces errors, and allows non-GIS users to independently manage complex spatial workflows. Outputs are directly integrated into organizational processes, including standardized Excel reports and data deliveries.

The talk will demonstrate how QGIS can be adapted from a specialist tool into a scalable operational platform, enabling large organizations to deliver environmental projects efficiently and consistently.

The presentation will cover experiments with styling a Swiss topographic map based on data from the 'Swiss Map Vector 25' dataset.

The presentation discusses and demonstrates styling, symbology and labelling topics, such as
- using units for either print or screen maps
- fixed reference scale (important primarily for print maps)
- the use of data-defined properties and expressions
- styling roads and trails with multiple symbol layers and advanced dashing
- splitting up layers according to drawing levels (e.g. buildings below or above railways or cable cars)
- organising layers: flat layer drawing order list vs. thematic organisation in layer tree
- point and area symbology tricks (e.g. advanced hachures (line pattern fills) that follow orientation of geometries)
- advanced labelling with manual or automatic labelling placement, labelling rules and data-defined expressions
- selective masking to better distinguish labels from darker geometry symbols in their background
- terrain representation (hillshading, rock drawing and contour lines)

The presentation will also discuss missing symbology features that, if implemented, would help to better style topographic maps, especially in the alpine regions with a lot of rocky areas.

The INTERLIS modeling standard and the QGIS Model Baker plugin provide everything you need to collect, manage and exchange harmonized data and ensure consistency, data quality and system independence. So let's have a look at it. This workshop provides an initial impression of INTERLIS and shows how easily you can use it in QGIS.

Authorities in Switzerland and Colombia use a model driven approach for collecting, managing and exchanging harmonized data. INTERLIS is the data modeling standard for geospatial data, ensuring consistency, data quality and system independence.

Model Baker is a QGIS plugin to create projects from plain text INTERLIS models including layer tree, forms, relationships and more.

In this workshop, we will explain the benefits of INTERLIS and guide you through the following workflow:
+ Analyze a conceptual model in INTERLIS
+ Convert a conceptual model to a database (ili2db)
+ Build automatic forms for data capture from your database (QGIS Model Baker)
+ Capture the data (QGIS)
+ Validate the data (QGIS Model Baker / iliValidator)
+ Exchange the data (ili2db)

This workshop is for INTERLIS beginners and people interested in this approach.

Requirements for the Attendees
+ QGIS LTR
+ Java Runtime Environment ( https://adoptium.net/ 1.6 or later) or openjdk (18)v

Integrating QGIS into a Visual Analytics platform: lessons from LanDS

The Land Degradation Decision-Support Toolbox (LanDS) is an open-source platform designed to support the monitoring, assessment, and upscaling of land restoration measures across Mediterranean regions within the REACT4MED project.
At its core, LanDS leverages QGIS Desktop and QGIS Server to power an interactive web-based visual analytics environment, where spatial data, model outputs, and indicators are seamlessly integrated into decision-support workflows. The platform enables stakeholders to explore the effectiveness and impact of restoration strategies through intuitive dashboards.
LanDS is built as a modular, open-source Docker-based stack, where cartographic data are stored in a STAC catalogue, authored in QGIS Desktop, dynamically published via QGIS Server and finally embedded into a web application based on Drupal, enhanced with reactive components developed in Vue.js. This architecture bridges the gap between traditional GIS workflows and modern web-based data exploration tools.
This presentation will showcase the system architecture, key design choices, and integration patterns to adopt QGIS as a core component of a scalable visual analytics platform. We will discuss challenges encountered—such as performance, data harmonisation, and user interaction design—and share practical lessons learned in deploying QGIS in production-ready environments.
A live demonstration will illustrate the QGIS-powered functionalities of LanDS toolbox. The talk will conclude with ongoing developments and perspectives on extending QGIS-based solutions toward reusable, market-ready visual analytics frameworks.
LanDS is developed by SoftWater within the framework of the REACT4MED project, funded by PRIMA-MED programme.

We used QGIS combined with the capabilities of PostGIS to create a plugin allowing to visualize and edit topological road network data with linear referencing capabilities.

The data is stored in a PostgreSQL database, and trigger functions are used to:
* Automatically populate certain fields (creation date, modification date, length, etc.)
* Respect topological rules (segments, nodes, connections, etc.)
* Automate certain tasks: automatically split roads at intersections, automatically create upstream and downstream nodes for segments, etc.

PostgreSQL functions are also used for linear referencing calculations: to determine the reference marker ID (“PR”), the curvilinear abscissa, the distance to the road (right or left). For example, “D809 PR 2+135, side G, offset 3.4 m” for a point on the map.

In QGIS, we have enabled the advanced editing options in the project properties to facilitate digitizing, including automatic transaction groups that allow users to immediately see how entering a feature affects other layers (clipping, moving, etc.). This allows users to see the results of the database calculations right away without having to save their edits.

We also made full use of QGIS's capabilities for interacting with the database:
* Advanced search by adding an item to QGIS's global search tool (shortcut “CTRL+K”) that automatically zooms in on a specific location using an address in the format “[road code] [marker] [abscissa]”
* Real-time display of references when hovering over a road via a toolbar button. When enabled, a query corresponding to the mouse coordinates is launched, and the database response is displayed
* Python actions for certain layers to initiate processing on an object. For example, a right-click allows you to finalize the creation of a roundabout based on the digitization of a circle at the intersection of road segments.

Of course, QGIS’s editing forms also ensure that attributes are edited correctly across different tables, particularly through expression constraints and advanced tools that provide drop-down lists, checkboxes, the ability to select a parent segment by clicking on the map (the “Relationship Reference” tool), and so on.

For the tool’s more complex functions, we created algorithms for the QGIS Processing toolbox: creating the structure (tables, functions), importing data, copying data into an editing sandbox, and validating that data.

In this presentation, we will demonstrate how QGIS addresses a complex business challenge while serving as a robust interface to a PostgreSQL database.

Cartografie for Amsterdam

The 'Kaart van Amsterdam' is a topographic map widely used within the municipality of Amsterdam. It has been cartographically designed and adjusted during the past decades and gets annual updates. The cartographic software currently in use is end-of-life and needs replacement. To test if QGIS could be an option for that, they ran a proof of concept project to recreate exactly the same map in QGIS. The data preparation and update process needed a redesign as well, because QGIS is data based and not just a digital drawing.
This presentation will show the process, challenges, found solutions and the resulting map. tl;dr QGIS has stunning cartographic capabilities!

Messy, overlapping labels are one of the most common challenges in map design - and a major source of time-consuming manual fixes. While QGIS provides a powerful labeling engine, many users only scratch the surface of what it can do.

In this hands-on workshop, participants will learn how to configure and optimize label placement using a range of practical techniques. Through guided exercises and real-world examples, we will explore key settings in the labeling engine and how they influence label behavior. Participants will also learn how to work with labels in map layouts to ensure clear and consistent map design.
By the end of the workshop, participants will have a solid understanding of how to create well-placed labels and how to streamline their labeling workflows in QGIS.

Target audience: QGIS users with basic experience who want to improve their labeling skills and gain more control over automated label placement.

Snow avalanches are a destructive force that pose significant risks for exposed buildings, public roads or ski resort infrastructure. In order to mitigate this risk to infrastructure and additionally reducing the exposure of professional workers, remote avalanche control systems (RACS) are widely used in mountainous regions all over the world. These RACS contain explosive charges that are deployed in fall before the start of winter, either by helicopter or by foot depending on the system. During winter, if meteorological circumstances require it, explosive charges can be triggered remotely in order to release avalanches in a controlled and save manner. When triggered, the explosive charge hangs on a rope underneath the deployment box and above the snowpack to maximize its effective range. In spring the magazine is flown down and stored in a building for maintenance and prolonging the lifetime of the system, while the 10 m tower stays in place. Due to these systems being placed within the release zone of the avalanches and in a high alpine environment they need to be anchored to the ground using five anchors of up to 9 m in length depending on ground conditions. An optimal planning phase ahead of construction work optimizes installation costs and avoids possible repositioning of the system in the future. Furthermore, the RACS should be placed in order to maximize the effective range of the explosive charge on the snowpack. Finding the optimal balance between minimizing the amount of systems needed while still affecting the release area with the explosive blast. QGIS supports this process of finding the optimized RACS placements and communicating proposed locations to our customers. As a base dataset a DEM of 2-5 m spatial resolution and the area of interest the customer wants to affect are used. Viewing the terrain in a 3D viewer allows to get a first understanding of the terrain in order to set the first possible locations of RACS. Due to the radial expansion of the pressure wave the explosive effect of the charge can be modeled by calculating a viewshed. Based on measurements of the pressure wave’s effect of a 4.5 kg explosive charge a 120 m radius effective range is applied for the viewshed at a viewpoint height of 4 m. After analysing the calculated viewshed, adaptions to the RACS placements can be made to further optimize the effective range. These steps will then be iterated until the optimal locations have been determined and verified in the terrain during a field visit. Versions of possible RACS placement can then be visualized in two dimensional or three dimensional maps. These maps we then use as a communication tool to the customer to discuss the amount of RACS and the optimal locations of the systems that we propose.

REDOG is a Swiss voluntary organisation that trains and deploys rescue teams consisting of people and dogs to locate missing or buried individuals. It is made up of volunteers who are often called upon at very short notice and then set out on the search.

The searchers are organised by an operations manager. This person assigns search areas to the searchers and their dogs, thereby coordinating the operations. The searchers have a tracker or a smartphone with which their search routes are recorded and ultimately visualised at the operations centre. The technology used must be easy to operate and robust.

REDOG has opted for the GI-ANT solution from GEOTEST. This solution is based on QField and is therefore technically processed and organised via QGIS. A cloud solution in the background enables the real-time synchronisation of the collected data (search areas and routes). QGIS would also be the tool for visualisation. However, as it is too much of an expert system, it is deliberately not used. Thanks to web solutions such as Lizmap or the QField Desktop App, it is nevertheless possible to use QGIS as the main organisational tool for project administration – in the background, visible and usable only by experts.

Thanks to the now very extensive QGIS ecosystem, expert solutions can nevertheless be very simple for users and reduced to the essentials. This means that searchers can be equipped with the necessary technology, which also functions under adverse conditions. At the same time, thanks to real-time synchronisation, the operations command centre has an overview of the areas already searched at all times. As REDOG, being a voluntary organisation, has very limited financial resources, open-source tools are very helpful in keeping costs low and, in particular, largely avoiding licence fees.

The presentation introduces the project and explains how the components mentioned are coordinated. It also discusses the challenges involved in implementing and maintaining such a project.

Traditional GIS outputs often focus on a single map or static chart, but modern communication demands richer, data-driven infographics that combine multiple visual elements-maps, line charts, pie charts, bar charts, and styled text-into publish-ready layouts. This presentation shares practical techniques for building complex, multi-page infographics entirely within QGIS, leveraging its native layout system to produce silky-clean charts without the need for external graphic design software.

Attendees will discover how to produce publication-quality line, pie, and bar charts directly from attribute data using QGIS’s built-in tools, layout items, and PostGIS functions—all, while maintaining full control over styling. The real challenge, however, lies in performance: generating multi-page infographics with dozens of data-driven elements can quickly become slow and resource-intensive.

To solve this, we will explore a performance-tuning strategy that distributes the data extraction workload across three key components of QGIS:

-SQL layers: pre-aggregating and filtering data at the database level to reduce processing overhead.

-Model Designer: building reusable, batch-processable models that prepare data for each page by storing required values as project variables.

-Layout expressions: using dynamic expressions to pull pre-processed data directly into layout items, avoiding repeated recalculation.

By properly distributing the load, we achieve near-instant layout refreshes even for infographics with 70+ layers or thousands of data points. The session will include live demonstrations of a real-world example.
A sample of the output can be viewed at
https://reliefweb.int/report/syrian-arab-republic/syrian-arab-republic-overview-humanitarian-response-january-december-2025

This presentation details the technical implementation of a QGIS-based geospatial workflow within the Municipal Treasury of Caucaia, Brazil. As the Secretariat of Finance (SEFIN) transitioned from fragmented legacy systems to a centralized spatial database, QGIS emerged as the primary tool for fiscal auditing and land administration.
The core of the methodology relies on the integration of QGIS with PostGIS to perform spatial analysis for tax consistency verification. We demonstrate how automated processing models cross-reference cadastral data with high-resolution imagery and external registries. A key focus of this session is the technical challenge of aligning municipal data with Brazilian national standards, specifically SINTER (National Land Management Information System) and CIB (Real Estate Registration National Code).
SINTER represents a major interoperability milestone and a significant technical hurdle for all 5,570 Brazilian municipalities. This presentation highlights how Caucaia successfully navigated these requirements using FOSS4G. Attendees will gain insights into how open-source tools facilitate fiscal justice through precise territorial management, offering a replicable success story for other jurisdictions facing complex national integration mandates in a demanding public sector environment.

For many years, our organisation Geotest AG relied on FeldApp, a custom-built field data collection tool that emerged as a modern digital solution when mobile GIS options were limited. Over time, however, maintaining and extending this homegrown application became increasingly demanding. With frequent updates, limited staff, and growing amounts of data and expectations, our in‑house capabilities reached their limits.
We decided to rethink our strategy and evaluated modern solutions with a clear focus: sustainability, interoperability, and full control over our data. Open source emerged as the strongest foundation. Among several candidates, QField stood out thanks to its seamless integration with QGIS, its customizability and an active community including opengis.ch as a local partner and supporter.
This led to the development of GI-ANT, our new field data ecosystem built around opensource components. GI-ANT combines:
• QField for mobile data collection
• A QFieldCloud instance, hosted by opengis.ch, to ensure data sovereignty
• A PostgreSQL/PostGIS backend
• Custom QGIS plugins based on qfieldcloud-sdk for project creation, cloud synchronization and export
• A WebGIS solution (currently under evaluation and development) to provide browser‑based access also for external customers
The migration from FeldApp to GI-ANT required reengineering workflows, automating maintenance processes, and aligning data models with modern standards. This has produced a powerful, scalable system that lowers maintenance demands while providing users with efficient, QGIS native tools. In doing this we can now concentrate our efforts on increasing functionality, capability and support for our users.
Our presentation highlights the strategic reasoning, migration experience, and lessons learned while transitioning from a homegrown solution to an open, future-proof architecture.

Maintaining spatial consistency between different thematic geographic datasets and reference layers (such as cadastral parcels or base maps) is a persistent challenge in GIS workflows. Manually snapping boundaries to match updated reference data is not only time-consuming and prone to human error but also difficult to reproduce. To address this, Athumi (The Flemish Data Utility Company) & Flanders Heritage Agency developed brdr, an open-source Python library, and its companion QGIS plugin, brdrQ, designed to automate and streamline the alignment of geometries to reference borders.

By decoupling the alignment logic (brdr) from the user interface (brdrQ), the project offers flexibility for both developers and GIS analysts. Developers can integrate the alignment engine into automated data pipelines, while analysts can leverage the QGIS plugin for visual validation and manual fine-tuning. Both ways of working ensure a significant reduction in workload to obtain higher-quality data.

In this presentation, we will demonstrate the underlying algorithm, showcase the QGIS integration, and discuss real-world use cases where these tools have improved the efficiency of spatial data management at the Flanders Heritage Agency.

Python library: brdr

At its core, brdr is a Python library built to detect and resolve geometric discrepancies through a series of deterministic spatial calculations. Unlike simple snapping tools, the brdr-algorithm evaluates candidate reference geometries by calculating relevant intersections and differences. It uses these metrics to generate alignment predictions: the library calculates the most likely intended geometry based on geometric stability. This predictive approach allows for a high degree of confidence in automated workflows, as ‘brdr’ can distinguish between a deliberate gap and a registration error, maintaining the overall structural integrity of the original dataset.

QGIS plugin: brdrQ

brdrQ integrates the 'brdr'-library into a user-friendly QGIS-plugin, making the 'brdr' logic more accessible through visual GIS-workflows. brdrQ offers several tools, including:

• Feature Aligner: An interactive tool for record-by-record inspection, allowing users to compare "predictions" (suggested alignments) with a correctness score before committing changes.
• AutoCorrectBorders: A processing algorithm for bulk alignment of datasets.

The Canton of Basel-Stadt uses QGIS as the main tool for publishing geospatial data. We pursue the goal of a self-service data publication to enable departments to publish their data independently.
In this approach, departments create their own QGIS projects. These projects are used directly for publication and are processed in an automated workflow. The data is validated and converted into a cloud format, metadata is added, and the projects are published through a shared QGIS Server endpoint. The QGIS Layer Definitions are saved as an artifact together with the data in an Object Storage and are loaded dynamically into QGIS Server.
During the publication workflow the data and the .qlr-file is automatically included into the qigs project during runtime.
This presentation introduces the approach and shares practical experiences from its implementation in the Canton of Basel-Stadt.

The NASA-ISRO Synthetic Aperture Radar (NISAR) mission will provide valuable, high-resolution earth observation data. However, bringing this data into standard GIS software like QGIS is currently difficult. NISAR Level-1 Radar Single Look Complex (RSLC) products are distributed as large HDF5 files containing complex arrays (real and imaginary numbers). QGIS cannot natively render these complex radar signals, meaning users often face memory crashes or are forced to learn specialized, command-line SAR software just to view the imagery. This creates a technical barrier for regular GIS users, disaster responders, and researchers who just want to integrate radar data into their existing maps.
To solve this, we developed a standalone Python plugin designed exclusively for QGIS 3. The plugin uses GDAL and NumPy to directly read the NISAR HDF5 data structure. Instead of loading the entire multi-gigabyte file into memory at once, the code reads and processes the data in small chunks. It performs the necessary mathematical conversions to extract physical, GIS-ready properties: Amplitude, Intensity, and Interferometric Phase.

The plugin's architecture was actively developed and validated using datasets available from NASA Earthdata Search, ensuring it flawlessly handles authentic NISAR file structures. The plugin saves the extracted output as standard GeoTIFF files and automatically loads them into the QGIS map canvas. Additionally, it reads the hidden Quality Assurance (QA) and product specifications from the HDF5 metadata and exports them as a clean PDF report for scientific validation.
This plugin makes viewing complex SAR data as easy as opening a regular raster file. Users simply open the plugin interface in QGIS, select their downloaded NISAR .h5 file, and choose their desired polarizations. With one click, the tool extracts the arrays into standard TIFF layers that can be styled, overlaid, and analyzed natively

Environmental decisions in under-resourced governments and NGOs are often delayed or poorly informed, not because of lack of data, but because of lack of accessible tools to process and visualize it. This talk presents one replicable open-source spatial methodology applied in two very different real world contexts: municipal conservation planning in Colombia and endangered subspecies protection in the Balearic Islands, Spain.
The methodology was first developed in La Unión, a small municipality in Valle del Cauca, Colombia. Using QGIS geoprocessing tools, including buffers, clip operations, and spatial joins, I built a workflow to identify priority areas for water resource conservation and biodiversity protection, integrating protected area layers, forest cover, terrain slope, and proximity to water sources. This approach is designed to be reproducible across municipalities sharing similar geographic and ecological profiles.
The impact went far beyond a single environmental study. Decades of municipal data stored in paper archives and AutoCAD files were migrated into structured QGIS databases, creating for the first time a shared spatial infrastructure across all municipal departments, environment, urban planning, agriculture, and territorial planning. Today, every department in La Unión's local government uses QGIS to make articulated, spatially informed decisions. QField played a key role in this transformation, enabling field teams and community members to collect georeferenced data directly, closing the gap between office analysis and on-the-ground reality.
Building on this experience, I am now applying the same open-source spatial methodology in a very different ecological context: island biodiversity conservation in the Mediterranean. Working with an environmental NGO in Ibiza, I am mapping the distribution of Podarcis pityusensis, a lizard with around 40 subspecies endemic to the Pityusic Islands, currently endangered by invasive predators such as snakes and feral cats. The same QGIS workflows are helping identify where populations have declined and where urgent conservation interventions are needed to ensure their survival.
One methodology. Two contexts. One conclusion: QGIS, combined with open data, QField for field collection, and community training, becomes a full decision-making infrastructure, accessible to any municipality or NGO regardless of budget or geography.

We are using Smallworld in the energy sector for our GIS. The Web-GIS is provided by NIS AG.
The use-case will show our path from a proprietary front-end solution to the open source landscape with QGIS, QGIS-Server and Qfield

Communication networks are often understood as immaterial flows—continuous, invisible, and detached from the physical world. This project challenges that assumption by showing how signal is shaped by, and entangled with, terrain, infrastructure, and socio-economic conditions.

The presentation will introduce a QGIS-based workflow that approaches telecommunication networks as spatial fields rather than abstract coverage. Using South Korea as a case study, multiple layers—including elevation (DEM), existing cell tower locations, population density, and proximity to maintenance and environmental resources—are brought together. Through viewshed analysis and multi-criteria mapping, these layers are combined to show how signal distribution is conditioned by geomorphology, access, and infrastructural logic.

Instead of treating signal as uniform, the research demonstrates how it is unevenly produced. Mountain ranges, urban density, and infrastructural clustering generate patterns of amplification and attenuation, creating differentiated zones of visibility and access. What appears continuous at the network level becomes highly variable when understood spatially.

This framework is then extended to the level of the user. Network performance is not only shaped by physical infrastructure, but also by economic structures embedded in mobile data plans. Different pricing tiers offer varying speeds, priorities, and levels of service, meaning that the same location can produce different experiences of connectivity. By relating infrastructural conditions to these tiers, the workflow begins to map how signal is not only distributed across space, but also stratified across users.

Coming from a design and architecture background, my research approaches QGIS not only as an analytical tool but as a way to make invisible systems legible. The goal is to visualize relationships that are typically treated as disconnected: between signal and terrain, infrastructure and population, and network access and economic differentiation, forming a basis for targeted spatial interventions and more informed infrastructure planning.

The presentation will walk through the following QGIS pipeline:
1. assembling and structuring multi-layer spatial datasets
2. performing viewshed analysis for terrain-based signal modeling
3. integrating physical and infrastructural factors into composite suitability maps
4. extending the analysis to user-level variation through pricing tiers

More broadly, this work highlights a particular way of using QGIS: not just to map what is already known, but to reveal spatial systems that are typically unseen or assumed to be immaterial. Even when data is partial or restricted, QGIS offers a set of geoprocessing tools that allow for creative combinations, inference, and experimentation, opening up ways to understand systems that cannot be directly observed. In this sense, QGIS becomes a tool for discovery, capable of generating new spatial readings and informing how we understand and intervene in everyday environments shaped by invisible infrastructures.

During emergencies like natural disasters, technology/infrastructure failures, or terrorism events, before official governing bodies can get statements out, social media is the first place these issues are documented. While million dollar sensors exist to collect data about the perceived severity of a disaster, the voices of people in crisis are often missing or distorted by algorithms optimized for profitability. I developed a custom QGIS tool designed to map social media data during times of disaster. This project’s aim is to better inform responders during crisis and researchers post crisis to visualize emotional topographies of a disaster in real time. In this presentation, I will discuss the methods and technical challenges of building a custom UI tool with large and messy datasets, delve into the underrepresented value of emotion in geography and emergency management, and discuss future direction for this project.

The Financial Times’ Visual and Data Journalism team produces more than 7,000 maps and charts annually covering the latest in international news and markets. For more than a decade, QGIS has been an invaluable part of our toolkit for data visualisation and analysis for breaking news and investigative work. In this presentation Graphics Editor Aditi Bhandari will share key examples of the team’s cartographic storytelling.

Extreme urban heat and wind events increasingly challenge conventional urban climate assessment tools. While parameterized, CFD, and RANS models are effective for routine analysis and design comparison, short-duration, high-risk events require explicit representation of turbulence, radiation, and interactions with complex urban morphology. High-resolution Large Eddy Simulation (LES) models such as PALM address these processes at the urban scale, but their adoption remains limited due to complex configuration workflows and lack of integration with standard GIS environments.

This presentation introduces PalmQ10, an open-source QGIS-based workflow and plugin concept designed to lower the barrier to entry for PALM simulations. PalmQ10 enables a streamlined, end-to-end workflow within QGIS, from defining simulation domains and parameters to automatically acquiring globally available datasets, preprocessing model inputs, executing PALM simulations, and producing communication-ready maps and graphs. By embedding high-fidelity simulation within a familiar geospatial interface, the workflow aims to bridge the gap between advanced atmospheric modeling and applied urban policy and planning practices. We present the plugin architecture and demonstrate its application through a case study in Ciutat Vella (Valencia), including initial validation against in-situ temperature and humidity measurements during extreme heat events.

The presentation concludes by outlining the broader vision for PalmQ10 as a platform for reconstructing past extreme events and exploring future urban climate scenarios, including climate change projections and design interventions such as modifications to materials, vegetation, and built form. Ultimately, PalmQ10 leverages the QGIS platform and open-source tools to support more informed, spatially explicit decision-making for climate adaptation and urban resilience.

The growing demand for energy from renewable sources is usually at odds with landscape protection. The use of QGIS capable of processing from a qualitative-quantitative perspective presents itself as a powerful and effective means of analyzing foreseeable impacts and guiding projects to minimize the effects on landscape and territory.

We will present and discuss selected real-world case studies on intervisibility and the visual impact of new renewable energy plants, using the viewshed analysis plugin. We will also examine the configuration of key parameters, such as observer height and viewing distance, the digital terrain model, and subsequent calculations, along with insights derived from both the raster outputs of the plugin and the processing techniques that best represent terrain morphology.

We will examine the different methodological approaches to intervisibility analysis for wind farms and photovoltaic plants. The “pure” results derived from these analyses will be compared with actual visibility conditions on site. To this end, maps will be produced that account not only for terrain morphology but also for vegetation cover and human visual perception parameters. The analysis will include the calculation of affected pixels and surface areas across visibility categories, as well as the definition of visibility (sharpness) bands to support a more consistent interpretation of the results.

The presentation will also focus on the graphic rendering and subsequent reading of this information, as well as on the production of bivariate legend cards for an in-depth study of the impacts of cumulative intervisibility.

Urban climate analysis increasingly relies on integrating heterogeneous geospatial datasets from multiple administrative levels, formats, and sources into a coherent and reproducible workflow. In this talk, we present our experience using QGIS as the central platform to harmonize and prepare urban geodata for the PALM city climate model as well as for evidence-based city planning.

Our work focuses on the practical challenges of handling diverse data types, with a technical emphasis on integrating CityGML datasets into PostgreSQL/PostGIS databases and utilizing QGIS for efficient management, visualization, and processing. We demonstrate how raw spatial data — including building footprints, land use, vegetation, and high-resolution imagery — can be transformed into consistent, model-ready inputs while maintaining traceability and reproducibility. A second focus is on deriving actionable urban planning recommendations from the analyses. We illustrate how to translate results into standardized climate analysis maps that depict city-wide climatic variables such as air and surface temperature, PET, wind fields, airflow, and the climatic functions of urban areas. Additionally, we show how clear action maps and practical planning guidelines can support decision‑making for non‑specialist administrators and political actors.

By showcasing a complete pipeline from raw geodata through QGIS-based preprocessing to climate simulation and interpretation of results, we illustrate how QGIS acts as a bridge between complex urban datasets and actionable insights for city planning. Attendees will profit from a practical application of QGIS in real large-scale urban climate adaptation projects, and how open-source tools can facilitate robust, reproducible, and scalable workflows that inform real-world decision-making. Our presentation is therefore aimed at attracting GIS practitioners, modelers, and urban planners to use and further develop QGIS not only as a mapping tool but as a versatile platform for data integration, simulation preparation and communication of results through standardized maps and planning principles for evidence-based city planning.

Marios S. Kyriakou, Ioannis Chrysostomou, Stelios G. Vrachimis, Konstantinos Papadopoulos, Demetrios G. Eliades
KIOS Research and Innovation Center of Excellence, University of Cyprus

Water losses in distribution networks remain a major challenge for utilities worldwide. Approximately 30% of water is classified as non-revenue water, while around 22% corresponds to real losses. To reduce real losses, pressure management is applied. In recent years, we have developed the OCEANOS Digital Twin, an integrated platform that uses QGIS as the interface for visualizing and processing data. The platform connects to a backend system that processes different data layers and models. It uses GIS information, such as elevations and pipe networks, to create a hydraulic model. In addition, it incorporates sensor data (flow, pressure) and smart meter data to solve an optimization problem that estimates flows and pressures. We designed a system that helps operators identify how much they can reduce pressure while considering building heights obtained from open data. This approach ensures that service levels remain unaffected. The methodology was tested in Limassol and Larnaca. The pressure estimates were validated using available measurements. Preliminary results showed that, in Larnaca, it was possible to achieve a reduction in real losses while maintaining adequate service conditions. This work presents the technical solution developed within QGIS and demonstrates how the OCEANOS Digital Twin supports pressure management strategies for leakage reduction.

Acknowledgments
The work was supported by the European Union’s Horizon 2020 Teaming programme under grant agreement No. 739551 (KIOS CoE), the IDEATION project (Grant Agreement No. 101157371), the projects Limassol Smart Water and Larnaca Digital Twin Decision Support System, funded by the Recovery and Resilience Plan of Cyprus under the European Union’s NextGenerationEU initiative, and the Government of the Republic of Cyprus through the Deputy Ministry of Research, Innovation and Digital Policy.

Large operational organisations increasingly rely on GPS data collected by vehicles on the field, but transforming raw GPS tracks into reliable and statistically meaningful operational parameters remains a complex and time-consuming task.

This talk presents a real-world use case developed within Iren SpA, one of the largest multi-utility companies in Italy, focusing on waste collection services. We introduce GPS Analyzer, a custom QGIS 3 plugin developed entirely by internal IT developers and currently used in production to support service monitoring, planning, and optimisation activities.

The plugin provides a semi-automatic workflow to analyse GPS tracks enriched with geospatial information and operational signals (engine status, power take-off activation, container lifting, emptying events, vehicle speed, etc.) coming directly from the vehicles. Starting from raw GPS data, the tool supports the identification of valid service tracks, the classification of service phases, and the calculation of key operational and productivity parameters. Each phase of the analysis workflow is encapsulated in a dedicated tool, allowing GIS operators to execute complex processing steps with minimal manual intervention. The parameters obtained are then used both for performance monitoring and for the design or optimisation of waste collection routes.

Before the introduction of GPS Analyzer, the analysis of a single GPS track required approximately 30 minutes of manual work by a GIS operator. Thanks to the semi-automated workflow implemented in QGIS, the same analysis can now be completed in about 5 minutes, resulting in a time reduction of more than 80%. This improvement makes it possible to analyse a significantly larger number of tracks, increasing the statistical robustness of the derived parameters and enabling data-driven decision-making at scale. The plugin has already been used to analyse hundreds of real-world GPS tracks.

Although the plugin is currently designed for internal use and tailored to the waste management domain, the overall approach is highly transferable. Any context where GPS tracks include both spatial information and operational signals can benefit from similar workflows implemented in QGIS.

The presentation will focus on the problem addressed, the geospatial data available, the QGIS-based workflow, the benefits achieved and the lessons learned from deploying and maintaining a custom QGIS plugin in a large operational organisation.

Fitness activity data usually lives inside proprietary platforms, which makes it hard to analyse, combine with other spatial data, or publish in reusable map products. qfit is a QGIS plugin that brings that data back into an open GIS workflow.

In this talk, I will present qfit, a plugin that imports fitness activities from Strava into a local GeoPackage, turns them into analysis-ready QGIS layers, and supports a complete workflow from import to publication. The plugin covers three main use cases: importing and synchronising activities, visualising and filtering them in QGIS, and generating PDF atlas outputs with activity pages, summaries, and profile-ready metadata.

I will show how personal activity data can become a real geospatial dataset: styled, filtered, queried, combined with basemaps, and prepared for high quality print layouts. I will also share a few practical lessons from building the plugin, including handling detailed track geometry, temporal data, and atlas-oriented layer design.

This session is aimed at QGIS users and plugin developers interested in personal mobility, sports data, and new geospatial workflows built on open tools.

Where did we start? What has the journey been like? Where are we now? What’s next?

In recounting our journey, I would also like to touch upon the general themes that have been guiding us along the way:
- Public sector geoinformation as a contribution to the state’s digital infrastructure - criteria and requirements.
- QGIS as a key component in the transition from closed expert systems to an open spatial data infrastructure.
- Implementation and maintenance of QGIS as a standard IT component for desktop GIS within the state administration.
- Opportunities and limitations, but also the responsibilities we, as a major user, recognise in ensuring the long-term availability of QGIS.

Last but not least the question: what opportunities and challenges do the current technological and geopolitical developments throw up?

Closing session will wrap up the two days of the conference.

Urban environmental challenges such as illegal dumping, land degradation, and ground instability increasingly require integrated, data-driven responses that go beyond isolated geospatial analysis. While a wide range of tools exists for satellite processing, spatial modelling, and field data collection, these systems often operate independently, limiting their effectiveness in real-world operational environments. This workshop introduces a practical framework for building an open System of Systems (SoS) using QGIS as a central integration platform for urban environmental monitoring and decision support.

The workshop positions QGIS not merely as a desktop GIS tool, but as an orchestration layer capable of connecting heterogeneous subsystems, including satellite-based Earth observation (e.g., Sentinel-1 InSAR products), AI-assisted detection workflows, multi-criteria decision analysis (MCDA), and field-based data collection. Participants will learn how to integrate these components into a coherent workflow that transforms raw geospatial data into actionable intelligence.

Through guided, hands-on sessions, participants will work with real-world datasets to (1) import and visualize time-series InSAR outputs, (2) integrate multiple spatial indicators relevant to urban environmental conditions, (3) implement MCDA techniques within QGIS for spatial prioritization, and (4) conceptualize how these analytical components can be embedded within a broader System of Systems architecture supporting operational decision-making.

The workshop emphasizes open-source tools, reproducible workflows, and interoperability, aligning with current discussions on GIS sovereignty and sustainable digital infrastructure. By the end of the session, participants will gain both technical skills and conceptual understanding of how QGIS can be leveraged as a strategic platform for integrating data, analytics, and operations in complex urban systems.

This workshop is suitable for GIS practitioners, urban planners, researchers, and decision-makers interested in advancing from standalone spatial analysis toward integrated, system-level geospatial solutions.

The Contributor Meeting will be held on Wednesday through Friday, and is open to anyone who wants to contribute to QGIS. Tackle bugs, write documentation, or help with translations, there is something for everyone!

See more information and register (not required but helps us ensure that there’s enough food and t-shirts) on https://github.com/qgis/QGIS/wiki/29th-Contributor-Meeting-in-Switzerland .

Aim:
Getting to know MM
Getting started

Mergin Maps is an open-source mobile application based on QGIS that makes field data collection easier.

With Mergin Maps, you can take your QGIS projects with you anywhere in the field. You can then add, store, and edit your data collaboratively, synchronizing it in real time between team members and from the mobile app to QGIS. In this workshop, discover all the benefits of collecting data with Mergin Maps compared with a traditional approach.

Discover how the Mergin Maps ecosystem integrates with QGIS:

The Mergin Maps QGIS plugin
The Mergin Maps mobile app
Mergin Maps Server and Web

This workshop offers an introduction to using Mergin Maps: converting a QGIS project into a Mergin Maps-compatible project, creating forms suited to mobile interfaces, and putting mobile data entry into practice with the app.

The workshop will also cover best practices for maintaining a Mergin Maps project, as well as an overview of the advanced features offered by Mergin Maps, including photo management, GNSS receiver support, synchronization with a PostGIS database, geofencing, and more.

And also… a look at the future improvements we are currently working on for upcoming versions of Mergin Maps!

Developing software as a team typically requires choosing and following coding standards to ensure things run smoothly (larger the team, stricter the rules). QGIS plugin development is no exception.This workshop aims to introduce modern Python development tools for QGIS plugin development.

During the session, we will create a simple QGIS plugin and set up the development environment using best practices. We will cover at least the following topics:
* Configuring Python formatting and linting tools alongside with modern package management (flake8-qgis, ruff, mypy, prek, uv)
* Trying out writing unit tests for the plugin and its UI components (pytest-qgis, pytest-qt)
* Learning how to update translations (qgis-plugin-dev-tools, Qt Linguist)
* Setting up up a CI pipelines for running tests and publishing your plugin automatically with GitHub Actions

QFieldCloud powers field data collection for thousands of projects, but most users only see the surface. This hands-on workshop goes under the hood.
The goal is to spin up a self-hosted QFieldCloud instance from scratch, then work through the official Python SDK (qfieldcloud-sdk) to automate real workflows: creating and managing projects, uploading QGIS project files, triggering packaging jobs, polling job status, and downloading packaged data programmatically.

We'll also cover organization and collaborator management via the API, and dig into the job/package cycle that sits at the heart of any automated field data pipeline — giving participants the tools to wire QFieldCloud into their own infrastructure, whether that's a CI/CD pipeline, a data processing script, or a lightweight custom app. If time permits, we'll sketch out a small LLM-assisted layer on top of the API.

One of the areas in which QGIS has developed the most in recent years is the support of point cloud data. There are now many options for displaying point clouds in both 2D and 3D and in the elevation profile panel. There are also many tools for processing point clouds. It is now even possible to edit point cloud attributes.
This comprehensive workshop will teach you how to work with point cloud data in QGIS. You will learn how to style point clouds to highlight important features, and process and edit them to extract meaningful information. The workshop you’ll learn to:
* Load and display point clouds in 2D.
* Explore point clouds using Elevation profiles.
* View point clouds in 3D.
* Create Virtual Point Clouds (VPCs).
* Use Point Cloud Processing Tools to filter, convert and analyze point cloud datasets.
* Edit Point Cloud attributes.
* Use PDAL Wrench

Software:
To get the most out of this workshop you are encouraged to install QGIS (v 4.x). There are several important enhancements and new processing tools for working with point clouds which are included with the release of QGIS 4.

Note 1: If you will be using a corporate laptop where permissions can be problematic, consider getting these installations completed with IT before you travel to the conference.

Note 2: It is recommended that you also bring a tablet. There is an accompanying step-by-step tutorial. Having a tablet will allow you to read the tutorial on your tablet while working on your laptop.

Data
We will provide the data for the workshop.

QGIS is widely used for geospatial analysis, editing, and cartography, but organizing collaborative workflows for teams working on shared datasets can be challenging. Common issues include synchronizing desktop and web environments, managing simultaneous edits, tracking data changes, and coordinating work across multiple users.

This hands-on workshop introduces an open-source workflow for collaborative QGIS environments using NextGIS Web - an open-source Web GIS server designed for publishing and managing geospatial data and web maps. It integrates closely with QGIS and provides features useful for collaborative teams, including:
- Publishing QGIS projects to the web while preserving map styles (QGIS is used as the rendering backend to ensure strong desktop–web style compatibility).
- Connecting multiple QGIS instances to shared server-hosted datasets.
- Simultaneous data editing from QGIS with interactive conflict resolution.
- Working with feature attachments (photos, documents, and other files) from both QGIS and the web interface.
- Built-in version control for vector datasets, allowing teams to track who changed what and when, review history, and roll back changes.
- Flexible user roles and permissions for managing team access.

During the workshop, participants will deploy their own NextGIS Web instance locally using Docker, perform initial configuration, and explore practical workflows for managing shared spatial data.

Attendees will learn how to:
- deploy and configure a NextGIS Web server,
- publish QGIS projects as web maps,
- connect QGIS to shared server datasets,
- perform collaborative editing,
- track and review data changes using version control.

The workshop will conclude with a multi-user exercise, where participants collaborate on a shared QGIS project to experience real-world team workflows including simultaneous editing and change tracking.

Requirements:
To fully participate in the workshop, attendees should have:
- Docker Engine installed and working on their laptop (local deployment is part of the workshop).
If Docker cannot be run locally, cloud instances can be provided.
- QGIS Desktop installed.

Recommended background:
Basic experience working with QGIS.
Basic familiarity with Docker is helpful but not required.

Workshop outline:
1 Introduction to NextGIS Web and collaborative QGIS workflows
2 Deploying NextGIS Web locally using Docker
3 Initial setup: global settings and user management
4 Creating layers and web maps in NextGIS Web
5 Installing and configuring the NextGIS Connect plugin in QGIS
6 Publishing a QGIS project to NextGIS Web
7 Configuring the published web map and datasets
8 Connecting a clean QGIS instance to the published project
9 Editing server-hosted data directly from QGIS
10 Reviewing dataset version history in NextGIS Web
11 Multi-user collaboration exercise: shared editing workflow

In this workshop, we will explore the diverse range of tools available in QGIS for conducting comprehensive hydrological analysis. Participants will gain hands-on experience with tools from GRASS, SAGA, WhiteboxTools, and PCRaster processing provider plugins, as well as other specialized plugins designed for hydrological studies.

Our interactive session will cover practical exercises on deriving streams and catchments, and calculating essential morphometric parameters such as drainage density, concentration time, and hypsometric curves. By the end of the workshop, attendees will have a solid understanding of how to leverage QGIS for hydrological analysis, enabling them to apply these techniques to their own projects and research.

For almost two years now, QGIS' best field companion QField has gained a plugin framework that allows users to expand the capabilities of QField through QML and Javascript. This workshop introduces the framework and goes through practical examples aimed at empowering the participants into writing their own plugins.

Tired of repetitive GIS workflows that consume time and lead to errors?
This hands-on workshop will show you how to automate and streamline spatial data analysis using QGIS expressions, built-in geoprocessing algorithms, and the Graphical Modeler — without writing a single line of code.
In today’s GIS workflows, repetitive tasks and manual processing can be time-consuming and prone to errors. Whether you are transferring data between layers, running step-by-step spatial analyses, or performing complex geoprocessing tasks, automation can significantly improve efficiency and accuracy.
Based on a used case we will create an efficient, repeatable workflow using OSM data and openly available satellite imagery.

🚀 What you'll learn:
• How to use QGIS expressions to enhance vector and raster analysis
• How to combine algorithms into automated workflows using the Graphical Modeler
• How to process and analyze spatial data without scripting
• How to work with real-world open datasets in a structured way

🛠️ Workshop structure:
1. Introduction to QGIS Graphical Modeler – we discuss the main elements and logic behind the tool
2. Vector & Raster Analysis – Learn how to apply expressions and algorithms to perform meaningful spatial operations (e.g., selections, buffer, raster calculations).
3. Workflow Design – Manually build step-by-step processing chains using QGIS tools and expressions.
4. Model Automation – Use the Graphical Modeler to convert your workflow into a repeatable, parameterized model.

By the end of the session, you’ll have practical experience building robust, automated models that improve efficiency, reduce errors, and boost the quality of your spatial analyses — all within the QGIS environment.

Aim:
Setting up your own self-hosted data capture infrastructure with Mergin Maps and QGIS
(docker / local)

Mergin Maps is built on an ecosystem of components that can also be deployed and used locally for development, testing, and integration purposes.

If you want to really understand how Mergin Maps works under the hood, the best way is to run the whole stack yourself. In this workshop, we're going to walk through setting up Mergin Maps Community Edition (CE) locally on your own machine.
Having a local setup is incredibly useful. Instead of testing things on a live server, you get a fast, isolated environment where you can freely experiment. We'll show you exactly how the database, server, and client apps connect. It’s the perfect sandbox for debugging issues, trying out custom integrations, or just getting comfortable with the architecture. By the end of the session, you'll have a working local instance and a much better grasp on how to manage the platform on your own terms.