Skip to content
Faisal Mahmud TusherDigital marketing, SEO & analytics
with Faisal Tusher

Marketing Technology › The Marketing Stack

Designing a Marketing Stack

How to design a marketing stack: starting from use cases, the layers from collection to activation, build versus buy, and integration-first selection.
Guideintermediate11 min readUpdated

Start from use cases

A use case is a sentence that describes something marketing needs to do, in plain language, with the outcome it serves. "Recover abandoned baskets with a message within an hour." "Follow up every trial sign-up with a sequence that depends on what they did in the product." "Report revenue by channel weekly in a way finance accepts." "Suppress existing customers from acquisition advertising." Each one implies data to collect, somewhere to store and join it, a decision to make and a channel to act through.

Writing the use cases first does three things. It makes the design about the business rather than about the market, so the chiefmartec.com landscape with its thousands of products becomes a reference to consult rather than a menu to order from. It exposes the data requirements early, because a use case that needs the product's usage events and the billing system's subscription state cannot be served by any tool until those events exist. And it gives every later selection a test: does this tool serve a written use case, and which? The guide to handling requests for new marketing tools applies that test at the front door, before anyone starts a trial or a selection.

The list does not need to be long. Most teams can write the use cases they run today in an afternoon and the ones they want in a year in another. Group them by outcome (acquisition, conversion, retention, reporting) and mark which are live, which are planned and which are aspirations. The measurement plan the business already has, or should have, supplies the outcomes and the events; the measurement plan guide in the analytics hub covers writing one, and the use-case list is its operational twin. The tutorial on writing the use-case list takes the list from a first draft to a record that is kept current.

The layers

With the use cases written, map each to the layers it touches. The layers are a model, not a product category, and most tools span more than one.

LayerWhat it doesQuestions the use cases answerCommon tool categories
CollectionRecords events and attributes from every surfaceWhich events, from which surfaces, with which parameters?Tag manager (GTM), analytics tags, server-side tagging, software development kits, form and call tracking
DataStores, joins and governsWhich sources must be joined? How is a person identified? What does consent allow?Warehouse, customer data platform (CDP), consent management, data quality tooling
DecisioningChooses what happens nextWhich segments, scores, rules and tests?Marketing automation, experimentation, personalisation engines, lead scoring
ActivationDelivers through channelsWhich channels, with what cadence and suppression?Advertising platforms, email and messaging, customer relationship management, on-site and in-app messaging
MeasurementCloses the loopWhich reports, for whom, at what grain?Analytics (GA4), business intelligence, attribution and incrementality tooling

The map usually shows three things at once. Some layers are served by several tools (two email platforms, two analytics properties), which is overlap to resolve. Some use cases touch a layer no tool serves, most often the data layer, where the join between site behaviour and the customer record simply does not exist. And some tools serve no use case, which is the clearest sign that they can go. The MarTech categories guide explains what each category does if the vocabulary is unfamiliar.

The data layer deserves most of the design attention because it is where the other layers meet. Older stacks put a data management platform (DMP) here, built on third-party cookies for advertising audiences; its role has shrunk as those cookies have, and the current pattern is first-party data in a warehouse or a customer data platform, or both. Which of those the business needs, and how they divide the work, is the subject of the data flow and integrations guide; at the design stage the question is only whether the use cases need a governed, joined view of the customer, and for how many channels.

Build vs buy

Every layer can in principle be built or bought, and the right answer differs by layer and by company. The question is not "can we build it?" but "is this where our engineering time earns the most?"

Collection is mostly bought: a tag manager and the platforms' own tags cover the site, and the custom work is the data layer the site exposes to them, which has to be built. Server-side collection is a mix; managed tagging services exist, and some teams run their own endpoints when they need control over what leaves the site.

The data layer is where the build-or-buy decision matters most. A warehouse is bought as a service and built on in the sense that every table, join and definition is the team's own work. A customer data platform is bought to avoid building identity resolution, profile storage and connectors, and the trade is flexibility for speed. Teams with data engineers often build the join in the warehouse and buy a thin activation layer on top; teams without them buy the platform and accept its model of the customer. Neither is wrong; the mistake is buying a platform and then rebuilding its logic in the warehouse anyway, or building a warehouse and then exporting from it by hand.

