Frequently Asked Questions

Clayva is the platform that lets Product Managers run mobile experiments without waiting for engineering. **The Problem:** PMs have experiment ideas. Engineering has a backlog. Result: 4+ week wait times, ideas dying in Jira tickets. **The Clayva Solution:** 1. **PM describes the variant** ("Make checkout button green with trust badge") 2. **AI writes the code** (Swift, Kotlin, or React Native) 3. **Cloud simulators test it** (No Mac or Android Studio needed) 4. **PM sees it live on Canvas** (Figma-like workspace) 5. **Dev just clicks Merge** (Like Dependabot—5 minutes) **The three pillars:** - **Canvas + Cloud Simulators** - See your app, create variants, no local setup - **AI-Powered Experimentation** - Describe experiments in plain English, AI writes code - **Analytics Engine** - Track results, declare winners automatically **What Clayva enables:** - PMs ship 20 experiments/day (vs 1/month waiting for engineering) - Devs just merge PRs (less work, not more) - No Mac, Xcode, or Android Studio required for PMs

Clayva is built for Product Managers who are tired of waiting for engineering. **Perfect for:** - **Product Managers** - Want to run experiments without writing code or waiting 4+ weeks - **Growth PMs** - Need to test 20 variants, not 1/month - **Solo founders** - Can't afford a mobile dev for every experiment - **Small product teams** - Want to move faster than enterprise competitors - **Mobile companies** - Using React Native, Swift, or Kotlin **How it works:** - **PM:** Describes variant, sees it on Canvas, ships PR - **Dev:** Clicks Merge (like Dependabot)—5 minutes each - **Result:** 20 experiments/day instead of 1/month **Not for:** - Teams where PMs are okay waiting months for experiments - Organizations that require developer involvement in every experiment - Companies that prefer long planning cycles over rapid iteration If you're a PM who wants to stop waiting for engineering, Clayva is for you.

Vibe coding is describing what you want and letting AI write the code—no programming skills required. **For developers:** Claude Code, Cursor, Copilot let them ship 10x faster by describing features instead of writing line-by-line. **For PMs (the Clayva way):** You describe an experiment variant—"Make the checkout button green with a trust badge"—and AI writes the Swift/Kotlin/React Native code. You see it live on cloud simulators. You ship it. **Why this matters for PMs:** - You don't need Mac, Xcode, or Android Studio - You don't need to know Swift, Kotlin, or JavaScript - You don't need to wait for your engineering team - You describe → AI codes → dev merges → you ship **The PM bottleneck is gone.** Before vibe coding, PMs had to wait 4+ weeks for every experiment. Now they ship 20 experiments/day. **Clayva is the vibe coding platform for PMs.** Describe the variant, see it on Canvas, ship the PR. Your dev just clicks Merge.

Traditional analytics = dashboards, SQL, waiting for the data team. Clayva = conversations, canvas, instant answers. | Traditional | Clayva | |-------------|--------| | Build dashboards | Ask questions | | Write SQL | Talk in English | | Wait for data team | Get answers instantly | | Navigate menus | Drag on canvas | | Read charts | Have conversations | | 2-4 week cycles | Same-day insights | **The key difference:** - **Mixpanel/Amplitude**: Self-serve analytics (you search for data) - **Looker/Tableau**: Dashboard builders (you build views) - **Clayva**: AI-first analytics (you just ask) You don't search for data. You don't build queries. You don't navigate dashboards. You just ask. And know.

Clayva is built on three core pillars that work together: ## 1. AI Analytics Engine Not dashboards. *Conversations.* ``` You: "What's broken in my funnel?" Clayva: "Your signup→activation drop is 67%. Mobile users on Android are 3x worse than iOS. The 'verify email' step takes 4.2 seconds on Android vs 0.8s on iOS. Want me to create an experiment to test a skip-verification flow?" You: "Yes" Clayva: [Experiment created. Running.] ``` Powered by Claude Sonnet 4.5. The BI team used to take 2 weeks to find this. Clayva finds it while you're still drinking coffee. ## 2. Canvas Workspace Your brain doesn't think in dashboards. It thinks in connections. - Drag data points anywhere - Connect insights visually - See patterns no dashboard could show - Collaborate in real-time It's Figma for data. Infinite space for infinite exploration. ## 3. Experiments Engine A/B testing shouldn't require a PhD in statistics. - **One click** to create an experiment - **Automatic** traffic splitting - **Real-time** statistical significance - **Plain English** results: "Version B wins. 94% confident. Ship it."

