In the digital world, one phrase is becoming increasingly common: “whoever controls the data — controls the outcome.”

But what if the data you rely on is inaccurate or incomplete? That’s exactly what happens in many eCommerce projects where analytics is set up just “to tick the box” — using Google Tag Manager and Google Analytics 4, without a deep dive into the technical side.

A common belief sounds simple: “we installed GTM, connected GA4 — analytics is ready.” But in reality, this often leads to chaos:

• critical events aren’t tracked;
• data doesn’t match the CRM;
• reports don’t reflect the actual business picture.

This article is a case study of how the newage. team helped a European digital agency implement structured eCommerce analytics built at the code level. We’ll show why “just GTM” isn’t enough — and how proper tracking implementation became the foundation for accurate decision-making, scalable growth, and trust in analytics.

The Problem: GTM and GA4 Aren’t Always Enough

​​A typical scenario for eCommerce projects: the website goes live, and the basic stack — Google Tag Manager and Google Analytics 4 — is set up. From a technical standpoint, everything looks fine: events are tracked, reports are generated, and analytics are in place.

But the problem begins when this analytics setup is actually used to make business decisions.

What Goes Wrong?

• Inaccurate or incomplete data: Some events aren’t tracked at all, or they’re recorded incorrectly.
• Critical conversions aren’t captured properly: For example, transactions or add-to-cart actions are often tracked based on clicks rather than actual completion. Or, events get duplicated if they’re triggered only by page views.
• Mismatch between GA4 and CRM: Analytics metrics don’t align with actual business results seen in the CRM or ad platforms.
• Distorted key metrics: As a result, indicators like ROAS, LTV, and CPA become unreliable — directly impacting budgeting and scaling decisions.

The result? Reports that don’t reflect reality and campaigns optimized based on flawed data. That’s the kind of analytics that does more harm than good.

Solution: Code-Based eCommerce Implementation

To overcome the limitations of the basic setup (GTM + GA4), we proposed a full code-based implementation of eCommerce tracking — a robust technical architecture designed to ensure maximum data accuracy.

Starting with a Technical Specification

The project began with a detailed technical specification, which included:

• a clear event structure (e.g. purchase, add_to_cart, view_item, etc.);
• defined parameters such as product IDs, revenue, currency, and client_id;
• well-specified event trigger points — after a transaction, during UI interactions, at checkout initiation, and more.

This specification became the single source of truth. It served as a unified reference point for all involved parties — developers, analysts, and the client.

On-site code as the foundation of reliability

The core event tracking was implemented directly in the website’s codebase (JavaScript, PHP), rather than relying solely on GTM. This approach enabled us to:

• avoid event loss caused by blockers or container misconfigurations;
• ensure stable transmission of variables and parameters;
• reduce dependence on third-party tags.

Google Tag Manager as a supplementary tool

We leveraged GTM for flexibility — primarily to deploy isolated events or set up third-party integrations. However, the core analytics stack was handled through direct code implementation, not via the tag manager. This minimized risks and ensured long-term stability.

Multilayer Testing

Before launching the project, we carried out in-depth verification using multiple tools and methods:

• GA4 DebugView — to monitor events in real-time and confirm their structure and payloads;

• Tag Assistant — to verify tags and their parameters on each relevant page;

• Server-side logging — to match the actual transactions with the triggered events;
• Cross-checking with CRM and internal data — to validate the accuracy and completeness of analytics.

This approach helped eliminate the “it seems to work” scenarios — ensuring the data was neither incomplete nor misleading.

Results & Insights

This case proved that proper tracking architecture is not just a technical task — it’s a strategic investment in a business’s future.

Here are the key takeaways we’ve gathered:

GTM + GA4: A Good Start, but Not Enough for eCommerce

Google Tag Manager and GA4 work well as a basic analytics stack. However, when it comes to advanced eCommerce tracking, their capabilities often fall short:

• Data can be delayed or inaccurate;
• Events may not trigger properly due to browser specifics or user behavior;
• It’s difficult to fully capture funnel logic using GTM alone.

Backend Events = Significantly Higher Accuracy

When events are generated at the code level (e.g., confirming an order after payment), the risk of tracking errors drops dramatically:

• No dependency on frontend behavior or browser quirks;
• Human error in GTM configuration is eliminated;
• Data more accurately reflects real business actions.

A Structured Approach Enables Full-Funnel Control

Working with a clear technical specification, defined event schemas, and precise trigger points allows you to:

• Build a transparent and reliable tracking system;
• Quickly identify and resolve issues;
• Easily scale the solution across other projects without redoing the setup.

Tracking Quality = Decision Quality

Data is the foundation of marketing effectiveness. When tracking is implemented correctly:

• ROAS is calculated accurately;
• CPA reflects the true cost of acquisition;
• Remarketing targets precise, behavior-based audiences;
• Decisions are made based on facts, not assumptions.

Proper analytics isn’t a “nice-to-have” — it’s a must-have for scaling eCommerce. The newage. team delivered more than just event tracking — we built a comprehensive system for full-funnel control.

Conclusion

Code-based eCommerce implementation isn’t just a better approach — it’s the only right choice for businesses that make decisions based on accurate data rather than guesswork.

If you’re relying solely on GTM, you could be losing tens of percent of valuable insights:

• Critical events may go untracked;
• Google Analytics data may not match your CRM;
• Ad optimization runs “in the dark.”

At newage., we don’t just “set up” analytics — we architect a structured, scalable, and precise data tracking system that:

• Aligns with real business processes;
• Enables marketing optimization based on ROAS, LTV, and CAC;
• Supports business growth without analytical chaos.

Your analytics should work for you.

If you want full control over the user journey — from click to purchase — reach out to the team at newage. We’ll help you build eCommerce analytics that actually works.

FAQ: Common Questions About eCommerce Tracking Implementation

Isn’t it enough to just connect GA4 via GTM?

GTM is a convenient tool, but it’s not meant to be the foundation of your tracking system. It doesn’t guarantee 100% data accuracy. Critical eCommerce events are best sent from the backend to avoid data loss due to script blockers, slow loading, or unpredictable browser behavior.

What does “code-based implementation” mean, and how is it different from GTM setup?

Code-based implementation means events are sent directly from the website (e.g., using JavaScript or PHP), not just through GTM. This approach minimizes errors, ensures more reliable data validation, and provides complete, accurate analytics.

What specific events should be sent for eCommerce analytics?

The core events include: view_item, add_to_cart, begin_checkout, and purchase. However, it’s also crucial to send the full set of parameters — product IDs, prices, quantities, transaction status, etc. These details significantly impact attribution accuracy and advertising optimization.

Can eCommerce analytics be integrated with Google Ads?

Absolutely — and it’s essential for effective remarketing and conversion optimization. By linking GA4 with Google Ads, analytics events are shared with the ad platform, allowing you to build audiences and optimize campaigns based on real user behavior.

Why doesn’t GA4 data match the CRM?

Most commonly, discrepancies arise from inaccurate event transmission, duplication, or data loss. A code-based implementation helps synchronize key business metrics with your analytics platform, reducing the gap between actual performance and what’s reflected in reports.