Decisioning and activation are almost always bought, because channels change their interfaces constantly and keeping up is a vendor's full-time job. The exception is the decision logic itself: a scoring model or a segment definition belongs to the business and should be expressible outside any one tool, which is an argument for defining it in the data layer and syncing it out rather than building it in each activation tool separately.

Measurement is bought for the analytics property and built for the business intelligence layer, where the business intelligence section covers the metrics layer that turns raw tables into definitions everyone shares.

A useful discipline for every build decision is to write down what it would cost to maintain, not just to create. Built components need an owner who will still be there in two years, documentation, and a plan for when the person who wrote them leaves. Most built components that fail do so for lack of maintenance rather than lack of capability. For AI, the equivalent choice is usually between a standalone assistant and the features already built into the stack's tools, which the comparison of standalone AI assistants and built-in AI features works through task by task.

Integration first

The most common selection error is choosing a tool for its features and discovering afterwards that it cannot exchange the data the use cases need. Integration-first selection reverses the order: before looking at features, establish what the tool has to receive, what it has to send, in what form and how often.

For each candidate tool, write the integration requirements as a short list. Inbound: which events and attributes it needs, from which source, at what latency (a basket recovery message needs the event within minutes; a weekly report does not). Outbound: which results it has to return (sends, opens, conversions, segment membership) and to where. Identity: which identifier it keys on, and whether that identifier exists in the data layer. Consent: whether it can read consent state and act on it. Then check each against what the tool offers: a native connector, a documented programming interface, a file import, or nothing.

A tool with a native connector to the data layer and a documented interface for the rest will fit most stacks. A tool whose only route in is a file upload will create a manual process that someone will eventually stop doing. A tool that keys on an identifier the stack does not hold will build its own view of the customer that never matches anyone else's. These are design facts, discoverable before a demo, and they rule out more candidates than any feature list.

Integration-first also means preferring open interfaces and standard event formats over proprietary ones. The site's data layer should emit events in one agreed schema, with the same names and parameters whichever tool consumes them, so that adding or replacing a tool is a mapping exercise rather than a new collection project. The data layer guide covers what that schema looks like on the site, and the tracking plan guide covers the document that holds it. The choosing and evaluating tools guide turns these checks into a scoring method. When a selection starts, the stack fit, criteria, scores and integration checks can be recorded in the marketing tool evaluation template.

Reference architectures by size

The right stack for a team depends less on budget than on how many channels it runs, how many sources it must join and whether it has engineering support. Three reference shapes cover most cases.

A small team, one site, a few channels. Collection through a tag manager and the platforms' own tags; the analytics property as the behavioural record; the customer relationship management system or e-commerce platform as the record of people; an email and messaging platform connected directly to it; advertising accounts fed by the platforms' tags and by uploaded customer lists where consent allows. No warehouse and no customer data platform. The use cases that need a join (suppress customers from acquisition, trigger on product events) are served by the direct integrations the email platform and the commerce platform already offer. The customer relationship management fundamentals guide explains the record-of-people role.

A mid-sized team, several channels, some engineering. The same collection layer, now with server-side tagging for the events that matter most; a warehouse that receives the analytics export, the customer relationship management data, the commerce data and the advertising platforms' reports; a metrics layer on top for reporting; and either a customer data platform or a reverse flow from the warehouse to push segments to email and advertising. Decisioning in the marketing automation platform, driven by segments the warehouse defines. This is the shape where identity resolution becomes a deliberate design, because the sources no longer share one identifier.

A large team, many channels and markets, a data team. A warehouse as the system of record for behaviour and customer data, with identity resolution, consent and definitions enforced there; a customer data platform or a built activation layer for real-time use cases; experimentation and personalisation as separate decisioning tools; multiple activation platforms per channel by market; and business intelligence with a governed metrics layer. The design work at this scale is mostly about governance: who may define an event, a segment or a metric, and how a change propagates.

Illustrative example — not a real result

A mid-sized retailer designs its stack

