Lg/intros revamp (#486)

* first draft of deployment modes

* fixed bad link

* sidebar revamp v1

* remove some whitespace on sidebar

* intro revamp v1

* adjusting card title size for mobile

* a few small edits

Author: lukasgoetzweiss

docs/home.md

@@ -4,57 +4,102 @@ id: home
 slug: /
 ---
 
+import FeatureCard from '../src/components/FeatureCard';
+
 # What is Eppo?
 
-Eppo is a next-generation feature flagging and experimentation platform built right on top of your data warehouse:
+Eppo is a composable next-generation feature flagging and experimentation platform focused on tightly integrating with your existing tech stack. 
+
+To get started right away, check out one of our quickstart guides below. Otherwise, read on to learn more about Eppo's approach to experimentation.
+
+<div className="feature-card-container">
+  <FeatureCard 
+    title="SDK Quickstart" 
+    description="Install the SDK and create a basic flag"
+    link="/feature-flag-quickstart/"
+    iconSrc="/img/what-is-eppo/feature-flag.svg"
+  />
+  <FeatureCard 
+    title="Creating a Metric" 
+    description="Annotate data in your warehouse and create a metric"
+    link="/metric-quickstart/"
+    iconSrc="/img/what-is-eppo/metric.svg"
+  />
+  <FeatureCard 
+    title="Analyzing an Experiment" 
+    description="Measure the impact of a past or running experiment"
+    link="/experiment-quickstart/"
+    iconSrc="/img/what-is-eppo/experiment.svg"
+  />
+</div>
+
+## Eppo's Architecture
+
+Eppo has two main components: a lightweight SDK to control feature rollouts, kill switches, and advanced experimentation use cases, and an analytics platform for experiment analysis and program management. These two components fit naturally into your tech stack. We have SDKs for most modern development frameworks, and support a variety of deployment options. Our warehouse-native analysis engine is tightly coupled with your existing data, either through our data annotation UI or through our code-based semantic framework.
+
+<div align="center">
+
+![What is Eppo](/img/what-is-eppo/basic-architecture.png)
+
+</div>
 
-![What is Eppo Gif](/img/building-experiments/what-is-eppo.gif)
 
-We offer companies an end-to-end suite of experimentation tools, but let you decide which ones are right for you. Here are a few common ways teams use Eppo:
+### The Eppo SDK
 
-- As an [**end-to-end experimentation platform**](/quick-starts) - feature flagging, randomization, and analysis.
-- For [**experiment analysis**](/experiment-quickstart) alongside internal or third party randomization systems.
-- For [**feature flagging**](/feature-flagging) without experimentation.
+Eppo's SDK supports feature gating, progressive rollouts and randomized experimentation through a simple, reusable interface. Our SDK is designed to be easy to get started with while also providing flexibility for more advanced deployment patterns. 
 
-<br />
+Feature gates and experiments are configured in Eppo's UI. Eppo then turns this into a generalized configuration file and distributes it across our global CDN. On initialization, this file is downloaded and cached locally (either on the user's device or on your server, depending on the SDK). Evaluating which variant a user should see is then done locally within the SDK with no further network requests. Most SDKs will also handle polling for you to ensure the configuration is up to date.
 
-# How feature flagging works
+![Eppo SDK](/img/what-is-eppo/sdk-architecture.png)
 
-Eppo feature flagging supports feature gating, progressive rollouts, and randomized experiments all with one consistent and intuitive interface. Eppo's lightweight SDKs can run either client side or server side. Our SDKs span the most common tech stacks, including [Node](/sdks/server-sdks/node), [JavaScript](/sdks/client-sdks/javascript) (including [React](/sdks/client-sdks/javascript#usage-in-react)), [Python](sdks/server-sdks/python), [Go](sdks/server-sdks/go), [PHP](sdks/server-sdks/php), [Ruby](sdks/server-sdks/ruby), [iOS](/sdks/client-sdks/ios), and [Android](/sdks/client-sdks/android). For a full list of SDKs, see the [SDKs page](/sdks).
+Eppo's SDK does not do any tracking of its own, meaning that no user-level data passes through Eppo's system. Instead you'll pass in a simple interface to your existing event tracking system. In addition to mitigating security risks of using a third party vendor, this also simplifies considerations around ad blocking and cookie consent.
 
-Using an Eppo feature flag involves the following steps:
-1. Encode the variant values as booleans, strings, JSONs, or numerics
-2. Specify allocation logic for what traffic should see what variants (including randomized variants)
-3. Install and Initialize the SDK with an environment-specific SDK key and provide a [logging callback](/sdks/event-logging/) function to track exposures in your data warehouse
-5. Enable the feature flagging in your local, test, or production environment
+To learn more about Eppo's SDK, check out the [SDK docs](/sdks) or read the [quickstart guide](/feature-flag-quickstart).
 
-# How experiment analysis works
+### The Eppo Analytics Platform
 
-Eppo's analysis is built on top of your data warehouse. Concretely, this means experiment results are computed within the warehouse without data leaving your system. As part of that process, intermediate and aggregate tables are available in the warehouse for you to audit. In Eppo, metrics are defined in SQL, the same definitions that you use for business reporting.
+Eppo processes experiment data within your data warehouse environment. This means that no data leaves your system and that you have full visibility into the SQL logic used to produce results. Further, Eppo will always use the latest logic for core business metrics. If this logic or data ever changes, Eppo can automatically recompute results to account for those changes without you having to update any data pipelines specific to experimentation.
+
+Metrics are added to Eppo by pointing Eppo at existing data models in your data warehouse. This can be a basic `select * from ...` statement, or a more complex SQL definition. Since Eppo's analysis engine is built on SQL, you can be very flexible in defining metrics.
+
+Once you've annotated your data models into Eppo's data model, you can craft metrics using either the in-app metric builder, or in code using Eppo's metric yaml standard. 
+
+![Eppo Analytics](/img/what-is-eppo/analytics-architecture.png)
+
+Eppo is designed so that once a Data team has annotated tables in their warehouse, anyone in the company can use them to plan, monitor, and analyze experiments. This is paired with a comprehensive set of automated diagnostics to ensure that data quality and statistical rigor are both held to a high standard. 
 
