If you've spent years in MapInfo Pro, QGIS can feel both familiar and slightly alien at the same time — the core concepts of layers, styling, and spatial queries are all there, but the tools that do the job often go by different names, or work in noticeably different ways. Whether you're exploring QGIS out of curiosity or actively planning a migration, here are five tools worth getting comfortable with early.
1. The Field Calculator MapInfo users are used to Update Column for running expressions against a table. QGIS's equivalent — the Field Calculator — does the same job but with a much larger built-in function library, including native spatial functions like $area, $length, and $geometry. It also supports creating new fields on the fly rather than requiring one to already exist, which speeds up everyday attribute work considerably.
2. The Processing Toolbox This is arguably QGIS's biggest single advantage over MapInfo out of the box: a searchable library of hundreds of geoprocessing tools — buffers, clips, intersections, dissolves, and far more — all accessible from one panel, with the ability to chain them into repeatable models via the Graphical Modeler. MapInfo users accustomed to running these operations one at a time, often via separate menus or the MapBasic window, will find the Processing Toolbox a genuine productivity jump, especially once you start saving your own custom models for recurring workflows.
3. The Layer Styling Panel MapInfo's styling is typically handled per-layer through fairly linear dialog boxes. QGIS's Layer Styling panel is more powerful but takes a bit of adjustment: symbology is rule-based and layered, supporting data-defined overrides (styling driven directly by attribute values), multiple rendering rules per layer, and live preview as you build. It's a steeper initial learning curve, but it opens up cartographic control that MapInfo's native styling tools don't offer as readily.
4. The Query Builder / Select by Expression Where MapInfo users would reach for SQL Select, QGIS offers both a similar SQL-style Select by Expression tool and, separately, the more visual Query Builder in the layer properties. The expression syntax is broadly comparable to SQL, so the transition is fairly gentle, but QGIS also layers in built-in spatial predicates (intersects, contains, within, and so on) directly in the same expression builder — handy for combining attribute and spatial logic without needing separate steps.
5. DB Manager (for PostGIS connections) If you're managing shared or larger datasets, DB Manager is QGIS's built-in tool for connecting to spatial databases like PostGIS directly — browsing tables, running SQL, and adding layers straight from the database rather than working off static files. For teams moving away from individually-edited MapInfo TAB files toward a proper shared database, this is often the single biggest workflow shift, and one well worth exploring early even if you're not ready to fully commit to PostGIS yet.
Getting comfortable with the shift None of these tools are difficult once you've used them a few times — the real adjustment is unlearning MapInfo's menu structure and trusting that QGIS's tools, while organised differently, generally do more with less clicking once you know where to look. If you're planning a full migration, working through these five in a hands-on session tends to be the fastest way to build real confidence.
Want hands-on guidance?
JPS Services runs instructor-led QGIS training courses designed specifically to help MapInfo and ArcGIS users make the switch — covering everything from loading and styling data through to queries, analysis, and producing print-ready maps. Find out more about our QGIS training courses →

​If you're using QGIS day to day, there's a good chance your data lives in shapefiles or file geodatabases. That works fine — until it doesn't. As datasets grow, teams grow, and projects get more complex, a lot of GIS users hit the same wall: file-based formats simply aren't built for multi-user editing, large-scale analysis, or serious data integrity. That's where PostgreSQL and its spatial extension, PostGIS, come in.

​PostgreSQL is a mature, open-source relational database. PostGIS extends it with spatial data types, spatial indexing, and a huge library of spatial functions — everything from ST_Intersects to ST_Buffer to topology validation. In practice, this means you can store millions of features in a single table and query them with genuine SQL power: joins, aggregations, spatial filters, all running server-side rather than choking your desktop machine.

QGIS talks to PostGIS natively — no plugins required. Once you connect, you get:

• Multi-user editing. Several people can edit the same dataset at once without the file-locking headaches of shapefiles or the single-writer limits of file geodatabases.
• Faster performance on big datasets. Spatial indexes mean QGIS only pulls back what's actually in view, rather than loading an entire layer into memory.
• Version control and data integrity. Constraints, triggers, and referential integrity live in the database, not scattered across loosely-linked files.
• A single source of truth. Instead of five copies of a "final_v3" shapefile floating around a shared drive, everyone points at the same live table.
• SQL-driven analysis inside QGIS. The DB Manager and Query Builder let you write spatial SQL directly, and virtual layers let you build views without duplicating data.

​Say you're managing forestry compartment boundaries across several sites. Store them in PostGIS, and every analyst on the team edits against the same live dataset. Run a spatial join to flag compartments within a buffer of a watercourse, and the query executes in the database — QGIS just renders the result. No manual exports, no mismatched copies, no "which version is current" confusion.

​The learning curve is real but not steep: it's mostly a matter of getting comfortable with basic SQL and understanding how spatial indexes work. Once that clicks, most users don't go back to file-based workflows for anything beyond quick one-off projects.

If you'd rather learn this properly than piece it together from blog posts, JPS Services runs a full-day PostgreSQL & PostGIS training course for GIS analysts — from the fundamentals through to spatial queries you can put to work in QGIS straight away. Please complete the enquiry form for more information.

MySQL and PostgreSQL are two of the most widely used open‑source databases in the world. Both are mature, reliable and well supported. But they are built on different philosophies, and those differences matter when choosing the right database for a new system or modernising an existing one.
This blog explains the practical differences in a clear style, simple language, no jargon, and focused on real‑world use.

MySQL has historically been the default choice for web applications, especially those built on the LAMP stack. It is simple, fast and widely supported.
PostgreSQL has grown rapidly in recent years and is now the preferred database for modern applications, analytics, GIS, and systems that need strong data integrity.
In short:

• MySQL focuses on speed and simplicity
  
• PostgreSQL focuses on correctness, features and extensibility
  

PostgreSQL has overtaken MySQL in developer surveys and is now the most commonly used database in new projects.
MySQL remains widely deployed, especially in legacy systems and CMS platforms such as WordPress, but PostgreSQL is increasingly the default choice for new development.

Both databases perform well, but they excel in different areas.
MySQL performs best when:

• Workloads are simple and read‑heavy
• The application is web‑based and not data‑intensive
• The priority is speed over advanced features

PostgreSQL performs best when:

• Queries are complex
• Data integrity is important
• The system needs advanced SQL features
• Spatial data or analytics are required

For most modern applications, PostgreSQL’s query planner and feature set give it the edge.

PostgreSQL strengths

• Very strong SQL standards compliance
  
• Advanced JSON support
  
• Window functions and analytical queries
  
• Highly extensible (custom data types, operators, extensions)
  
• Excellent concurrency handling
  

MySQL strengths

• Simple to set up and maintain
  
• Fast for basic read‑heavy workloads
  
• Multiple storage engines
  
• Well supported by hosting providers
  

PostgreSQL’s extensibility is a major reason it is chosen for modern engineering teams.

​PostgreSQL’s PostGIS extension is widely regarded as the most advanced open‑source spatial database technology.
MySQL includes spatial features, but they are far more limited.
For any organisation working with mapping, assets, inspections or geospatial analysis, PostgreSQL is the obvious choice.

Choose PostgreSQL if you need:

• Complex queries
  
• Strong data integrity
  
• Spatial data (PostGIS)
  
• Multi‑tenant SaaS
  
• Analytics or reporting
  
• Long‑term scalability
  

Choose MySQL if you need:

• A simple, fast database for web applications
  
• WordPress or CMS hosting
  
• A lightweight system with minimal complexity
  

For most new systems — especially those involving GIS, analytics, multi‑department data sharing or long‑term scalability — PostgreSQL is the stronger, more future‑proof choice.
MySQL still has a place in legacy environments and simple web applications, but PostgreSQL has become the default database for modern development.