The AI Analytics Engine uses Claude Sonnet 4.5 to understand your data and answer questions in plain English. **How it works:** 1. **Your data flows in** via the SDK (events, user actions, metrics) 2. **AI learns your product** by understanding your schema and patterns 3. **You ask questions** in natural language 4. **AI queries your data** using DuckDB and S3 Parquet 5. **You get answers** with context, insights, and suggested actions **Example conversations:** ``` "Why did signups drop this week?" → Identifies the specific step, user segment, and device causing issues "Which features do power users use?" → Segments users, analyzes behavior, shows usage patterns "Should I ship this feature?" → Analyzes experiment results, explains confidence level, gives recommendation ``` **What makes it different:** - **Not just search**: It reasons about your data, finds patterns, suggests experiments - **Context-aware**: Knows your product, remembers previous conversations - **Action-oriented**: Doesn't just show data, helps you decide what to do - **Stateless chat**: Full history sent each request for consistent context

The Canvas is Clayva's visual workspace for exploring and understanding your data. Think Figma, but for data analysis. **Key features:** - **Infinite space**: Pan, zoom, organize however your brain works - **Elements**: Data points, charts, insights, metrics - drag them anywhere - **Frames**: Group related elements together - **Connections**: Draw relationships between insights visually - **Real-time sync**: Changes sync instantly across your team **Why canvas instead of dashboards:** Dashboards force your thinking into predefined boxes. The canvas lets you: - Place related metrics next to each other - Draw connections between cause and effect - See the big picture and zoom into details - Explore without constraints **Technical details:** - Built with Pixi.js 8.11 for 60fps rendering - Uses Elm Architecture pattern for predictable state - Real-time collaboration via Phoenix PubSub - Handles thousands of elements smoothly **Use cases:** - Map your entire funnel visually - Create experiment war rooms - Build dynamic investigation boards - Collaborate on data explorations in real-time

The Experiments Engine makes A/B testing accessible to anyone, with built-in statistical rigor. **Creating an experiment:** 1. Click "New Experiment" or ask AI: "Test a skip-verification flow" 2. Define variants (A: control, B: new version) 3. Choose metrics to track 4. Set traffic allocation 5. Click run **What Clayva handles automatically:** - **Traffic splitting**: Random, statistically valid allocation - **Sample size calculation**: Know when you have enough data - **Statistical significance**: Real-time p-values and confidence intervals - **Multiple comparison correction**: Avoid false positives - **Stopping rules**: Know when to stop early (winner or loser) **Reading results:** Instead of p-values and confidence intervals, you get: ``` "Version B wins. 94% confident. Conversion up 12% (8.3% to 9.3%). Ship it." ``` Or: ``` "No winner yet. Need 3 more days of data. Current trend: Version B +5%, but not significant." ``` **Experiment types:** - Feature flags - UI changes - Pricing tests - Flow variations - Copy tests

Clayva's vision is to replace your entire back-office, not just your data team. ## Phase 1: The Loop (Now) **Analytics + Canvas + Experiments** Ship → Track → Understand → Iterate. The core vibe loop is live today. ## Phase 2: Personalization Engine (Coming) **Replace your ML team** ``` You: "Which users are about to churn?" Clayva: "Found 847 users showing churn signals. Common patterns: no login in 14 days, skipped onboarding, mobile-only. Want me to create a re-engagement experiment for this segment?" ``` - Automatic user segmentation - Predictive models without Python - Personalized experiences in plain English ## Phase 3: DevOps Engine (Coming) **Replace your DevOps team** ``` You: "Deploy the new checkout flow to 10% of users" Clayva: [Deployed. Monitoring enabled.] "Alert: Error rate spiked 3x. Rolling back automatically." ``` - One-click deploys with automatic rollback - Real-time monitoring tied to experiments - Incident detection before users complain ## Phase 4: Security Engine (Coming) **Replace your Security team** - Continuous vulnerability scanning - OWASP Top 10 detection - Plain English security reports ## Phase 5: The Autopilot **Full autonomy for trusted patterns** For patterns you trust, Clayva runs the loop automatically.

