NextGIS GeoServices: controlled basemaps inside your own infrastructure

Basemaps are often treated as a background component of a GIS project: select a public tile service, add its URL to the application, and move on.

This approach works for an individual map or a small team. At an organizational scale, however, a basemap becomes part of the infrastructure. It must remain available under high load, work consistently across applications, follow the organization’s visual standards, and respect its security and access policies.

Depending on an external public service can create several problems:

  • the service may be rate-limited or unavailable at a critical moment
  • map performance depends on an external provider and internet connection
  • content and update cycles remain outside your control
  • different teams may use inconsistent basemaps
  • external services may be unavailable in isolated networks

NextGIS GeoServices solves these problems by providing a dedicated, self-hosted environment for creating, caching, managing, and delivering raster and vector tile services.

It is deployed within your organization’s infrastructure and can operate without access to the public internet. It provides a central source of basemaps for desktop GIS, web applications, internal portals, mobile applications, and other systems that consume tile services.

A basemap server designed for organizational use

NextGIS GeoServices is a specialized server application for highly loaded tile services. It combines tile generation and caching with user management, access permissions, API keys, service organization, task monitoring, and storage management.

Instead of configuring separate scripts, rendering tools, proxy servers, caches, and authentication mechanisms, administrators manage the complete basemap delivery workflow through one web interface.

GeoServices can be used to:

  • create raster and vector basemaps from OpenStreetMap data with custom styles
  • publish cached versions of maps created in NextGIS Web
  • connect and cache external TMS services
  • publish pre-rendered tile packages
  • prepare tile caches for selected areas and zoom levels
  • provide different basemap services to different teams or applications
  • monitor processing tasks and storage consumption

The result is a controlled internal catalogue of ready-to-use map services.

Build your own basemaps from OpenStreetMap data

OpenStreetMap is an excellent foundation for organizational basemaps, but the standard public OSM tile servers are not intended to serve as a free backend for high-traffic corporate or institutional applications.

With NextGIS GeoServices, organizations can create independent basemap services by uploading OpenStreetMap data in PBF format (can be obtained at data.nextgis.com).

For every service, administrators can configure the geographic coverage, minimum and maximum zoom levels, OpenStreetMap layers included in the map, and map style.

One source dataset can be used to create multiple services with different territories, styles, layer combinations, and scale ranges. A national organization, for example, might maintain one general-purpose basemap for the entire country, detailed operational maps for selected cities, and simplified low-contrast maps for thematic dashboards.

NextGIS GeoServices includes default basemap styles, while custom styles can be uploaded as JSON files. This allows the basemap to follow corporate design requirements or the cartographic needs of a particular project.

A utility company might emphasize streets, buildings, and industrial objects while reducing the visual prominence of points of interest. An environmental organization might highlight water bodies, vegetation, protected areas, and terrain-related features. A public authority could create separate public and internal versions of the same basemap.

The generated basemaps can be connected to external applications as raster tiles or vector tiles. Vector tiles provide additional flexibility because labels and other visual properties can be adjusted on the client side without regenerating the underlying data.

Turn NextGIS Web maps into high-performance tile services

NextGIS Web is designed to store, manage, and publish geospatial data. A Web Map may combine many layers, styles, external sources, and project-specific settings.

When a map is opened by a large number of users, repeatedly rendering the same content can create unnecessary load on the main Web GIS server.

NextGIS GeoServices can use a NextGIS Web Map as the source for a separate cached tile service. The administrator specifies the Web Map, service name, geographic extent, and scale limits. GeoServices then serves the resulting tiles independently.

Once tiles have been generated, routine requests are handled by GeoServices rather than causing NextGIS Web to render the map again. This separates interactive data management from high-volume map delivery and helps the infrastructure handle peak demand.

NextGIS Web remains the environment where data and maps are managed. NextGIS GeoServices becomes the optimized distribution layer through which finalized cartographic output reaches users.

Cache external TMS services

Organizations often rely on third-party tile services alongside their own datasets. Repeatedly requesting the same external tiles can reduce application performance and make the system dependent on the availability and response time of another server.

NextGIS GeoServices can connect an external TMS source, cache its tiles, and expose the service through the organization’s own infrastructure. Administrators configure the source URL, zoom range, coordinate reference system, and service name.

This provides a consistent connection point for internal applications and can reduce repeated external requests. It also allows administrators to manage access to the cached service using the same tools as for internally generated basemaps.

Important. The terms of use of the original service must permit this type of access and caching. GeoServices provides the technical capability, while responsibility for complying with the source provider’s licensing and usage conditions remains with the organization.

Publish ready-made tilesets

GeoServices can also publish a pre-generated tileset. Administrators upload the prepared tile package, and the service parameters are detected and configured automatically. This is useful when tiles have already been produced through another workflow or ordered as a prepared package for a specified territory and zoom range.

