diff --git a/crates/frontend/src/components/condition_pills/condition_pills.rs b/crates/frontend/src/components/condition_pills/condition_pills.rs
index 5c180e6e..93868d64 100644
--- a/crates/frontend/src/components/condition_pills/condition_pills.rs
+++ b/crates/frontend/src/components/condition_pills/condition_pills.rs
@@ -1,31 +1,28 @@
-use super::utils::{extract_and_format, parse_conditions};
+use crate::components::condition_pills::types::ConditionOperator;
+
+use super::types::Condition;
 use leptos::*;
-use serde_json::Value;
 
 #[component]
-pub fn context_pills(context: Value) -> impl IntoView {
-    let condition = extract_and_format(&context);
-    let ctx_values = parse_conditions(condition.clone());
-
+pub fn condition_pills(#[prop(into)] conditions: Vec<Condition>) -> impl IntoView {
     view! {
-        {ctx_values
+        {conditions
             .into_iter()
             .map(|condition| {
                 let dimension = condition.left_operand;
                 let op = condition.operator;
                 let val = condition.right_operand;
-                let operator = op.clone();
                 view! {
                     <span class="inline-flex items-center rounded-md bg-gray-50 px-2 py-1 text-xs ring-1 ring-inset ring-purple-700/10 shadow-md gap-x-2">
                         <span class="font-mono font-medium context_condition text-gray-500">
                             {dimension}
                         </span>
                         <span class="font-mono font-medium text-gray-650 context_condition ">
-                            {op}
+                            {op.to_string()}
                         </span>
 
-                        {match operator.trim() {
-                            "BETWEEN" => {
+                        {match op {
+                            ConditionOperator::Between => {
                                 let split_val: Vec<String> = val
                                     .clone()
                                     .split(",")
diff --git a/crates/frontend/src/components/condition_pills/types.rs b/crates/frontend/src/components/condition_pills/types.rs
index 05681bb1..0ace1f6c 100644
--- a/crates/frontend/src/components/condition_pills/types.rs
+++ b/crates/frontend/src/components/condition_pills/types.rs
@@ -1,6 +1,145 @@
+use std::fmt::Display;
+
+use serde_json::{Map, Value};
+
+use crate::types::Context;
+
+#[derive(Debug, Clone)]
+pub enum ConditionOperator {
+    Is,
+    In,
+    Has,
+    Between,
+    Other(String),
+}
+
+impl Display for ConditionOperator {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Has => f.write_str("has"),
+            Self::Is => f.write_str("is"),
+            Self::In => f.write_str("in"),
+            Self::Between => f.write_str("between"),
+            Self::Other(o) => f.write_str(o),
+        }
+    }
+}
+
+impl From<(String, &Vec<Value>)> for ConditionOperator {
+    fn from(value: (String, &Vec<Value>)) -> Self {
+        let (operator, operands) = value;
+        let operand_0 = operands.get(0);
+        let operand_1 = operands.get(1);
+        let operand_2 = operands.get(2);
+        match (operator.as_str(), operand_0, operand_1, operand_2) {
+            // assuming there will be only two operands, one with the dimension name and other with the value
+            ("==", _, _, None) => ConditionOperator::Is,
+            ("<=", Some(_), Some(Value::Object(a)), Some(_)) if a.contains_key("var") => {
+                ConditionOperator::Between
+            }
+            // assuming there will be only two operands, one with the dimension name and other with the value
+            ("in", Some(Value::Object(a)), Some(_), None) if a.contains_key("var") => {
+                ConditionOperator::In
+            }
+            // assuming there will be only two operands, one with the dimension name and other with the value
+            ("in", Some(_), Some(Value::Object(a)), None) if a.contains_key("var") => {
+                ConditionOperator::Has
+            }
+            _ => ConditionOperator::Other(operator),
+        }
+    }
+}
+
 #[derive(Clone)]
 pub struct Condition {
     pub left_operand: String,
-    pub operator: String,
+    pub operator: ConditionOperator,
     pub right_operand: String,
 }
+
+impl TryFrom<&Map<String, Value>> for Condition {
+    type Error = &'static str;
+    fn try_from(source: &Map<String, Value>) -> Result<Self, Self::Error> {
+        if let Some(operator) = source.keys().next() {
+            let emty_vec = vec![];
+            let operands = source[operator].as_array().unwrap_or(&emty_vec);
+
+            let operator = ConditionOperator::from((operator.to_owned(), operands));
+
+            let dimension_name = operands
+                .iter()
+                .find_map(|item| match item.as_object() {
+                    Some(o) if o.contains_key("var") => {
+                        Some(o["var"].as_str().unwrap_or(""))
+                    }
+                    _ => None,
+                })
+                .unwrap_or("");
+
+            let other_operands = operands
+                .iter()
+                .filter_map(|item| {
+                    if item.is_object() && item.as_object().unwrap().contains_key("var") {
+                        return None;
+                    }
+
+                    match item {
+                        Value::Null => String::from("null"),
+                        Value::String(v) => v.clone(),
+                        _ => format!("{}", item),
+                    }
+                    .into()
+                })
+                .collect::<Vec<String>>()
+                .join(",");
+
+            return Ok(Condition {
+                operator,
+                left_operand: dimension_name.to_owned(),
+                right_operand: other_operands,
+            });
+        }
+
+        Err("not a valid condition map")
+    }
+}
+
+impl TryFrom<&Value> for Condition {
+    type Error = &'static str;
+    fn try_from(value: &Value) -> Result<Self, Self::Error> {
+        let obj = value
+            .as_object()
+            .ok_or("not a valid condition value, should be an object")?;
+        Condition::try_from(obj)
+    }
+}
+
+impl TryFrom<&Context> for Vec<Condition> {
+    type Error = &'static str;
+    fn try_from(context: &Context) -> Result<Self, Self::Error> {
+        context
+            .condition
+            .as_object()
+            .ok_or("failed to parse context.condition as an object")
+            .and_then(|obj| match obj.get("and") {
+                Some(v) => v
+                    .as_array()
+                    .ok_or("failed to parse value of and as array")
+                    .and_then(|arr| {
+                        arr.iter()
+                            .map(|condition| Condition::try_from(condition))
+                            .collect::<Result<Vec<Condition>, &'static str>>()
+                    }),
+                None => Condition::try_from(obj).and_then(|v| Ok(vec![v])),
+            })
+    }
+}
+
+impl Into<String> for Condition {
+    fn into(self) -> String {
+        format!(
+            "{} {} {}",
+            self.left_operand, self.operator, self.right_operand
+        )
+    }
+}
diff --git a/crates/frontend/src/components/condition_pills/utils.rs b/crates/frontend/src/components/condition_pills/utils.rs
index bd6f93ff..7b8946be 100644
--- a/crates/frontend/src/components/condition_pills/utils.rs
+++ b/crates/frontend/src/components/condition_pills/utils.rs
@@ -1,135 +1,20 @@
-use std::mem::swap;
-
 use super::types::Condition;
 use serde_json::Value;
 
-pub fn parse_conditions(input: Vec<Condition>) -> Vec<Condition> {
-    let mut conditions = Vec::new();
-
-    // Split the string by "&&" and iterate over each condition
-    for condition in input {
-        let mut key = condition.left_operand;
-        let mut op = condition.operator;
-        let mut val = condition.right_operand;
-        if op == "in" {
-            swap(&mut key, &mut val)
-        }
-        // Add a space after key
-        key.push(' ');
-        match op.as_str() {
-            "==" => {
-                val = val.trim_matches('"').to_string();
-                op = "is".to_string();
-            }
-            "<=" => {
-                val = val.trim_matches('"').to_string();
-                op = "BETWEEN".to_string();
-            }
-            _ => {
-                val = val.trim_matches('"').to_string();
-                op = "has".to_string();
-            }
-        }
-        op.push(' ');
-
-        conditions.push(Condition {
-            left_operand: key,
-            operator: op,
-            right_operand: val,
-        });
-    }
-
-    conditions
-}
-
-pub fn extract_and_format(condition: &Value) -> Vec<Condition> {
-    let mut formatted_conditions = Vec::new();
-    if condition.is_object() && condition.get("and").is_some() {
-        // Handling complex "and" conditions
-        let empty_vec = vec![];
-        let conditions_json = condition
-            .get("and")
-            .and_then(|val| val.as_array())
-            .unwrap_or(&empty_vec); // Default to an empty vector if not an array
-
-        for cond in conditions_json {
-            if let Some(formatted_condition) = format_condition(cond) {
-                formatted_conditions.push(formatted_condition);
-            }
-        }
-    } else if let Some(formatted_condition) = format_condition(condition) {
-        // Handling single conditions
-        formatted_conditions.push(formatted_condition);
-    }
-    formatted_conditions
-}
-
-fn format_condition(condition: &Value) -> Option<Condition> {
-    if let Some(ref operator) = condition.as_object().and_then(|obj| obj.keys().next()) {
-        let empty_vec = vec![];
-        let operands = condition[operator].as_array().unwrap_or(&empty_vec);
-
-        // Handling the "in" operator differently
-        if operator.as_str() == "in" {
-            let left_operand = &operands[0];
-            let right_operand = &operands[1];
-
-            let left_str = if left_operand.is_string() {
-                format!("\"{}\"", left_operand.as_str().unwrap())
-            } else {
-                format!("{}", left_operand)
-            };
-
-            if right_operand.is_object() && right_operand["var"].is_string() {
-                let var_str = right_operand["var"].as_str().unwrap();
-                return Some(Condition {
-                    left_operand: left_str,
-                    operator: operator.to_string(),
-                    right_operand: var_str.to_string(),
-                });
-            }
-        }
-
-        // Handline the "<=" operator differently
-        if operator.as_str() == "<=" {
-            let left_operand = &operands[0];
-            let right_operand = &operands[2];
-            let mid_operand = &operands[1];
-
-            let left_str = format!("{}", left_operand).trim_matches('"').to_string();
-            let right_str = format!("{}", right_operand).trim_matches('"').to_string();
-
-            if mid_operand.is_object() && mid_operand["var"].is_string() {
-                let var_str = mid_operand["var"].as_str().unwrap();
-                return Some(Condition {
-                    left_operand: var_str.to_string(),
-                    operator: operator.to_string(),
-                    right_operand: left_str + "," + &right_str,
-                });
-            }
-        }
-        // Handling regular operators
-        if let Some(first_operand) = operands.get(0) {
-            if first_operand.is_object() && first_operand["var"].is_string() {
-                let key = first_operand["var"]
-                    .as_str()
-                    .unwrap_or("UnknownVar")
-                    .to_string();
-                if let Some(value) = operands.get(1) {
-                    let val_str = match value {
-                        Value::Null => "null".to_string(),
-                        Value::String(v) => v.clone(),
-                        _ => value.to_string(),
-                    };
-                    return Some(Condition {
-                        left_operand: key.to_string(),
-                        operator: operator.to_string(),
-                        right_operand: val_str,
-                    });
-                }
-            }
-        }
-    }
-
-    None
+pub fn extract_conditions(context: &Value) -> Vec<Condition> {
+    context
+        .as_object()
+        .and_then(|obj| {
+            obj.get("and")
+                .and_then(|v| v.as_array())
+                .and_then(|arr| {
+                    Some(
+                        arr.iter()
+                            .filter_map(|condition| Condition::try_from(condition).ok())
+                            .collect::<Vec<Condition>>(),
+                    )
+                })
+                .or_else(|| Condition::try_from(obj).ok().and_then(|v| Some(vec![v])))
+        })
+        .unwrap_or_default()
 }
diff --git a/crates/frontend/src/components/context_form/context_form.rs b/crates/frontend/src/components/context_form/context_form.rs
index 123a6c46..4ba62a5a 100644
--- a/crates/frontend/src/components/context_form/context_form.rs
+++ b/crates/frontend/src/components/context_form/context_form.rs
@@ -35,13 +35,14 @@ where
 
     create_effect(move |_| {
         let f_context = context.get();
+        logging::log!("{:?}", f_context);
         handle_change(f_context.clone());
     });
 
     let handle_select_dropdown_option = move |selected_dimension: Dimension| {
         let dimension_name = selected_dimension.dimension;
         set_context.update(|value| {
-            leptos::logging::log!("{:?}", value);
+            logging::log!("{:?}", value);
             value.push((dimension_name.to_string(), "".to_string(), "".to_string()))
         });
         set_used_dimensions.update(|value: &mut HashSet<String>| {
@@ -127,7 +128,7 @@ where
                                                 >
                                                     "IS"
                                                 </option>
-                                                <option value="IN" selected=operator.clone() == "IN">
+                                                <option value="in" selected=operator.clone() == "in">
                                                     "HAS"
                                                 </option>
                                                 <option value="<=" selected=operator.clone() == "<=">
@@ -157,24 +158,26 @@ where
                                                     placeholder="Type here"
                                                     class="input input-bordered w-full bg-white text-gray-700 shadow-md"
                                                 />
-                                                <Show when=move || !disabled >
-                                                <button
-                                                    class="btn btn-ghost btn-circle btn-sm"
-                                                    disabled=disabled
-                                                    on:click=move |_| {
-                                                        let mut current_context = context.get();
-                                                        current_context.remove(idx);
-                                                        set_context.set(current_context.clone());
-                                                        logging::log!("current context {:?}",current_context.clone());
-                                                        set_used_dimensions
-                                                            .update(|value| {
-                                                                value.remove(&dimension_name.get_value());
-                                                            });
-                                                    }
-                                                >
-
-                                                    <i class="ri-delete-bin-2-line text-xl text-2xl font-bold"></i>
-                                                </button>
+                                                <Show when=move || !disabled>
+                                                    <button
+                                                        class="btn btn-ghost btn-circle btn-sm"
+                                                        disabled=disabled
+                                                        on:click=move |_| {
+                                                            let mut current_context = context.get();
+                                                            current_context.remove(idx);
+                                                            set_context.set(current_context.clone());
+                                                            logging::log!(
+                                                                "current context {:?}", current_context.clone()
+                                                            );
+                                                            set_used_dimensions
+                                                                .update(|value| {
+                                                                    value.remove(&dimension_name.get_value());
+                                                                });
+                                                        }
+                                                    >
+
+                                                        <i class="ri-delete-bin-2-line text-xl text-2xl font-bold"></i>
+                                                    </button>
                                                 </Show>
                                             </div>
                                         </div>
@@ -196,7 +199,7 @@ where
                             }
                         />
 
-                        <Show when=move || { context.get().len() != 0 && !disabled}>
+                        <Show when=move || { context.get().len() != 0 && !disabled }>
                             <div class="mt-4">
 
                                 {move || {
diff --git a/crates/frontend/src/components/default_config_form/default_config_form.rs b/crates/frontend/src/components/default_config_form/default_config_form.rs
index 27956291..bc3c5ba0 100644
--- a/crates/frontend/src/components/default_config_form/default_config_form.rs
+++ b/crates/frontend/src/components/default_config_form/default_config_form.rs
@@ -298,7 +298,10 @@ where
                                     logging::log!("{:?}", event_target_value(& ev));
                                     set_config_value.set(event_target_value(&ev));
                                 }
-                            >{config_value.get()} </textarea>
+                            >
+
+                                {config_value.get()}
+                            </textarea>
 
                         </div>
 
diff --git a/crates/frontend/src/components/drawer/drawer.rs b/crates/frontend/src/components/drawer/drawer.rs
index 68ff68a7..d983d16e 100644
--- a/crates/frontend/src/components/drawer/drawer.rs
+++ b/crates/frontend/src/components/drawer/drawer.rs
@@ -39,6 +39,7 @@ pub fn drawer_btn(
                 on_click.call(e);
             }
         >
+
             {children()}
         </button>
     }
diff --git a/crates/frontend/src/components/experiment/experiment.rs b/crates/frontend/src/components/experiment/experiment.rs
index 2ddf7a99..b0eaec40 100644
--- a/crates/frontend/src/components/experiment/experiment.rs
+++ b/crates/frontend/src/components/experiment/experiment.rs
@@ -2,7 +2,7 @@ use std::rc::Rc;
 
 use leptos::*;
 
-use crate::components::condition_pills::utils::extract_and_format;
+use crate::components::condition_pills::utils::extract_conditions;
 use crate::components::table::table::Table;
 
 use super::utils::gen_variant_table;
@@ -23,7 +23,7 @@ where
     HE: Fn() + 'static + Clone,
 {
     let experiment_rc = Rc::new(experiment.clone());
-    let contexts = extract_and_format(&experiment_rc.clone().context);
+    let contexts = extract_conditions(&experiment_rc.clone().context);
 
     view! {
         <div class="flex flex-col overflow-x-auto p-2 bg-transparent">
diff --git a/crates/frontend/src/components/override_form/override_form.rs b/crates/frontend/src/components/override_form/override_form.rs
index 8212f265..f63dfdd9 100644
--- a/crates/frontend/src/components/override_form/override_form.rs
+++ b/crates/frontend/src/components/override_form/override_form.rs
@@ -120,7 +120,8 @@ where
                                                     });
                                             }
                                         >
-                                            { config_value }
+
+                                            {config_value}
                                         </textarea>
 
                                     </div>
diff --git a/crates/frontend/src/pages/ContextOverride/context_override.rs b/crates/frontend/src/pages/ContextOverride/context_override.rs
index 58f3c169..33151ef5 100644
--- a/crates/frontend/src/pages/ContextOverride/context_override.rs
+++ b/crates/frontend/src/pages/ContextOverride/context_override.rs
@@ -1,10 +1,8 @@
 use crate::api::fetch_config;
 use crate::api::{delete_context, fetch_default_config, fetch_dimensions};
 use crate::components::button::button::Button;
-use crate::components::condition_pills::{
-    condition_pills::ContextPills,
-    utils::{extract_and_format, parse_conditions},
-};
+use crate::components::condition_pills::condition_pills::ConditionPills;
+use crate::components::condition_pills::types::Condition;
 use crate::components::context_form::context_form::ContextForm;
 use crate::components::context_form::utils::{create_context, update_context};
 use crate::components::drawer::drawer::{close_drawer, open_drawer, Drawer, DrawerBtn};
@@ -12,6 +10,7 @@ use crate::components::override_form::override_form::OverrideForm;
 use crate::components::skeleton::{Skeleton, SkeletonVariant};
 use crate::components::table::{table::Table, types::Column};
 use crate::types::{Config, DefaultConfig, Dimension};
+use crate::utils::extract_conditions;
 use futures::join;
 use leptos::*;
 use serde::{Deserialize, Serialize};
@@ -130,7 +129,6 @@ pub fn context_override() -> impl IntoView {
                           });
                           };
                         if let Some(_selected_data) = selected_context_and_override.get() {
-                            logging::log!("it entered 1");
                             let handle_close =
                                 move || {
                                     close_drawer("context_and_override_drawer");
@@ -138,21 +136,9 @@ pub fn context_override() -> impl IntoView {
                                     form_data.set(None);
                                     edit_signal.set(false);
                                 };
-                            logging::log!("form data overrides {:?}", form_data.get_untracked().unwrap().overrides);
-                            logging::log!("form data contexts {:?}", form_data.get_untracked().unwrap().context);
 
                             let form_data_untracked = form_data.get_untracked().unwrap();
 
-                            let cleaned_context = form_data_untracked.context.iter().map(|(dim, op, val)| {
-                                let new_op = match op.trim().to_uppercase().as_str() {
-                                    "IS" => "==",
-                                    "HAS" => "IN",
-                                    "BETWEEN (inclusive)" => "<=",
-                                    _ => op.trim()
-                                };
-                                (dim.trim().to_string(), new_op.to_string(), val.clone())
-                            }).collect::<Vec<(String, String, String)>>();
-
                             let overrides = form_data_untracked.overrides.clone();
                             let cleaned_overrides = overrides.iter().map(|(key, value)| {
                                 let clean_key = key.trim_matches('\"').to_string();
@@ -169,7 +155,7 @@ pub fn context_override() -> impl IntoView {
                                 <Drawer id="context_and_override_drawer".to_string() header="Update Overrides" handle_close=handle_close>
                                     <ContextForm
                                         dimensions=dimension_value.unwrap_or_default()
-                                        context=cleaned_context
+                                        context=form_data_untracked.context
                                         is_standalone=false
                                       handle_change=move |new_context| {
                                          form_data.update(|prev| {
@@ -285,9 +271,9 @@ pub fn context_override() -> impl IntoView {
                                             }
                                             let overrides_clone = overrides.clone();
                                             let context_data_clone_for_display = context.condition.clone();
+                                            let conditions: Vec<Condition>  = context.try_into().unwrap_or(vec![]);
                                             let context_data_clone_for_click = context.condition.clone();
                                             let context_id = context.id.clone();
-                                            logging::log!("override signal: {:?}", overrides_clone.clone());
 
                                             let create_view = || {
                                                         let override_data = overrides_clone.clone();
@@ -302,22 +288,15 @@ pub fn context_override() -> impl IntoView {
                                                                             "Condition"
                                                                         </h3>
                                                                         <i class="ri-arrow-right-fill ri-xl text-blue-500"></i>
-                                                                        <ContextPills context=context_data_clone_for_display/>
+                                                                        <ConditionPills conditions=conditions />
                                                                     </div>
                                                                     <div class= "flex space-x-4">
                                                                     <i class="ri-pencil-line ri-xl text-blue-500 cursor-pointer" on:click = move |_| {
                                                                         edit_signal.set(true);
-                                                                        logging::log!("entered 1") ;
-                                                                        let condition = extract_and_format(&context_data_clone_for_click);
-                                                                        let ctx_values = parse_conditions(condition.clone());
-                                                                        let transformed_context_data = ctx_values.iter().map(|item| {
-                                                                            (item.left_operand.clone(), item.operator.clone(),item.right_operand.clone())
-                                                                        }).collect::<Vec<(String, String, String)>>();
-
-                                                                        logging::log!("override data for edit: {:?}", override_data_for_edit.clone());
+                                                                        let conditions = extract_conditions(&context_data_clone_for_click).unwrap_or(vec![]);
 
                                                                         form_data.set(Some(TableData {
-                                                                            context: transformed_context_data.clone(),
+                                                                            context: conditions,
                                                                             overrides: override_data_for_edit.clone()
                                                                         }));
                                                                         selected_context_and_override.set(Some(TableData {
@@ -328,16 +307,10 @@ pub fn context_override() -> impl IntoView {
                                                                     }> </i>
                                                                     <i class="ri-file-copy-line ri-xl text-blue-500 cursor-pointer" on:click = move |_| {
                                                                         edit_signal.set(false);
-                                                                        logging::log!("entered 1") ;
-                                                                        let condition = extract_and_format(&context_data_for_edit);
-                                                                        let ctx_values = parse_conditions(condition.clone());
-                                                                        let transformed_context_data = ctx_values.iter().map(|item| {
-                                                                            (item.left_operand.trim().to_string(), item.operator.trim().to_string(), item.right_operand.trim().to_string())
-                                                                        }).collect::<Vec<(String, String, String)>>();
-                                                                        logging::log!("transformed data {:?}",transformed_context_data.clone());
+                                                                        let conditions = extract_conditions(&context_data_for_edit).unwrap_or(vec![]);
 
                                                                         form_data.set(Some(TableData {
-                                                                            context: transformed_context_data.clone(),
+                                                                            context: conditions,
                                                                             overrides: override_data.clone()
                                                                         }));
                                                                         selected_context_and_override.set(Some(TableData {
diff --git a/crates/frontend/src/pages/Home/Home.rs b/crates/frontend/src/pages/Home/Home.rs
index b635282f..2640a386 100644
--- a/crates/frontend/src/pages/Home/Home.rs
+++ b/crates/frontend/src/pages/Home/Home.rs
@@ -1,6 +1,7 @@
 use std::time::Duration;
 
-use crate::components::condition_pills::condition_pills::ContextPills;
+use crate::components::condition_pills::condition_pills::ConditionPills;
+use crate::components::condition_pills::types::Condition;
 use crate::components::skeleton::{Skeleton, SkeletonVariant};
 use crate::{
     api::{fetch_config, fetch_dimensions},
@@ -402,11 +403,14 @@ pub fn home() -> impl IntoView {
                                                                     })
                                                                     .map(|(k, v)| { rows(&k, &v, true) })
                                                                     .collect();
+                                                                let conditions: Vec<Condition> = context
+                                                                    .try_into()
+                                                                    .unwrap_or(vec![]);
                                                                 view! {
                                                                     <div class="card bg-base-100 shadow m-6">
                                                                         <div class="card-body">
                                                                             <h2 class="card-title">
-                                                                                <ContextPills context=context.condition.clone()/>
+                                                                                <ConditionPills conditions=conditions/>
                                                                             </h2>
                                                                             <table class="table table-zebra mt-10">
                                                                                 <thead>
diff --git a/crates/frontend/src/pages/experiment_list/utils.rs b/crates/frontend/src/pages/experiment_list/utils.rs
index e9a70f22..b5d0e213 100644
--- a/crates/frontend/src/pages/experiment_list/utils.rs
+++ b/crates/frontend/src/pages/experiment_list/utils.rs
@@ -1,5 +1,6 @@
 use crate::components::{
-    condition_pills::condition_pills::ContextPills, table::types::Column,
+    condition_pills::{condition_pills::ConditionPills, utils::extract_conditions},
+    table::types::Column,
 };
 use core::time::Duration;
 use leptos::*;
@@ -106,7 +107,7 @@ pub fn experiment_table_columns() -> Vec<Column> {
 
                 view! {
                     <div class="inline-flex flex-col gap-y-2">
-                        <ContextPills context=context />
+                        <ConditionPills conditions=extract_conditions(&context) />
                     </div>
                 }
                 .into_view()