An online furniture retailer with 14 people in marketing writes 22 use cases, of which 15 are live and 7 planned. Mapping them to layers shows that 9 need site behaviour joined to order history, and that no tool currently holds both: the email platform keys on email address, the analytics property on a cookie, and the commerce platform on a customer id. The team chooses a warehouse fed by the three sources, builds the join on email address and customer id with a hashed email as the bridge to advertising platforms, and adds a reverse-sync tool to push warehouse-defined segments to the email platform and two advertising accounts. Of the 31 tools in the inventory, 6 are retired as overlapping. The design is delivered in three phases over 9 months, with the first phase (warehouse and join) live in 11 weeks and the first warehouse-driven segment, lapsed buyers of upholstery, in use by week 14.

The roadmap

A designed stack is rarely built in one move, and it should not be. The roadmap sequences the change so that each phase delivers a use case, pays for the next and can be stopped without leaving the stack worse than it was.

Phase one is usually the data layer, because every later phase depends on it: the site's event schema, the warehouse or platform that receives it, the join on identity and the consent rules. The deliverable is one use case that was impossible before, chosen for visibility rather than size, so that the organisation sees the point. Phase two is consolidation: retiring overlapping tools, moving their integrations to the data layer and cleaning the tag inventory, which the tag governance guide covers; each tool leaves in the order the tutorial on retiring a marketing tool gives, with its jobs moved and its data exported before anything is closed. Phase three is new capability: the planned use cases, each added with its integrations written and its owner named.

Run every phase with the same three artefacts: the use-case list with status, the layer map with tools and owners, and the data flow diagram. Update them as the phases land, and treat a change that is not reflected in them as not done. The layer map's owners column matters most when an agency leaves: the agency offboarding checklist uses it to bring domains, page builders and tool logins back into the business's name. The marketing stack hub holds the layer model that the artefacts are built on.

Avoid the two failure modes of roadmaps. The big bang replaces everything at once, with a migration that takes longer than planned and a period in which nothing works reliably. The perpetual pilot adds tools in trial without ever retiring anything, until the stack is twice the size with no more capability. Phases that each deliver and each retire are the middle path.

Common mistakes

  • Designing from the vendor landscape. Thousands of products, each with a demo; the use-case list is the filter that makes the landscape usable.
  • Buying the data layer before the use cases need it. A customer data platform with nothing to activate is an expensive database.
  • Choosing on features and checking integration afterwards. The integration facts are discoverable first and rule out more candidates than any feature list.
  • Building what will not be maintained. A built component needs an owner, documentation and a succession plan, or it becomes the thing nobody dares touch.
  • Letting each tool resolve identity its own way. Segments that disagree and reports that cannot be reconciled follow directly.
  • Treating the roadmap as a procurement schedule. Each phase should deliver a use case and retire something, not just add a contract.
  • Skipping the artefacts. Without the use-case list, the layer map and the flow diagram, the design exists only in the head of whoever wrote it.

Frequently asked questions

Should the stack be designed around a customer data platform?

Only if the use cases need one. A customer data platform solves a specific set of problems: resolving identity across sources, holding governed profiles and pushing segments to many channels. If the business runs one site, one email platform and a couple of advertising accounts, direct integrations and the customer relationship management system cover those jobs. Design from the use cases, and let the platform earn its place when several of them need it.

How many tools should a marketing stack have?

There is no right number, and counting tools is the wrong measure. The test is whether every job the use cases need is covered once, by a tool with an owner and working integrations. A stack with many small tools that each do one job and connect cleanly can be healthier than one with a few large suites whose modules nobody uses. Overlap, not count, is the warning sign.

What comes first, the stack design or the measurement plan?

The measurement plan, by a short margin. It defines the outcomes and the events the business cares about, and those events are the collection requirements the stack has to meet. In practice the two are written together, because the plan reveals what the current stack cannot collect and the stack design reveals which measures are affordable. Writing either in isolation produces a plan the stack cannot serve or a stack that measures the wrong things.

Terms used on this page

Frameworks

Where this page is used

Also related

Sources

  1. Marketing technology landscape — chiefmartec.com

Related