​Released on 20 June 2025,  QGIS 3.44 (Solothurn)  marks the last feature-packed release in the 3.x series before the transition to QGIS 4.0. This version refines workflows, boosts performance, and introduces a stunning new way to visualise your data — making it a worthwhile upgrade for all GIS users.

Below is an overview of the main highlights.

​One of the most exciting new features in QGIS 3.44 is the  3D Globe View . You can now open your map project on a full 3D globe rather than a flat plane, allowing for true planetary-scale visualisation.

Key benefits include:

• Support for  3D Tiles  and  point-cloud layers  directly in Globe View.
• Smooth performance when zooming between local and global scales.
• Simple access via  View → 3D Map Views → New 3D Globe View .

For consultants and trainers, this feature offers a visually engaging way to demonstrate global datasets and spatial relationships.

QGIS 3.44 continues to improve the daily user experience with advancements across the Processing toolbox and Expression engine.

Highlights include:

• Enhanced  database connectivity  for smoother integration with PostGIS and other data sources.
• Faster, more stable  processing algorithms  for geoprocessing workflows.
• Refined  labelling and layout tools , giving better control over print maps and atlas outputs.

These updates make QGIS more efficient and reliable, particularly when creating deliverables for clients or during live training sessions.

Version 3.44 introduces several refinements that make working across machines and teams much easier:

• Improved project portability with enhanced relative path handling.
• More responsive performance when working with large datasets.
• Better compatibility with plugins and third-party data providers.

This stability and compatibility make 3.44 a strong, dependable platform for production work and teaching environments.

​For those providing GIS training and consultancy — especially if you work with clients transitioning from ArcGIS or MapBasic — this release has several advantages:

• For beginners:  The 3D Globe provides an immediate visual “wow” factor, helping new users grasp spatial concepts quickly.
• For advanced users:  Improved automation and processing mean more time analysing data and less time fixing issues.
• For clients:  Using the latest QGIS version demonstrates commitment to best practice and modern tools.
• For trainers:  QGIS 3.44 ensures stability and plugin compatibility before the move to version 4.0.

​1.  Update your setup:  Install QGIS 3.44 on all training or project computers.
2.  Revise your materials:  Add short examples showing the 3D Globe and layout enhancements.
3.  Test your plugins:  Confirm compatibility before running live demos or workshops.
4.  Inform your clients:  Mention that your deliverables and lessons use QGIS 3.44 for full compatibility.
5.  Prepare for QGIS 4.0:  The next major release will bring the transition to Qt 6, but 3.44 remains a solid, long-term platform.

​QGIS 3.44 is a polished, professional-grade release that rounds off the 3.x series beautifully. The addition of the Globe View, along with numerous workflow and performance improvements, makes it an excellent choice for consultants, educators, and GIS professionals alike.

If you haven’t yet upgraded, now is a great time to do so — and to start preparing your workflows and training materials for the next big leap to QGIS 4.0.

​If you’d like support setting up QGIS, migrating existing projects, or providing staff training materials, we can help.
Please get in touch and discuss your GIS requirements.

This blog will provide an overview of QGIS, its interface, and basic navigation.
​
What is QGIS?

QGIS (Quantum GIS) is a free, open-source Geographic Information System that allows you to create, edit, visualize, analyse, and publish geospatial information on Windows, Mac, Linux, and mobile devices. It supports vector, raster, and database formats.

​Interface Overview

When you first open QGIS, you’ll see the following main components:
​
Menu Bar: Contains menus for various functions like Project, Edit, View, Layer, Settings, Plugins, Vector, Raster, Database, Web, Processing, and Help.

Toolbar: Quick access to common tools such as zoom, pan, selection, and layer management.

Layers Panel: Lists all the layers in your project. You can manage layer visibility, group layers, and set properties here.

Browser Panel: Provides easy access to your data sources including local files, databases, and web services.

Map Canvas: The main area where your map is displayed and edited.

Status Bar: Displays map coordinates, scale, and other useful information.

Opening QGIS

Launch QGIS: Double-click the QGIS icon on your desktop or find it in your start menu.

