Analytics / Growth
Industry: Analytics
1
Source of truth
In short
Arcetis built a unified analytics platform — a React dashboard backed by a Node.js API, a BigQuery data warehouse, and a Looker semantic layer — that pulled a client's siloed campaign and growth data into one place. The result was a single dashboard for spend, performance, and attribution that became the marketing team's source of truth and coincided with a 27% increase in ROAS.
The client is an analytics-heavy business where marketing and growth performance is tracked across multiple campaigns, channels, and internal systems. Like many organizations running paid campaigns alongside broader growth initiatives, the team needed a way to see spend, performance, and attribution in one place rather than piecing numbers together from separate tools and exports. Arcetis was brought in to design and build a custom analytics platform that could ingest campaign and growth data into a centralized warehouse, model it consistently, and present it through a dashboard built around how the marketing and growth teams actually make decisions. The engagement combined data engineering on BigQuery, business intelligence on Looker, and custom application development in React and Node.js to replace a fragmented, multi-source reporting process with one governed view of return on ad spend.
Before this engagement, the client's campaign data lived in silos with no unified view of return on investment — a pattern that's common in analytics-heavy organizations once they're running campaigns across more than a handful of channels. Performance numbers, spend figures, and growth outcomes each tend to live wherever the tool or system that produced them lives, and each source typically comes with its own definitions, its own time windows, and its own way of counting something as basic as a "conversion" or a "customer." Nothing tied spend on a given campaign back to the growth outcomes it was supposed to produce. The practical effect of that kind of fragmentation is that nobody can answer, with confidence, a basic question: what is the actual return on ad spend, channel by channel and campaign by campaign? Without a unifying system, getting even a rough answer typically means manually pulling data from multiple sources, reconciling mismatched date ranges and metric definitions, and stitching the result together by hand — a process that tends to get repeated every reporting cycle and that can produce a different answer depending on who does the stitching and what assumptions they make. That kind of manual reconciliation is slow, error-prone, and hard to fully trust, which is the kind of condition under which budget and channel decisions get made on partial or dated information rather than a current, unified view of performance. This is a common failure mode for teams whose marketing and growth efforts scale faster than their data infrastructure: each new channel or tool adds another silo, and without a deliberate integration and modeling layer, the number of sources grows faster than anyone's ability to reconcile them by hand. The cost isn't just wasted analyst time — it's slower, less confident decisions about where to spend, which campaigns to scale, and which to cut, plus a persistent internal debate over whose numbers are "right" because different teams pull from different sources using different logic. The client needed a system that could ingest data from wherever it originated, apply one consistent set of definitions for spend, performance, and attribution, and present it in a single dashboard that both marketing and growth stakeholders could trust and act on — without a manual reconciliation step standing between the data and the decision.
Arcetis led the end-to-end design and build of the analytics platform, from data architecture through to the dashboard the marketing and growth teams use day to day. Arcetis architected a centralized data warehouse in BigQuery to consolidate campaign and growth data that had previously lived in separate systems. Arcetis built the semantic and reporting layer in Looker, defining consistent metrics for spend, performance, and attribution so every team worked from the same numbers. Arcetis developed the Node.js API layer connecting the underlying data models to a custom-built React frontend, giving the client a purpose-built dashboard rather than a generic BI template. Arcetis managed the data modeling work required to unify previously siloed sources into one consistent ROAS calculation, and was responsible for delivering a platform the client could adopt as its ongoing source of truth for campaign and growth reporting.
Arcetis designed a centralized data warehouse in BigQuery to serve as the single ingestion point for campaign and growth data that had previously been scattered across separate platforms and spreadsheets. This included structuring datasets and tables so spend, performance, and attribution data could be joined and queried consistently, replacing a set of disconnected exports with one queryable source. The warehouse became the foundation every other part of the platform — the Looker reporting layer, the API, and the dashboard — was built on top of.
A core part of the engagement was agreeing on and implementing one consistent definition of spend, performance, and attribution across every campaign and channel feeding the platform. Arcetis modeled the logic needed to calculate ROAS and related performance metrics consistently, removing the source-by-source definitions that had made cross-channel comparisons unreliable. This modeling layer is what let the client compare campaigns and channels on equal terms and trust the resulting numbers enough to act on them.
Arcetis built the reporting and semantic layer in Looker, giving the marketing and growth teams governed, self-serve access to spend, performance, and attribution data without needing custom reports each time a question came up. Defining these metrics once in Looker's modeling layer meant every dashboard, report, and ad hoc query pulled from the same governed definitions, closing the gap between teams reporting different numbers for the same campaign.
Rather than rely solely on Looker's native interface, Arcetis built a custom-facing dashboard using React on the frontend and a Node.js API layer to serve the underlying data. This gave the client a single, purpose-built view of spend, performance, and attribution designed around how the marketing and growth teams actually make decisions, rather than a generic BI template retrofitted to the use case.
Arcetis handled the technical work of connecting the BigQuery warehouse, the Looker semantic layer, and the custom Node.js/React application into one working platform, including the API contracts and data flows between each layer. The result was delivered as a single system the client's team could log into and rely on, replacing the manual, multi-source reporting process that existed before the engagement.
The build followed a standard pattern for consolidating multi-source marketing and growth data into one governed platform: get the data into a single warehouse, define the metrics once, then build a presentation layer on top that the business can actually use. The first phase was data engineering. Campaign, spend, and growth data that had previously lived across separate tools and spreadsheets needed to land in one place before anything else could happen. Arcetis used BigQuery as the central warehouse, structuring it so campaign-level spend data, performance data, and growth/outcome data could all be joined on common keys — campaign, channel, and date being the typical join points in this kind of model. BigQuery's ability to handle large volumes of campaign- and event-level data at low query latency made it a practical fit for a reporting workload that needs to support both scheduled dashboard refreshes and ad hoc analysis. With the raw data consolidated, the next phase was metrics modeling — usually the highest-leverage and most failure-prone part of any unified-analytics build. If two teams define "conversion" or "attributed revenue" differently, no amount of good engineering will make their numbers agree. Arcetis worked through this by defining spend, performance, and attribution logic once, at the data layer, rather than leaving each report or dashboard to calculate its own version. That single set of definitions is what let ROAS be calculated consistently across every campaign and channel rather than recalculated — and potentially redefined — every time someone pulled a new report. Looker sat on top of this modeling layer as the semantic and BI layer. Looker's approach is built around defining metrics and dimensions once, in a governed modeling layer (LookML), and reusing them across every downstream report or exploration — precisely the property this engagement needed: one governed definition of ROAS, spend, and performance metrics that both a scheduled dashboard and an analyst's ad hoc query would pull from consistently. This is standard practice for teams adopting Looker specifically to solve an "everyone has different numbers" problem, since the alternative — defining metrics independently in every tool or spreadsheet — is exactly the failure mode that created the original silos. On top of the BigQuery/Looker foundation, Arcetis built a custom-facing application layer rather than shipping Looker's native interface directly to end users. A Node.js API layer sat between the data layer and the frontend, handling requests for aggregated spend, performance, and attribution data and shaping it for the dashboard's needs — a common pattern when a business wants a purpose-built interface rather than a generic BI tool's default views. The React frontend consumed that API to render the actual dashboard: a single, focused view surfacing spend, performance, and attribution together, built around the specific questions the marketing and growth teams needed answered rather than a one-size-fits-all reporting template. Throughout the build, the guiding principle was consistency before completeness at every stage: get the data unified and the definitions agreed on before layering on visualization, since a well-designed dashboard built on inconsistent underlying metrics would only reproduce the original trust problem in a nicer interface. That sequencing — warehouse, then metrics model, then BI layer, then custom application — is what let the platform become the team's actual source of truth rather than one more report to reconcile against everything else.
Campaign, spend, and growth data that previously lived in separate systems was consolidated into a single BigQuery warehouse, structured around common keys like campaign, channel, and date. This gave every downstream layer — Looker, the API, and the dashboard — one consistent source to query against instead of reconciling multiple exports, and gave the platform room to scale as more campaigns and channels were added over time.
Spend, performance, and attribution metrics were defined once in Looker's modeling layer rather than recalculated independently in each report. That single governed definition is what let ROAS and related metrics stay consistent across every dashboard view and ad hoc query, directly addressing the inconsistent-numbers problem that existed before the platform was built.
Rather than exposing Looker's default interface to end users, Arcetis built a custom React frontend designed around the specific spend, performance, and attribution questions the marketing and growth teams needed answered day to day, giving them one purpose-built screen instead of a generic BI template.
A Node.js service layer sat between the BigQuery/Looker data foundation and the React dashboard, handling requests for aggregated metrics and shaping the underlying data to match the dashboard's needs — a standard pattern for teams that want a custom-built interface on top of a governed data and BI layer rather than off-the-shelf reporting screens.
Attribution had previously been calculated differently depending on which source system produced the numbers. Arcetis modeled one consistent attribution logic at the data layer so spend could be tied back to performance and growth outcomes the same way across every campaign and channel, which is what made a single, trustworthy ROAS figure possible.
Source of truth
ROAS
Technology used
Key learnings
This engagement is a good example of a pattern that shows up repeatedly in analytics-heavy organizations: the hardest part of a unified-reporting project usually isn't the dashboard people see, it's the modeling work underneath it. Silos rarely exist because a business lacks data — they exist because that data lives in different systems with different definitions, and nobody has done the often-unglamorous work of reconciling those definitions into one governed model. Building the dashboard before doing that work tends to produce a nicer-looking version of the same trust problem: teams still argue about whose numbers are right, just with better charts. The sequencing that worked here — consolidate the raw data first, agree on one set of metric definitions second, and only then build the reporting and application layers on top — is standard practice for a reason. It front-loads the hard, cross-functional work of getting stakeholders to agree on what "ROAS" or "attribution" actually means, so that by the time the dashboard ships, it's reporting numbers people already trust rather than introducing a new set of numbers to debate. The ROAS improvement that coincided with this work reinforces the point: a trustworthy, unified view of spend and performance is what let the team evaluate and act on campaign and channel decisions with more confidence. The platform itself doesn't change a business's marketing strategy — it changes how quickly and confidently that strategy can be assessed and adjusted, which is where better outcomes like this one tend to come from. For any organization running campaigns across multiple channels and tools, the lesson generalizes well beyond this one engagement.
It typically replaces a manual process of exporting data from individual ad platforms, spreadsheets, and internal systems and reconciling it by hand every reporting cycle. In this engagement, that manual reconciliation was replaced with a single BigQuery warehouse, a governed Looker metrics layer, and a custom React/Node.js dashboard that became the team's single source of truth for spend, performance, and attribution.
BigQuery and Looker handle data consolidation and governed metric definitions well, but a custom frontend lets the interface be built specifically around the questions a given team needs answered rather than a generic BI template. In this case, Arcetis used BigQuery and Looker as the data and metrics foundation, then built a purpose-built React dashboard on top, served through a Node.js API layer.
By giving decision-makers one consistent, trusted view of spend, performance, and attribution instead of numbers reconciled by hand from multiple sources, teams can make faster, more confident calls about which campaigns and channels to scale or cut. In this engagement, that shift coincided with a 27% increase in ROAS.
It means every team pulling a spend, performance, or attribution number gets it from the same governed definition, rather than each team calculating it independently from its own export or tool. That was the outcome reported for this client: the platform became the team's single source of truth for campaign and growth metrics.