This approach is suitable for:

  • fixed cartographic products that change infrequently
  • offline or disconnected deployments
  • projects where tile generation is performed on another server
  • rapid deployment of a prepared regional basemap
  • migration of an existing tile archive into a managed service catalogue

It also provides a straightforward route from a static tile package to a service with centralized access control, API keys, monitoring, and organizational management.

Generate the cache before users arrive

By default, tiles for a newly created service can be generated when they are requested for the first time. This saves processing and storage for areas that may never be opened, but the first user requesting a tile may experience a delay.

For production systems, NextGIS GeoServices supports seeding: generating the required cache in advance.

Administrators can define:

  • raster or vector tiles to seed
  • required zoom levels
  • geographic area, drawn on the map or uploaded as a boundary
  • whether to render only missing tiles or perform a complete render
  • whether to delete an existing cache

Each seeding operation becomes a managed task whose status can be monitored in the interface. This makes it possible to prepare a service before a launch, major event, field campaign, or planned period of intensive use.

A practical workflow might look like this:

  1. Upload current OpenStreetMap data.
  2. Configure the required map style and coverage.
  3. Create raster and vector tile services.
  4. Seed the most frequently used zoom levels for the operational area.
  5. Test the services in QGIS and web applications.
  6. Distribute controlled service URLs and API keys to users.

Users then receive tiles from a prepared cache rather than waiting for individual map fragments to be rendered.

One basemap infrastructure for different teams

GeoServices allows services to be organized into groups. Access rules can be assigned either to an entire service group or to an individual service inside it. Administrators can create local users and user groups and then grant or deny read, write, and management permissions. 

For example:

  • employees can access all internal services
  • contractors can access only the basemap required for their project
  • external applications can use a selected public-facing service
  • cartographers can manage styles and service settings
  • system administrators can manage all users and services

This model allows one GeoServices deployment to support different departments, projects, partners, and applications without creating a separate server for every audience.

Controlled access through API keys

External applications generally do not log in through the administrative web interface. Instead, they access tile services using API keys.

GeoServices administrators can create and revoke keys and configure restrictions including:

  • expiration date
  • geographic extent
  • minimum and maximum scale
  • permitted origins

These controls help limit where and how a key can be used. A key issued to a regional application can be restricted to the application’s territory and required zoom levels. A key used by a web portal can be limited to requests originating from the portal’s domain. Temporary integrations can receive keys that expire automatically.

This is more manageable than distributing a single unrestricted URL across every application and user.

Monitoring and storage management

Tile generation can involve large numbers of files and long-running processing tasks. Administrators need to understand what is happening on the server and how much storage each service consumes.

The GeoServices log records processing history and other application actions. Entries include the operation status, source, start and finish time, task identifier, and diagnostic messages.

The storage section provides an estimate of total cache size and the storage used by individual services. This helps administrators identify particularly large caches, estimate future capacity requirements, and decide whether all generated zoom levels are still needed.

Designed for air-gapped environments

NextGIS GeoServices is deployed with Docker on a physical or virtual Linux server. 

For systems without internet access, NextGIS can provide the container images as an archive that can be transferred to the isolated server and loaded locally. The production service can therefore run entirely inside a closed network without depending on external cloud infrastructure.

This makes GeoServices suitable for organizations with strict infrastructure requirements, including government and municipal systems, utilities and infrastructure operators, industrial facilities, environmental monitoring networks, research institutions, corporate intranets, emergency and field operations, organizations working with confidential geospatial data and systems deployed in remote locations with unstable connectivity.

NextGIS Web and GeoServices: two complementary roles

NextGIS Web and NextGIS GeoServices address different parts of a spatial data infrastructure.

NextGIS Web is the central environment for working with geospatial resources: storing data, creating Web Maps, managing permissions, editing features, publishing services, and organizing collaborative GIS workflows.

NextGIS GeoServices is the dedicated map delivery layer: generating, caching, controlling, and serving tile-based basemaps efficiently.

Used together, they create a clear division of responsibilities:

  • data is maintained in NextGIS Web
  • maps are assembled and styled in NextGIS Web
  • finalized Web Maps are cached by GeoServices
  • high-volume tile requests are handled by GeoServices
  • users continue editing data without competing with public or organization-wide map traffic

GeoServices can also work independently from NextGIS Web by using OpenStreetMap data, external TMS sources, or prepared tilesets.

Deployment and support

NextGIS GeoServices is available as a supported on-premise product.

The NextGIS team can assist with installation, initial configuration, service architecture, migration of existing basemaps, integration with NextGIS Web, and preparation of the system for production use.

Make your basemaps part of the infrastructure you control

A basemap is present in almost every GIS application. Once dozens of projects and hundreds of users depend on it, its availability, performance, and governance become too important to leave to an unmanaged collection of external URLs.

NextGIS GeoServices gives organizations a dedicated environment for publishing fast, consistent, and controlled basemaps from their own infrastructure, including private networks.

Create and publish basemaps under your full control

Comments are closed.