Clayva is priced to replace your data team, not add another expense. ## Pricing Philosophy **The old way**: $500k+/yr for data engineers, BI analysts, and A/B test specialists **The Clayva way**: A fraction of that cost, instant results ## Plans ### Starter For solo builders testing the waters - Up to 100K events/month - AI chat (Sonnet 4.5) - Basic canvas - 3 experiments - 1 user ### Pro For serious vibe coders - Up to 1M events/month - Unlimited AI chat - Full canvas features - Unlimited experiments - 5 users - Email support ### Scale For growing teams - Up to 10M events/month - Priority AI processing - Team collaboration - Advanced analytics - 25 users - Slack support ### Enterprise For larger organizations - Unlimited events - Dedicated infrastructure - Custom integrations - SLA guarantees - Unlimited users - Dedicated support ## ROI Calculator If you're currently paying: - 1 data engineer: $150k/yr - 1 BI analyst: $120k/yr **Total**: $270k/yr Clayva Pro at $X/mo = $Y/yr **Savings**: $250k+/yr while getting faster results *Contact sales for current pricing details.*

Yes. We want you to experience the vibe loop before committing. ## Trial Details - **Duration**: 14 days - **Full access**: All Pro features - **No credit card**: Start immediately - **Real data**: Connect your app, see real insights ## What Happens After Trial - **Love it**: Pick a plan, keep your data and setup - **Need more time**: Just ask, we're flexible - **Not for you**: No hard feelings, data deleted ## Why We Do Free Trials The best way to understand Clayva is to use it. No demo can show you the feeling of: 1. Asking "Why did conversions drop?" 2. Getting an answer in 10 seconds 3. Creating an experiment with one click 4. Seeing results the next day Try it. You'll get it.

