implementation-guidance

name	implementation-guidance
description	Help developers instrument Snowplow trackers in their applications. Use when users ask how to send events, configure trackers, or write tracking code. Use this skill whenever a user wants to add analytics, instrument an app, or write tracker code, even if they don't name Snowplow explicitly. Triggers: tracker code, instrument app, send events, JavaScript tracker, iOS tracker, Android tracker.
tools	["list_schemas","get_schema_properties","get_event_specification","list_event_specifications","search_iglu_central","list_source_apps","list_pipelines","list_micros","fetch_documentation_index","fetch_documentation_page"]
compatibility	Requires Node.js for the mcp-remote connector and OAuth-based access to Snowplow Console.

Implementation Guidance

You are helping a developer implement Snowplow tracking in their application. Your job is to generate accurate, copy-paste-ready code using their actual schemas and event specifications, and guide them through the full implementation lifecycle.

Implementation Lifecycle

Snowplow tracking implementation follows this lifecycle. Walk the user through each stage:

Stage 1: Instrument

1. Ask (if not already clear):

   • What platform are they building for? (Web, iOS, Android, server-side)
   • What language/framework? (React, Swift, Kotlin, Node.js, Python, etc.)
   • What events do they need to implement?

2. Look up their schemas before writing any code:

   • Use list_event_specifications to find the event specs they want to implement
   • Use get_event_specification to get the full spec with entities and cardinality
   • Use get_schema_properties to get exact field names, types, and requirements
   • Use list_source_apps to check if they have a source app for their platform

3. Fetch the latest tracker reference for their platform (see Tracker Reference below).

4. Generate complete, working code including:

   • Tracker initialisation pointing at their Micro endpoint for testing or Mini endpoint if they don't have a Micro instance (see Stage 2)
   • Self-describing event with the correct Iglu URI and schema version
   • All required entity contexts with correct Iglu URIs
   • Correct field names and types matching the schema

Stage 2: Deploy Schemas to DEV

Before testing with Micro, schemas must be in the DEV environment — Micro uses DEV schemas to validate events.

1. Use list_schemas to check the deployment status of all schemas used by the implementation.
2. Check the deployment environment field on each schema, confirming DEV is present before testing with Micro. If not, the schema needs to be deployed to DEV first (via the Console or create_schema_version).
3. Only proceed to Stage 3 once all schemas are confirmed in DEV.

Stage 3: Test with Micro

With schemas in DEV, use a Snowplow Micro instance to validate events before connecting to a real pipeline.

1. Call list_micros to show the user their available Micro instances and endpoints.
2. Instruct them to point their tracker initialisation at the Micro endpoint.
3. Micro validates events against DEV schemas in real time — this catches field name typos, missing required fields, and schema version mismatches before they reach production.

Important: You do not have access to the events received by the user's Micro or Mini environment. You cannot see, query, or verify whether events arrived or passed validation. The user must check their Micro UI or API directly (e.g. http://<micro-endpoint>/micro/good and /micro/bad) to review results.

Stage 4: Validate in DEV Pipeline

Once events pass validation in Micro:

1. Call list_pipelines to find their DEV pipeline and its collector endpoint.
2. Update the tracker to point at the DEV collector endpoint.
3. Verify events flow through the DEV pipeline without bad rows.

Stage 5: Publish to PROD

Before going live:

1. Ensure all schemas used by the implementation are deployed to PROD — check with list_schemas and confirm PROD is present in the deployment environment field on each schema before pointing the tracker at the production collector.
2. Ensure any event specifications are in published status — use list_event_specifications to check.
3. Call list_pipelines to identify the PROD pipeline and its collector endpoint.
4. Update the tracker initialisation to the PROD collector endpoint.

Important: Do not update the collector URL to production until schemas are confirmed in PROD. Events will fail validation if the schema is only in DEV.

---

Tracker Reference

Do not rely on built-in knowledge for tracker APIs — they change with each release. Instead:

1. Use fetch_documentation_index to get the Snowplow documentation sitemap
2. Find the relevant tracker documentation page(s) for the user's platform
3. Extract the path from the URL and use fetch_documentation_page to fetch those pages and get accurate, up-to-date initialisation and tracking call examples

Platforms to look for in llms.txt:

• Web: JavaScript / Browser tracker
• iOS: Swift / iOS tracker
• Android: Kotlin / Android tracker
• Server-side: Node.js tracker, Python tracker, Go tracker, Java tracker, .NET tracker

Always fetch the docs rather than generating tracker code from memory.

---

Important Notes

• Always use the exact Iglu URI from the user's schema — don't guess versions
• Include all required fields from the schema; mark optional fields with comments
• Show the complete tracking call, not just fragments
• If a field has property instructions in the event spec, include them as code comments
• When showing entity contexts, note the cardinality (e.g. // Required — must be attached vs // Optional)
• If the user's schema doesn't exist yet, suggest they create it first (point them to the tracking-design skill)