diff --git a/crates/frontend/src/components/condition_pills.rs b/crates/frontend/src/components/condition_pills.rs
index 02d4bc1d..f28da555 100644
--- a/crates/frontend/src/components/condition_pills.rs
+++ b/crates/frontend/src/components/condition_pills.rs
@@ -1,5 +1,5 @@
 use crate::{
-    logic::{Condition, Conditions, Operand, Operator},
+    logic::{Conditions, Constant, Expression, Operator},
     schema::HtmlDisplay,
 };
 
@@ -32,10 +32,10 @@ pub fn use_condition_collapser() -> WindowListenerHandle {
 pub fn condition_expression(
     #[prop(into)] id: String,
     #[prop(into)] list_id: String,
-    condition: Condition,
+    expression: Expression,
 ) -> impl IntoView {
     let id = store_value(id);
-    let condition = store_value(condition);
+    let expression = store_value(expression);
 
     let (expand_rs, expand_ws) = create_signal(false);
     let condition_id_rs = use_context::<ReadSignal<ConditionId>>().expect(
@@ -57,16 +57,14 @@ pub fn condition_expression(
             } else {
                 ("condition-item-collapsed", "condition-value-collapsed")
             };
-            let Condition { dimension, operator, operands } = condition.get_value();
-            let operand_str: Vec<String> = operands
-                .iter()
-                .filter_map(|operand| {
-                    match operand {
-                        Operand::Dimension(_) => None,
-                        Operand::Value(v) => Some(v.html_display()),
-                    }
-                })
-                .collect();
+            let (dimension, operator, operands): (String, Operator, Vec<String>) = expression
+                .with_value(|exp| {
+                    (
+                        exp.variable_name(),
+                        exp.to_operator(),
+                        exp.to_constants_vec().iter().map(|c| c.html_display()).collect(),
+                    )
+                });
             view! {
                 <li
                     id=id.get_value()
@@ -85,34 +83,25 @@ pub fn condition_expression(
                         {operator.to_string()}
                     </span>
 
-                    {match operator {
-                        Operator::Between => {
-                            if operand_str.len() == 2 {
-                                view! {
-                                    <>
-                                        <span class="font-mono font-semibold context_condition">
-                                            {&operand_str[0]}
-                                        </span>
-                                        <span class="font-mono font-medium text-gray-650 context_condition">
-                                            {"and"}
-                                        </span>
-                                        <span class="font-mono font-semibold context_condition">
-                                            {&operand_str[1]}
-                                        </span>
-                                    </>
-                                }
-                                    .into_view()
-                            } else {
-                                view! {
-                                    <span class="font-mono text-red-500">
-                                        "Invalid between values"
+                    {match expression.get_value() {
+                        Expression::Between(Constant(c1), _, Constant(c2)) => {
+                            view! {
+                                <>
+                                    <span class="font-mono font-semibold context_condition">
+                                        {c1.html_display()}
+                                    </span>
+                                    <span class="font-mono font-medium text-gray-650 context_condition">
+                                        {"and"}
+                                    </span>
+                                    <span class="font-mono font-semibold context_condition">
+                                        {c2.html_display()}
                                     </span>
-                                }
-                                    .into_view()
+                                </>
                             }
+                                .into_view()
                         }
                         _ => {
-                            let rendered_value = operand_str.join(", ");
+                            let rendered_value = operands.join(", ");
                             view! { <span class=value_class>{rendered_value}</span> }.into_view()
                         }
                     }}
@@ -146,11 +135,11 @@ pub fn condition(
                     .get_value()
                     .iter()
                     .enumerate()
-                    .map(|(idx, condition)| {
+                    .map(|(idx, expression)| {
                         let item_id = format!("{}-{}", id, idx);
                         view! {
                             <ConditionExpression
-                                condition=condition.clone()
+                                expression=expression.clone()
                                 id=item_id
                                 list_id=id.clone()
                             />
diff --git a/crates/frontend/src/components/context_card.rs b/crates/frontend/src/components/context_card.rs
index e6104442..16efc45d 100644
--- a/crates/frontend/src/components/context_card.rs
+++ b/crates/frontend/src/components/context_card.rs
@@ -7,7 +7,7 @@ use crate::{
         condition_pills::Condition as ConditionComponent,
         table::{types::Column, Table},
     },
-    logic::{Conditions, Operator},
+    logic::{Conditions, Expression},
 };
 
 #[component]
@@ -52,12 +52,12 @@ pub fn context_card(
         && !conditions
             .0
             .iter()
-            .any(|condition| condition.dimension == "variantIds");
+            .any(|expression| expression.variable_name() == "variantIds");
 
     let edit_unsupported = conditions
         .0
         .iter()
-        .any(|condition| matches!(condition.operator, Operator::Other(_)));
+        .any(|expression| matches!(expression, Expression::Other(_, _)));
 
     view! {
         <div class="rounded-lg shadow bg-base-100 p-6 flex flex-col gap-4">
diff --git a/crates/frontend/src/components/context_form.rs b/crates/frontend/src/components/context_form.rs
index 019cb4d9..f73a0679 100644
--- a/crates/frontend/src/components/context_form.rs
+++ b/crates/frontend/src/components/context_form.rs
@@ -2,7 +2,7 @@ pub mod utils;
 use std::collections::{HashMap, HashSet};
 
 use crate::components::input::{Input, InputType};
-use crate::logic::{Condition, Conditions, Operand, Operands, Operator};
+use crate::logic::{Conditions, Constant, Expression, Operator, Variable};
 use crate::schema::EnumVariants;
 use crate::types::Dimension;
 use crate::{
@@ -17,19 +17,72 @@ pub fn condition_input(
     disabled: bool,
     resolve_mode: bool,
     allow_remove: bool,
-    condition: StoredValue<Condition>,
+    expression: StoredValue<Expression>,
     input_type: StoredValue<InputType>,
     schema_type: StoredValue<SchemaType>,
     #[prop(into)] on_remove: Callback<String, ()>,
-    #[prop(into)] on_value_change: Callback<(usize, Value), ()>,
+    #[prop(into)] on_value_change: Callback<Expression, ()>,
     #[prop(into)] on_operator_change: Callback<Operator, ()>,
 ) -> impl IntoView {
-    let Condition {
-        dimension,
-        operator,
-        operands,
-    } = condition.get_value();
+    let (dimension, operator) =
+        expression.with_value(|v| (v.variable_name(), v.to_operator()));
 
+    let inputs: Vec<(Value, Callback<Value, ()>)> = match expression.get_value() {
+        Expression::Is(Variable(v), Constant(c)) => {
+            vec![(
+                c,
+                Callback::new(move |value: Value| {
+                    on_value_change
+                        .call(Expression::Is(Variable(v.clone()), Constant(value)));
+                }),
+            )]
+        }
+        Expression::In(Variable(v), Constant(c)) => {
+            vec![(
+                c,
+                Callback::new(move |value: Value| {
+                    on_value_change
+                        .call(Expression::In(Variable(v.clone()), Constant(value)));
+                }),
+            )]
+        }
+        Expression::Has(Constant(c), Variable(v)) => {
+            vec![(
+                c,
+                Callback::new(move |value: Value| {
+                    on_value_change
+                        .call(Expression::Has(Constant(value), Variable(v.clone())));
+                }),
+            )]
+        }
+        Expression::Between(Constant(c1), Variable(v), Constant(c2)) => {
+            let v_clone = v.clone();
+            let c2_clone = c2.clone();
+            vec![
+                (
+                    c1.clone(),
+                    Callback::new(move |value: Value| {
+                        on_value_change.call(Expression::Between(
+                            Constant(value),
+                            Variable(v_clone.clone()),
+                            Constant(c2_clone.clone()),
+                        ));
+                    }),
+                ),
+                (
+                    c2.clone(),
+                    Callback::new(move |value: Value| {
+                        on_value_change.call(Expression::Between(
+                            Constant(c1.clone()),
+                            Variable(v.clone()),
+                            Constant(value),
+                        ));
+                    }),
+                ),
+            ]
+        }
+        _ => vec![],
+    };
     view! {
         <div class="flex gap-x-6">
             <div class="form-control">
@@ -87,48 +140,39 @@ pub fn condition_input(
 
             <div class="flex gap-x-6 items-center">
 
-                {operands
-                    .0
-                    .clone()
+                {inputs
                     .into_iter()
                     .enumerate()
-                    .map(|(idx, operand): (usize, Operand)| {
-                        match operand {
-                            Operand::Dimension(_) => view! {}.into_view(),
-                            Operand::Value(v) => {
-                                view! {
-                                    <Input
-                                        value=v
-                                        schema_type=schema_type.get_value()
-                                        on_change=move |value: Value| {
-                                            on_value_change.call((idx, value));
-                                        }
+                    .map(|(idx, (value, on_change)): (usize, (Value, Callback<Value, ()>))| {
+                        view! {
+                            <Input
+                                value=value
+                                schema_type=schema_type.get_value()
+                                on_change=on_change
 
-                                        r#type=input_type.get_value()
-                                        disabled=disabled
-                                        id=format!(
-                                            "{}-{}",
-                                            condition
-                                                .with_value(|v| format!("{}-{}", v.dimension, v.operator)),
-                                            idx,
-                                        )
+                                r#type=input_type.get_value()
+                                disabled=disabled
+                                id=format!(
+                                    "{}-{}",
+                                    expression
+                                        .with_value(|v| {
+                                            format!("{}-{}", v.variable_name(), v.to_operator())
+                                        }),
+                                    idx,
+                                )
 
-                                        class="w-[450px]"
-                                        name=""
-                                        operator=Some(condition.with_value(|v| v.operator.clone()))
-                                    />
-                                }
-                                    .into_view()
-                            }
+                                class="w-[450px]"
+                                name=""
+                                operator=Some(operator.clone())
+                            />
                         }
                     })
-                    .collect_view()}
-                <Show when=move || allow_remove>
+                    .collect_view()} <Show when=move || allow_remove>
                     <button
                         class="btn btn-ghost btn-circle btn-sm mt-1"
                         disabled=disabled
                         on:click=move |_| {
-                            on_remove.call(condition.with_value(|v| v.dimension.clone()));
+                            on_remove.call(expression.with_value(|v| v.variable_name()));
                         }
                     >
 
@@ -162,7 +206,7 @@ where
     let (used_dimensions_rs, used_dimensions_ws) = create_signal(
         context
             .iter()
-            .map(|condition| condition.dimension.clone())
+            .map(|expression| expression.variable_name())
             .collect::<HashSet<String>>(),
     );
     let (context_rs, context_ws) = create_signal(context.clone());
@@ -193,44 +237,29 @@ where
                 value.insert(dimension_name.clone());
             });
             context_ws.update(|value| {
-                value.push(
-                    Condition::try_from((Operator::Is, dimension_name, r#type)).unwrap(),
-                )
+                value.push(Expression::is(dimension_name.as_str(), r#type))
             });
         }
         // TODO show alert in case of invalid dimension
     });
 
-    let on_operator_change = Callback::new(
-        move |(idx, d_name, d_type, operator): (usize, String, SchemaType, Operator)| {
-            if let Ok(operands) =
-                Operands::try_from((&operator, d_name.as_str(), &d_type))
-            {
-                context_ws.update(|v| {
-                    if idx < v.len() {
-                        v[idx].operator = operator;
-                        v[idx].operands = operands.clone();
-                    }
-                })
-            }
-            // TODO show alert in case of invalid dimension operator combinations
-        },
-    );
-
-    let on_value_change =
-        Callback::new(move |(idx, operand_idx, value): (usize, usize, Value)| {
+    let on_operator_change =
+        Callback::new(move |(idx, expression): (usize, Expression)| {
             context_ws.update(|v| {
                 if idx < v.len() {
-                    let operands = &(v[idx].operands);
-                    if operand_idx < operands.len()
-                        && matches!(operands[operand_idx], Operand::Value(_))
-                    {
-                        v[idx].operands[operand_idx] = Operand::from_operand_json(value);
-                    }
+                    v[idx] = expression;
                 }
-            })
+            });
         });
 
+    let on_value_change = Callback::new(move |(idx, expression): (usize, Expression)| {
+        context_ws.update(|v| {
+            if idx < v.len() {
+                v[idx] = expression;
+            }
+        })
+    });
+
     let on_remove = Callback::new(move |(idx, d_name): (usize, String)| {
         used_dimensions_ws.update(|value| {
             value.remove(&d_name);
@@ -270,62 +299,67 @@ where
                                 .0
                                 .into_iter()
                                 .enumerate()
-                                .collect::<Vec<(usize, Condition)>>()
+                                .collect::<Vec<(usize, Expression)>>()
                         }
 
-                        key=|(idx, condition)| {
-                            format!("{}-{}-{}", condition.dimension, idx, condition.operator)
+                        key=|(idx, expression)| {
+                            format!(
+                                "{}-{}-{}",
+                                expression.variable_name(),
+                                idx,
+                                expression.to_operator(),
+                            )
                         }
 
-                        children=move |(idx, condition)| {
+                        children=move |(idx, expression)| {
                             let (schema_type, enum_variants) = dimension_map
                                 .with_value(|v| {
-                                    let d = v.get(&condition.dimension).unwrap();
+                                    let d = v.get(&expression.variable_name()).unwrap();
                                     (
                                         SchemaType::try_from(d.schema.clone()),
                                         EnumVariants::try_from(d.schema.clone()),
                                     )
                                 });
+                            let operator = Operator::from(&expression);
+                            let dimension_name = expression.variable_name();
                             if schema_type.is_err() || enum_variants.is_err() {
-                                return view! {
-                                    <span class="text-sm red">An error occured</span>
-                                }
+                                return view! { <span class="text-sm red">An error occured</span> }
                                     .into_view();
                             }
                             let schema_type = store_value(schema_type.unwrap());
                             let allow_remove = !disabled
-                                && !mandatory_dimensions.get_value().contains(&condition.dimension);
+                                && !mandatory_dimensions
+                                    .get_value()
+                                    .contains(&expression.variable_name());
                             let input_type = store_value(
                                 InputType::from((
                                     schema_type.get_value(),
                                     enum_variants.unwrap(),
-                                    condition.operator.clone(),
+                                    operator,
                                 )),
                             );
-                            logging::log!(
-                                "here {:?} {:?}",  input_type.get_value(), condition.operator
-                            );
-                            let condition = store_value(condition);
+                            let expression = store_value(expression);
                             let on_remove = move |d_name| on_remove.call((idx, d_name));
-                            let on_value_change = move |(operand_idx, value)| {
-                                on_value_change.call((idx, operand_idx, value))
+                            let on_value_change = move |expression| {
+                                on_value_change.call((idx, expression))
                             };
                             let on_operator_change = move |operator| {
                                 on_operator_change
                                     .call((
                                         idx,
-                                        condition.with_value(|v| v.dimension.clone()),
-                                        schema_type.get_value(),
-                                        operator,
+                                        Expression::from((
+                                            dimension_name.as_str(),
+                                            schema_type.get_value(),
+                                            operator,
+                                        )),
                                     ))
                             };
                             view! {
-
                                 <ConditionInput
                                     disabled
                                     resolve_mode
                                     allow_remove
-                                    condition
+                                    expression
                                     input_type
                                     schema_type
                                     on_remove
diff --git a/crates/frontend/src/components/experiment.rs b/crates/frontend/src/components/experiment.rs
index 6ea17d36..bded6359 100644
--- a/crates/frontend/src/components/experiment.rs
+++ b/crates/frontend/src/components/experiment.rs
@@ -4,8 +4,6 @@ use std::collections::HashMap;
 
 use crate::{components::table::Table, schema::HtmlDisplay};
 
-use crate::logic::{Condition, Operand};
-
 use crate::types::{Experiment, ExperimentStatusType};
 use crate::{
     components::table::types::Column,
@@ -188,20 +186,14 @@ where
 
                         {contexts
                             .iter()
-                            .map(|condition| {
-                                let Condition { dimension, operands, .. } = condition;
-                                let operand_views = operands
+                            .map(|expression| {
+                                let dimension = expression.variable_name();
+                                let operand_views = expression
+                                    .to_constants_vec()
                                     .iter()
-                                    .filter_map(|op| {
-                                        match op {
-                                            Operand::Dimension(_) => None,
-                                            Operand::Value(v) => {
-                                                Some(
-                                                    view! {
-                                                        <div class="stat-value text-base">{v.html_display()}</div>
-                                                    },
-                                                )
-                                            }
+                                    .map(|c| {
+                                        view! {
+                                            <div class="stat-value text-base">{c.html_display()}</div>
                                         }
                                     })
                                     .collect_view();
diff --git a/crates/frontend/src/logic.rs b/crates/frontend/src/logic.rs
index 857b6833..891e7c8c 100644
--- a/crates/frontend/src/logic.rs
+++ b/crates/frontend/src/logic.rs
@@ -355,4 +355,3 @@ impl TryFrom<&Context> for Conditions {
         Self::from_context_json(&context.condition.as_ref())
     }
 }
-
diff --git a/crates/frontend/src/pages/context_override.rs b/crates/frontend/src/pages/context_override.rs
index 5499a8cd..e9b9d576 100644
--- a/crates/frontend/src/pages/context_override.rs
+++ b/crates/frontend/src/pages/context_override.rs
@@ -15,7 +15,7 @@ use crate::components::delete_modal::DeleteModal;
 use crate::components::drawer::{close_drawer, open_drawer, Drawer, DrawerBtn};
 use crate::components::override_form::OverrideForm;
 use crate::components::skeleton::{Skeleton, SkeletonVariant};
-use crate::logic::{Condition, Conditions, Operator};
+use crate::logic::{Conditions, Expression};
 use crate::providers::alert_provider::enqueue_alert;
 use crate::providers::condition_collapse_provider::ConditionCollapseProvider;
 use crate::providers::editor_provider::EditorProvider;
@@ -178,17 +178,9 @@ pub fn context_override() -> impl IntoView {
                 return;
             }
 
-            let condition = Condition::try_from((
-                Operator::Is,
-                dim.dimension.clone(),
-                r#type.unwrap(),
-            ));
-            if let Err(_) = condition {
-                //TODO emit and alert and return
-                return;
-            }
+            let expression = Expression::is(dim.dimension.as_str(), r#type.unwrap());
 
-            default_ctx.push(condition.unwrap());
+            default_ctx.push(expression);
         }
 
         selected_context_ws.set(Some(Data {
diff --git a/crates/frontend/src/pages/experiment_list/utils.rs b/crates/frontend/src/pages/experiment_list/utils.rs
index 0f027295..5cfbca36 100644
--- a/crates/frontend/src/pages/experiment_list/utils.rs
+++ b/crates/frontend/src/pages/experiment_list/utils.rs
@@ -1,6 +1,5 @@
 use crate::{
     components::{
-        condition_pills::utils::extract_conditions,
         condition_pills::Condition as ConditionComponent,
         table::types::{Column, ColumnSortable},
     },
@@ -11,7 +10,7 @@ use core::time::Duration;
 use leptos::*;
 use leptos_router::A;
 use serde::{Deserialize, Serialize};
-use serde_json::{json, Map, Value};
+use serde_json::{Map, Value};
 use std::vec::Vec;
 use strum_macros::Display;
 use web_sys::MouseEvent;
diff --git a/crates/frontend/src/types.rs b/crates/frontend/src/types.rs
index 8616f890..e48f14c8 100644
--- a/crates/frontend/src/types.rs
+++ b/crates/frontend/src/types.rs
@@ -8,14 +8,11 @@ use chrono::{DateTime, NaiveDateTime, Utc};
 use derive_more::{Deref, DerefMut};
 use serde_json::{json, Map, Value};
 
+use crate::logic::Conditions;
 use crate::{
-    components::{
-        condition_pills::{types::Condition, utils::extract_conditions},
-        dropdown::utils::DropdownOption,
-    },
+    components::dropdown::utils::DropdownOption,
     pages::experiment_list::utils::ExperimentSortOn,
 };
-use crate::logic::Conditions;
 
 #[derive(Clone, Debug)]
 pub struct AppRoute {