Skip to content

🐸 Rybbit - open-source and privacy-friendly alternative to Google Analytics that is 10x more intuitive.

Adding more articles, and fixing all internal links that were failing

Joey Meng82f56257653e
diff --git a/docs/content/blog/5k-stars.mdx b/docs/content/blog/5k-stars.mdx
index 3232e14dc..4d0b81bdb 100644
--- a/docs/content/blog/5k-stars.mdx
+++ b/docs/content/blog/5k-stars.mdx
@@ -3,7 +3,7 @@ title: Getting 5,000 Stars in 9 days
date: 2025-05-26
description: How Rybbit got 5,000 Github stars in 9 days with zero marketing effort
tags: ['growth']
-author: Bill Yang
+author: Rybbit Team
---
# How my open source SaaS got 5,000 Github stars in 9 days with zero marketing effort
diff --git a/docs/content/blog/_meta.js b/docs/content/blog/_meta.js
index 5474bc738..a0699642e 100644
--- a/docs/content/blog/_meta.js
+++ b/docs/content/blog/_meta.js
@@ -3,6 +3,8 @@ export default {
"How my open source SaaS got 5,000 Github stars in 9 days with zero marketing effort",
"website-traffic-drop":
"Why did my website traffic drop?",
+ "churn-rate-vs-retention-rate":
+ "Churn Rate vs Retention Rate – What's the Difference and Why It Matters",
"ecommerce-analytics":
"Rybbit Analytics for E-commerce Websites",
"onyx-ai-knowledge-platform":
diff --git a/docs/content/blog/bounce-rate.mdx b/docs/content/blog/bounce-rate.mdx
index 92cba785e..79300b168 100644
--- a/docs/content/blog/bounce-rate.mdx
+++ b/docs/content/blog/bounce-rate.mdx
@@ -3,7 +3,7 @@ title: How to Calculate Bounce Rate with Rybbit Analytics
description: How to Calculate Bounce Rate with Rybbit Analytics
date: 2025-11-21
tags: ['analytics', 'metrics']
-author: Bill Yang
+author: Rybbit Team
---
# How to Calculate Bounce Rate with Rybbit Analytics
@@ -48,6 +48,8 @@ Bounce Rate = (Single-Page Sessions ÷ Total Sessions) × 100
**Real example:** You had 1,000 sessions yesterday. 350 were single-page visits. Your bounce rate: 35%.
+For more on session behavior and user engagement patterns, see our [Sessions Tab Guide](/docs/behavior-analytics/sessions) and [Churn Rate vs Retention Rate article](/blog/churn-rate-vs-retention-rate).
+
## Segmenting Your Data
Rybbit's filtering capabilities let you dig into the "why" behind your bounce rate numbers.
diff --git a/docs/content/blog/churn-rate-vs-retention-rate.mdx b/docs/content/blog/churn-rate-vs-retention-rate.mdx
new file mode 100644
index 000000000..d02425737
--- /dev/null
+++ b/docs/content/blog/churn-rate-vs-retention-rate.mdx
@@ -0,0 +1,533 @@
+---
+title: Churn Rate vs Retention Rate - What's the Difference and Why It Matters
+description: Understanding the difference between churn rate and retention rate, how to calculate both, and why tracking both metrics matters for your business growth
+date: 2025-11-22
+tags: ['analytics', 'metrics', 'product', 'retention']
+author: Rybbit Team
+---
+
+# Churn Rate vs Retention Rate: What's the Difference and Why It Matters
+
+You're sitting in a product review meeting. Someone throws out a number: "Our churn rate is 5% this month."
+
+Everyone nods. But is that good? Bad? Should you panic or celebrate?
+
+Here's the thing - churn rate and retention rate are two sides of the same coin. Most people treat them interchangeably. But they're not quite the same, and understanding the difference changes how you interpret your data.
+
+In this article, we'll break down what each metric means, how to calculate them, and more importantly - why you should be tracking both.
+
+## What is Churn Rate?
+
+Churn rate measures the percentage of customers you've lost during a specific period.
+
+If you started the month with 100 customers and 5 left, your monthly churn rate is 5%.
+
+Mathematically:
+
+```
+Churn Rate = (Customers Lost During Period / Customers at Start of Period) x 100
+```
+
+**Why does it matter?** Churn is the enemy of growth. A high churn rate means you're burning through customers faster than you can acquire them. You can acquire customers all day, but if they're leaving out the back door, you're stuck on a treadmill.
+
+For SaaS companies, churn hits different. A 5% monthly churn rate compounds - it means roughly 46% of your customer base leaves in a year. That's brutal.
+
+### Example: A SaaS with a Churn Problem
+
+Let's say you're running an analytics startup (hypothetically):
+- Month 1: 100 customers
+- Monthly churn: 5%
+- Month 2: 95 customers
+- Month 3: 90 customers
+- Month 4: 85 customers
+- By month 12: You've dropped to 54 customers
+
+Even if you acquire 50 new customers each month, you're just replacing what you lost. No net growth.
+
+## What is Retention Rate?
+
+Retention rate is the inverse. It measures the percentage of customers you *kept* during a period.
+
+If you had 100 customers at the start of the month and 95 remained, your retention rate is 95%.
+
+Mathematically:
+
+```
+Retention Rate = (Customers at End of Period / Customers at Start of Period) x 100
+```
+
+Or more directly:
+
+```
+Retention Rate = 100 - Churn Rate
+```
+
+**Why does it matter?** Retention is a leading indicator of product-market fit. Happy customers stick around. If your retention rate is climbing, it means customers are finding value. If it's dropping, something's broken - either your product, your onboarding, or your pricing.
+
+### Example: The Same Company, Different Perspective
+
+Using the same numbers:
+- Month 1 retention: 95%
+- Month 2 retention: 95%
+- Month 3 retention: 95%
+
+Looks fine, right? But 95% monthly retention compounds just as aggressively as 5% churn. They're mathematically identical, but retention *feels* more positive. And that matters for how you think about your business.
+
+## The Key Difference: Perspective
+
+Here's where it gets interesting. Churn and retention measure the exact same thing from opposite angles.
+
+**Churn focuses on loss.** It's the failure metric. When your CEO asks about churn, they're really asking: "How badly are we bleeding customers?"
+
+**Retention focuses on success.** It's the victory metric. When your product team optimizes retention, they're asking: "How do we keep customers coming back?"
+
+Same data, different stories you can tell yourself.
+
+### Why Both Matter
+
+**Churn is about sustainability.** If your churn is too high, your business dies. Period. You need to understand and minimize it.
+
+**Retention is about growth.** If your retention is too low, growth becomes unreasonably expensive. You end up spending all your time (and money) replacing customers instead of scaling.
+
+They're two ways of saying the same thing, but they lead to different conversations:
+- "Our churn is 10% monthly" = sounds like a problem
+- "Our retention is 90% monthly" = sounds... slightly less alarming?
+
+Both are true. Both are 90% annual churn. But retention sounds better, which is why it's popular in pitch decks.
+
+## How to Actually Measure Both
+
+### Simple Churn/Retention
+
+The most straightforward approach:
+
+```
+Churn = (Customers Lost This Month / Customers at Start of Month) x 100
+Retention = 100 - Churn
+```
+
+This works for month-to-month comparisons and is easy to explain to stakeholders.
+
+### Cohort-Based Retention
+
+This is more sophisticated and more useful for product teams.
+
+Cohort-based retention tracks customers by when they joined, then measures what percentage stick around after 1 day, 7 days, 30 days, 90 days, etc.
+
+Why? Because new customers have different behavior than existing customers. Your 3-month retention on customers acquired in January looks different from customers acquired in June.
+
+Example cohort retention table:
+
+| Cohort | Day 1 | Day 7 | Day 30 | Day 90 |
+|----------|-------|-------|--------|--------|
+| January | 95% | 85% | 75% | 60% |
+| February | 92% | 82% | 72% | 58% |
+| March | 94% | 84% | 74% | 62% |
+| April | 93% | 83% | 73% | 61% |
+
+This tells you way more than "our retention is 75%". You can see:
+- Day 1 retention is stable (approximately 93-95%) - good onboarding
+- Day 30 retention is stable (approximately 72-75%) - decent product-market fit
+- Day 90 retention is slowly improving - your improvements are working
+
+### Rolling Window Retention
+
+Another approach for subscription businesses:
+
+Track the percentage of customers from 30 days ago who are still active today. This gives you a real-time signal of retention health without waiting for month-end.
+
+If you had 100 customers 30 days ago and 90 are still paying, you're at 90% rolling 30-day retention.
+
+## What is a Good Churn or Retention Rate?
+
+This varies wildly by industry and business model.
+
+### B2B SaaS
+
+- Acceptable monthly churn: 3-5%
+- Good monthly churn: 1-3%
+- Great monthly churn: less than 1%
+
+Annual churn is where it gets scary. 5% monthly churn = approximately 46% annual churn. 3% monthly = approximately 30% annual. 1% monthly = approximately 11% annual.
+
+Most healthy B2B SaaS companies target monthly churn under 2%.
+
+### B2C / Free-to-Paid
+
+- Acceptable monthly churn: 5-10%
+- Good monthly churn: 2-5%
+- Great monthly churn: less than 2%
+
+Why higher? Consumer product churn is inherently higher. People are more willing to try, and more willing to cancel. That's normal.
+
+### Freemium Models
+
+- Acceptable conversion + churn: Varies wildly
+- But: If you're losing users faster than you're acquiring them, you have a problem
+
+The point: Your benchmark depends on your model. But don't get comfortable with high churn just because "that's how this business works". Stripe didn't get to their payment dominance by accepting industry-standard churn rates.
+
+## Why Both Metrics Matter for Different Teams
+
+### Product Teams
+
+Care about **retention**. It's the signal that users find value. Churn feels like failure. Retention sounds like success.
+
+But here's the trap: You can have 90% retention and still have a dying business if your churn offsets your acquisition. You need to understand both numbers together.
+
+### Finance Teams
+
+Care about **churn**. It's the denominator in your CAC payback period, your LTV calculations, your growth projections. Everything financial depends on churn.
+
+A finance person saying "our monthly churn improved from 5% to 4%" is saying "we just made our business 25% more valuable".
+
+### Executive Leadership
+
+Should care about **both**, but often only focus on churn. It's the number that determines whether you're viable long-term.
+
+But they also need to understand retention trends, because retention signals product-market fit, which is what investors and boards really care about.
+
+## How to Track Both in Rybbit
+
+Rybbit makes tracking churn and retention straightforward because it gives you both user-level data and event tracking. Here's how to use it effectively:
+
+### Setting Up Churn Tracking
+
+1. **Define your churn event**: First, create a custom event that fires when a customer churns. This might be:
+ - Subscription cancellation
+ - Account deletion
+ - Failed payment after retry
+ - Days without login (for free products)
+
+Use Rybbit's event tracking to capture this:
+
+```javascript
+// When a customer cancels their subscription
+rybbit.event("Churn", {
+ reason: "subscription_cancelled",
+ customer_lifetime_days: 180,
+ mrr_lost: 99,
+ plan_type: "professional"
+});
+
+// Or when they haven't been active in 30 days
+rybbit.event("Churn", {
+ reason: "inactivity",
+ days_inactive: 30,
+ customer_lifetime_days: 45
+});
+```
+
+2. **Track cohorts of customers**: Use Rybbit's cohort analysis to group customers by signup month, then measure what percentage churned each month.
+
+3. **Calculate churn from your dashboard**: In Rybbit, navigate to the Events tab and filter by your "Churn" event. Divide the count of churned users by your starting user count for that month to get your monthly churn rate.
+
+### Measuring Retention with Rybbit
+
+The more powerful use case is building retention curves:
+
+1. **Create user cohorts by signup date**: In Rybbit, go to the Users tab and filter by "First Visit Date" to create cohorts of users who signed up in specific time periods (January, February, March, etc.).
+
+2. **Track engagement events**: For each cohort, monitor which events they trigger over time. Create custom events that signal retention:
+ - Product signup or first login
+ - First feature usage
+ - Scheduled action (e.g., "report_generated")
+ - Subscription renewal
+ - Support interaction
+
+Example:
+
+```javascript
+// User takes a meaningful action
+rybbit.event("Feature_Usage", {
+ feature_name: "advanced_reporting",
+ user_signup_cohort: "2025-10"
+});
+
+// Track weekly active users
+rybbit.event("Weekly_Active", {
+ days_since_signup: 7,
+ signup_month: "2025-10"
+});
+
+// Track 30-day and 90-day retention markers
+rybbit.event("Milestone_Reached", {
+ milestone_type: "30_day_user",
+ signup_month: "2025-10"
+});
+
+rybbit.event("Milestone_Reached", {
+ milestone_type: "90_day_user",
+ signup_month: "2025-10"
+});
+```
+
+3. **Analyze retention trends**: Use Rybbit's Users tab to see:
+ - How many users from each cohort are still active this week/month
+ - Which cohorts have better retention than others
+ - Whether new changes improved retention
+
+4. **Compare cohorts**: Look at your retention curves month-over-month:
+ - If your January cohort shows 70% retention at day 30, and your February cohort shows 75%, you're improving
+ - If retention is dropping across cohorts, you have a problem that needs investigation
+
+### Rybbit Dashboard Usage
+
+Here's how to use Rybbit's specific features:
+
+**Users Tab:**
+- Filter by first visit date to see cohorts
+- Monitor "Total Sessions" and "Pages Viewed" to see if cohort engagement is changing
+- Compare metrics between cohorts to spot retention improvements
+
+**Events Tab:**
+- Filter by your custom retention/churn events
+- See conversion rates for each milestone event
+- Track how many users from each cohort hit each milestone
+
+**Sessions Tab:**
+- Analyze session duration trends for different cohorts
+- See if users are getting more engaged (longer sessions) or less (shorter sessions)
+- Identify behavior changes that correlate with churn
+
+**Filtering & Segmentation:**
+- Use custom date ranges to compare cohorts
+- Filter by properties like plan type, signup method, or geography to see which segments have better retention
+- Create segments like "high-value customers" and track their retention separately
+
+### Real Example: A SaaS Tracking Retention
+
+Let's say you're running a project management tool:
+
+**Week 1 After Signup:**
+```javascript
+// Day 1: User signs up
+rybbit.event("Account_Created", {
+ plan_type: "free",
+ signup_source: "organic"
+});
+
+// Day 3: User creates first project
+rybbit.event("Feature_Used", {
+ feature: "create_project",
+ days_active: 3
+});
+
+// Day 7: Still using the app
+rybbit.event("Retention_Day7", {
+ active: true,
+ sessions: 4,
+ projects_created: 2
+});
+```
+
+**Month 1:**
+```javascript
+// Day 30: User still active
+rybbit.event("Retention_Day30", {
+ active: true,
+ sessions: 12,
+ projects_created: 4,
+ plan_upgraded: false // Still on free plan = churn risk
+});
+```
+
+**Month 3:**
+```javascript
+// If they upgraded, they're retained
+rybbit.event("Plan_Upgraded", {
+ from_plan: "free",
+ to_plan: "professional",
+ days_to_upgrade: 45
+});
+
+// If they're inactive
+rybbit.event("Churn", {
+ reason: "inactivity",
+ days_active: 31
+});
+```
+
+In your Rybbit dashboard, you can now:
+- See what percentage of users hit Day 7 retention milestone
+- See what percentage made it to Day 30
+- See upgrade rates (converted churners to retained customers)
+- Compare these rates across cohorts to measure improvement
+
+### Key Rybbit Features for Churn/Retention
+
+**Cohort Analysis**: Group users by signup date and track their metrics over time. This is essential for retention curves.
+
+**Custom Events**: Define exactly what "retention" means for your business and track it specifically.
+
+**Filtering**: Segment by plan type, signup source, geography, etc. to find which users are at higher churn risk.
+
+**Date Range Comparison**: Compare this month's cohorts to last month's to see if you're improving retention.
+
+**Users Tab Metrics**: Track total sessions, pages viewed, and activity frequency for each cohort.
+
+The key insight: Retention isn't a single number. It's a curve that changes over time. By tracking your cohorts in Rybbit and monitoring their engagement events, you can see exactly when and why users churn - and whether your retention improvements are working.
+
+## How to Reduce Churn and Increase Retention
+
+Knowing your churn rate is only half the battle. The real value comes from improving it. Here are practical strategies that actually work:
+
+### 1. Optimize Your Onboarding
+
+Most churn happens in the first 30 days. A user who successfully completes onboarding is 5-10x more likely to stick around.
+
+**What to do:**
+- Create a clear path to first value. Don't overwhelm new users with features. Guide them to the one action that makes your product meaningful.
+- Track onboarding milestones in Rybbit: "Completed profile setup", "Imported first data", "Created first project"
+- Measure time-to-value. How long until a new user takes their first meaningful action? Shorter is better.
+- A/B test your onboarding. Try different flows and measure which cohort has better day 7 and day 30 retention.
+
+**Real example:** Slack measures "first message sent" as a milestone. Users who send their first message are dramatically more likely to remain active. They don't measure users who just signed up - they measure users who experienced value.
+
+### 2. Identify and Segment At-Risk Users
+
+Not all customers are equal. Some are high-value and worth saving. Others are low-engagement and might not be a good fit.
+
+**What to do:**
+- Use Rybbit to identify users with declining engagement: fewer logins, fewer features used, shorter sessions
+- Create segments like "power users", "casual users", and "at-risk users"
+- Set up alerts for behavioral changes. If a previously active user goes silent for a week, that's a warning sign.
+- Target at-risk segments with intervention: email outreach, feature guidance, support check-in
+
+**Real example:** If you notice that users in a specific industry vertical churn at 2x the rate of others, that's a signal. Either your product doesn't fit that vertical, or they need different onboarding/support.
+
+### 3. Gather Qualitative Feedback
+
+Data shows you *that* users are churning. Talking to them shows you *why*.
+
+**What to do:**
+- When a user cancels, ask why. Offer a discount or feature request capture. Most importantly, listen.
+- For highly engaged users, ask what's working. Double down on that.
+- Run surveys or interviews with long-term users to understand what retention is built on
+- Share churn feedback with your product team. "We're losing customers because feature X is broken" is more actionable than "monthly churn is 5%"
+
+**Real example:** You might discover that users churn because they don't know about a feature that would solve their problem. That's a messaging problem, not a product problem. Cheap to fix.
+
+### 4. Focus on Core Value, Not Vanity Features
+
+Building more features doesn't improve retention. Building the right features does.
+
+**What to do:**
+- Use Rybbit to track which features are actually used by retained users
+- Compare feature usage between users who churned vs. users who stayed. What's the difference?
+- Ruthlessly deprioritize features that don't correlate with retention
+- Invest heavily in the features that retained users depend on
+
+**Real example:** A project management tool might have 50 features. But 80% of retained users only use 5 of them. Focus on those 5. Make them bulletproof.
+
+### 5. Improve Customer Support Response Time
+
+Users who get help quickly stick around. Users who wait days for support tend to leave.
+
+**What to do:**
+- Track support response time as a metric that correlates with retention
+- Measure: Do users who got support within 1 hour have better retention than users who waited 24 hours?
+- If response time is slow, that's a retention leak. Fix it.
+- Proactive support > reactive. Help users before they ask.
+
+**Real example:** Intercom found that users who get a helpful message within 24 hours of a problematic event have 40% higher lifetime value. Not because of what the message says, but because someone cared enough to reach out.
+
+### 6. Price Correctly
+
+Wrong pricing is an invisible churn driver. Too expensive, and you lose customers. Too cheap, and you attract wrong-fit customers who churn.
+
+**What to do:**
+- Analyze churn by pricing tier. Does one tier have dramatically higher churn?
+- If low-tier customers churn fast, they might be wrong-fit. Either improve product fit for them or increase prices to attract higher-commitment customers.
+- Offer annual plans. Customers who commit annually are more engaged (they've already paid).
+- Make upgrade paths clear. Customers should know how to get more value as their needs grow.
+
+**Real example:** A SaaS with $10/month and $100/month plans might see 30% monthly churn on $10 plans and 2% on $100 plans. The low price attracts tire-kickers. Raising the floor price or making the entry-level tier more limited can improve retention.
+
+### 7. Create Network Effects or Switching Costs
+
+The harder it is to leave, the less they churn.
+
+**What to do:**
+- Export is expensive. If a user has invested 6 months of data in your system, switching costs are high.
+- Integrations matter. If your tool integrates with the other tools they use, it becomes essential infrastructure.
+- Community. Users with friends/teammates using your product stick around longer.
+- Track engagement with your ecosystem, not just your product.
+
+**Real example:** Figma's network effect is powerful. A designer might use it alone, but once the whole team is on Figma, leaving is impossible. Your product doesn't have to do everything - it just has to be essential to the user's workflow.
+
+### 8. Monetize Engagement, Not Users
+
+Bad: Charge per user, then lock users into plans they don't use. They resent being charged and they churn.
+
+Better: Charge based on usage or value delivered. Users see ROI. They stay.
+
+**What to do:**
+- Structure pricing around value metrics (projects, reports, API calls) not seats
+- Track which pricing model correlates with retention for your business
+- Give users ways to control their costs. If they see their bill shrinking, great. If it's growing for unclear reasons, they'll leave.
+
+**Real example:** Stripe charges based on volume processed. More usage = more revenue, but users see that Stripe is making money *because* the customer is successful. That's aligned incentives.
+
+### 9. Build a Feedback Loop
+
+Retention improvements compound. Each fix should feed into the next.
+
+**What to do:**
+- Set a baseline churn metric and commit to improving it by 1% per quarter
+- After each change, measure impact with Rybbit. Did cohort retention improve?
+- Share results with the team. "We improved onboarding and day 7 retention went from 65% to 72%"
+- Make retention a company metric, not just a product metric. Marketing, sales, support all influence retention.
+
+**Real example:** A company that commits to "reduce churn from 5% to 3% annually" will make different product decisions than a company that ignores churn. The target creates accountability.
+
+### The Retention Funnel
+
+Think of retention like a funnel:
+
+1. **Day 1**: Did they experience value? (Onboarding)
+2. **Day 7**: Did they come back? (Habit formation)
+3. **Day 30**: Are they using core features? (Product fit)
+4. **Day 90**: Are they engaged enough to upgrade/advocate? (Expansion)
+
+Each stage has different failure points.
+
+- If you have 50% day 1 retention, fix onboarding
+- If you have 90% day 1 but 40% day 30, your product doesn't deliver value
+- If you have 80% day 30 but 60% day 90, you're losing long-term engagement
+
+Use Rybbit to measure each stage and fix the biggest leak first.
+
+## The Bottom Line
+
+Churn rate and retention rate are two ways of measuring the same thing. Neither is "more important" - but they serve different purposes:
+
+- Use churn when you want to focus on the problem (we're losing customers)
+- Use retention when you want to focus on the solution (we're keeping customers)
+- Track both to understand your business health
+
+In practice:
+
+1. Monitor your monthly churn to ensure sustainability
+2. Build cohort retention curves to understand product-market fit
+3. Use both to set company OKRs (e.g., "reduce monthly churn from 5% to 3%")
+4. Analyze retention by segment - your high-value customers might have different retention than low-value ones
+5. Correlate retention changes with product changes - did that new feature move the needle?
+6. Implement improvements systematically: onboarding first, then feature focus, then support
+7. Measure everything. If you're not tracking retention by segment and by cohort, you're flying blind
+
+Remember: A business doesn't scale by acquisition alone. It scales by finding the right customers, delivering value, and keeping them. That's retention.
+
+Everything else is just trying to fix the leak in your bucket while you're pouring water in the top.
+
+---
+
+**Related Reading:**
+- [Behavior Analytics - Sessions Tab](/docs/behavior-analytics/sessions)
+- [Behavior Analytics - Users Tab](/docs/behavior-analytics/users)
+- [Behavior Analytics - Events Tab](/docs/behavior-analytics/events)
+- [Behavior Analytics - Errors Tab](/docs/behavior-analytics/errors)
+- [Product Analytics - Retention Guide](/docs/product-analytics/retention_guide)
+- [Track Custom Events](/docs/track-events)
+- [Blog: Bounce Rate Guide](/blog/bounce-rate)
+- [Blog: Website Traffic Drop Analysis](/blog/website-traffic-drop)
diff --git a/docs/content/blog/ecommerce-analytics.mdx b/docs/content/blog/ecommerce-analytics.mdx
index 7d3a4d0cd..1ad17d293 100644
--- a/docs/content/blog/ecommerce-analytics.mdx
+++ b/docs/content/blog/ecommerce-analytics.mdx
@@ -3,7 +3,7 @@ title: Rybbit Analytics for E-commerce Websites
date: 2025-11-22
description: A comprehensive guide to using Rybbit Analytics for your e-commerce website to track sales, conversions, and customer behavior
tags: ["analytics", "ecommerce", "conversion"]
-author: Bill Yang
+author: Rybbit Team
---
If you run an e-commerce website, understanding your customer behavior and sales funnel is crucial for growth. Whether you're running a small online store or a large marketplace, having the right analytics in place can mean the difference between scaling successfully and struggling to understand why your sales are declining.
@@ -355,4 +355,16 @@ Whether you're just starting out with a small online store or scaling a multi-mi
The combination of Rybbit's clean interface, powerful filtering capabilities, performance monitoring, and privacy-first approach makes it the ideal analytics solution for modern e-commerce businesses. And with both hosted and self-hosted options, you can choose the setup that best fits your needs.
-Ready to get better insights into your e-commerce business? Give Rybbit a try and see how much clearer your data becomes when you focus on what actually matters.
\ No newline at end of file
+Ready to get better insights into your e-commerce business? Give Rybbit a try and see how much clearer your data becomes when you focus on what actually matters.
+
+---
+
+**Related Reading:**
+- [Bounce Rate Guide](/blog/bounce-rate)
+- [Churn Rate vs Retention Rate](/blog/churn-rate-vs-retention-rate)
+- [Website Traffic Drop Analysis](/blog/website-traffic-drop)
+- [Behavior Analytics - Sessions](/docs/behavior-analytics/sessions)
+- [Behavior Analytics - Events](/docs/behavior-analytics/events)
+- [Behavior Analytics - Users](/docs/behavior-analytics/users)
+- [Track Custom Events](/docs/track-events)
+- [Getting Started with Rybbit](/docs)
\ No newline at end of file
diff --git a/docs/content/blog/multivariate-testing.mdx b/docs/content/blog/multivariate-testing.mdx
new file mode 100644
index 000000000..fc9cdf296
--- /dev/null
+++ b/docs/content/blog/multivariate-testing.mdx
@@ -0,0 +1,459 @@
+---
+title: What is Multivariate Testing? Examples and How to Run Tests with Rybbit
+date: 2025-11-22
+description: A complete guide to multivariate testing - how it works, when to use it, real-world examples, and how to run multivariate tests with Rybbit Analytics
+tags: ["testing", "experimentation", "optimization", "analytics"]
+author: Rybbit Team
+---
+
+# What is Multivariate Testing? Examples and How to Run Tests with Rybbit
+
+You have a checkout page that isn't converting as well as you'd like. The problem is obvious: something needs to change. But what?
+
+The button color? The copy? The form layout? The trust badge position? All of the above?
+
+If you test each change one at a time (button color this week, copy next week), you're looking at months of experimentation. By then, you've lost potential customers and revenue.
+
+This is where multivariate testing comes in. Instead of testing one variable at a time, you test multiple variables simultaneously. It's faster, cheaper, and gives you deeper insights into what actually drives conversions.
+
+Let's walk through what multivariate testing is, how it works, when to use it, and how to implement it with Rybbit Analytics.
+
+## What is Multivariate Testing?
+
+Multivariate testing (MVT) is an experimentation method where you test multiple variables at the same time to see how they work together and individually.
+
+**Example:** Instead of testing:
+- Just the button color (red vs blue)
+
+You test:
+- Button color (red vs blue) × Button copy ("Buy Now" vs "Add to Cart") × Form fields (3 fields vs 5 fields)
+
+This creates multiple combinations (variations) that users are randomly exposed to. Then you measure which combination performs best.
+
+**Key distinction:** Multivariate testing is different from A/B testing:
+- **A/B Testing**: Test one variable (button color)
+- **Multivariate Testing**: Test multiple variables simultaneously (button color + copy + layout)
+
+Think of multivariate testing as A/B testing on steroids. You're not just comparing two options. You're exploring a matrix of possibilities.
+
+## How Multivariate Testing Works
+
+Let's say you're running a multivariate test on your landing page with three variables:
+
+1. **Headline**: Option A ("Save Time") vs Option B ("Save Money")
+2. **CTA Button**: Option A ("Start Free") vs Option B ("See Demo")
+3. **Image**: Option A (Product screenshot) vs Option B (Customer testimonial)
+
+That creates 2 × 2 × 2 = **8 possible combinations** (variations):
+
+| Variation | Headline | Button | Image |
+|-----------|----------|--------|-------|
+| 1 | Save Time | Start Free | Screenshot |
+| 2 | Save Time | Start Free | Testimonial |
+| 3 | Save Time | See Demo | Screenshot |
+| 4 | Save Time | See Demo | Testimonial |
+| 5 | Save Money | Start Free | Screenshot |
+| 6 | Save Money | Start Free | Testimonial |
+| 7 | Save Money | See Demo | Screenshot |
+| 8 | Save Money | See Demo | Testimonial |
+
+Each visitor randomly sees one of these 8 combinations. You then measure which combination converts the best.
+
+### The Math Behind Multivariate Testing
+
+Multivariate testing uses **factorial design** - a statistical method that efficiently tests multiple variables and their interactions.
+
+Here's the key insight: A multivariate test gives you more data than running separate A/B tests.
+
+**Example:** If you want to test 3 variables with 2 options each:
+- **Separate A/B tests**: 3 tests × 2 weeks each = 6 weeks to get all the data
+- **One multivariate test**: 2 weeks to test all 8 combinations simultaneously
+
+But there's a catch: You need enough traffic to detect winners across all combinations.
+
+**Rule of thumb:** Each variation needs at least 100-200 conversions to be statistically significant. So if you have 8 variations, you need 800-1,600 conversions total.
+
+If your traffic is lower, you might not have enough data to reach statistical significance. That's when A/B testing individual changes becomes smarter.
+
+## Multivariate Testing vs A/B Testing: When to Use Each
+
+**Use A/B Testing when:**
+- You have lower traffic (< 100 conversions/week)
+- You're testing one specific hypothesis (Does red button convert better than blue?)
+- You need results fast and traffic is limited
+- You're optimizing a single element (headline, CTA, etc.)
+
+**Use Multivariate Testing when:**
+- You have higher traffic (> 500 conversions/week)
+- You want to understand how multiple elements interact
+- You have time to gather data (2-4 weeks)
+- You're trying to optimize an entire page experience
+- You want to find unexpected winner combinations
+
+**Real example:** Slack probably uses multivariate testing on their signup page because they have massive traffic and want to optimize multiple elements (headline, CTA, form fields, imagery). A small SaaS with 50 signups/week would be better off with A/B testing one element at a time.
+
+## Real-World Multivariate Testing Examples
+
+### Example 1: E-commerce Product Page
+
+You're running an online bookstore and want to increase purchases.
+
+**Variables:**
+- **Price display**: Show as "$15.99" vs Show as "Only 1 left - $15.99" (scarcity)
+- **Social proof**: Show 1,200 reviews vs Show 4.8★ rating
+- **Shipping info**: "FREE shipping" vs "FREE 2-day shipping"
+
+**Result:** The combination of scarcity + star rating + specific shipping info converts 23% better than the baseline.
+
+**Finding:** Customers care more about shipping specificity than just the word "free."
+
+### Example 2: SaaS Pricing Page
+
+You're testing what makes people upgrade.
+
+**Variables:**
+- **Pricing comparison**: Monthly vs Annual prominent
+- **Social proof**: "Used by 500+ companies" vs "10,000+ users"
+- **CTA color**: Blue vs Green
+
+**Result:** Annual pricing prominent + user count + green button wins, converting 18% higher.
+
+**Finding:** B2C appeals more to user quantity; the specific button color matters (small but consistent winner).
+
+### Example 3: Mobile App Onboarding
+
+You want users to complete onboarding.
+
+**Variables:**
+- **Progress indicator**: Shows steps (Step 1/4) vs No progress indicator
+- **Skip option**: Visible skip button vs Hidden skip option
+- **Visuals**: Animation + icons vs Static images
+
+**Result:** Progress indicator + no visible skip + animations convert 31% better.
+
+**Finding:** Psychological commitment (progress bar) + removing friction (hidden skip) + engagement (animation) work together better than individually.
+
+## The Real Power: Interaction Effects
+
+Here's why multivariate testing is powerful: **variables don't exist in a vacuum**.
+
+In the onboarding example above, the progress indicator might only improve completion by 5% on its own. But combined with animations and a hidden skip button, it jumps to 31%.
+
+This is called an **interaction effect** - when variables work better together than they would individually.
+
+This is nearly impossible to discover with A/B testing alone. You'd test progress indicator vs no progress indicator and see a small 5% lift. You might even conclude it's not worth it. But in combination with other changes, it's powerful.
+
+Multivariate testing reveals these hidden synergies.
+
+## How to Run a Multivariate Test with Rybbit
+
+Rybbit Analytics lets you set up and analyze multivariate tests by tracking variations and comparing performance metrics.
+
+### Step 1: Define Your Variables and Create Variations
+
+First, identify what you want to test. Let's say you're optimizing your signup page:
+
+**Variables:**
+- Headline: "Start Free" vs "See How It Works"
+- Button color: Blue vs Green
+- Form fields: 2 fields vs 4 fields
+
+**Result:** 2 × 2 × 2 = 8 variations to test
+
+### Step 2: Implement Variation Tracking with Rybbit
+
+Add the variation name/ID to your page when a user lands on one. Use Rybbit's event tracking to record which variation each user sees:
+
+```javascript
+// Determine which variation user gets (your testing library handles this)
+const variationName = "headline_start_blue_2fields"; // variation ID
+
+// Track that user saw this variation
+window.rybbit.event("Signup_Variation_Shown", {
+ variation: variationName,
+ headline: "Start Free",
+ button_color: "blue",
+ form_fields: "2"
+});
+```
+
+### Step 3: Track Conversion Events
+
+Track when users complete the desired action (signup, purchase, etc.):
+
+```javascript
+// User signs up
+window.rybbit.event("Signup_Completed", {
+ variation: variationName,
+ signup_source: "multivariate_test",
+ signup_date: new Date().toISOString()
+});
+```
+
+### Step 4: Analyze Results in Rybbit
+
+Use Rybbit's filtering and segmentation to compare conversion rates across variations:
+
+1. Go to **Behavior Analytics → Events**
+2. Filter for your test variations
+3. Create a **Funnel** from "Signup_Variation_Shown" to "Signup_Completed"
+4. Segment by variation to see which combination wins
+
+**What you'll see:**
+- Conversion rate for each variation
+- Which combinations perform best
+- Statistical significance (are differences real or random?)
+- How long it takes to reach statistical significance
+
+### Step 5: Analyze Interaction Effects
+
+To understand which variable combinations matter most, create additional analysis:
+
+```javascript
+// Track the individual variable impact
+window.rybbit.event("Test_Conversion", {
+ variation: "headline_start_blue_2fields",
+ headline_variant: "start_free", // 0 or 1
+ button_variant: "blue", // 0 or 1
+ fields_variant: "2_fields", // 0 or 1
+ converted: true
+});
+```
+
+Then in Rybbit, you can create **custom cohorts** by each variable to see:
+- Conversion rate when headline = "Start Free" (across all button colors and field counts)
+- Conversion rate when button = "Blue" (across all headlines and field counts)
+- Conversion rate when fields = "2" (across all headlines and buttons)
+
+This reveals which individual variables matter most, plus their interactions.
+
+### Step 6: Determine Statistical Significance
+
+This is crucial: **Don't stop the test too early just because one variation is winning.**
+
+Rybbit doesn't automatically calculate statistical significance (you'll need to use an external tool like [this calculator](https://www.optimizely.com/sample-size-calculator/)), but you can estimate:
+
+**Rule of thumb:** Run the test until each variation has at least 100-200 conversions.
+
+If you have 8 variations, that's 800-1,600 total conversions needed. At 500 conversions/week, that's about 2-3 weeks.
+
+### Step 7: Document Learnings
+
+Create a record of what you learned:
+
+```javascript
+// After test ends, track the winner
+window.rybbit.event("Test_Winner_Identified", {
+ test_name: "signup_page_mvt",
+ winning_variation: "headline_money_green_2fields",
+ lift_vs_control: "23%",
+ conversions_tested: 1200,
+ duration_days: 21
+});
+```
+
+## Multivariate Testing Best Practices
+
+### 1. Start Simple
+
+Don't test 5 variables with 3 options each on your first attempt. That's 3^5 = 243 variations. You'll never reach statistical significance.
+
+Start with 2-3 variables, 2 options each. That's 4-8 variations - manageable and testable.
+
+### 2. Test Independent Variables
+
+Make sure your variables don't overlap. Testing both "button color" and "button style" at the same time confuses results.
+
+Good: Button color + Headline + Form length
+Bad: Button color + Button size (these affect each other)
+
+### 3. Have Enough Traffic
+
+This is non-negotiable. Low-traffic sites should do A/B testing, not multivariate testing.
+
+**Traffic check:** (Traffic per variation per week) × (Number of variations) = Do you have enough?
+
+If variation 1 gets 50 visitors/week and you have 8 variations, each gets about 6-7 visitors/week. That's not enough to measure conversions accurately.
+
+### 4. Run Tests Long Enough
+
+Don't stop after 1 week. Run for at least 2 full weeks to account for day-of-week effects (Monday traffic might differ from Friday traffic).
+
+### 5. Test the Right Metrics
+
+Don't just track clicks. Track conversions - the action that matters to your business.
+
+- E-commerce: Track purchases, not just add-to-cart
+- SaaS: Track signups, not just clicks
+- Content: Track time-on-page, not just visits
+
+### 6. Understand Diminishing Returns
+
+Each additional variable you test increases complexity exponentially. 2 variables = 4 combinations. 3 variables = 8 combinations. 4 variables = 16 combinations.
+
+At some point, the added complexity outweighs the benefit. Usually 3-4 variables is the sweet spot.
+
+### 7. Have a Hypothesis
+
+Don't test random combinations. Have a theory about what will work and why.
+
+**Good hypothesis:** "We think shortening the form (2 fields vs 4) combined with a specific CTA ('Start Free' vs 'See Demo') will increase conversions because it reduces friction while being clear on value."
+
+**Bad hypothesis:** "Let's test random stuff and see what sticks."
+
+## Common Multivariate Testing Mistakes
+
+**Mistake 1: Not having enough traffic**
+- You can't trust results with only 10-20 conversions per variation
+- Minimum 100-200 conversions per variation
+
+**Mistake 2: Too many variables**
+- Testing 5 variables = 32 combinations at minimum
+- You need massive traffic to reach statistical significance
+
+**Mistake 3: Stopping too early**
+- "We have a winner after 3 days!" - No, you need 2-3 weeks minimum
+- Variance will make random variation look like a winner early on
+
+**Mistake 4: Not tracking properly**
+- If you don't know which variation each user saw, you can't analyze results
+- Always track variation assignment with every event
+
+**Mistake 5: Testing insignificant changes**
+- Testing button color shade (navy vs dark blue) is a waste of time
+- Test changes that could meaningfully impact behavior
+
+**Mistake 6: Not planning for "no winner"**
+- Sometimes all variations perform similarly
+- That's still valuable data - it means this area isn't a lever for improvement
+
+## When Multivariate Testing Isn't the Right Choice
+
+**Don't use multivariate testing if:**
+
+1. **You have low traffic** - Stick to A/B testing one element at a time
+2. **You need results fast** - Multivariate tests take 2-4 weeks
+3. **Changes are risky** - If one variation could break the experience, test one thing at a time
+4. **Variables are intertwined** - If changing one necessarily changes the other, you can't isolate effects
+5. **You're testing radical redesigns** - This is better suited to A/B testing or user research
+
+**Do use multivariate testing if:**
+
+1. ✅ You have 500+ conversions per week
+2. ✅ You want to optimize multiple elements together
+3. ✅ You're willing to wait 2-3 weeks for results
+4. ✅ You want to discover interaction effects
+5. ✅ You're testing independent variables
+
+## Multivariate Testing with Rybbit: Real Example
+
+Let's walk through a complete example with real numbers.
+
+### Scenario: E-commerce Checkout Page
+
+You run an online store and want to increase purchase completion.
+
+**Current state:** 1,000 visitors/week to checkout, 100 purchases/week (10% conversion rate)
+
+**What you want to test:**
+- Payment options prominence: Show all options vs Highlight most popular
+- Trust badge position: Top of form vs Bottom of form
+- Shipping timeline: "Ships in 1-2 days" vs "Free shipping" (benefit vs timeline)
+
+**That's 2 × 2 × 2 = 8 variations**
+
+### Week 1-3: Run the Test
+
+Using Rybbit event tracking:
+
+```javascript
+const variations = {
+ "v1": { payment: "all", badge: "top", shipping: "timeline" },
+ "v2": { payment: "all", badge: "top", shipping: "benefit" },
+ "v3": { payment: "all", badge: "bottom", shipping: "timeline" },
+ "v4": { payment: "all", badge: "bottom", shipping: "benefit" },
+ "v5": { payment: "highlight", badge: "top", shipping: "timeline" },
+ "v6": { payment: "highlight", badge: "top", shipping: "benefit" },
+ "v7": { payment: "highlight", badge: "bottom", shipping: "timeline" },
+ "v8": { payment: "highlight", badge: "bottom", shipping: "benefit" },
+};
+
+// User lands on checkout
+window.rybbit.event("Checkout_Viewed", {
+ variation: variationKey,
+ ...variations[variationKey]
+});
+
+// User completes purchase
+window.rybbit.event("Purchase_Completed", {
+ variation: variationKey,
+ amount: 49.99
+});
+```
+
+### Week 4: Analyze in Rybbit
+
+Create a funnel in Rybbit from "Checkout_Viewed" to "Purchase_Completed", segmented by variation:
+
+**Results after 3,000 total visitors:**
+
+| Variation | Views | Purchases | Conversion Rate |
+|-----------|-------|-----------|-----------------|
+| v1 (baseline) | 375 | 32 | 8.5% |
+| v2 | 375 | 35 | 9.3% |
+| v3 | 375 | 30 | 8% |
+| v4 | 375 | 38 | 10.1% |
+| v5 | 375 | 36 | 9.6% |
+| v6 | 375 | 42 | 11.2% |
+| v7 | 375 | 33 | 8.8% |
+| v8 | 375 | 40 | 10.7% |
+
+**Winner: Variation 6** (Highlight payment + Badge at top + Show benefit)
+
+**11.2% conversion rate = 31% lift vs baseline (8.5%)**
+
+### What You Learned
+
+1. **Highlighting payment options matters** - Variations with "highlight" outperform "all options"
+2. **Badge at top works better** - Top positioning won 4 of the top 5 variations
+3. **Benefit messaging wins** - "Free shipping" performs better than timeline information
+4. **Interaction effect:** The combination is more powerful than any single change
+
+### Implementation
+
+Roll out variation 6 to all users:
+- Highlight most popular payment options
+- Put trust badge at top of form
+- Emphasize "Free shipping" over timeline
+
+**Expected impact:** +31% conversion = 131 purchases/week instead of 100 = $1,500+ additional revenue per week (assuming $50 average order value)
+
+Over a year: **$78,000+ in additional revenue from one multivariate test.**
+
+This is why companies obsess over testing.
+
+## The Bottom Line
+
+Multivariate testing is powerful because it's efficient. Instead of spending months testing one variable at a time, you test multiple variables simultaneously and discover how they interact.
+
+The key requirements are:
+1. **Enough traffic** - At least 500+ conversions per week
+2. **Clear variables** - Independent factors you want to test
+3. **Time** - 2-4 weeks to gather data
+4. **Proper tracking** - Know which variation each user saw
+5. **Statistical rigor** - Wait for real significance, not random luck
+
+With Rybbit's event tracking and analytics, you can set up and measure multivariate tests without complex testing platforms. You get the data, you make the decisions.
+
+The companies that win are the ones that test relentlessly and act on data. Multivariate testing is how you scale optimization from "one variable at a time" to "multiple hypotheses, simultaneously."
+
+---
+
+**Related Reading:**
+- [Behavior Analytics - Events Tab](/docs/behavior-analytics/events)
+- [Behavior Analytics - Users Tab](/docs/behavior-analytics/users)
+- [Track Custom Events](/docs/track-events)
+- [Product Analytics - Funnels Guide](/docs/product-analytics/funnels_guide)
+- [Product Analytics - Journeys Dashboard](/docs/product-analytics/journeys_dashboard)
+- [Blog: Churn Rate vs Retention Rate](/blog/churn-rate-vs-retention-rate)
+- [Blog: E-commerce Analytics](/blog/ecommerce-analytics)
diff --git a/docs/content/blog/onyx-ai-knowledge-platform.mdx b/docs/content/blog/onyx-ai-knowledge-platform.mdx
index 333a30520..c04047d39 100644
--- a/docs/content/blog/onyx-ai-knowledge-platform.mdx
+++ b/docs/content/blog/onyx-ai-knowledge-platform.mdx
@@ -3,7 +3,7 @@ title: How We Use Onyx to Power Knowledge Management at Rybbit
date: 2025-10-08
description: Discover how Rybbit leverages Onyx, an open-source AI knowledge platform, to streamline development, enhance collaboration, and accelerate our analytics platform.
tags: ['tools', 'ai', 'productivity']
-author: Bill Yang
+author: Rybbit Team
---
# How We Use Onyx to Power Knowledge Management at Rybbit
diff --git a/docs/content/blog/website-traffic-drop.mdx b/docs/content/blog/website-traffic-drop.mdx
index 464f0c21c..b84f0bac2 100644
--- a/docs/content/blog/website-traffic-drop.mdx
+++ b/docs/content/blog/website-traffic-drop.mdx
@@ -3,7 +3,7 @@ title: Why did my website traffic drop?
date: 2025-06-08
description: Find out why your website traffic dropped using Rybbit
tags: ['traffic', 'analytics']
-author: Bill Yang
+author: Rybbit Team
---
If you are reading this article right now you are probably panicking about a recent drop in traffic, while this is a reasonable response, it is possible to reverse engineer why your traffic has dropped and to apply the correct measures to remediate the issue.
@@ -222,4 +222,16 @@ The key is to approach the investigation systematically:
4. **Monitor recovery** \- Track the effectiveness of your fixes
5. **Learn for the future** \- Use the experience to build better monitoring and prevention strategies
-Most importantly, remember that while traffic drops can be concerning, they often provide valuable insights into how to improve your website's performance, content quality, and user experience. With Rybbit's detailed analytics at your disposal, you're well-equipped to not just recover from traffic drops, but to build a stronger, more resilient web presence.
\ No newline at end of file
+Most importantly, remember that while traffic drops can be concerning, they often provide valuable insights into how to improve your website's performance, content quality, and user experience. With Rybbit's detailed analytics at your disposal, you're well-equipped to not just recover from traffic drops, but to build a stronger, more resilient web presence.
+
+---
+
+**Related Reading:**
+- [Bounce Rate Guide](/blog/bounce-rate)
+- [Churn Rate vs Retention Rate](/blog/churn-rate-vs-retention-rate)
+- [E-commerce Analytics Guide](/blog/ecommerce-analytics)
+- [Behavior Analytics - Sessions](/docs/behavior-analytics/sessions)
+- [Behavior Analytics - Users](/docs/behavior-analytics/users)
+- [Behavior Analytics - Errors](/docs/behavior-analytics/errors)
+- [Track Custom Events](/docs/track-events)
+- [Troubleshooting Guide](/docs/troubleshooting)
\ No newline at end of file
diff --git a/docs/content/docs/behavior-analytics/errors.mdx b/docs/content/docs/behavior-analytics/errors.mdx
new file mode 100644
index 000000000..07d015d00
--- /dev/null
+++ b/docs/content/docs/behavior-analytics/errors.mdx
@@ -0,0 +1,286 @@
+---
+title: Errors Tab
+description: A comprehensive guide to tracking and resolving errors in Rybbit's Behavior Analytics
+---
+
+# A Guide to Rybbit's Errors Tab
+
+The Errors tab in Rybbit's Behavior Analytics section provides visibility into JavaScript errors and exceptions occurring on your website. While users often silently suffer through broken features and technical issues, the Errors tab brings these problems into the light, allowing you to quickly identify and resolve the bugs that degrade user experience and cost you conversions.
+
+## What is Error Tracking?
+
+Error tracking monitors JavaScript errors that occur in the browser as users interact with your website. These might include syntax errors, network failures, unhandled exceptions, or any other JavaScript issues that break functionality or degrade the user experience.
+
+By automatically capturing errors and the context in which they occur, Rybbit helps you transition from reactive debugging (users report problems) to proactive quality assurance (you identify and fix issues before they hurt your business).
+
+## Why Error Tracking Matters
+
+JavaScript errors on your website directly impact your business:
+
+**Lost Conversions**: A broken checkout button might prevent customers from completing purchases. Error tracking reveals these critical issues immediately.
+
+**Poor User Experience**: Errors often cascade, breaking features and confusing users. Early detection prevents negative user experiences.
+
+**Hidden Problems**: Many users silently abandon your site when they encounter errors. Without error tracking, you'd never know there was a problem.
+
+**Development Efficiency**: Instead of developers chasing vague user reports ("your site is broken"), error tracking provides exact error messages and stack traces.
+
+**Quality Assurance**: Errors that slip through testing in production are caught and fixed much faster with visibility into real user errors.
+
+## Accessing the Errors Tab
+
+To view and analyze errors on your website:
+
+1. Log into your Rybbit dashboard
+2. Navigate to the **Behavior** section in the left sidebar
+3. Click on the **Errors** tab
+
+You'll see a list of all JavaScript errors occurring on your website, grouped by error type and severity.
+
+## Key Error Metrics
+
+When examining the Errors tab, you'll encounter important metrics about your website's health:
+
+### Error Type
+The classification of the error (ReferenceError, TypeError, SyntaxError, NetworkError, etc.). This helps you categorize and prioritize fixes.
+
+### Error Message
+The specific error message returned by JavaScript. This often clearly describes what went wrong.
+
+### Stack Trace
+The chain of function calls that led to the error. This shows you exactly where in your code the error occurred.
+
+### Affected Users
+The number of unique users who encountered this error. A single user seeing an error is less critical than hundreds of users affected.
+
+### Occurrence Count
+How many times this specific error has been triggered. Frequent errors indicate high-priority issues.
+
+### First Seen
+When the error first appeared. New errors might indicate recently introduced bugs.
+
+### Last Seen
+When the error most recently occurred. Errors that went away might have been fixed. Errors that persist need attention.
+
+### Affected Pages
+Which pages on your website generated this error. This reveals if the issue is site-wide or isolated to specific areas.
+
+### Severity Level
+The impact level of the error (critical, major, minor). Critical errors often prevent core functionality.
+
+### Browser & Device
+Which browsers and devices experience this error. Some errors only occur in specific environments.
+
+## Error Types and Causes
+
+Understanding different error types helps you prioritize fixes:
+
+### Reference Errors
+Caused by attempting to use undefined variables. Often indicates missing dependencies or incorrect variable names.
+
+### Type Errors
+Occur when code tries to perform an operation on the wrong data type (e.g., calling a method on undefined). Common in code that doesn't validate input.
+
+### Syntax Errors
+Issues in code structure. Usually caught during development but can occur in dynamically generated code.
+
+### Network Errors
+Failed API calls or failed resource loading. Might indicate server issues, CDN problems, or user connectivity issues.
+
+### Permission Errors
+Attempt to access restricted resources. Often indicates incorrect authentication or authorization.
+
+### Range Errors
+Operations outside valid ranges (e.g., array access out of bounds).
+
+### Custom Errors
+Errors thrown intentionally by your code for validation or business logic purposes.
+
+## Analyzing Error Patterns
+
+The Errors tab becomes most valuable when you identify patterns:
+
+### Error Frequency
+Monitor if errors are increasing, staying stable, or decreasing. Sudden spikes indicate new problems. Gradual increases suggest systematic issues.
+
+### Error Clustering
+Multiple errors from the same user might indicate they're triggering a specific error condition. Look for patterns in which actions cause errors.
+
+### Device-Specific Errors
+Some errors occur only on mobile or only on specific browsers. This helps you test in the right environment.
+
+### Timing Patterns
+Do errors spike at specific times? This might correlate with deployments, heavy traffic periods, or external service outages.
+
+### Conversion Impact
+Which errors are preventing users from completing important actions? Prioritize fixing errors on critical pages.
+
+## Common Use Cases
+
+### Identifying Critical Issues
+When errors are preventing users from converting or accessing core features, fix them immediately.
+
+### Post-Deployment Monitoring
+After deploying new code, monitor the Errors tab for sudden spikes indicating bugs introduced by the deployment.
+
+### Debugging User Reports
+When users report problems, the Errors tab often provides the exact technical issue and stack trace.
+
+### Improving Stability
+Regularly reviewing and fixing errors improves your overall application stability and user satisfaction.
+
+### A/B Testing Validation
+After launching A/B tests or feature experiments, monitor errors to ensure new variants don't introduce bugs.
+
+### Performance Debugging
+Some errors are caused by memory leaks or performance issues. Tracking errors helps identify performance problems.
+
+### Third-Party Integration Issues
+Errors often indicate that third-party integrations (analytics, payment processors, chat tools) are malfunctioning.
+
+## Error Tracking Configuration
+
+To use the Errors tab effectively:
+
+1. **Enable Error Tracking**: Ensure error tracking is enabled in your Rybbit configuration
+2. **Proper Installation**: Verify the Rybbit script is installed before other scripts that might throw errors
+3. **Source Maps**: If you use minified code, upload source maps for readable stack traces
+4. **Environment Tagging**: Tag errors by environment (production, staging, development) to ignore non-production errors
+5. **Filtering**: Configure the system to ignore known, harmless errors in your stack
+
+## Understanding Stack Traces
+
+Stack traces show you the exact execution path that led to an error:
+
+```
+ReferenceError: cart is not defined
+ at checkout() (app.js:245)
+ at handlePaymentClick() (app.js:180)
+ at HTMLElement.onclick (checkout.html:50)
+```
+
+This tells you:
+- **Error**: Variable `cart` is undefined
+- **Root Location**: Line 245 in app.js, in the `checkout()` function
+- **Call Chain**: `checkout()` was called from `handlePaymentClick()` which was called from a click handler
+
+With this information, you can quickly find and fix the bug.
+
+## Prioritizing Error Fixes
+
+Not all errors are equally important. Use these criteria to prioritize:
+
+**By Impact**: How many users are affected? Critical = hundreds of users, Major = dozens, Minor = few
+
+**By Severity**: Does it completely break functionality (critical) or just degrade it (major/minor)?
+
+**By Visibility**: Does the error occur on frequently visited pages or obscure pages?
+
+**By Business Impact**: Does the error prevent conversions or affect core features?
+
+**By Frequency**: Is the error happening constantly (high priority) or rarely (lower priority)?
+
+## Best Practices for Error Management
+
+**Fix Frequently Occurring Errors First**: Errors affecting many users should be fixed before edge-case errors.
+
+**Use Source Maps**: Keep source maps handy so you can read stack traces in minified code.
+
+**Test Fixes**: When fixing an error, verify the fix works before deploying to production.
+
+**Monitor After Fixes**: After fixing an error, monitor the Errors tab to verify it's actually gone.
+
+**Set Up Alerts**: Configure alerts for critical error spikes to catch new issues immediately.
+
+**Document Errors**: Keep notes on errors you've fixed to avoid repeating mistakes.
+
+**Version Tracking**: If possible, track which code version each error is associated with to isolate when bugs were introduced.
+
+## Advanced Error Debugging
+
+### Correlating Errors with Sessions
+Find users who encountered errors and examine their sessions to understand what they were doing when the error occurred.
+
+### Analyzing Error Sequences
+Sometimes multiple errors occur in sequence. Understanding the sequence helps identify root causes.
+
+### Monitoring Third-Party Errors
+Track errors from third-party scripts (ads, analytics, chat widgets). Some can be ignored, others indicate integration failures.
+
+### Performance-Related Errors
+Memory errors and timeout errors often indicate performance issues. Address these alongside traditional error fixes.
+
+### Error Recovery Success
+Monitor whether errors automatically recover or if they break functionality. Unrecoverable errors are more critical.
+
+## Privacy Considerations
+
+Rybbit's error tracking respects privacy:
+
+- Error messages and stack traces don't automatically include PII
+- You should review error data to ensure no sensitive information is leaking
+- Users can opt out of error tracking
+- Error data follows the same retention and security policies as other analytics
+
+Be careful not to log sensitive information (passwords, API keys, personal data) in error messages.
+
+## Common Error Scenarios
+
+### Redux/State Management Errors
+Often indicate components trying to access undefined state properties. Fix by ensuring proper state initialization.
+
+### Third-Party Library Errors
+When errors come from libraries you didn't write, check for compatibility issues or incorrect usage.
+
+### Network Timeout Errors
+Indicate slow API responses or failed requests. Consider implementing retry logic.
+
+### CORS Errors
+Indicate requests blocked by browser security policies. Review your CORS configuration.
+
+### Memory Leak Errors
+When browser memory consumption grows continuously, track down code creating unreferenced objects.
+
+### Timing-Related Errors
+Errors that occur intermittently might be timing-related (race conditions, asynchronous issues).
+
+## Troubleshooting Error Tracking
+
+### No errors appearing
+Check that error tracking is enabled and that you have JavaScript errors occurring on your site (they might be being caught elsewhere).
+
+### Errors seem inaccurate
+Verify source maps are properly configured. Without source maps, minified code shows unhelpful stack traces.
+
+### Too many trivial errors
+Configure the system to ignore errors that don't affect users, or filter them in your dashboard.
+
+### Missing error context
+Ensure the Rybbit script loads early and before other scripts that might throw errors.
+
+## Connecting Errors with Other Analytics
+
+### Errors and Sessions
+See in which sessions errors occurred to understand user impact.
+
+### Errors and Users
+Identify which users are affected by specific errors, allowing for targeted support.
+
+### Errors and Events
+Some errors might be preceded by specific events. Track these sequences to understand error causes.
+
+## Conclusion
+
+The Errors tab in Rybbit's Behavior Analytics transforms your website monitoring from reactive (waiting for user complaints) to proactive (automatically detecting and fixing issues). By systematically reviewing and addressing errors, you dramatically improve user experience, increase conversions, and build a more stable product.
+
+Make it a habit to check the Errors tab regularly, prioritize fixes based on user impact, and monitor after deployments for any unexpected issues. Combined with other Behavior Analytics features, error tracking gives you complete visibility into your website's health and your users' experience.
+
+**Additional Resources:**
+- [Sessions Tab Guide](/docs/behavior-analytics/sessions)
+- [Events Tab Guide](/docs/behavior-analytics/events)
+- [Users Tab Guide](/docs/behavior-analytics/users)
+- [Track Custom Events](/docs/track-events)
+- [Debugging Performance Issues](/docs/troubleshooting)
+- [Product Analytics - Funnels Guide](/docs/product-analytics/funnels_guide)
+- [API - Sending Events](/docs/api/sending-events)
+- [Blog: Website Traffic Drop](/blog/website-traffic-drop)
diff --git a/docs/content/docs/behavior-analytics/events.mdx b/docs/content/docs/behavior-analytics/events.mdx
new file mode 100644
index 000000000..e89ab88d9
--- /dev/null
+++ b/docs/content/docs/behavior-analytics/events.mdx
@@ -0,0 +1,271 @@
+---
+title: Events Tab
+description: A comprehensive guide to tracking and analyzing custom events in Rybbit's Behavior Analytics
+---
+
+# A Guide to Rybbit's Events Tab
+
+The Events tab in Rybbit's Behavior Analytics section lets you track and analyze custom events that happen on your website. While standard analytics tracks page views and basic interactions, the Events tab gives you control over what actions matter most to your business—whether that's button clicks, form submissions, purchases, sign-ups, feature usage, or any other meaningful user interaction.
+
+## What is a Custom Event?
+
+A custom event is any action you define as important for your business. Unlike page views which happen automatically, custom events require you to implement tracking code. This intentional approach means you only track what matters to you, keeping your analytics focused and your data collection minimal.
+
+Custom events are the bridge between your business goals and user behavior. By tracking events, you transform raw user actions into meaningful signals that show you what users are doing and whether they're achieving your desired outcomes.
+
+## Types of Events You Can Track
+
+Rybbit allows you to track virtually any user action as a custom event:
+
+### Engagement Events
+- Button clicks (CTA, "Learn More," "Get Started")
+- Link clicks
+- Video plays and completions
+- Form submissions
+- Content shares
+- Feature interactions
+
+### Conversion Events
+- Product purchases
+- Sign-ups and registrations
+- Newsletter subscriptions
+- Account upgrades
+- Demo requests
+- Contact form submissions
+
+### Feature Usage Events
+- Feature activations
+- Tool usage
+- Feature completions
+- API calls
+- File uploads/downloads
+
+### User Journey Events
+- Onboarding completion
+- Tutorial progression
+- Milestone achievements
+- Status changes
+- User level-ups
+
+## Accessing the Events Tab
+
+To view and analyze your events:
+
+1. Log into your Rybbit dashboard
+2. Navigate to the **Behavior** section in the left sidebar
+3. Click on the **Events** tab
+
+You'll see a comprehensive list of all tracked events on your website, along with frequency, user information, and other metrics.
+
+## Key Event Metrics
+
+When examining the Events tab, you'll encounter important metrics about your custom events:
+
+### Event Name
+The name you assigned to the custom event. Clear, consistent naming makes it easier to track and analyze events.
+
+### Event Count
+The total number of times this event has been triggered across all users and sessions. High counts indicate frequent user actions around this feature or functionality.
+
+### Unique Users
+The number of distinct users who have triggered this event. This shows how many of your users interact with this specific feature or functionality.
+
+### Conversion Rate
+For key events (especially purchases), this shows what percentage of your total users or sessions resulted in this event. High conversion rates on important events indicate strong product-market fit.
+
+### Average Value
+If you track monetary value with your events (common for purchases), this shows the average transaction value.
+
+### Event Properties
+Custom data attached to each event. For example, a "Purchase" event might include properties like product_id, price, quantity, and category.
+
+### First Triggered
+When the first instance of this event occurred, showing how long you've been tracking this action.
+
+### Last Triggered
+The most recent time this event was triggered, indicating current user engagement with this feature.
+
+## Filtering and Analyzing Events
+
+Rybbit provides powerful filtering to help you understand specific events:
+
+### Filter by Event Name
+Focus on specific events you care about most. For example, analyze only "Purchase" events or "Feature A Activation" events.
+
+### Filter by User
+See which specific users triggered events, useful for understanding power users or investigating individual user journeys.
+
+### Filter by Session
+Analyze events within specific sessions to understand the context and sequence of user actions.
+
+### Filter by Event Properties
+Drill down into specific event details. For example, filter "Purchase" events by product category or price range.
+
+### Filter by Time Range
+Compare event trends across different time periods to measure growth, impact of changes, or seasonal patterns.
+
+### Filter by Source
+If tracking events from multiple sources (website, app, etc.), filter by source to analyze platform-specific behavior.
+
+## Common Use Cases
+
+### Measuring Conversion Funnel
+Track events across your user journey (sign-up → feature activation → purchase) to measure conversion rates at each stage and identify where users drop off.
+
+### Feature Adoption Tracking
+Monitor how many users discover and use new features you've released. Low adoption might indicate the feature needs better onboarding or visibility.
+
+### Understanding Feature Engagement
+Track which features users interact with most frequently. This data guides your product roadmap and feature prioritization.
+
+### Validating Product Changes
+After making changes to your product, monitor event metrics to measure impact. Did the change increase desired actions or decrease undesired ones?
+
+### Identifying Power Users
+Find users who trigger many important events. These engaged users are valuable for retention and can provide product feedback.
+
+### Analyzing User Workflow
+Track the sequence of events users follow when accomplishing a goal. Optimization opportunities often appear when users take unexpected or inefficient paths.
+
+### Debugging Issues
+Monitor error events to identify when users encounter problems on your site. Spikes in error events might indicate a bug or performance issue.
+
+### Measuring Marketing Campaign Impact
+Track campaign-specific events to measure whether users from specific campaigns take desired actions at higher rates.
+
+## Setting Up Event Tracking
+
+Before you can analyze events, you need to track them. This typically involves:
+
+1. **Identify Key Events**: Determine which user actions matter most to your business
+2. **Implement Tracking**: Add event tracking code to your website using Rybbit's SDK or API
+3. **Name Consistently**: Use clear, consistent names for your events (e.g., "purchase_completed" not "sale" or "checkout")
+4. **Add Context**: Include relevant properties with events to provide additional context
+5. **Test**: Verify events are firing correctly before relying on the data
+6. **Monitor**: Regularly review event data to ensure tracking is working as expected
+
+## Event Property Best Practices
+
+When tracking custom events, include relevant properties to add context:
+
+### For E-commerce Events
+Include product_id, price, category, quantity, discount, currency, etc.
+
+### For Sign-up Events
+Include plan_type, source, location, device_type, etc.
+
+### For Engagement Events
+Include feature_name, action_type, duration, success, etc.
+
+### For Error Events
+Include error_type, error_message, page_path, severity, etc.
+
+Include only relevant properties—more isn't always better. Cleaner events are easier to analyze and require less data storage.
+
+## Analyzing Event Patterns
+
+Look for patterns across your event data:
+
+### Event Sequences
+Do users typically trigger events in a specific sequence? Understanding natural workflows helps you optimize your user experience.
+
+### Time Patterns
+Do certain events spike at specific times of day or days of the week? This might indicate optimal times for marketing or feature releases.
+
+### Cohort Differences
+Do different user segments (by device, location, referrer) have different event patterns? This reveals optimization opportunities for specific groups.
+
+### Conversion Funnel Efficiency
+Track how users move through your conversion funnel. Where do most users drop off? What's the typical path for converters?
+
+### Feature Engagement Trends
+Do usage patterns for specific features increase or decrease over time? This guides feature maintenance and development priorities.
+
+## Advanced Event Analysis Techniques
+
+### Funnel Analysis
+Manually analyze the sequence of events users trigger. For example: "view_product" → "add_to_cart" → "view_checkout" → "purchase_completed"
+
+### Cohort Comparison
+Compare event behavior between user cohorts (acquired at different times, from different sources, using different devices) to identify factors that drive engagement.
+
+### Retention Analysis
+For users who trigger important events (like "premium_upgrade"), track how their retention differs from other users over time.
+
+### Lifetime Value Calculation
+For monetization events, sum the total value generated by each user across all their events to calculate user lifetime value.
+
+### Event Attribution
+When users trigger important conversion events, trace back which previous events or sessions contributed to that conversion.
+
+## Troubleshooting Event Tracking
+
+### Events not appearing
+Verify that tracking code is properly installed and that you're using the correct event names. Check browser console for JavaScript errors.
+
+### Inconsistent event names
+If the same action is tracked with different names (e.g., "signup" and "sign_up"), consolidate to a single name for cleaner analysis.
+
+### Missing event properties
+Ensure your tracking code includes relevant properties. Without properties, it's harder to analyze event context.
+
+### Event counts seem low
+Compare event counts to your overall traffic. If conversion events are below 1%, you may have product issues or incorrect tracking.
+
+### Properties showing unexpected values
+Validate that your code is passing the correct values to event properties. Test thoroughly before relying on the data.
+
+## Privacy and Event Data
+
+Rybbit's event tracking respects user privacy:
+
+- Events don't require cookies
+- PII (passwords, emails, credit cards) should never be included in events
+- You control what data is collected through your event definitions
+- Users can opt out of event tracking
+- Event data follows the same retention policies as other analytics data
+
+Configure PII masking to automatically redact sensitive information from event properties.
+
+## Best Practices for Event Tracking
+
+**Start Simple**: Begin with your most important events. Add more later as you understand your data needs.
+
+**Use Consistent Naming**: Adopt a naming convention (e.g., verb_noun like "button_clicked," "form_submitted") and stick with it.
+
+**Include Context**: Events are more useful when you understand the context. Include relevant properties.
+
+**Test Thoroughly**: Before deploying tracking to production, verify events fire correctly in development.
+
+**Document Your Events**: Keep a document listing all events you track, their names, and what properties they include.
+
+**Monitor for Changes**: Periodically review event counts to spot unusual spikes or drops that might indicate tracking issues.
+
+**Connect to Business Goals**: Ensure you're tracking events that actually relate to your business objectives.
+
+## Connecting Events with Other Analytics
+
+### Events and Users
+Analyzing which users trigger which events helps you identify user segments and power users.
+
+### Events and Sessions
+Understanding events within the context of sessions shows how events relate to the overall user journey.
+
+### Events and Errors
+Correlation between user actions and errors can help you identify which features are causing issues.
+
+## Conclusion
+
+The Events tab in Rybbit's Behavior Analytics transforms your website into a feedback machine that shows you exactly what users are doing and whether they're achieving your business goals. By thoughtfully selecting what to track and analyzing the resulting data, you gain actionable insights that drive product improvement and business growth.
+
+Start by identifying your most important user actions, implement tracking, and then regularly review the data to understand user behavior patterns. Over time, event data becomes an invaluable tool for measuring product success and guiding optimization efforts.
+
+**Additional Resources:**
+- [Track Custom Events Guide](/docs/track-events)
+- [Users Tab Guide](/docs/behavior-analytics/users)
+- [Sessions Tab Guide](/docs/behavior-analytics/sessions)
+- [Errors Tab Guide](/docs/behavior-analytics/errors)
+- [Product Analytics - Funnels Guide](/docs/product-analytics/funnels_guide)
+- [Event Tracking Best Practices](/docs/track-events)
+- [API - Sending Events](/docs/api/sending-events)
+- [Blog: Churn Rate vs Retention Rate](/blog/churn-rate-vs-retention-rate)
diff --git a/docs/content/docs/behavior-analytics/meta.json b/docs/content/docs/behavior-analytics/meta.json
new file mode 100644
index 000000000..bdadf5dc7
--- /dev/null
+++ b/docs/content/docs/behavior-analytics/meta.json
@@ -0,0 +1,4 @@
+{
+ "title": "Behavior Analytics",
+ "pages": ["sessions", "users", "events", "errors"]
+}
diff --git a/docs/content/docs/behavior-analytics/sessions.mdx b/docs/content/docs/behavior-analytics/sessions.mdx
new file mode 100644
index 000000000..75945a713
--- /dev/null
+++ b/docs/content/docs/behavior-analytics/sessions.mdx
@@ -0,0 +1,188 @@
+---
+title: Sessions Tab
+description: A comprehensive guide to understanding and analyzing user sessions in Rybbit's Behavior Analytics
+---
+
+# A Guide to Rybbit's Sessions Tab
+
+The Sessions tab in Rybbit's Behavior Analytics section provides deep insights into how users interact with your website during individual visits. Unlike traditional analytics that show aggregated metrics, the Sessions tab reveals the complete picture of individual user journeys, allowing you to understand exactly how your visitors navigate, engage, and convert on your site.
+
+## What is a Session?
+
+A session represents a continuous period of user activity on your website. It includes all page views, interactions, events, and behavioral data from the moment a user arrives until they leave or become inactive. Sessions are fundamental to understanding user behavior because they capture the context and sequence of user actions rather than isolated data points.
+
+In Rybbit, sessions are tracked without cookies while still maintaining the privacy-first approach that defines our platform. Each session is identified through an anonymous identifier that allows you to replay and analyze user journeys without compromising privacy.
+
+## Accessing the Sessions Tab
+
+To view your site's sessions data:
+
+1. Log into your Rybbit dashboard
+2. Navigate to the **Behavior** section in the left sidebar
+3. Click on the **Sessions** tab
+
+You'll be presented with a comprehensive list of all sessions on your website, along with key metrics and filtering options to help you find the sessions most relevant to your analysis.
+
+## Key Session Metrics
+
+When examining the Sessions tab, you'll encounter several important metrics:
+
+### Session Duration
+The total length of time a user spends on your website during a single visit. Longer sessions generally indicate higher engagement, though this varies by website type. For example, a news site might have longer sessions than an e-commerce checkout flow.
+
+### Pages Visited
+The number of pages a user views during their session. This metric helps identify how much of your site visitors explore and can indicate whether your navigation and content discovery are effective.
+
+### Events Triggered
+The count of custom events that occurred during the session. Events might include button clicks, form submissions, video plays, or any other tracked interactions you've configured in Rybbit.
+
+### Device & Browser
+Information about the device and browser used during the session. This helps you understand your audience's technical environment and identify any device-specific issues.
+
+### Location
+The geographic location of the user based on IP address. This provides valuable insights into your geographic audience distribution and can help with localization efforts.
+
+### Entry Page
+The first page the user visited in the session. Understanding entry pages reveals which content attracts visitors and can guide your SEO and marketing strategies.
+
+### Exit Page
+The last page before the user left your site. Exit pages are critical for identifying where users abandon their journey, which can indicate problem areas that need optimization.
+
+### Bounce Status
+Whether the user bounced (left the site after viewing only one page). High bounce rates on specific pages often indicate issues with content relevance, page load speed, or user experience.
+
+## Filtering and Searching Sessions
+
+Rybbit provides powerful filtering capabilities to help you find the sessions most relevant to your analysis:
+
+### Filter by Duration
+Find sessions within a specific time range. For example, you might focus on users who spent more than 5 minutes on your site, indicating high engagement.
+
+### Filter by Page
+Analyze sessions that include specific pages. This is useful for understanding user behavior around particular content or features.
+
+### Filter by Events
+Search for sessions that contain specific events. For instance, find all sessions where users triggered a "Purchase" event to understand successful customer journeys.
+
+### Filter by Device
+Isolate sessions from specific devices (desktop, mobile, tablet) to identify device-specific user behavior patterns.
+
+### Filter by Browser
+Examine sessions from specific browsers to diagnose browser-specific issues or understand browser preferences in your audience.
+
+### Filter by Location
+Segment sessions by geographic location to understand regional user behaviors and preferences.
+
+### Filter by Referrer
+Find sessions from specific traffic sources. This helps you understand which marketing channels and referral sources drive quality traffic.
+
+### Filter by Date Range
+Use custom date ranges to compare user behavior across different time periods, seasonal trends, or after implementing changes to your site.
+
+## Analyzing Session Patterns
+
+The Sessions tab becomes most powerful when you look for patterns across multiple sessions:
+
+### High-Engagement Sessions
+Identify users who spend significant time on your site, visit many pages, and trigger important events. These sessions often represent your most engaged users and can reveal what's working well on your site.
+
+### Problem Sessions
+Look for patterns in sessions with high bounce rates or quick exits. Sessions where users visited critical pages but then left immediately might indicate usability issues or missing information.
+
+### Conversion Paths
+Track the typical sequence of pages and events that lead to conversions. Understanding the conversion path helps you optimize the user journey and remove friction.
+
+### Feature Discovery
+Monitor sessions to see which features users discover and interact with. Low usage of certain features might indicate poor discoverability or unclear value proposition.
+
+## Common Use Cases
+
+### Debugging User Experience Issues
+When users report problems on your site, the Sessions tab allows you to replay their exact experience and understand what went wrong.
+
+### Identifying Bottlenecks
+Look for sessions where users get stuck or abandon the process. Common bottlenecks include complex forms, slow-loading pages, or confusing navigation.
+
+### Validating Feature Changes
+After implementing new features or redesigning sections of your site, compare session patterns before and after the change to measure impact.
+
+### Understanding Traffic Quality
+Sessions from high-quality traffic sources typically show longer duration, more pages visited, and higher conversion rates. Use this to optimize your marketing spend.
+
+### Improving Onboarding
+Analyze sessions from first-time visitors to see where they get confused or drop off. Improving onboarding reduces churn among new users.
+
+### Optimizing for Mobile
+Compare sessions on mobile devices versus desktop to identify mobile-specific issues. Many sites see dramatic differences in session quality between devices.
+
+## Session Privacy Considerations
+
+Rybbit's Sessions tab maintains privacy-first principles:
+
+- Sessions are identified anonymously without requiring cookies
+- Personal information like passwords, credit card numbers, and sensitive form data can be masked using Rybbit's PII protection features
+- Users can opt out of session tracking without affecting other analytics
+- Session data is retained according to your configured data retention policy
+
+You can customize PII masking rules to ensure sensitive information is never recorded, even in sessions.
+
+## Tips for Effective Session Analysis
+
+**Look Beyond Averages**: A high average session duration might hide the fact that some users bounce immediately while others stay for hours. Segment your data to understand the distribution.
+
+**Compare Cohorts**: Compare session patterns between different user segments (by device, location, traffic source) to identify where improvements are needed.
+
+**Correlate with Events**: Cross-reference sessions with important events to understand which behaviors lead to conversions or desired outcomes.
+
+**Monitor Over Time**: Track how session metrics change over time. Improvements in engagement metrics often precede changes in conversion rates.
+
+**Use with Session Replay**: While the Sessions tab shows aggregate metrics, pair it with individual session replays (if enabled) to see exactly what users are doing.
+
+**Test and Iterate**: Use session insights to identify problems, implement fixes, then monitor whether new session metrics improve.
+
+## Troubleshooting Common Issues
+
+### No session data appearing
+Ensure the Rybbit tracking script is properly installed on your website and that you've waited for some user traffic to accumulate.
+
+### Session durations seem incorrect
+Session timeout is typically 30 minutes of inactivity. If a user closes their browser, that session ends even if they return the next day.
+
+### Missing sessions from certain browsers
+Check browser console for JavaScript errors that might prevent tracking. Some browser extensions block tracking scripts.
+
+### Unexpected location data
+IP-based geolocation has inherent limitations and occasional inaccuracies. Location data should be used as an approximation rather than an exact science.
+
+## Advanced Analysis Techniques
+
+### Funnel Analysis through Sessions
+Identify the sequence of pages users visit before converting. Create a mental model of your conversion funnel by observing which page sequences are most common in converting sessions.
+
+### Session Segmentation
+Create mental segments of users based on session characteristics:
+- **Browsers**: Users who quickly scan content
+- **Explorers**: Users who visit many pages
+- **Converters**: Users who complete desired actions
+- **Bouncers**: Users who leave after one page
+
+Each segment may require different optimization strategies.
+
+### Behavioral Cohorts
+Compare sessions from different time periods or traffic sources to identify behavioral differences that might explain performance variations.
+
+## Conclusion
+
+The Sessions tab in Rybbit's Behavior Analytics is a powerful tool for understanding your users. By examining session patterns, metrics, and behaviors, you can identify opportunities for optimization, diagnose problems, and ultimately build a better experience for your users.
+
+Start by exploring your most recent sessions, look for patterns among high-engagement and low-engagement users, and use those insights to guide your optimization efforts. Paired with other analytics features like event tracking and behavior flow analysis, the Sessions tab gives you a complete understanding of how users interact with your website.
+
+**Additional Resources:**
+- [Getting Started with Rybbit Analytics](/docs)
+- [Users Tab Guide](/docs/behavior-analytics/users)
+- [Events Tab Guide](/docs/behavior-analytics/events)
+- [Errors Tab Guide](/docs/behavior-analytics/errors)
+- [Track Custom Events](/docs/track-events)
+- [Product Analytics - Retention Guide](/docs/product-analytics/retention_guide)
+- [Session Replay Guide](/docs/product-analytics/replay-session)
+- [API - Sending Events](/docs/api/sending-events)
diff --git a/docs/content/docs/behavior-analytics/users.mdx b/docs/content/docs/behavior-analytics/users.mdx
new file mode 100644
index 000000000..92c533c16
--- /dev/null
+++ b/docs/content/docs/behavior-analytics/users.mdx
@@ -0,0 +1,225 @@
+---
+title: Users Tab
+description: A comprehensive guide to understanding and analyzing individual users in Rybbit's Behavior Analytics
+---
+
+# A Guide to Rybbit's Users Tab
+
+The Users tab in Rybbit's Behavior Analytics section provides detailed insights into the individual people visiting your website. While traditional analytics often focuses on aggregated metrics and traffic patterns, the Users tab shifts the perspective to show you who your visitors are, their behaviors, engagement patterns, and how they interact with your site over time.
+
+## What is a User?
+
+A user in Rybbit represents a unique visitor to your website. Unlike cookie-based analytics, Rybbit identifies users through privacy-first mechanisms that don't compromise visitor privacy. Each user is assigned a unique identifier that allows you to track their behavior across multiple sessions without using cookies.
+
+Understanding users is fundamental to modern analytics because it allows you to move beyond "how many people visited" to answer more meaningful questions like "who are my users," "what do they do," and "how can I better serve them."
+
+## Accessing the Users Tab
+
+To view your site's user data:
+
+1. Log into your Rybbit dashboard
+2. Navigate to the **Behavior** section in the left sidebar
+3. Click on the **Users** tab
+
+You'll be presented with a comprehensive list of unique visitors along with key information about each user, their activity, and engagement metrics.
+
+## Key User Metrics
+
+When examining the Users tab, you'll find several important metrics about each user:
+
+### User ID
+A unique, anonymized identifier for each visitor. This ID allows you to track a user across multiple sessions and devices (if they use the same browser).
+
+### First Visit
+The date and time when the user first visited your website. This helps you understand user acquisition patterns and identify your oldest engaged users.
+
+### Last Visit
+The most recent date and time the user visited your site. This metric indicates user retention and helps identify dormant or churned users.
+
+### Total Sessions
+The number of separate visits the user has made to your website. Users with more sessions are generally more engaged and loyal.
+
+### Pages Viewed
+The total number of pages visited across all sessions by this user. High page view counts often indicate strong engagement with your content.
+
+### Events Triggered
+The total number of custom events (like button clicks, form submissions, or purchases) triggered by this user across all their sessions.
+
+### Device Type
+The type of device(s) the user has accessed your site from (desktop, mobile, tablet). Some users may appear multiple times if they visit from different devices.
+
+### Location
+The geographic location where the user accessed your site, based on IP address geolocation.
+
+### Referrer
+How the user initially arrived at your site (organic search, paid ads, social media, direct, etc.).
+
+### Last Activity
+The type of action the user took during their most recent visit (page view, event triggered, scroll, etc.).
+
+## Filtering and Searching Users
+
+Rybbit provides powerful filtering options to help you segment and analyze specific user groups:
+
+### Filter by Total Sessions
+Find users who have visited your site a specific number of times. For example, identify one-time visitors versus loyal users who return frequently.
+
+### Filter by Page Views
+Isolate users based on how many pages they've viewed. This helps identify power users who deeply engage with your content versus casual browsers.
+
+### Filter by Events
+Search for users who have triggered specific events. For instance, find all users who have completed a purchase or signed up for a newsletter.
+
+### Filter by Device
+Segment users by their device type (desktop, mobile, tablet) to understand usage patterns across different platforms.
+
+### Filter by Location
+Analyze users from specific geographic regions or countries to understand your global audience and identify regions for growth.
+
+### Filter by Referrer
+Find users who arrived from specific traffic sources to understand which channels bring high-quality visitors.
+
+### Filter by Activity Date
+Isolate users who visited within a specific time period. This helps identify recently active users versus historical users.
+
+### Filter by First Visit Date
+Find users who discovered your site within a specific timeframe. This is useful for measuring the impact of marketing campaigns or product launches.
+
+## Analyzing User Behavior Patterns
+
+The Users tab becomes most powerful when you identify and analyze patterns across user groups:
+
+### High-Value Users
+Identify users who visit frequently, view many pages, and trigger important events. These power users often provide the most value and should be prioritized in retention efforts.
+
+### One-Time Visitors
+Find users who visited only once and didn't return. Understanding why these visitors churn can help you improve your onboarding and value proposition.
+
+### Device-Specific Users
+Look for patterns in how different user groups use different devices. Some users may primarily access your site on mobile while others prefer desktop.
+
+### Geographic Patterns
+Analyze user behavior by location to identify regional differences in engagement, preferences, and conversion patterns.
+
+### Traffic Source Quality
+Compare users from different referrers to determine which marketing channels and traffic sources bring the most engaged and valuable users.
+
+## Common Use Cases
+
+### Understanding User Retention
+Track how many users return to your site over time. Compare new users versus returning users to measure customer loyalty and identify churn risks.
+
+### Identifying High-Value Customers
+Find users who have completed valuable actions (purchases, sign-ups, upgrades) and analyze what they have in common. Use these patterns to identify similar users for targeted outreach.
+
+### Improving New User Onboarding
+Analyze the behavior of first-time visitors to see where they struggle or drop off. Use these insights to streamline your onboarding experience.
+
+### Measuring Marketing Campaign Effectiveness
+Compare users acquired through different marketing channels to determine which campaigns bring the most engaged and valuable users.
+
+### Optimizing for Key User Segments
+Identify your most valuable user segments (by geography, device, behavior) and optimize your product and marketing specifically for them.
+
+### Detecting Bot or Spam Activity
+Look for unusual user behavior patterns that might indicate bots or malicious activity, such as users triggering hundreds of events in seconds.
+
+## User Privacy and Data Protection
+
+Rybbit's Users tab maintains strict privacy standards:
+
+- User identification is anonymous and doesn't rely on cookies
+- No personally identifiable information (PII) is collected without explicit consent
+- Users can opt out of tracking at any time
+- All user data is encrypted and stored securely
+- User data retention follows GDPR and CCPA compliance standards
+
+You maintain full control over your user data with options for self-hosting and complete data ownership.
+
+## Tips for Effective User Analysis
+
+**Segment by Behavior, Not Just Demographics**: While location and device data is useful, segmenting by behavior (pages viewed, events triggered) often reveals more actionable insights.
+
+**Look for First-Time User Patterns**: Understanding how new users interact differently from returning users can dramatically improve your onboarding and activation rates.
+
+**Track User Lifecycle**: Monitor how individual users progress through different stages (awareness, engagement, conversion, retention). Use this to identify drop-off points and opportunities.
+
+**Correlate with Business Metrics**: Connect user data with your business outcomes. Which user segments generate the most revenue, sign-ups, or other valuable actions?
+
+**Monitor Emerging Segments**: Regularly check the Users tab for new patterns. Emerging user segments sometimes represent new market opportunities.
+
+**Compare Before and After Changes**: When you make changes to your site or product, monitor how user behavior patterns change to measure impact.
+
+## Troubleshooting Common Issues
+
+### Missing user data
+Ensure the Rybbit tracking script is installed and that your privacy settings allow user identification. Some strict privacy settings may disable user-level tracking.
+
+### Users appearing multiple times
+This typically happens when users visit from different browsers or devices. This is expected behavior in Rybbit's privacy-first approach.
+
+### Unexpected user counts
+If user numbers seem low, check that your traffic is actually being tracked. Verify the script is loading correctly and no content blockers are interfering.
+
+### Location data seems inaccurate
+IP-based geolocation has inherent limitations. Location should be used as an approximation, particularly for mobile users.
+
+## Advanced User Analytics
+
+### User Cohort Analysis
+Group users by when they first visited (weekly, monthly cohorts) and track how retention and engagement differ. This helps you understand if recent traffic quality differs from historical users.
+
+### User Lifetime Value (LTV)
+For users who complete valuable actions (purchases), calculate their lifetime value by tracking their total contribution over all sessions. This helps prioritize high-value user retention.
+
+### Activation Analysis
+Track the path new users take to reach their first meaningful action (first page view, event, conversion). Users who activate quickly are more likely to become long-term users.
+
+### Churn Prediction
+Monitor users who haven't visited recently. Users with long gaps between visits are at higher risk of permanent churn. Consider re-engagement campaigns for these users.
+
+### User Segmentation Strategies
+Create mental models of different user types:
+- **Casual Browsers**: Few sessions, low engagement
+- **Regular Users**: Consistent visits, moderate engagement
+- **Power Users**: Frequent visits, high engagement, multiple events
+- **Converters**: Users who complete valuable actions
+
+Each segment may require different optimization strategies.
+
+## Connecting Users with Other Analytics
+
+### Users and Sessions
+Each user typically has multiple sessions. Use the Sessions tab to understand the specific behavior within individual user sessions.
+
+### Users and Events
+Custom events provide context for user behavior. Correlate user segments with the events they trigger to understand motivation and satisfaction.
+
+### Users and Errors
+If enabled, error tracking shows which users are experiencing issues. Investigate error patterns to improve product quality.
+
+## Best Practices
+
+**Privacy-First Approach**: Always remember that behind every user ID is a real person. Respect their privacy and use data responsibly.
+
+**Focus on Actionable Segments**: Don't just identify segments—use insights to make concrete changes to improve their experience.
+
+**Regular Monitoring**: Check the Users tab regularly to spot emerging trends, new user segments, or changing behavior patterns.
+
+**Balance Quantitative and Qualitative**: Pair user metrics with qualitative feedback (surveys, support tickets) for a complete understanding.
+
+## Conclusion
+
+The Users tab in Rybbit's Behavior Analytics transforms raw traffic data into human-centered insights. By understanding who your users are, how they behave, and what drives their engagement, you can build a better product and marketing strategy.
+
+Start by exploring your recent users, identify your most engaged and valuable users, and use those patterns to guide your optimization efforts. Combined with session analysis and event tracking, user data gives you a complete picture of how people interact with your website.
+
+**Additional Resources:**
+- [Sessions Tab Guide](/docs/behavior-analytics/sessions)
+- [Events Tab Guide](/docs/behavior-analytics/events)
+- [Errors Tab Guide](/docs/behavior-analytics/errors)
+- [Track Custom Events](/docs/track-events)
+- [Product Analytics - Retention Guide](/docs/product-analytics/retention_guide)
+- [User Cohort Analysis](/docs/product-analytics/journeys_dashboard)
+- [Getting Started with Rybbit Analytics](/docs)
+- [Blog: Churn Rate vs Retention Rate](/blog/churn-rate-vs-retention-rate)
diff --git a/docs/content/docs/filter-traffic.mdx b/docs/content/docs/filter-traffic.mdx
index 650c3c56f..822b0b241 100644
--- a/docs/content/docs/filter-traffic.mdx
+++ b/docs/content/docs/filter-traffic.mdx
@@ -115,4 +115,4 @@ Content-Type: application/json
}
```
-See the [API documentation](/docs/api) for more details on authentication and request formats.
+See the [API documentation](/docs/api/stats-api) for more details on authentication and request formats.
diff --git a/docs/content/docs/meta.json b/docs/content/docs/meta.json
index ba4b1e2f6..d1aa5ab37 100644
--- a/docs/content/docs/meta.json
+++ b/docs/content/docs/meta.json
@@ -15,6 +15,7 @@
"filter-traffic",
"---User Guide---",
"web-analytics",
+ "behavior-analytics",
"product-analytics",
"---Self-hosting---",
"self-hosting",
diff --git a/docs/content/docs/product-analytics/funnels_guide.mdx b/docs/content/docs/product-analytics/funnels_guide.mdx
index c6f29c36a..97a81bb3a 100644
--- a/docs/content/docs/product-analytics/funnels_guide.mdx
+++ b/docs/content/docs/product-analytics/funnels_guide.mdx
@@ -393,6 +393,17 @@ If you have questions about setting up funnels, interpreting your data, or need
Start with one important conversion goal, set up a funnel to measure it, identify your biggest drop-off point, and make one improvement. Then measure the results and iterate. That simple cycle, repeated consistently, is how great products get built and successful businesses grow.
+---
+
+**Related Reading:**
+- [Product Analytics - Retention Guide](/docs/product-analytics/retention_guide)
+- [Product Analytics - Journeys Dashboard](/docs/product-analytics/journeys_dashboard)
+- [Behavior Analytics - Events Tab](/docs/behavior-analytics/events)
+- [Behavior Analytics - Sessions Tab](/docs/behavior-analytics/sessions)
+- [Track Custom Events](/docs/track-events)
+- [Blog: Churn Rate vs Retention Rate](/blog/churn-rate-vs-retention-rate)
+- [Blog: E-commerce Analytics](/blog/ecommerce-analytics)
+
## Questions about any feature?
- **Documentation**: [rybbit.com/docs](https://rybbit.com/docs)
diff --git a/docs/content/docs/product-analytics/journeys_dashboard.mdx b/docs/content/docs/product-analytics/journeys_dashboard.mdx
index 5c9c9ebe7..fd91a867c 100644
--- a/docs/content/docs/product-analytics/journeys_dashboard.mdx
+++ b/docs/content/docs/product-analytics/journeys_dashboard.mdx
@@ -232,6 +232,17 @@ Journey analysis can reveal profound insights about your user experience, but it
Every journey tells a story. Your job is to listen to what your users' journeys are telling you and use those insights to create better experiences. Happy exploring!
+---
+
+**Related Reading:**
+- [Product Analytics - Retention Guide](/docs/product-analytics/retention_guide)
+- [Product Analytics - Funnels Guide](/docs/product-analytics/funnels_guide)
+- [Behavior Analytics - Users Tab](/docs/behavior-analytics/users)
+- [Behavior Analytics - Sessions Tab](/docs/behavior-analytics/sessions)
+- [Behavior Analytics - Events Tab](/docs/behavior-analytics/events)
+- [Track Custom Events](/docs/track-events)
+- [Blog: Churn Rate vs Retention Rate](/blog/churn-rate-vs-retention-rate)
+
## Questions about any feature?
- **Documentation**: [rybbit.com/docs](https://rybbit.com/docs)
diff --git a/docs/content/docs/product-analytics/retention_guide.mdx b/docs/content/docs/product-analytics/retention_guide.mdx
index 25bca9481..1f0a6e114 100644
--- a/docs/content/docs/product-analytics/retention_guide.mdx
+++ b/docs/content/docs/product-analytics/retention_guide.mdx
@@ -140,6 +140,17 @@ Retention analysis is one of the most powerful tools in your analytics toolkit.
Remember: good retention doesn't happen by accident. It's the result of deeply understanding your users, continuously improving your product, and making sure every interaction delivers value. Your retention dashboard is your guide on that journey.
+---
+
+**Related Reading:**
+- [Behavior Analytics - Users Tab](/docs/behavior-analytics/users)
+- [Behavior Analytics - Sessions Tab](/docs/behavior-analytics/sessions)
+- [Behavior Analytics - Events Tab](/docs/behavior-analytics/events)
+- [Product Analytics - Journeys Dashboard](/docs/product-analytics/journeys_dashboard)
+- [Product Analytics - Funnels Guide](/docs/product-analytics/funnels_guide)
+- [Track Custom Events](/docs/track-events)
+- [Blog: Churn Rate vs Retention Rate](/blog/churn-rate-vs-retention-rate)
+
## Questions about any feature?
diff --git a/docs/content/docs/self-hosting-guides/custom-nginx.mdx b/docs/content/docs/self-hosting-guides/custom-nginx.mdx
index b280362c1..1509b57b2 100644
--- a/docs/content/docs/self-hosting-guides/custom-nginx.mdx
+++ b/docs/content/docs/self-hosting-guides/custom-nginx.mdx
@@ -245,5 +245,5 @@ docker compose logs -f
```
<Callout type="info">
-For step-by-step Nginx installation and SSL setup, see our [Nginx Setup Guide](/docs/self-hosting-nginx).
+For step-by-step Nginx installation and SSL setup, see our [Nginx Setup Guide](/docs/self-hosting-guides/custom-nginx).
</Callout>
\ No newline at end of file
diff --git a/docs/content/docs/self-hosting-guides/self-hosting-manual.mdx b/docs/content/docs/self-hosting-guides/self-hosting-manual.mdx
index 57c378000..5b8938221 100644
--- a/docs/content/docs/self-hosting-guides/self-hosting-manual.mdx
+++ b/docs/content/docs/self-hosting-guides/self-hosting-manual.mdx
@@ -486,5 +486,5 @@ docker compose ps
Both postgres and clickhouse should show "healthy" status.
<Callout type="info">
-For more advanced configurations and setup script options, see our [Advanced Self-Hosting Guide](/docs/self-hosting-advanced).
+For more advanced configurations and setup script options, see our [Advanced Self-Hosting Guide](/docs/self-hosting-guides/self-hosting-advanced).
</Callout>
\ No newline at end of file
diff --git a/docs/content/docs/track-events.mdx b/docs/content/docs/track-events.mdx
index 20ba3e2af..7fd65d481 100644
--- a/docs/content/docs/track-events.mdx
+++ b/docs/content/docs/track-events.mdx
@@ -191,4 +191,16 @@ For tracking events from server-side applications, mobile apps, or any platform
- Backend integrations and webhooks
- Scenarios where the JavaScript snippet can't be used
-See the [API documentation](/docs/api) for detailed examples in multiple languages including authentication, parameters, and rate limiting information.
\ No newline at end of file
+See the [API documentation](/docs/api/sending-events) for detailed examples in multiple languages including authentication, parameters, and rate limiting information.
+
+---
+
+**Related Documentation:**
+- [Behavior Analytics - Events Tab](/docs/behavior-analytics/events)
+- [Behavior Analytics - Users Tab](/docs/behavior-analytics/users)
+- [Behavior Analytics - Sessions Tab](/docs/behavior-analytics/sessions)
+- [Product Analytics - Retention Guide](/docs/product-analytics/retention_guide)
+- [Product Analytics - Funnels](/docs/product-analytics/funnels_guide)
+- [API - Sending Events](/docs/api/sending-events)
+- [Blog: Churn Rate vs Retention Rate](/blog/churn-rate-vs-retention-rate)
+- [Web SDK Reference](/docs/sdks/web)
\ No newline at end of file