CMS & Matomo: Inconsistent Page Access Counts Explained

Have you ever noticed discrepancies in page access data between your Content Management System (CMS) and Matomo, the web analytics platform? It's a common issue that can lead to confusion and make it challenging to accurately assess your content's performance. This article delves into the reasons behind these inconsistencies, offering insights and potential solutions to ensure your data aligns.

The Bug: Discrepancies in Page Access Data

The core issue lies in the differing page access numbers reported by the CMS and Matomo. For instance, when navigating to the 'Statistics' section within the CMS (e.g., for 'Augsburg') and selecting a specific time period, the access counts for a particular language (e.g., 'German') may vary significantly from the page views recorded in Matomo for the same period and page.

To illustrate, let's walk through the steps to reproduce this bug:

1. First, go to the statistics section in CMS.
2. Select a time before the 10th of November 2025 or any other particular day.
3. Choose a language from the legend. For example, German.
4. Notice the number of accesses displayed.
5. After that, you need to log in to statistics.integreat-app.de.
6. Select the same day as you chose in the CMS section.
7. Go to the Behaviour section and then to the pages.
8. Search a page slug in the search bar.
9. Notice the page views will differ from the accesses you saw in the CMS section.

This discrepancy raises concerns about the reliability of the data and its impact on decision-making processes. Accurately tracking page views is crucial for understanding user engagement, identifying popular content, and optimizing website performance. When these numbers don't align, it becomes difficult to form a clear picture of how users are interacting with your site.

Expected vs. Actual Behavior

The expected behavior is straightforward: page views in Matomo and page accesses in the CMS should ideally be the same, or at least very close. Both systems are designed to track user interactions with web pages, and their data should reflect a consistent view of website traffic.

However, the actual behavior reveals a significant divergence. Page views in Matomo and page accesses in the CMS differ, causing confusion and raising questions about data accuracy. This inconsistency can stem from a variety of factors, which we will explore in detail in the following sections.

Visual Evidence: The Power of Screenshots

Screenshots can be invaluable in pinpointing and understanding bugs. Capturing the state of the system immediately before and after the bug occurs provides a clear visual record of the issue. In this case, screenshots of the statistics pages in both the CMS and Matomo, showing the differing access counts, would serve as compelling evidence of the problem. These visual aids help developers and stakeholders quickly grasp the scope and nature of the inconsistency, facilitating faster troubleshooting and resolution.

Delving Deeper: The Root Cause of the Issue

So, what's causing this discrepancy? Initial investigations suggest a key factor: how Matomo handles parent pages. When data is requested from Matomo, particularly for parent pages, the platform returns a summary of views encompassing not only the parent page itself but also all its child pages. This aggregated data is then saved in the database, potentially skewing the access counts for the parent page.

To further illustrate, consider a scenario where you have a parent page titled 'Services' with child pages like 'Web Design,' 'Digital Marketing,' and 'SEO.' When you request data for 'Services' from Matomo, it may return the combined views for 'Services,' 'Web Design,' 'Digital Marketing,' and 'SEO.' This aggregated number, if stored directly as the access count for 'Services,' will naturally be higher than the actual views for the 'Services' page alone.

Technical Insights: Traceback Analysis

A traceback provides a detailed record of the code execution path leading up to an error or unexpected behavior. Analyzing the traceback can reveal the specific functions, methods, and lines of code involved in the discrepancy. While a traceback isn't included in the original bug report, obtaining and examining one would be a crucial step in diagnosing the issue. It would help pinpoint exactly where the aggregation of child page views is occurring and how it's being stored in the database.

Related Issues: A Web of Interconnections

Identifying related issues is a critical aspect of bug resolution. Often, seemingly isolated problems are interconnected, sharing underlying causes or dependencies. By exploring related issues, developers can gain a broader perspective on the bug, uncover potential patterns, and avoid addressing symptoms rather than the root cause. In this case, it would be beneficial to examine any related issues within both the CMS and the integreat-app (if applicable) to see if similar data discrepancies have been reported or if any code changes might have inadvertently introduced this bug.

Unpacking the Discussion: A Collaborative Approach

Effective bug resolution often involves collaborative discussions and updates to the initial problem description. As developers and stakeholders investigate the issue, new information emerges, assumptions are tested, and the understanding of the bug evolves. Summarizing these discussions and incorporating updates into the bug report ensures that everyone remains on the same page and that the troubleshooting process is well-documented.

The Importance of Clear Communication

For instance, imagine a scenario where, after initial investigation, a developer discovers that the issue is specific to a particular version of the CMS. This crucial piece of information should be promptly added to the bug report, perhaps under a 'Summary of discussion and updates' section, along with a timestamp indicating when the update was made. This level of detail helps prevent wasted effort and ensures that the resolution efforts are focused on the relevant areas.

Potential Solutions and Workarounds

Addressing the inconsistency in page access counts requires a multi-faceted approach. Here are some potential solutions and workarounds:

1. Modify the Data Aggregation Logic: The most direct solution is to adjust the logic that retrieves and stores page view data from Matomo. Instead of aggregating child page views with parent page views, the system should store them separately. This would ensure that the access counts for each page accurately reflect its individual traffic.

2. Implement Data Filtering: Another approach is to implement filtering mechanisms that differentiate between parent and child page views. This could involve analyzing the URL structure or using custom dimensions in Matomo to tag pages as either parent or child. The CMS could then use these filters to retrieve only the relevant data for each page.

3. Refine Matomo Queries: The queries sent to Matomo could be refined to specifically request data for individual pages, avoiding the aggregation issue altogether. This might involve using Matomo's API to fetch page view data based on specific page URLs or IDs.

4. Data Reconciliation: As a temporary workaround, a data reconciliation process could be implemented. This would involve periodically comparing the access counts in the CMS and Matomo and manually adjusting the CMS data to match Matomo's numbers. While this isn't a long-term solution, it can help maintain data accuracy until a more permanent fix is implemented.

Proactive Steps: Preventing Future Discrepancies

Beyond addressing the immediate bug, it's crucial to implement proactive measures to prevent similar discrepancies from arising in the future. This includes:

• Thorough Testing: Implement comprehensive testing procedures that specifically check for data inconsistencies between different systems. This should be part of the regular development and deployment process.
• Data Validation: Incorporate data validation steps to ensure that data is being stored and retrieved correctly. This might involve setting up automated checks that compare data across systems and flag any discrepancies.
• Clear Documentation: Maintain clear and up-to-date documentation of the data flow between systems, including how data is aggregated, stored, and retrieved. This makes it easier to identify potential issues and troubleshoot problems.

Conclusion: Ensuring Data Integrity

Inconsistent page access counts between a CMS and Matomo can be a frustrating issue, but understanding the underlying causes and implementing appropriate solutions can restore data integrity. By addressing the data aggregation logic, refining queries, and implementing proactive measures, you can ensure that your analytics data accurately reflects user behavior and supports informed decision-making. Remember, accurate data is the foundation of effective website optimization and content strategy.

For further reading on web analytics and data consistency, you might find valuable information on the Matomo official website. This resource provides in-depth documentation, best practices, and community support to help you make the most of your analytics data.