Create a New Project: Go to Project > New to start a new project. You can also use the New Project button on the toolbar

Understanding the Interface

Menu Bar:

Familiarize yourself with the menus.

For example, Project for project-related tasks, Layer for layer management, and View for map navigation tools.

Toolbar:

Explore the toolbar icons. Hover over each icon to see a tooltip that describes its function.
Common tools include:
Zoom In/Out: Magnify or reduce the map view.
Pan: Move the map without changing the zoom level.
Select Features: Select features from layers.
Identify Features: Click on a feature to see its attributes.
Measure: Measure distances and areas on the map.

Layers Panel:

This panel displays all the layers in your project. You can control the visibility of layers by checking or unchecking the boxes next to each layer name. Right-clicking on a layer opens a context menu with options for layer management.

Browser Panel:

This panel helps you navigate through your files and databases. You can drag and drop data directly from the browser to the map canvas.

Map Canvas:

The central part of the interface where your map is displayed. You can interact with the map using the tools from the toolbar.

Status Bar:

Located at the bottom of the QGIS window, it shows useful information such as the current map coordinates, scale, and rendering progress.

Basic Navigation

Zooming and Panning:

Use the Zoom In and Zoom Out tools to change the map view. Alternatively, you can use the scroll wheel on your mouse.
Use the Pan tool or hold down the middle mouse button to move the map around.

Selecting Features:

Click on the Select Features tool.

Then click and drag on the map canvas to select features within the drawn rectangle.

Identifying Features:

Use the Identify Features tool to click on any feature on the map.

 A window will pop up displaying the attributes of the selected feature.

Summary
In this blog, we have covered the basic components of the QGIS interface and how to navigate within the software. Understanding the interface is the first step in utilizing QGIS for geospatial analysis and map creation.

Working on GIS projects in QGIS (Quantum GIS) can be an enriching experience, but it’s not uncommon to encounter issues such as broken links to data sources. Broken links occur when the paths to your data files change, which might happen due to file relocation, renaming, or transfer to a different system. Here’s a  guide to repairing broken links in a QGIS project to ensure your data is correctly loaded and your project runs smoothly.

Moving files: If you move your data files to a different directory or drive.
Renaming files or directories: Changing the name of your data files or the directories they reside in.
Relative paths: Using relative paths in your project and then moving the entire project to a different location without updating the paths.

 When you open a QGIS project with broken links, QGIS will alert you to the missing layers. Here’s how you can identify them:

 When you open a project, QGIS will display a message box listing the layers that couldn't be found. Select the Keep unavailable layers option.

 In the Layer Panel, layers with broken links are usually displayed with a red exclamation mark or an error message.

 When the dialog box shows the layers with broken links opt to keep them in the project.

You can open the Data Source Manager by right-clicking on the problematic layer in the Layer Panel and selecting "Repair Data Source”

 In the "Repair Data Source" dialog box you can browse to the new location of your data file

After selecting the correct file, click "Apply" and then "OK" to update the data source. Then repeat this process with any other layers containing a red triangle.

In conclusion, QGIS is a versatile and powerful GIS software that offers a wealth of features and capabilities for spatial data analysis and visualization. By familiarizing yourself with its user interface, mastering its mapping tools, and exploring its spatial analysis techniques, you can unlock the full potential of QGIS and embark on a rewarding journey of GIS exploration and discovery. Remember, learning GIS is a gradual process that requires patience, practice, and perseverance. So don't hesitate to dive in, experiment with different features, and seek guidance from experienced GIS professionals. ​

If you're new to GIS (Geographic Information Systems), you might wonder how to perform specific tasks efficiently. QGIS, an open-source GIS software, provides a powerful scripting interface that allows you to automate processes. In this blog, we'll explore a practical example: calculating the total area of features in a vector layer using a custom script. Don't worry; we'll break it down step by step.

