Bugs come back with the next releases
The fix removes the visible symptom, but the dependency in the data model, the integration or the custom code stays unchanged. The next release triggers the same problem again.
We take over the maintenance of existing Pimcore installations that carry product data, digital assets, content or e‑commerce processes. We bring order to the technical state, the incoming requests, the updates and the backlog.
Pimcore can tie together data, assets, content and sales channels. A problem in one part of the system may only surface when a product is published, a price is synchronised or a user works in the admin panel.
Individual requests can be closed for a long time without removing their cause. The cost shows up later, when every further change requires caution, the knowledge sits with one person, and the business team stops trusting the data or the dates.
See the scope of maintenanceThe fix removes the visible symptom, but the dependency in the data model, the integration or the custom code stays unchanged. The next release triggers the same problem again.
The team is not sure which modules and modifications will stop working after a version change. Every postponement widens the scope of the future update.
It is unclear whether the error originated in Pimcore, the source system, a queue, a scheduled job or the target channel. Diagnosis takes longer than the fix itself.
Operational requests, growth work, bugs and technical debt all land on one list. Priority depends on whoever is reporting at that moment.
The documentation does not reflect the current architecture, and the decisions made during the implementation carry no rationale a new team can read.
More than fixing failures. Maintenance also means updates, security patches, monitoring and the growth of the platform itself — its data models, workflows, imports, exports and APIs. The exact responsibility depends on the architecture, the Pimcore version, the modules in use, the customisations and the infrastructure; we establish those before proposing a permanent model of cooperation.
| Area | What it can cover | What it means for the company |
|---|---|---|
| Pimcore updates | Assessing the impact of a version change, updating dependencies, adaptation work, testing and the production release | Updates are planned on the basis of their impact rather than postponed without a date |
| Security patches | Watching Pimcore and library security releases, judging whether they affect this installation, and shipping fixes outside the usual release cycle | A known vulnerability does not wait for the next large update |
| Monitoring | Watching scheduled jobs, queues, logs and critical processes; the scope is agreed after reviewing the hosting and the administrators' responsibilities | A problem is visible before a user reports it or a product goes missing from a channel |
| Error handling | Taking in requests, diagnosing logs, fixing code and removing the causes rather than only the visible symptoms | Fewer situations where the same problem returns after the next release |
| Maintaining integrations | Diagnosing existing connections, synchronisation errors, queues, APIs and schedules | Faster answers to where the data flow was interrupted |
| Growing the data models | New classes, fields, relations and dictionaries, migrations of data already in place, and untangling a model that no longer matches the offer | A new product group needs no workaround in a spreadsheet or an extra “notes” field |
| Growing the workflows | New stages of data preparation, transition conditions, notifications, and permissions and roles matched to changes in the team | The publishing process matches how the team actually works |
| New imports and exports | Further data sources and further recipients: supplier files, feeds, exports to marketplaces, catalogues and trade partners | Another channel or supplier does not mean preparing a file by hand |
| Growing the API | Extending endpoints, Datahub configuration, permissions and the data contracts for systems that consume Pimcore | A new system can pull the data without an export written just for it |
| Performance | Analysing what slows down the admin panel, data processing, indexing or publication | Shorter operations for both users and automated processes |
| Documentation | Keeping the description of architecture, integrations, environments, releases and technical decisions current | Knowledge does not stay with individual developers alone |
What it can cover
Assessing the impact of a version change, updating dependencies, adaptation work, testing and the production release
What it means for the company
Updates are planned on the basis of their impact rather than postponed without a date
What it can cover
Watching Pimcore and library security releases, judging whether they affect this installation, and shipping fixes outside the usual release cycle
What it means for the company
A known vulnerability does not wait for the next large update
What it can cover
Watching scheduled jobs, queues, logs and critical processes; the scope is agreed after reviewing the hosting and the administrators' responsibilities
What it means for the company
A problem is visible before a user reports it or a product goes missing from a channel
What it can cover
Taking in requests, diagnosing logs, fixing code and removing the causes rather than only the visible symptoms
What it means for the company
Fewer situations where the same problem returns after the next release
What it can cover
Diagnosing existing connections, synchronisation errors, queues, APIs and schedules
What it means for the company
Faster answers to where the data flow was interrupted
What it can cover
New classes, fields, relations and dictionaries, migrations of data already in place, and untangling a model that no longer matches the offer
What it means for the company
A new product group needs no workaround in a spreadsheet or an extra “notes” field
What it can cover
New stages of data preparation, transition conditions, notifications, and permissions and roles matched to changes in the team
What it means for the company
The publishing process matches how the team actually works
What it can cover
Further data sources and further recipients: supplier files, feeds, exports to marketplaces, catalogues and trade partners
What it means for the company
Another channel or supplier does not mean preparing a file by hand
What it can cover
Extending endpoints, Datahub configuration, permissions and the data contracts for systems that consume Pimcore
What it means for the company
A new system can pull the data without an export written just for it
What it can cover
Analysing what slows down the admin panel, data processing, indexing or publication
What it means for the company
Shorter operations for both users and automated processes
What it can cover
Keeping the description of architecture, integrations, environments, releases and technical decisions current
What it means for the company
Knowledge does not stay with individual developers alone
Monitoring scope, SLA levels, server administration, backups and out-of-hours cover: to be confirmed at the proposal stage.
It starts with the dependencies, before the first change in the code. A new team needs access to the code, the environments, the logs, the documentation and the people who know the business processes. The scope of the first work follows from what is actually in the system.
We establish the role Pimcore plays, which teams use it, which processes are critical and where the current problems appear. The result is a list of required access, contact people and sources of knowledge.
Artefactaccess list and responsibility map
We review the project structure, the modules in use, the customisations, the dependencies, the release process and the differences between environments. This is where the first risks requiring a prompt decision appear.
Artefacttechnical inventory
We map the source systems, target channels, APIs, scheduled jobs, queues and the places where data is transformed. The diagram also shows who owns each part of the process.
Artefactmap of integrations and data flows
We group problems by their impact on data, users, sales channels and the ability to release further work. The plan separates urgent fixes from work that can be done later.
Artefactrisk register and stabilisation plan
After the takeover we agree on request handling, backlog management, change approval, testing, releases and reporting. The details depend on the scale of the platform and the client's team.
Artefactagreed maintenance and growth process
What the takeover audit looks at
The results of the audit are what the plan for further maintenance and growth is built on: they say what needs an urgent fix, what can be scheduled into the coming releases, and what enters the backlog as technical debt. Without that, a permanent arrangement would be a quote for an unknown system.
We plan an update around its impact on the whole architecture. A major version change can affect public APIs, functions previously marked as deprecated, custom modules and dependencies. The Pimcore documentation recommends performing and verifying the update on a non-production environment before running it on production.
Before an update we review the scope of changes, the project dependencies and the places that need adapting. Test scenarios should cover the processes that users and data distribution depend on.
A production release requires an agreed way back, log monitoring and observation of the most important processes afterwards. The scope of testing and rollback should follow from the architecture of the specific platform.
Pimcore now ships the platform as a core framework plus modular extensions, so before an update we check the compatibility of the whole stack rather than the core version number alone. The extensions have releases and dependencies of their own — a compatible core version does not mean the project's full set of modules and custom extensions will work after the change.
Release gates
Do we know which modules, custom extensions and dependencies the version change touches?
Does the project build, boot and pass its migrations after the update, off production?
Do the APIs, queues, scheduled jobs and critical processes pass their tests?
Are the release plan, the maintenance window and the way back agreed?
Do the logs, queues and key processes behave as they did before the change?
A product missing from the store may come from the data source, validation in Pimcore, a queue, a scheduled job or an error on the target channel's side. Diagnosis should cover the whole flow.
As part of maintenance we analyse the existing connections, logs, schedules, APIs and synchronisation errors. We also establish which part of the process belongs to Pimcore, the infrastructure, the source system or the recipient of the data.
A new connector, a thorough rebuild of the data exchange model or an additional integration layer should be described as a separate project. That scope leads to the Pimcore integration service.
See the Pimcore integration serviceControl points
Did the data arrive in the expected format, scope and time?
Did validation, transformation, the queue or the scheduled job finish correctly?
Was the data accepted and published by the store, the marketplace or another system?
We do not give a single rate, because maintaining one installation can cost several times less than another under the same service name. Below are the eight things that decide the estimate — each one written so you can look for it in your own project.
What decides the estimate
Specific arrangements, response times and SLA terms are provided at the proposal stage, after the takeover audit — without knowing the state of the platform, a rate would be a quote for unknown risk. If the project is about building a new environment rather than an existing one, the scope is described by a Pimcore implementation.
The questions that come up most often on a first call about an existing platform.
We do not give a single rate. The estimate is driven by the scope of monthly work, the number of integrations and custom extensions, the platform version, the technical state of the project, the scope of development, the number of environments and the response requirements — all eight are set out in the section on the cost of maintenance. Specific arrangements follow in the proposal, after the takeover audit.
Yes, taking over an existing project can be the starting point of the cooperation. First we need to get to know the code, the environments, the integrations, the platform version, the documentation and the problems users report. Only then can the scope of stabilisation and ongoing maintenance be set.
With an audit, not with the first fix. We look at the Pimcore version and its modules, the architecture, the data models, the integrations, the custom code, the APIs, the scheduled jobs and queues, the infrastructure, the documentation and the backlog. The whole process, with the artefact each stage produces, is in the section on taking over maintenance.
Usually the code repository, access to the environments, logs, implementation documentation, a description of the integrations and contact with the people who know the business processes. The full list depends on the architecture and on how responsibility is split between providers.
Yes, updates and security patches are part of maintenance rather than a separate project — as long as the installation sits on a version it can be updated from without a rebuild. If the platform runs on an unsupported version, getting it to a current one can be a scope of work of its own, estimated after a compatibility assessment.
We start by analysing the version, the dependencies, the custom extensions and the change notes. The update goes onto a non-production environment, where processes and integrations can be checked. The production plan covers the way back and observation after the release. We check the compatibility of the whole stack rather than the core version number alone — modules and extensions have releases of their own.
Yes, and that is a typical part of maintenance. It brings new classes, fields, relations and dictionaries, migrations of data already entered, and changes to preparation stages and permissions. We settle the scope together with the effect on integrations and exports, because the data model is a contract for the channels receiving the data too.
The service can combine day-to-day maintenance with delivering a growth backlog. Both kinds of work have separate priorities, because a failure affecting data needs different handling from a planned feature.
Yes. Single tasks — a new export, extra fields in the model, a performance fix — can be delivered from an agreed pool of hours or estimated separately. For larger architectural changes or a new connector we go back to a project scope, so that a rebuild is not run as a series of tickets.
Yes, for the connections that already exist: we diagnose synchronisation errors, queues, schedules and APIs, and develop what is already running. Building a new connector or thoroughly rebuilding the data exchange is treated as a separate scope under the Pimcore integration service.
Yes. In projects with a large backlog it makes sense to start with an inventory, a risk list and a stabilisation plan. The permanent model of cooperation can be set once the real state of the platform is known.
The model follows from the number of requests, the expected response time, how critical the processes are, the monitoring scope and the planned growth. Specific variants, response times and SLA terms are provided at the proposal stage.
On the first call we will establish the role of Pimcore, the current version, the main integrations, the problems users report and the scope of responsibility you expect. At this stage you do not need to hand over access or confidential technical data.
Basic information about the platform and about what you expect from a maintenance team is enough to start.

What we cover on the call