-![How Eppo Works](/img/building-experiments/how-eppo-works.png)
 
 Generating an experiment report on Eppo involves five steps:
 
 1. Connect Eppo to your data warehouse: [Snowflake](/data-management/connecting-dwh/snowflake), [Redshift](/data-management/connecting-dwh/redshift), [BigQuery](/data-management/connecting-dwh/bigquery), or [Databricks](/data-management/connecting-dwh/databricks)
-2. Point Eppo at randomization logs from your application, email marketing system, ML models, or any other surface area on which you experiment
+2. Point Eppo at randomization logs from Eppo's SDK, or your own email marketing system, ML models, or other surface area on which you experiment
 3. Map metric data in your warehouse into Eppo's entity, fact, and dimension data model
 4. Analyze the impact the experiment had on business metrics
 5. Perform diagnostics, deep dive on results, and curate learnings in sharable experiment reports
 
+To learn more about Eppo's analytics platform, check out the [Data Management](/data-management) and [Experiment Analysis](/experiment-analysis) sections.
+
 ## Navigating the docs
 
-To quickly get up and running, check out our [getting started guides](/quick-starts). If you want to dive deeper into how Eppo works and understand Eppo's full functionality, check out the following pages:
+The docs are organized into the following sections:
+
+#### Getting Started
+
+- [**Quickstart Guides**](/quick-starts) - Start here for basic 10 minute tutorials on using core Eppo functionality.
 
-1. [SDKs](/sdks)
-2. [Feature flagging](/feature-flagging)
-3. [Experimentation analysis](/experiment-analysis)
-4. [Data management](/data-management)
-5. [Statistics](/statistics)
+#### Core Concepts
 
-Finally, check out our [how to guides](/guides/) to get detailed instruction on how to best accomplish advanced tasks, such as integrating with third-party tools and performing advanced analysis.
+- [**Flag and experiment configuration**](/feature-flagging) - Learn the core concepts, workflows, and use cases for Eppo feature flags and how to configure them in the UI, as well as details on advanced concepts like targeting, mutual exclusion, and global holdouts.
+- [**SDKs**](/sdks) - Learn about how to install and use Eppo's SDKs into your environment(s), as well as more details on the Eppo architecture and supported deployment patterns.
+- [**Data Management**](/data-management) - Learn about Eppo's data and metric model, how to connect your data warehouse, and how to use Eppo to manage data governance across experimentation use cases.
+- [**Experiment Analysis**](/experiment-analysis) - Learn about how to create experiment analysis in Eppo's UI, as well as how to deep dive into experiment results and curate custom experiment reports to communicate and track learnings.
+- [**Contextual Bandits**](/contextual-bandits) - Learn how to use Eppo to personalize user experiences with contextual bandits.
 
+#### Reference
+- [**Guides**](/guides) - Dive into detailed guides on advanced use cases including marketing integrations, engineering tutorials, and advanced experimentation topics.
+- [**Statistics**](/statistics) - Learn about the nitty-gritty details of how Eppo's statistical engine works, including confidence interval methods, CUPED++, sample size calculation, and more.
+- **Administration** - Learn about Eppo's approach to Role Based Access Control, SSO, SCIM, Teams, and other global admin settings.
 
 :::note
-Need help? Do not hesitate to reach out to us via `[email protected]`; we would love to hear from you!
+Need help? Do not hesitate to reach out to us via [email protected]; we would love to hear from you!
 :::

docs/quick-starts/experiment-allocation-quickstart.md

@@ -35,17 +35,15 @@ Give the flag a descriptive human readable name and create variations for each v
 
 ### 3. Create an experiment allocation
 
-After creating the flag, switch into the Test environment:
+After creating the flag, you'll see a page where you can define how variants should be allocated in each environment. Make sure you are in the Test environment, and click **Add Allocation** >> **Experiment**.
 
-![Feature gate 2](/img/feature-flagging/feature-flag-qs-2.png)
+![Feature gate 2](/img/feature-flagging/feature-flag-qs-2e.png)
 
-Now that you're in the Test environment, add an Experiment allocation to your flag. If you want to force certain segments or users into one variant, you can also add a Feature Gate allocation. You can read more about using Eppo for Feature Gates [here](/feature-flagging/concepts/feature-gates).
+If you want to force certain segments or users into one variant, you can also add a **Feature Gate** allocation. You can read more about using Eppo for Feature Gates [here](/feature-flagging/concepts/feature-gates).
 
-![Feature gate 3](/img/feature-flagging/feature-flag-qs-3.png)
+For this example, we will assign all users to the experiment. If you want to target specific users, you can add [targeting rules](/feature-flagging/concepts/targeting) to the allocation.
 
-For this example, we will assign all users to the experiment. If you want to target specific users, you can add targeting rules to the allocation. You can read more about targeting [here](/feature-flagging/concepts/targeting).
-
-![Feature gate 4](/img/feature-flagging/feature-flag-qs-4.png)
+![Feature gate 4](/img/feature-flagging/feature-flag-qs-3e.png)
 
 ### 4. Connect a logging function to the Eppo SDK