Events are the core billing unit. Here's exactly how we count them. ## What Counts as an Event Every `clayva.track()` call = 1 event ```javascript // This is 1 event clayva.track('button_clicked', { button: 'signup' }); // This is 1 event clayva.track('purchase_completed', { amount: 99.99 }); // This is 1 event (even with lots of properties) clayva.track('page_viewed', { page: '/pricing', referrer: 'google', device: 'mobile', country: 'US', // ...more properties don't add events }); ``` ## What Doesn't Count - **AI queries**: Ask unlimited questions - **Canvas usage**: Create unlimited elements - **Experiment calculations**: Statistical analysis is free - **Team members**: Inviting users doesn't add events ## Event Estimation | App Size | Monthly Events | |----------|---------------| | Side project | 10K - 50K | | Growing startup | 100K - 500K | | Established product | 500K - 5M | | High-traffic app | 5M+ | ## Going Over Limits - We don't cut you off mid-month - You get a notification at 80% - Overages billed at reasonable rates - Or upgrade plan anytime

Your data is yours. We take security seriously. ## Data Storage - **Location**: AWS US regions (configurable for enterprise) - **Encryption**: AES-256 at rest, TLS 1.3 in transit - **Backup**: Daily automated backups, 30-day retention - **Isolation**: Each customer's data is logically separated ## Data Access **Who can access your data:** - Your team members (based on permissions you set) - Claude AI (for analysis, no training on your data) - Our engineering team (only for support, with your permission) **Who cannot access your data:** - Other Clayva customers - Third parties - Advertising networks ## AI and Your Data Claude processes your data to answer questions, but: - Your data is **not used to train AI models** - Queries are processed and forgotten - No data leaves the Clayva infrastructure ## Data Deletion - Delete any data anytime from dashboard - Account deletion removes all data within 30 days - GDPR/CCPA compliant deletion processes ## Questions? Email security@clayva.com for detailed security documentation.

We're building Clayva with compliance in mind from day one. ## Current Status ### GDPR (EU Data Protection) - **Status**: Compliant - **Features**: Data deletion requests, export, consent tracking - **DPA**: Available for customers ### SOC 2 Type II - **Status**: In progress - **Expected**: Q2 2025 - **Scope**: Security, Availability, Confidentiality ### HIPAA - **Status**: Planned for enterprise tier - **Expected**: Q3 2025 - **Scope**: BAA available for healthcare customers ## What This Means for You **Most startups**: GDPR compliance is enough. You're covered. **Enterprise/Regulated**: Talk to us about your specific requirements. We can often accommodate with custom deployments. ## Self-Hosted Option For maximum control: - Deploy Clayva in your own infrastructure - Your data never leaves your environment - All compliance handled by you - Available on Enterprise plan ## Compliance Documents Enterprise customers can request: - Security whitepaper - Penetration test results - Architecture diagrams - Vendor questionnaire completion Contact enterprise@clayva.com

Yes, with appropriate handling. ## PII Handling Options ### Option 1: Don't Send PII Best practice for most use cases: ```javascript // Instead of this clayva.track('signup', { email: 'user@example.com' }); // Do this clayva.track('signup', { user_id: 'usr_abc123' }); ``` Keep PII in your database, send anonymized IDs to Clayva. ### Option 2: Send PII with Encryption For when you need the data: ```javascript clayva.configure({ encryptPII: true }); clayva.track('signup', { email: 'user@example.com', // Encrypted at rest user_id: 'usr_abc123' }); ``` ### Option 3: PII-Free Mode Strict mode that rejects any suspected PII: ```javascript clayva.configure({ piiMode: 'reject' }); // Will reject events containing emails, names, etc. ``` ## What We Consider PII - Email addresses - Full names - Phone numbers - Physical addresses - IP addresses (hashed by default) - Payment information (never send this) ## Recommendations 1. **Use IDs, not emails** for user identification 2. **Enable PII encryption** if you must send it 3. **Review your events** regularly for accidental PII 4. **Set up alerts** for PII detection (coming soon)

Integration takes 5 minutes. One line to install, one line to configure. ## Installation ### JavaScript/TypeScript ```bash npm install @clayva/sdk ``` ```javascript import { Clayva } from '@clayva/sdk'; Clayva.init({ apiKey: 'your-api-key', appId: 'your-app-id' }); ``` ### React ```javascript import { ClayvaProvider } from '@clayva/react'; function App() { return ( ); } ``` ### iOS (Swift) ```swift import Clayva Clayva.configure( apiKey: "your-api-key", appId: "your-app-id" ) ``` ### Android (Kotlin) ```kotlin import com.clayva.sdk.Clayva Clayva.configure( context = applicationContext, apiKey = "your-api-key", appId = "your-app-id" ) ``` ## Tracking Events ```javascript // Track any event Clayva.track('button_clicked', { button_name: 'signup', page: '/home' }); // Identify users Clayva.identify('user_123', { plan: 'pro', signup_date: '2025-01-15' }); ``` ## That's It Events start flowing immediately. No schema to define, no pipelines to set up.

Clayva automatically tracks common events so you can focus on custom ones. ## Auto-Tracked Events (Web) With `autoTrack: true` (default): | Event | When | Properties | |-------|------|------------| | `page_viewed` | Every page load | url, referrer, title | | `session_started` | New session detected | device, browser, os | | `click` | Any click | element, text, href | | `form_submitted` | Form submission | form_id, fields | | `scroll_depth` | 25/50/75/100% scroll | depth, page | | `time_on_page` | Every 30s | duration, page | ## Disable Auto-Track If you want full control: ```javascript Clayva.init({ apiKey: 'your-key', autoTrack: false // Manual tracking only }); ``` ## Custom Event Recommendations Auto-tracking gives you the basics. Add custom events for: ```javascript // User actions Clayva.track('signup_completed', { method: 'google' }); Clayva.track('feature_used', { feature: 'export' }); Clayva.track('upgrade_started', { from_plan: 'free' }); // Product metrics Clayva.track('search_performed', { query: 'pricing' }); Clayva.track('item_added_to_cart', { item_id: 'abc', price: 29.99 }); Clayva.track('checkout_completed', { total: 149.99 }); ``` ## Schema Auto-Discovery You don't need to define schemas. Clayva automatically: - Detects new event types - Discovers properties - Infers data types - Suggests related metrics

