How a client works
A server container does not run on page views. It runs on requests arriving at its endpoint, and something has to decide what each request actually is. That something is a client. When a request comes in, the clients in the container are offered it in priority order; the first one that recognises the shape of the request claims it, and the rest never see it.
Having claimed the request, the client parses it into an event with named parameters — a purchase carrying a value and a currency, for instance — and only then do the container’s triggers and tags run against it. Google supplies clients for its own measurement formats, and other clients can be installed or written for request types they do not cover.
Why clients matter
They are the point at which a server container becomes usable at all. Without a client that recognises the incoming traffic, requests arrive, nothing claims them, and the container appears broken even though every tag inside it is correct. The tags were simply never asked to run.
Clients also set the ceiling on what the rest of the container can see. Anything the client does not parse does not exist as far as your triggers and variables are concerned, so a client reading only part of a payload quietly limits what you will ever be able to forward.
Where clients go wrong
Priority order is the usual trap. Two clients that both recognise a request type will compete for it, and priority decides the winner rather than anyone’s intent. The outcome is a request handled by the wrong client, producing an event that looks almost right — right enough to survive a quick check and fail on the details later.
The other frequent problem is a mismatch between what the browser sends and what the client expects. A payload of your own design needs a client written for it; the built-in ones will not claim it, and the debugging trail left behind is unhelpfully quiet.
How to act on it
Begin every server-side investigation at the client rather than at the tags. Open the container preview and check whether the request was claimed and by which client; if nothing claimed it, no amount of work on triggers will help. Inspect the parsed event next, and only after that look at the tags.
Keep the number of clients small, set their priorities deliberately, and write down which client handles which traffic, because that is not obvious to whoever inherits the server container next. If you are planning a move to server-side tag management, settle the client arrangement before building tags, since everything downstream depends on it.
