diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..da02c7c
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,370 @@
+# Snowplow Java Tracker - Architecture & Development Guide
+
+## Project Overview
+
+The Snowplow Java Tracker is a library for tracking analytics events and sending them to Snowplow collectors. It provides a robust, configurable event tracking system for Java applications (JDK 8+) with support for batch processing, retry logic, and multiple HTTP client implementations.
+
+**Key Technologies:**
+- Java 8+ (minimum requirement)
+- Gradle 6.5.0 build system
+- Jackson for JSON processing
+- OkHttp/Apache HTTP clients (optional features)
+- JUnit 4/5 for testing
+- SLF4J for logging
+
+## Development Commands
+
+```bash
+# Build and run tests
+./gradlew build
+
+# Run tests only
+./gradlew test
+
+# Publish to local Maven repository
+./gradlew publishToMavenLocal
+
+# Generate version info
+./gradlew generateSources
+
+# Clean build artifacts
+./gradlew clean
+
+# Run example application
+cd examples/simple-console
+./gradlew jar
+java -jar ./build/libs/simple-console-all-0.0.1.jar "http://collector-url"
+```
+
+## Architecture
+
+### Core Components
+
+1. **Tracker**: Central component that processes and sends events
+2. **Emitter**: Handles HTTP communication and batch processing
+3. **Events**: Type-safe event models (PageView, Structured, SelfDescribing, etc.)
+4. **Subject**: User/device information attached to events
+5. **Payload**: Event data structures and serialization
+6. **Configuration**: Builder-pattern configuration objects
+
+### Layer Organization
+
+```
+com.snowplowanalytics.snowplow.tracker/
+├── configuration/     # Configuration builders
+├── emitter/          # Event transmission layer
+├── events/           # Event type definitions
+├── payload/          # Data structures & serialization
+├── http/             # HTTP client adapters
+└── constants/        # Constants and parameters
+```
+
+## Core Architectural Principles
+
+### 1. Configuration-First Design
+All components use configuration objects with fluent builders:
+```java
+// ✅ Use configuration objects
+TrackerConfiguration config = new TrackerConfiguration(namespace, appId)
+    .platform(DevicePlatform.ServerSideApp)
+    .base64Encoded(true);
+
+// ❌ Don't use complex constructors
+new Tracker(namespace, appId, platform, base64, emitter, subject);
+```
+
+### 2. Builder Pattern for Events
+All events use the builder pattern for construction:
+```java
+// ✅ Use builders for events
+PageView event = PageView.builder()
+    .pageUrl("https://example.com")
+    .customContext(contexts)
+    .build();
+
+// ❌ Don't use constructors or setters
+PageView event = new PageView();
+event.setPageUrl("https://example.com");
+```
+
+### 3. Immutable Event Data
+Events are immutable after creation:
+```java
+// ✅ Create complete events
+Structured event = Structured.builder()
+    .category("category")
+    .action("action")
+    .build();
+
+// ❌ Don't modify after creation
+event.setCategory("new-category"); // No such method
+```
+
+### 4. Nullable Pattern with Validation
+Required fields are validated, optional fields can be null:
+```java
+// ✅ Validate required fields
+Objects.requireNonNull(namespace);
+if (namespace.isEmpty()) {
+    throw new IllegalArgumentException("namespace cannot be empty");
+}
+
+// ✅ Optional fields can be null
+private Subject subject; // Can be null
+```
+
+## Critical Import Patterns
+
+### Standard Package Organization
+```java
+// ✅ Correct import order
+// 1. Java standard library
+import java.util.*;
+import java.io.Closeable;
+
+// 2. Third-party libraries
+import org.slf4j.Logger;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+// 3. Snowplow tracker packages
+import com.snowplowanalytics.snowplow.tracker.*;
+import com.snowplowanalytics.snowplow.tracker.events.*;
+```
+
+## Essential Library Patterns
+
+### 1. Tracker Creation Pattern
+```java
+// ✅ Use Snowplow factory with configurations
+Tracker tracker = Snowplow.createTracker(
+    trackerConfig,
+    networkConfig,
+    emitterConfig,
+    subjectConfig
+);
+
+// ❌ Don't create tracker directly
+Tracker tracker = new Tracker(config, emitter);
+```
+
+### 2. Event Tracking Pattern
+```java
+// ✅ Track returns event IDs
+List<String> eventIds = tracker.track(event);
+
+// ✅ Handle batch events (EcommerceTransaction)
+List<String> ids = tracker.track(transaction); // May return multiple IDs
+```
+
+### 3. SelfDescribingJson Pattern
+```java
+// ✅ Use schema + data constructor
+SelfDescribingJson context = new SelfDescribingJson(
+    "iglu:com.example/context/jsonschema/1-0-0",
+    Collections.singletonMap("key", "value")
+);
+
+// ❌ Don't use TrackerPayload as data
+new SelfDescribingJson(schema, new TrackerPayload()); // Contains unwanted eid/dtm
+```
+
+### 4. HTTP Client Adapter Pattern
+```java
+// ✅ Let configuration choose adapter
+BatchEmitter emitter = new BatchEmitter(networkConfig, emitterConfig);
+
+// ✅ Or provide custom adapter
+HttpClientAdapter adapter = new OkHttpClientAdapter(url);
+networkConfig.httpClientAdapter(adapter);
+```
+
+## Model Organization Pattern
+
+### Event Hierarchy
+```
+Event (interface)
+└── AbstractEvent (base class)
+    ├── PageView
+    ├── Structured
+    ├── SelfDescribing
+    ├── ScreenView
+    ├── Timing
+    ├── EcommerceTransaction
+    └── EcommerceTransactionItem
+```
+
+### Payload Types
+```
+Payload (interface)
+├── TrackerPayload (main event payload)
+├── SelfDescribingJson (schema-based data)
+└── BatchPayload (POST request wrapper)
+```
+
+## Common Pitfalls & Solutions
+
+### 1. TrackerPayload in SelfDescribingJson
+```java
+// ❌ Wrong: TrackerPayload adds unwanted eid/dtm
+SelfDescribingJson data = new SelfDescribingJson(
+    schema,
+    new TrackerPayload()
+);
+
+// ✅ Correct: Use Map or Object
+SelfDescribingJson data = new SelfDescribingJson(
+    schema,
+    new HashMap<String, Object>()
+);
+```
+
+### 2. Synchronous Event Sending
+```java
+// ❌ Wrong: Expecting immediate send
+tracker.track(event);
+// Event not sent yet!
+
+// ✅ Correct: Events are batched
+tracker.track(event);
+tracker.getEmitter().flushBuffer(); // Force send
+tracker.close(); // Or close to flush
+```
+
+### 3. Missing Required Configuration
+```java
+// ❌ Wrong: Missing collector URL
+NetworkConfiguration network = new NetworkConfiguration();
+
+// ✅ Correct: Provide URL or adapter
+NetworkConfiguration network = new NetworkConfiguration("https://collector.example.com");
+```
+
+### 4. Thread Safety
+```java
+// ❌ Wrong: Sharing Subject across threads
+Subject shared = new Subject();
+// Multiple threads modifying shared
+
+// ✅ Correct: Event-specific subjects
+PageView.builder()
+    .subject(new Subject()) // Thread-local
+    .build();
+```
+
+## File Structure Template
+
+```
+snowplow-java-tracker/
+├── build.gradle                 # Main build configuration
+├── src/
+│   ├── main/java/com/snowplowanalytics/snowplow/tracker/
+│   │   ├── Tracker.java        # Core tracker
+│   │   ├── Snowplow.java       # Factory & registry
+│   │   ├── Subject.java        # User/device info
+│   │   ├── configuration/      # Config objects
+│   │   ├── emitter/           # Event transmission
+│   │   ├── events/            # Event types
+│   │   ├── payload/           # Data structures
+│   │   └── http/              # HTTP adapters
+│   └── test/java/             # Unit tests
+└── examples/
+    └── simple-console/        # Usage example
+```
+
+## Testing Patterns
+
+### 1. Mock Emitter Pattern
+```java
+// ✅ Use MockEmitter for testing
+class MockEmitter implements Emitter {
+    public List<TrackerPayload> eventList = new ArrayList<>();
+    
+    @Override
+    public boolean add(TrackerPayload payload) {
+        eventList.add(payload);
+        return true;
+    }
+}
+```
+
+### 2. MockWebServer for HTTP Tests
+```java
+// ✅ Use OkHttp MockWebServer
+MockWebServer server = new MockWebServer();
+server.enqueue(new MockResponse().setResponseCode(200));
+String url = server.url("/").toString();
+```
+
+### 3. Test Event Creation
+```java
+// ✅ Test with all optional fields
+PageView event = PageView.builder()
+    .pageUrl("https://example.com")
+    .customContext(contexts)
+    .trueTimestamp(timestamp)
+    .subject(subject)
+    .build();
+```
+
+## Quick Reference
+
+### Event Types Checklist
+- [ ] **PageView**: Web page views
+- [ ] **Structured**: Category/action events
+- [ ] **SelfDescribing**: Custom schema-based events
+- [ ] **ScreenView**: Mobile screen views
+- [ ] **Timing**: Performance timing
+- [ ] **EcommerceTransaction**: Purchase events (deprecated)
+
+### Configuration Components
+- [ ] **TrackerConfiguration**: namespace, appId, platform
+- [ ] **NetworkConfiguration**: collector URL, HTTP client
+- [ ] **EmitterConfiguration**: batch size, thread count, callbacks
+- [ ] **SubjectConfiguration**: user ID, session, device info
+
+### Snowplow Concepts
+- **Collector**: Endpoint receiving events
+- **Schema**: Iglu schema for self-describing data
+- **Context**: Additional data attached to events
+- **Subject**: User/device information
+- **Namespace**: Unique tracker identifier
+
+## Contributing to CLAUDE.md
+
+When adding or updating content in this document, please follow these guidelines:
+
+### File Size Limit
+- **CLAUDE.md must not exceed 40KB** (currently ~19KB)
+- Check file size after updates: `wc -c CLAUDE.md`
+- Remove outdated content if approaching the limit
+
+### Code Examples
+- Keep all code examples **4 lines or fewer**
+- Focus on the essential pattern, not complete implementations
+- Use `// ❌` and `// ✅` to clearly show wrong vs right approaches
+
+### Content Organization
+- Add new patterns to existing sections when possible
+- Create new sections sparingly to maintain structure
+- Update the architectural principles section for major changes
+- Ensure examples follow current codebase conventions
+
+### Quality Standards
+- Test any new patterns in actual code before documenting
+- Verify imports and syntax are correct for the codebase
+- Keep language concise and actionable
+- Focus on "what" and "how", minimize "why" explanations
+
+### Multiple CLAUDE.md Files
+- **Directory-specific CLAUDE.md files** can be created for specialized modules
+- Follow the same structure and guidelines as this root CLAUDE.md
+- Keep them focused on directory-specific patterns and conventions
+- Maximum 20KB per directory-specific CLAUDE.md file
+
+### Instructions for LLMs
+When editing files in this repository, **always check for CLAUDE.md guidance**:
+
+1. **Look for CLAUDE.md in the same directory** as the file being edited
+2. **If not found, check parent directories** recursively up to project root
+3. **Follow the patterns and conventions** described in the applicable CLAUDE.md
+4. **Prioritize directory-specific guidance** over root-level guidance when conflicts exist
\ No newline at end of file
diff --git a/src/main/java/com/snowplowanalytics/snowplow/tracker/emitter/CLAUDE.md b/src/main/java/com/snowplowanalytics/snowplow/tracker/emitter/CLAUDE.md
new file mode 100644
index 0000000..bbb5ad2
--- /dev/null
+++ b/src/main/java/com/snowplowanalytics/snowplow/tracker/emitter/CLAUDE.md
@@ -0,0 +1,350 @@
+# Emitter Module - Snowplow Java Tracker
+
+## Module Overview
+
+The emitter module handles event transmission to Snowplow collectors. It provides batching, buffering, retry logic, and asynchronous event sending with configurable HTTP clients. The BatchEmitter is the primary implementation with sophisticated error handling and exponential backoff.
+
+## Core Components
+
+```
+Emitter (interface)
+└── BatchEmitter          # Main implementation with batching
+    ├── EventStore        # Event persistence interface
+    │   └── InMemoryEventStore  # Default in-memory storage
+    ├── BatchPayload      # POST request wrapper
+    ├── EmitterCallback   # Success/failure callbacks
+    └── FailureType       # Failure categorization
+```
+
+## Emitter Architecture Principles
+
+### 1. Asynchronous Processing
+All events are processed asynchronously:
+```java
+// ✅ Events queued, not sent immediately
+emitter.add(payload);  // Returns quickly
+// Event sent later by executor
+
+// ❌ Don't expect synchronous sending
+emitter.add(payload);
+// Event may not be sent yet!
+```
+
+### 2. Batch Processing Pattern
+Events are batched for efficiency:
+```java
+// ✅ Configure batch size
+EmitterConfiguration config = new EmitterConfiguration()
+    .batchSize(25)        // Send when 25 events buffered
+    .bufferCapacity(1000); // Max buffer size
+```
+
+### 3. Retry with Exponential Backoff
+Failed requests retry with increasing delays:
+```java
+// ✅ Automatic retry handling
+// Initial: 0ms delay
+// First failure: 100ms delay
+// Second failure: 200ms delay
+// Max delay: 600000ms (10 min)
+```
+
+### 4. Thread Pool Management
+Configurable thread pool for sending:
+```java
+// ✅ Configure thread count
+EmitterConfiguration config = new EmitterConfiguration()
+    .threadCount(2);  // Number of sender threads
+```
+
+## BatchEmitter Implementation
+
+### Constructor Pattern
+```java
+// ✅ Use configuration objects
+BatchEmitter emitter = new BatchEmitter(
+    networkConfig,   // URL and HTTP client
+    emitterConfig    // Batching and threading
+);
+
+// ❌ Don't use deprecated builder
+BatchEmitter.builder().url(url).build();
+```
+
+### Event Addition Flow
+```java
+// ✅ Standard flow
+boolean success = emitter.add(payload);
+if (!success) {
+    // Buffer full, event dropped
+}
+```
+
+### Buffer Management
+```java
+// ✅ Force flush buffer
+emitter.flushBuffer();
+
+// ✅ Close and flush
+emitter.close();  // Flushes remaining events
+```
+
+## EventStore Pattern
+
+### Interface Contract
+```java
+public interface EventStore {
+    boolean add(TrackerPayload payload);
+    boolean remove(TrackerPayload payload);
+    boolean removeAll(List<TrackerPayload> payloads);
+    List<TrackerPayload> getBuffer();
+    long getSize();
+}
+```
+
+### InMemoryEventStore Implementation
+```java
+// ✅ Thread-safe implementation
+public class InMemoryEventStore implements EventStore {
+    private final AtomicLong bufferSize = new AtomicLong(0);
+    private final ConcurrentLinkedDeque<TrackerPayload> buffer;
+    private final long bufferCapacity;
+}
+```
+
+## HTTP Client Configuration
+
+### Client Adapter Options
+```java
+// ✅ OkHttp (default)
+HttpClientAdapter client = new OkHttpClientAdapter(url);
+
+// ✅ Apache HTTP
+HttpClientAdapter client = new ApacheHttpClientAdapter(url);
+
+// ✅ Custom implementation
+HttpClientAdapter custom = new CustomAdapter();
+networkConfig.httpClientAdapter(custom);
+```
+
+### Cookie Management
+```java
+// ✅ Cookie jar for network_userid
+OkHttpClientWithCookieJarAdapter adapter = 
+    new OkHttpClientWithCookieJarAdapter(url);
+```
+
+## Callback Pattern
+
+### EmitterCallback Interface
+```java
+// ✅ Implement callbacks
+EmitterCallback callback = new EmitterCallback() {
+    @Override
+    public void onSuccess(List<TrackerPayload> payloads) {
+        // Handle successful send
+    }
+    
+    @Override
+    public void onFailure(FailureType type, boolean willRetry, 
+                          List<TrackerPayload> payloads) {
+        // Handle failure
+    }
+};
+```
+
+### Failure Types
+```java
+public enum FailureType {
+    REJECTED_BY_COLLECTOR,  // 4xx responses
+    TRACKER_ISSUE,         // 5xx or network errors
+    EMITTER_REQUEST_FAILURE // Client-side issues
+}
+```
+
+## Custom Retry Logic
+
+### Status Code Configuration
+```java
+// ✅ Custom retry for status codes
+Map<Integer, Boolean> customRetry = new HashMap<>();
+customRetry.put(403, false);  // Don't retry 403
+customRetry.put(500, true);   // Retry 500
+
+EmitterConfiguration config = new EmitterConfiguration()
+    .customRetryForStatusCodes(customRetry);
+```
+
+## Request Building
+
+### GET Request Pattern
+```java
+// ✅ Single event GET request
+String url = collectorUrl + "/i?" + payload.toString();
+```
+
+### POST Request Pattern
+```java
+// ✅ Batch POST request
+BatchPayload batch = new BatchPayload();
+batch.add(payload1);
+batch.add(payload2);
+String json = batch.toString();
+// POST to collectorUrl + "/com.snowplowanalytics.snowplow/tp2"
+```
+
+## Thread Safety Patterns
+
+### 1. Concurrent Buffer Access
+```java
+// ✅ Thread-safe operations
+private final ConcurrentLinkedDeque<TrackerPayload> buffer;
+private final AtomicLong bufferSize;
+```
+
+### 2. Executor Management
+```java
+// ✅ Proper shutdown
+@Override
+public void close() {
+    isClosing = true;
+    flushBuffer();
+    executor.shutdown();
+    executor.awaitTermination(timeout, TimeUnit.SECONDS);
+}
+```
+
+### 3. Atomic Retry Delay
+```java
+// ✅ Thread-safe retry counter
+private final AtomicInteger retryDelay = new AtomicInteger(0);
+```
+
+## Testing Emitter Behavior
+
+### 1. Mock EventStore
+```java
+// ✅ Test with mock store
+EventStore mockStore = mock(EventStore.class);
+when(mockStore.getBuffer()).thenReturn(payloads);
+```
+
+### 2. MockWebServer Testing
+```java
+// ✅ Test HTTP interactions
+MockWebServer server = new MockWebServer();
+server.enqueue(new MockResponse().setResponseCode(200));
+BatchEmitter emitter = new BatchEmitter(
+    new NetworkConfiguration(server.url("/").toString()),
+    new EmitterConfiguration()
+);
+```
+
+### 3. Callback Testing
+```java
+// ✅ Verify callbacks
+AtomicBoolean success = new AtomicBoolean(false);
+EmitterCallback callback = new EmitterCallback() {
+    @Override
+    public void onSuccess(List<TrackerPayload> payloads) {
+        success.set(true);
+    }
+};
+```
+
+## Common Pitfalls
+
+### 1. Synchronous Expectations
+```java
+// ❌ Wrong: Expecting immediate send
+emitter.add(payload);
+assert(eventSent);  // May fail
+
+// ✅ Correct: Wait or flush
+emitter.add(payload);
+emitter.flushBuffer();
+Thread.sleep(100);
+```
+
+### 2. Ignoring Buffer Limits
+```java
+// ❌ Wrong: Not checking return value
+emitter.add(payload);  // Might be dropped
+
+// ✅ Correct: Check success
+if (!emitter.add(payload)) {
+    // Handle dropped event
+}
+```
+
+### 3. Resource Leaks
+```java
+// ❌ Wrong: Not closing emitter
+BatchEmitter emitter = new BatchEmitter(...);
+// Use emitter...
+// Never closed!
+
+// ✅ Correct: Always close
+try (BatchEmitter emitter = new BatchEmitter(...)) {
+    // Use emitter
+}  // Auto-closed
+```
+
+### 4. Improper Thread Count
+```java
+// ❌ Wrong: Too many threads
+.threadCount(100)  // Excessive
+
+// ✅ Correct: Reasonable count
+.threadCount(2)    // Good default
+```
+
+## Performance Considerations
+
+### Batch Size Tuning
+- Small batches (1-10): Lower latency, more requests
+- Medium batches (25-50): Balanced
+- Large batches (100+): Higher latency, fewer requests
+
+### Buffer Capacity
+- Set based on expected event volume
+- Consider memory constraints
+- Default: 10,000 events
+
+### Thread Count
+- 1-2 threads for most applications
+- More threads for high-volume scenarios
+- Consider collector capacity
+
+## Adding Custom Emitters
+
+### Template for Custom Emitter
+```java
+public class CustomEmitter implements Emitter {
+    @Override
+    public boolean add(TrackerPayload payload) {
+        // Custom logic
+        return true;
+    }
+    
+    @Override
+    public void flushBuffer() {
+        // Send all buffered events
+    }
+    
+    @Override
+    public void close() {
+        // Cleanup resources
+    }
+}
+```
+
+## Contributing to Emitter Module
+
+### Guidelines
+1. Maintain thread safety in all operations
+2. Implement proper resource cleanup in close()
+3. Honor the EmitterCallback contract
+4. Test retry logic with various failure scenarios
+5. Document any custom retry strategies
+6. Ensure buffer limits are respected
\ No newline at end of file
diff --git a/src/main/java/com/snowplowanalytics/snowplow/tracker/events/CLAUDE.md b/src/main/java/com/snowplowanalytics/snowplow/tracker/events/CLAUDE.md
new file mode 100644
index 0000000..c54d243
--- /dev/null
+++ b/src/main/java/com/snowplowanalytics/snowplow/tracker/events/CLAUDE.md
@@ -0,0 +1,293 @@
+# Events Module - Snowplow Java Tracker
+
+## Module Overview
+
+The events module defines all trackable event types in the Snowplow Java Tracker. Each event type implements the Event interface and extends AbstractEvent, providing a consistent builder-based API for event creation and immutable event objects.
+
+## Event Type Hierarchy
+
+```
+Event (interface)
+└── AbstractEvent (abstract base)
+    ├── PageView         # Web page views
+    ├── Structured       # Generic structured events
+    ├── SelfDescribing   # Schema-based custom events
+    ├── ScreenView       # Mobile/app screen views
+    ├── Timing          # Performance timing events
+    ├── EcommerceTransaction     # Purchase events (deprecated)
+    └── EcommerceTransactionItem # Line items (deprecated)
+```
+
+## Core Event Patterns
+
+### 1. Builder Pattern Mandatory
+Every event MUST use the builder pattern:
+```java
+// ✅ Correct: Builder pattern
+PageView event = PageView.builder()
+    .pageUrl("https://example.com")
+    .build();
+
+// ❌ Wrong: Direct instantiation
+new PageView("https://example.com");
+```
+
+### 2. AbstractEvent Base Class
+All events extend AbstractEvent for common fields:
+```java
+// ✅ Inherit common behavior
+public class PageView extends AbstractEvent {
+    public static class Builder extends AbstractEvent.Builder<Builder> {
+        // Event-specific fields
+    }
+}
+```
+
+### 3. Self-Returning Builder Pattern
+Builders must return self() for chaining:
+```java
+// ✅ Correct self() implementation
+public static class Builder extends AbstractEvent.Builder<Builder> {
+    @Override
+    protected Builder self() {
+        return this;
+    }
+}
+```
+
+### 4. Payload Generation Pattern
+Each event implements getPayload():
+```java
+// ✅ Standard payload creation
+@Override
+public TrackerPayload getPayload() {
+    TrackerPayload payload = new TrackerPayload();
+    payload.add(Parameter.EVENT, Constants.EVENT_PAGE_VIEW);
+    payload.add(Parameter.PAGE_URL, pageUrl);
+    return putTrueTimestamp(payload);
+}
+```
+
+## Event-Specific Patterns
+
+### PageView Events
+```java
+// ✅ Complete PageView example
+PageView pageView = PageView.builder()
+    .pageUrl("https://example.com")      // Required
+    .pageTitle("Example Page")           // Optional
+    .referrer("https://google.com")      // Optional
+    .customContext(contexts)             // From AbstractEvent
+    .trueTimestamp(timestamp)            // From AbstractEvent
+    .subject(eventSubject)               // From AbstractEvent
+    .build();
+```
+
+### Structured Events
+```java
+// ✅ Structured event with all fields
+Structured event = Structured.builder()
+    .category("video")        // Required
+    .action("play")           // Required
+    .label("tutorial")        // Optional
+    .property("intro")        // Optional
+    .value(1.5)              // Optional
+    .build();
+```
+
+### SelfDescribing Events
+```java
+// ✅ Schema-based custom event
+SelfDescribing event = SelfDescribing.builder()
+    .eventData(new SelfDescribingJson(
+        "iglu:com.example/event/jsonschema/1-0-0",
+        eventDataMap
+    ))
+    .build();
+```
+
+### EcommerceTransaction Pattern
+```java
+// ✅ Transaction with items
+EcommerceTransaction transaction = EcommerceTransaction.builder()
+    .orderId("ORDER-123")
+    .totalValue(99.99)
+    .items(item1, item2)  // Variadic items
+    .build();
+// Note: Generates multiple events when tracked
+```
+
+## Common Implementation Requirements
+
+### 1. Field Validation
+```java
+// ✅ Validate required fields in build()
+public PageView build() {
+    Objects.requireNonNull(pageUrl, "pageUrl cannot be null");
+    if (pageUrl.isEmpty()) {
+        throw new IllegalArgumentException("pageUrl cannot be empty");
+    }
+    return new PageView(this);
+}
+```
+
+### 2. Immutability Enforcement
+```java
+// ✅ Final fields, no setters
+public class PageView extends AbstractEvent {
+    private final String pageUrl;
+    private final String pageTitle;
+    // No setters, only getters
+}
+```
+
+### 3. Context Handling
+```java
+// ✅ Contexts are copied, not referenced
+@Override
+public List<SelfDescribingJson> getContext() {
+    return new ArrayList<>(this.context);
+}
+```
+
+### 4. Timestamp Management
+```java
+// ✅ True timestamp is optional
+Long trueTimestamp = getTrueTimestamp();
+if (trueTimestamp != null) {
+    payload.add(Parameter.TRUE_TIMESTAMP, Long.toString(trueTimestamp));
+}
+```
+
+## Event Parameters Reference
+
+### Common Parameters (AbstractEvent)
+- `customContext`: List of SelfDescribingJson contexts
+- `trueTimestamp`: User-defined timestamp (milliseconds)
+- `subject`: Event-specific Subject override
+
+### PageView Parameters
+- `pageUrl` (required): URL of the page
+- `pageTitle`: Title of the page
+- `referrer`: Referring URL
+
+### Structured Parameters
+- `category` (required): Event category
+- `action` (required): Event action
+- `label`: Event label
+- `property`: Event property
+- `value`: Numeric value
+
+### SelfDescribing Parameters
+- `eventData` (required): SelfDescribingJson with schema and data
+
+## Testing Event Creation
+
+### 1. Test Required Fields
+```java
+// ✅ Test validation
+@Test(expected = NullPointerException.class)
+public void testMissingRequiredField() {
+    PageView.builder().build(); // Should throw
+}
+```
+
+### 2. Test Optional Fields
+```java
+// ✅ Test with nulls
+PageView event = PageView.builder()
+    .pageUrl("https://example.com")
+    .pageTitle(null)  // Should work
+    .build();
+```
+
+### 3. Test Event Payload
+```java
+// ✅ Verify payload contents
+TrackerPayload payload = event.getPayload();
+assertEquals("pv", payload.getMap().get("e"));
+assertEquals(url, payload.getMap().get("url"));
+```
+
+## Anti-Patterns to Avoid
+
+### 1. Mutable Events
+```java
+// ❌ Never add setters
+public void setPageUrl(String url) {
+    this.pageUrl = url;
+}
+```
+
+### 2. Public Constructors
+```java
+// ❌ Don't expose constructors
+public PageView(String url) {
+    this.pageUrl = url;
+}
+```
+
+### 3. Direct Field Access
+```java
+// ❌ Don't expose mutable fields
+public List<SelfDescribingJson> context;
+```
+
+### 4. Missing Validation
+```java
+// ❌ Don't skip validation
+public Event build() {
+    return new PageView(this); // No checks
+}
+```
+
+## Adding New Event Types
+
+### Template for New Event
+```java
+public class NewEvent extends AbstractEvent {
+    private final String requiredField;
+    private final String optionalField;
+    
+    public static class Builder extends AbstractEvent.Builder<Builder> {
+        private String requiredField;
+        private String optionalField;
+        
+        @Override
+        protected Builder self() { return this; }
+        
+        public Builder requiredField(String value) {
+            this.requiredField = value;
+            return self();
+        }
+        
+        public NewEvent build() {
+            Objects.requireNonNull(requiredField);
+            return new NewEvent(this);
+        }
+    }
+    
+    private NewEvent(Builder builder) {
+        super(builder);
+        this.requiredField = builder.requiredField;
+        this.optionalField = builder.optionalField;
+    }
+    
+    @Override
+    public TrackerPayload getPayload() {
+        TrackerPayload payload = new TrackerPayload();
+        payload.add(Parameter.EVENT, "new");
+        return putTrueTimestamp(payload);
+    }
+}
+```
+
+## Contributing to Events Module
+
+### Guidelines
+1. All new events MUST extend AbstractEvent
+2. All new events MUST use the builder pattern
+3. Required fields MUST be validated in build()
+4. Events MUST be immutable after creation
+5. Test both required and optional field scenarios
+6. Document schema requirements for SelfDescribing events
\ No newline at end of file
diff --git a/src/test/java/CLAUDE.md b/src/test/java/CLAUDE.md
new file mode 100644
index 0000000..341be05
--- /dev/null
+++ b/src/test/java/CLAUDE.md
@@ -0,0 +1,371 @@
+# Testing Guide - Snowplow Java Tracker
+
+## Testing Overview
+
+The test suite uses JUnit 4 with JUnit 5 Vintage Engine for backward compatibility. Tests focus on unit testing individual components with extensive use of mocking for external dependencies like HTTP servers.
+
+## Test Organization
+
+```
+src/test/java/com/snowplowanalytics/snowplow/tracker/
+├── TrackerTest.java           # Core tracker functionality
+├── SnowplowTest.java          # Factory and registry
+├── SubjectTest.java           # Subject data management
+├── UtilsTest.java            # Utility functions
+├── emitter/                  # Emitter layer tests
+├── events/                   # Event type tests
+├── payload/                  # Payload serialization tests
+└── http/                     # HTTP client tests
+```
+
+## Core Testing Patterns
+
+### 1. Mock Emitter Pattern
+Essential for testing tracker behavior without network calls:
+```java
+// ✅ Standard MockEmitter
+public static class MockEmitter implements Emitter {
+    public List<TrackerPayload> eventList = new ArrayList<>();
+    
+    @Override
+    public boolean add(TrackerPayload payload) {
+        eventList.add(payload);
+        return true;
+    }
+}
+```
+
+### 2. Test Setup Pattern
+Consistent test initialization:
+```java
+// ✅ Standard setUp
+@Before
+public void setUp() {
+    mockEmitter = new MockEmitter();
+    TrackerConfiguration config = new TrackerConfiguration("AF003", "cloudfront")
+        .base64Encoded(false);
+    tracker = new Tracker(config, mockEmitter);
+}
+```
+
+### 3. MockWebServer Pattern
+For testing HTTP interactions:
+```java
+// ✅ HTTP testing setup
+MockWebServer server = new MockWebServer();
+server.enqueue(new MockResponse()
+    .setResponseCode(200)
+    .setBody("ok"));
+String url = server.url("/").toString();
+```
+
+### 4. Assertion Patterns
+Verify event payloads correctly:
+```java
+// ✅ Payload verification
+TrackerPayload payload = mockEmitter.eventList.get(0);
+Map<String, String> map = payload.getMap();
+assertEquals("pv", map.get("e"));        // Event type
+assertEquals(url, map.get("url"));       // Page URL
+assertNotNull(map.get("eid"));          // Event ID
+```
+
+## Event Testing Patterns
+
+### 1. Builder Validation Tests
+```java
+// ✅ Test required fields
+@Test(expected = NullPointerException.class)
+public void testMissingRequiredField() {
+    PageView.builder().build();  // Missing pageUrl
+}
+```
+
+### 2. Optional Field Tests
+```java
+// ✅ Test optional fields
+@Test
+public void testOptionalFields() {
+    PageView event = PageView.builder()
+        .pageUrl("https://example.com")
+        .pageTitle(null)  // Should work
+        .build();
+    assertNotNull(event);
+}
+```
+
+### 3. Context Testing
+```java
+// ✅ Test custom contexts
+@Test
+public void testCustomContext() {
+    List<SelfDescribingJson> contexts = singletonList(
+        new SelfDescribingJson("schema", 
+            Collections.singletonMap("key", "value"))
+    );
+    PageView event = PageView.builder()
+        .pageUrl("https://example.com")
+        .customContext(contexts)
+        .build();
+}
+```
+
+## Emitter Testing Patterns
+
+### 1. Batch Processing Tests
+```java
+// ✅ Test batching behavior
+@Test
+public void testBatchSize() throws InterruptedException {
+    BatchEmitter emitter = new BatchEmitter(
+        networkConfig,
+        new EmitterConfiguration().batchSize(2)
+    );
+    emitter.add(payload1);
+    emitter.add(payload2);  // Should trigger send
+    Thread.sleep(500);
+    // Verify batch sent
+}
+```
+
+### 2. Retry Logic Tests
+```java
+// ✅ Test retry on failure
+@Test
+public void testRetryLogic() {
+    server.enqueue(new MockResponse().setResponseCode(500));
+    server.enqueue(new MockResponse().setResponseCode(200));
+    // Add event and verify retry
+}
+```
+
+### 3. Callback Tests
+```java
+// ✅ Test callbacks
+@Test
+public void testSuccessCallback() {
+    AtomicBoolean called = new AtomicBoolean(false);
+    EmitterCallback callback = new EmitterCallback() {
+        @Override
+        public void onSuccess(List<TrackerPayload> payloads) {
+            called.set(true);
+        }
+    };
+    // Verify callback invoked
+}
+```
+
+## Payload Testing Patterns
+
+### 1. Serialization Tests
+```java
+// ✅ Test JSON serialization
+@Test
+public void testJsonSerialization() {
+    SelfDescribingJson json = new SelfDescribingJson(
+        "schema",
+        Collections.singletonMap("key", "value")
+    );
+    String result = json.toString();
+    assertTrue(result.contains("\"schema\":\"schema\""));
+}
+```
+
+### 2. Base64 Encoding Tests
+```java
+// ✅ Test encoding
+@Test
+public void testBase64Encoding() {
+    TrackerConfiguration config = new TrackerConfiguration("ns", "app")
+        .base64Encoded(true);
+    // Verify contexts are base64 encoded
+}
+```
+
+### 3. Size Calculation Tests
+```java
+// ✅ Test payload size
+@Test
+public void testPayloadSize() {
+    TrackerPayload payload = new TrackerPayload();
+    payload.add("key", "value");
+    assertTrue(payload.getByteSize() > 0);
+}
+```
+
+## Subject Testing Patterns
+
+### 1. Subject Merging Tests
+```java
+// ✅ Test subject override
+@Test
+public void testSubjectOverride() {
+    Subject trackerSubject = new Subject();
+    trackerSubject.setUserId("tracker-user");
+    
+    Subject eventSubject = new Subject();
+    eventSubject.setUserId("event-user");
+    
+    // Event subject should override
+}
+```
+
+### 2. Platform Detection Tests
+```java
+// ✅ Test platform setting
+@Test
+public void testPlatformDetection() {
+    Subject subject = new Subject();
+    subject.setPlatform(DevicePlatform.Mobile);
+    assertEquals("mob", subject.getSubject().get("p"));
+}
+```
+
+## Thread Safety Testing
+
+### 1. Concurrent Access Tests
+```java
+// ✅ Test thread safety
+@Test
+public void testConcurrentAccess() throws InterruptedException {
+    CountDownLatch latch = new CountDownLatch(10);
+    for (int i = 0; i < 10; i++) {
+        new Thread(() -> {
+            tracker.track(event);
+            latch.countDown();
+        }).start();
+    }
+    latch.await();
+    // Verify all events tracked
+}
+```
+
+### 2. Buffer Overflow Tests
+```java
+// ✅ Test buffer limits
+@Test
+public void testBufferOverflow() {
+    EmitterConfiguration config = new EmitterConfiguration()
+        .bufferCapacity(2);
+    // Add 3 events, verify one dropped
+}
+```
+
+## Test Utilities
+
+### 1. Event ID Validation
+```java
+// ✅ Validate UUID format
+private boolean isValidUUID(String id) {
+    try {
+        UUID.fromString(id);
+        return true;
+    } catch (Exception e) {
+        return false;
+    }
+}
+```
+
+### 2. Timestamp Validation
+```java
+// ✅ Validate timestamp
+private boolean isValidTimestamp(String ts) {
+    try {
+        long timestamp = Long.parseLong(ts);
+        return timestamp > 0;
+    } catch (Exception e) {
+        return false;
+    }
+}
+```
+
+### 3. JSON Validation
+```java
+// ✅ Validate JSON structure
+private boolean isValidJson(String json) {
+    try {
+        new ObjectMapper().readTree(json);
+        return true;
+    } catch (Exception e) {
+        return false;
+    }
+}
+```
+
+## Common Test Anti-Patterns
+
+### 1. Real Network Calls
+```java
+// ❌ Don't use real endpoints
+BatchEmitter emitter = new BatchEmitter(
+    new NetworkConfiguration("https://real-collector.com"),
+    config
+);
+
+// ✅ Use MockWebServer
+MockWebServer server = new MockWebServer();
+```
+
+### 2. Sleep Without Reason
+```java
+// ❌ Arbitrary sleep
+Thread.sleep(5000);  // Why?
+
+// ✅ Sleep with purpose
+Thread.sleep(100);  // Allow async operation
+```
+
+### 3. Missing Cleanup
+```java
+// ❌ Resources not cleaned
+MockWebServer server = new MockWebServer();
+// Never shutdown
+
+// ✅ Proper cleanup
+@After
+public void tearDown() throws IOException {
+    server.shutdown();
+}
+```
+
+### 4. Overly Complex Mocks
+```java
+// ❌ Complex mock setup
+when(mock.method1()).thenReturn(x);
+when(mock.method2()).thenReturn(y);
+// 20 more lines...
+
+// ✅ Simple test double
+class SimpleEmitter implements Emitter {
+    // Minimal implementation
+}
+```
+
+## Test Execution
+
+### Running Tests
+```bash
+# Run all tests
+./gradlew test
+
+# Run specific test class
+./gradlew test --tests TrackerTest
+
+# Run with coverage
+./gradlew test jacocoTestReport
+```
+
+### Test Categories
+- **Unit Tests**: Individual component testing
+- **Integration Tests**: Component interaction
+- **Concurrency Tests**: Thread safety verification
+- **Performance Tests**: Not in main suite
+
+## Contributing Test Guidelines
+
+1. **Test Naming**: Use descriptive names (testPageViewWithAllFields)
+2. **One Assertion Per Test**: Keep tests focused
+3. **Mock External Dependencies**: Never make real network calls
+4. **Test Edge Cases**: Null values, empty strings, limits
+5. **Document Complex Tests**: Add comments for non-obvious logic
+6. **Clean Up Resources**: Always close/shutdown in @After
\ No newline at end of file