Yes. We support multiple import methods for historical data. ## Import Options ### 1. Bulk Import API For large historical datasets: ```javascript const events = [ { event: 'signup', timestamp: '2024-01-15T10:30:00Z', properties: {...} }, { event: 'purchase', timestamp: '2024-01-15T11:45:00Z', properties: {...} }, // ... up to 10,000 events per batch ]; await Clayva.importBatch(events); ``` ### 2. CSV Upload For non-technical users: 1. Go to Settings → Import 2. Upload CSV file 3. Map columns to event properties 4. Click Import ### 3. Warehouse Sync Connect directly to your existing warehouse: - Snowflake - BigQuery - Redshift - PostgreSQL We sync on schedule and keep data fresh. ## Data Format Events need at minimum: - `event` - Event name (string) - `timestamp` - When it happened (ISO 8601) Everything else is optional properties. ## Import Limits | Plan | Monthly Import Limit | |------|---------------------| | Starter | 1M events | | Pro | 10M events | | Scale | 100M events | | Enterprise | Unlimited | ## Migration Support Moving from Mixpanel, Amplitude, or Segment? We can help: - Format conversion - Property mapping - Historical backfill - Parallel running Contact support@clayva.com for migration assistance.

Clayva works with any platform that can make HTTP requests. ## Official SDKs ### Web - JavaScript/TypeScript (vanilla) - React - Vue - Next.js - Nuxt - Svelte - Angular ### Mobile - iOS (Swift) - Android (Kotlin/Java) - React Native - Flutter - Expo ### Backend - Node.js - Python - Ruby - Go - Elixir - PHP ## Framework-Specific Features ### Next.js ```javascript // Automatic page tracking with App Router import { ClayvaProvider } from '@clayva/nextjs'; export default function RootLayout({ children }) { return {children}; } ``` ### React Native ```javascript // Automatic screen tracking import { ClayvaNavigationTracker } from '@clayva/react-native'; {/* Your screens */} ``` ## No SDK? No Problem Direct HTTP API works everywhere: ```bash curl -X POST https://api.clayva.com/v1/track \ -H "Authorization: Bearer YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{"event": "signup", "properties": {"plan": "pro"}}' ``` ## Coming Soon - Shopify App - WordPress Plugin - Webflow Integration - Framer Integration

Clayva connects to GitHub to tie your code changes to your data. ## What GitHub Integration Does ### 1. Deployment Tracking Automatically marks when deployments happen in your metrics: ``` [Metrics graph showing conversion rate] ↓ "Deploy v2.3.1" ↓ [Conversion jumps 12%] ``` ### 2. Code-to-Impact Correlation Ask: "What caused the signup drop on Tuesday?" Clayva: "Deploy abc123 went out Tuesday 2pm. The drop started 2:15pm. Here's the changed code..." ### 3. CI/CD Integration Run Clayva checks in your pipeline: - Verify events are still firing - Check for regressions - Validate experiment setup ## Setup 1. Go to Settings → Integrations → GitHub 2. Click "Connect GitHub" 3. Select repositories to connect 4. Done - deployments auto-detected ## Supported Actions - **Push to main/master**: Marked as deployment - **Release tags**: Major version markers - **PR merge**: Change attribution - **Workflow runs**: CI status tracking ## Permissions Required - **Read access**: Repositories, deployments, actions - **No write access**: Clayva never changes your code ## Privacy We only access: - Commit SHAs - Deployment timestamps - Branch names - Release tags We don't store your source code.