Why Calculate Total Area?
Calculating the total area of features in a vector layer can be essential in various GIS projects. For instance, you might want to determine the total area of land parcels, water bodies, or administrative regions in a map. This information is valuable for urban planning, environmental analysis, and many other applications.

The QGIS Script
Here's the Python script that accomplishes this task:

How the Script Works
Let's break down the script into simpler terms:

1. Imports and Class Definition: The script starts by importing necessary modules from QGIS. Then, it defines a custom algorithm class `CalculateTotalAreaAlgorithm` that inherits from `QgsProcessingAlgorithm`. This class contains several methods that control the algorithm's behavior.

2. Algorithm Configuration: The `initAlgorithm` method sets up the algorithm's parameters. In this case, it defines the input and output layers.

3. Processing: The core logic happens in the `processAlgorithm` method. Here's a simplified explanation of what it does:
   - It retrieves the input vector layer.
   - It checks if the input source is valid.
   - It prepares an output layer.
   - It iterates through the features in the input layer.
   - For each feature, it checks if the geometry is valid.
   - If the geometry is valid, it calculates the area and creates a new feature.
   - The new features are added to the output layer.

4. Result: The script prints the total area to the Python console and returns the output layer.

Running the Script
To run this script in QGIS, you'll need to:
1. Open QGIS.
2. Go to the 'Processing' menu.
3. Open the 'Toolbox.'
4. Save your script as 'Calculate Total Area'
5. Under 'Scripts,' you should find 'Example Scripts,' and within that, 'Calculate Total Area.' 

6. Set your input vector layer.
7. Choose an output location.
8. Click 'Run.'

​The result will be a new layer with the total area of each feature in the input layer.

​Understanding this script is a great step towards harnessing QGIS's scripting capabilities. You can use this knowledge to automate various GIS tasks. Experiment with it, modify it to suit your needs, and explore other QGIS scripts to expand your GIS skills.

 Getting Started with the Python Console in QGIS: A Beginner's Guide

In this blog post, we'll explore a fundamental tool within QGIS - the Python Console - and guide you through its basics, step by step. Don't worry if you're new to Python or QGIS; we'll keep it beginner-friendly.

Step 1: Opening the Python Console

To access the Python Console in QGIS, follow these simple steps:

1. Launch QGIS.
2. Go to the "Plugins" menu.
3. Select "Python Console."
You'll see a new window at the bottom of your QGIS interface.  

 Step 2: Understanding the Python Console Interface

Before we start coding, let's understand the layout of the Python Console:

The main input area: This is where you'll write your Python code.
The "Output" tab: Displays the results of your code execution.
The "Log" tab: Shows any error messages or additional information.

 Step 3: Writing Your First Python Script
Now, let's write a simple Python script to get a feel for the Python Console. Type the following code into the input area:

Step 4: Accessing QGIS Layers
One of the most powerful aspects of the Python Console in QGIS is its ability to interact with your GIS data. Let's start by accessing a layer. Suppose you have a layer named "Departments_Metro" You can access it like this:

 Here, we've created a variable 'layer' that contains our 'Departments_Metro' layer. Note that 'Departments_Metro' should be replaced with the name of your actual layer.

Step 5: Working with Features
Now, let's work with the features within the 'Departments_Metro' layer. We'll iterate through the features and print their attributes:

 This code retrieves all the features in the 'Departments_Metro' layer and prints their attributes.

Step 6: Performing Spatial Operations
Python in QGIS also allows you to perform spatial operations. For example, you can calculate the area of a polygon feature:

Here is the output from the above code:-

In this code, we check if a feature is a polygon and then calculate its area.

Step 7: Saving Your Work​
The Python Console in QGIS is a versatile tool that empowers GIS specialists like you to automate tasks, manipulate data, and perform complex spatial analyses. In this beginner-friendly guide, we've covered the basics of opening the console, writing and running Python scripts, and interacting with GIS layers. As you continue your journey into the world of QGIS and Python, this knowledge will serve as a solid foundation for more advanced tasks in geographic information science.

Geographic Information Systems (GIS) enthusiasts are continually exploring ways to enhance the functionality of their favourite GIS software, QGIS. While QGIS itself is a powerful tool, its extensibility through plugins allows users to customise it to their specific needs. In this blog post, we'll dive into the world of QGIS plugins and explore a unique integration—linking QGIS with PHP. As a GIS user, you'll gain insights into QGIS plugin development and learn how to create a simple QGIS plugin that interacts with a PHP web application.

The Power of QGIS Plugins
QGIS plugins are small software add-ons that extend the capabilities of QGIS. Whether you're looking to streamline workflows, access additional data sources, or perform complex spatial analyses, there's likely a QGIS plugin that can help. These plugins are developed by the QGIS community and third-party developers, making it possible to tailor QGIS to your specific needs.

Getting Started with QGIS Plugin Development
Before we look at PHP integration, let's cover the basics of QGIS plugin development:

1. Development Environment Setup
To get started with QGIS plugin development, you'll need a development environment. Most QGIS plugins are written in Python, so having a basic understanding of Python is essential. Install Python, QGIS, and Qt Designer (a visual tool for designing user interfaces) to set up your development environment.

2. Plugin Builder
QGIS offers a handy Plugin Builder tool that simplifies the creation of new plugins. This tool generates a basic plugin template, including the necessary files and folder structure. It's an excellent starting point, especially for beginners, as it takes care of some of the initial setup complexities.

​3. Plugin Development
Once your development environment is set up, you can start coding your QGIS plugin. QGIS plugins typically consist of a combination of Python scripts, XML files for defining user interfaces, and resources like icons or images.

4. Testing and Debugging
QGIS provides a testing framework that allows you to check your plugin's functionality within the QGIS environment. Proper testing and debugging are essential to ensure your plugin works as expected.

5. Documentation and Distribution
Documentation is crucial for users who want to install and use your plugin. Fortunately, QGIS provides tools to create user-friendly documentation. After thoroughly testing and documenting your plugin, you can distribute it to others through the official QGIS Plugin Repository or other platforms.

PHP Integration with QGIS
Now, let's examine the integration of QGIS with PHP. While Python is the primary language for QGIS plugin development, you can indirectly integrate PHP with QGIS through the following steps:

1. Create a QGIS Plugin
In our example, we'll create a simple QGIS plugin that opens a PHP web application when a menu item is clicked.

Here's the code for the QGIS plugin:

2. Create a PHP Web Application
Next, develop a simple PHP web application that serves as the integration point between QGIS and PHP. Your PHP application can offer various functionalities, such as displaying maps, running spatial queries, or visualizing GIS data. For simplicity, we'll create an example that displays a "Hello, QGIS World!" message.

3. Deploy Your PHP Application
Host your PHP web application on a web server or use a local web server like XAMPP or WAMP for development. Ensure that your PHP application is accessible via a URL.

4. Install and Use the QGIS Plugin
Follow the steps below to install and use the QGIS plugin:

- Save the QGIS plugin code as a `.py` file, such as simple_plugin.py.
- Copy the file to the QGIS plugins directory. On most systems, this directory is located at:

• Linux: ~/.local/share/QGIS/QGIS3/profiles/default/python/plugins
• Windows: C:\Users\YourUsername\AppData\Roaming\QGIS\QGIS3\profiles\default\python\plugins

- Start or restart QGIS.
- Go to the "Plugins" menu in QGIS, and you should see "simple_plugin" as an option.
- Click "simple_plugin," and it will open the PHP web application in your default web browser.

When you click on the simple_plugin  it will open the default browser and display a message as in the example below.

​In this blog post, we explored QGIS plugin development and created a simple QGIS plugin that integrates with a PHP web application. While QGIS primarily relies on Python for plugin development, the indirect integration with PHP via QGIS plugins and web applications opens up exciting possibilities for extending QGIS's functionality. Whether you're building web-based GIS applications or simply customizing your QGIS experience, this integration can help you achieve your geospatial goals.