diff --git a/datafusion-examples/examples/query_planning/expr_api.rs b/datafusion-examples/examples/query_planning/expr_api.rs
index 386273c72817b..94589a24706c1 100644
--- a/datafusion-examples/examples/query_planning/expr_api.rs
+++ b/datafusion-examples/examples/query_planning/expr_api.rs
@@ -175,9 +175,10 @@ fn simplify_demo() -> Result<()> {
     // the ExecutionProps carries information needed to simplify
     // expressions, such as the current time (to evaluate `now()`
     // correctly)
-    let context = SimplifyContext::default()
+    let context = SimplifyContext::builder()
         .with_schema(schema)
-        .with_current_time();
+        .with_current_time()
+        .build();
     let simplifier = ExprSimplifier::new(context);
 
     // And then call the simplify_expr function:
@@ -192,9 +193,10 @@ fn simplify_demo() -> Result<()> {
 
     // here are some other examples of what DataFusion is capable of
     let schema = Schema::new(vec![make_field("i", DataType::Int64)]).to_dfschema_ref()?;
-    let context = SimplifyContext::default()
+    let context = SimplifyContext::builder()
         .with_schema(Arc::clone(&schema))
-        .with_current_time();
+        .with_current_time()
+        .build();
     let simplifier = ExprSimplifier::new(context);
 
     // basic arithmetic simplification
@@ -554,9 +556,10 @@ fn type_coercion_demo() -> Result<()> {
     assert!(physical_expr.evaluate(&batch).is_ok());
 
     // 2. Type coercion with `ExprSimplifier::coerce`.
-    let context = SimplifyContext::default()
+    let context = SimplifyContext::builder()
         .with_schema(Arc::new(df_schema.clone()))
-        .with_current_time();
+        .with_current_time()
+        .build();
     let simplifier = ExprSimplifier::new(context);
     let coerced_expr = simplifier.coerce(expr.clone(), &df_schema)?;
     let physical_expr = datafusion::physical_expr::create_physical_expr(
diff --git a/datafusion/core/src/execution/context/mod.rs b/datafusion/core/src/execution/context/mod.rs
index 5dbae61fc534d..1731120558dfb 100644
--- a/datafusion/core/src/execution/context/mod.rs
+++ b/datafusion/core/src/execution/context/mod.rs
@@ -1488,12 +1488,13 @@ impl SessionContext {
         })?;
 
         let state = self.state.read();
-        let context = SimplifyContext::default()
+        let context = SimplifyContext::builder()
             .with_schema(Arc::clone(prepared.plan.schema()))
             .with_config_options(Arc::clone(state.config_options()))
             .with_query_execution_start_time(
                 state.execution_props().query_execution_start_time,
-            );
+            )
+            .build();
         let simplifier = ExprSimplifier::new(context);
 
         // Only allow literals as parameters for now.
diff --git a/datafusion/core/src/execution/session_state.rs b/datafusion/core/src/execution/session_state.rs
index 9560616c1b6da..347c8eb3d25a4 100644
--- a/datafusion/core/src/execution/session_state.rs
+++ b/datafusion/core/src/execution/session_state.rs
@@ -743,12 +743,13 @@ impl SessionState {
         df_schema: &DFSchema,
     ) -> datafusion_common::Result<Arc<dyn PhysicalExpr>> {
         let config_options = self.config_options();
-        let simplify_context = SimplifyContext::default()
+        let simplify_context = SimplifyContext::builder()
             .with_schema(Arc::new(df_schema.clone()))
             .with_config_options(Arc::clone(config_options))
             .with_query_execution_start_time(
                 self.execution_props().query_execution_start_time,
-            );
+            )
+            .build();
         let simplifier = ExprSimplifier::new(simplify_context);
         // apply type coercion here to ensure types match
         let mut expr = simplifier.coerce(expr, df_schema)?;
@@ -1835,11 +1836,12 @@ impl ContextProvider for SessionContextProvider<'_> {
             .get(name)
             .cloned()
             .ok_or_else(|| plan_datafusion_err!("table function '{name}' not found"))?;
-        let simplify_context = SimplifyContext::default()
+        let simplify_context = SimplifyContext::builder()
             .with_config_options(Arc::clone(self.state.config_options()))
             .with_query_execution_start_time(
                 self.state.execution_props().query_execution_start_time,
-            );
+            )
+            .build();
         let simplifier = ExprSimplifier::new(simplify_context);
         let schema = DFSchema::empty();
         let args = args
diff --git a/datafusion/core/src/test_util/parquet.rs b/datafusion/core/src/test_util/parquet.rs
index dba017f83ba1e..53084fd9a0df5 100644
--- a/datafusion/core/src/test_util/parquet.rs
+++ b/datafusion/core/src/test_util/parquet.rs
@@ -166,7 +166,9 @@ impl TestParquetFile {
         let df_schema = Arc::clone(&self.schema).to_dfschema_ref()?;
 
         // run coercion on the filters to coerce types etc.
-        let context = SimplifyContext::default().with_schema(Arc::clone(&df_schema));
+        let context = SimplifyContext::builder()
+            .with_schema(Arc::clone(&df_schema))
+            .build();
         if let Some(filter) = maybe_filter {
             let simplifier = ExprSimplifier::new(context);
             let filter = simplifier.coerce(filter, &df_schema).unwrap();
diff --git a/datafusion/core/tests/expr_api/mod.rs b/datafusion/core/tests/expr_api/mod.rs
index 91dd5de7fcd64..8726c5aec9057 100644
--- a/datafusion/core/tests/expr_api/mod.rs
+++ b/datafusion/core/tests/expr_api/mod.rs
@@ -421,7 +421,9 @@ fn create_simplified_expr_test(expr: Expr, expected_expr: &str) {
     let df_schema = DFSchema::try_from(batch.schema()).unwrap();
 
     // Simplify the expression first
-    let simplify_context = SimplifyContext::default().with_schema(Arc::new(df_schema));
+    let simplify_context = SimplifyContext::builder()
+        .with_schema(Arc::new(df_schema))
+        .build();
     let simplifier = ExprSimplifier::new(simplify_context).with_max_cycles(10);
     let simplified = simplifier.simplify(expr).unwrap();
     create_expr_test(simplified, expected_expr);
diff --git a/datafusion/core/tests/expr_api/simplification.rs b/datafusion/core/tests/expr_api/simplification.rs
index 02f2503faf22a..245aba66849ce 100644
--- a/datafusion/core/tests/expr_api/simplification.rs
+++ b/datafusion/core/tests/expr_api/simplification.rs
@@ -88,9 +88,10 @@ fn test_evaluate_with_start_time(
     expected_expr: Expr,
     date_time: &DateTime<Utc>,
 ) {
-    let context = SimplifyContext::default()
+    let context = SimplifyContext::builder()
         .with_schema(schema())
-        .with_query_execution_start_time(Some(*date_time));
+        .with_query_execution_start_time(Some(*date_time))
+        .build();
     let simplifier = ExprSimplifier::new(context);
     let simplified_expr = simplifier
         .simplify(input_expr.clone())
@@ -153,9 +154,10 @@ fn to_timestamp_expr(arg: impl Into<String>) -> Expr {
 
 #[test]
 fn basic() {
-    let context = SimplifyContext::default()
+    let context = SimplifyContext::builder()
         .with_schema(schema())
-        .with_query_execution_start_time(Some(Utc::now()));
+        .with_query_execution_start_time(Some(Utc::now()))
+        .build();
 
     // The `Expr` is a core concept in DataFusion, and DataFusion can
     // help simplify it.
@@ -171,7 +173,7 @@ fn basic() {
 
 #[test]
 fn fold_and_simplify() {
-    let context = SimplifyContext::default().with_schema(schema());
+    let context = SimplifyContext::builder().with_schema(schema()).build();
 
     // What will it do with the expression `concat('foo', 'bar') == 'foobar')`?
     let expr = concat(vec![lit("foo"), lit("bar")]).eq(lit("foobar"));
@@ -565,7 +567,9 @@ fn expr_test_schema() -> DFSchemaRef {
 }
 
 fn test_simplify(input_expr: Expr, expected_expr: Expr) {
-    let context = SimplifyContext::default().with_schema(expr_test_schema());
+    let context = SimplifyContext::builder()
+        .with_schema(expr_test_schema())
+        .build();
     let simplifier = ExprSimplifier::new(context);
     let simplified_expr = simplifier
         .simplify(input_expr.clone())
@@ -581,9 +585,10 @@ fn test_simplify_with_cycle_count(
     expected_expr: Expr,
     expected_count: u32,
 ) {
-    let context = SimplifyContext::default()
+    let context = SimplifyContext::builder()
         .with_schema(expr_test_schema())
-        .with_query_execution_start_time(Some(Utc::now()));
+        .with_query_execution_start_time(Some(Utc::now()))
+        .build();
     let simplifier = ExprSimplifier::new(context);
     let (simplified_expr, count) = simplifier
         .simplify_with_cycle_count_transformed(input_expr.clone())
diff --git a/datafusion/expr/src/simplify.rs b/datafusion/expr/src/simplify.rs
index 8c68067a55a37..522cf122a273c 100644
--- a/datafusion/expr/src/simplify.rs
+++ b/datafusion/expr/src/simplify.rs
@@ -40,6 +40,14 @@ pub struct SimplifyContext {
     config_options: Arc<ConfigOptions>,
 }
 
+/// Builder for [`SimplifyContext`].
+#[derive(Debug, Default)]
+pub struct SimplifyContextBuilder {
+    schema: Option<DFSchemaRef>,
+    query_execution_start_time: Option<DateTime<Utc>>,
+    config_options: Option<Arc<ConfigOptions>>,
+}
+
 impl Default for SimplifyContext {
     fn default() -> Self {
         Self {
@@ -51,18 +59,35 @@ impl Default for SimplifyContext {
 }
 
 impl SimplifyContext {
+    /// Returns a builder for [`SimplifyContext`].
+    pub fn builder() -> SimplifyContextBuilder {
+        SimplifyContextBuilder::default()
+    }
+
+    #[deprecated(
+        since = "54.0.0",
+        note = "Use SimplifyContextBuilder if you intend to use non-default values."
+    )]
     /// Set the [`ConfigOptions`] for this context
     pub fn with_config_options(mut self, config_options: Arc<ConfigOptions>) -> Self {
         self.config_options = config_options;
         self
     }
 
+    #[deprecated(
+        since = "54.0.0",
+        note = "Use SimplifyContextBuilder if you intend to use non-default values."
+    )]
     /// Set the schema for this context
     pub fn with_schema(mut self, schema: DFSchemaRef) -> Self {
         self.schema = schema;
         self
     }
 
+    #[deprecated(
+        since = "54.0.0",
+        note = "Use SimplifyContextBuilder if you intend to use non-default values."
+    )]
     /// Set the query execution start time
     pub fn with_query_execution_start_time(
         mut self,
@@ -72,6 +97,10 @@ impl SimplifyContext {
         self
     }
 
+    #[deprecated(
+        since = "54.0.0",
+        note = "Use SimplifyContextBuilder if you intend to use non-default values."
+    )]
     /// Set the query execution start to the current time
     pub fn with_current_time(mut self) -> Self {
         self.query_execution_start_time = Some(Utc::now());
@@ -110,6 +139,46 @@ impl SimplifyContext {
     }
 }
 
+impl SimplifyContextBuilder {
+    /// Set the [`ConfigOptions`] for this context.
+    pub fn with_config_options(mut self, config_options: Arc<ConfigOptions>) -> Self {
+        self.config_options = Some(config_options);
+        self
+    }
+
+    /// Set the schema for this context.
+    pub fn with_schema(mut self, schema: DFSchemaRef) -> Self {
+        self.schema = Some(schema);
+        self
+    }
+
+    /// Set the query execution start time.
+    pub fn with_query_execution_start_time(
+        mut self,
+        query_execution_start_time: Option<DateTime<Utc>>,
+    ) -> Self {
+        self.query_execution_start_time = query_execution_start_time;
+        self
+    }
+
+    /// Set the query execution start to the current time.
+    pub fn with_current_time(mut self) -> Self {
+        self.query_execution_start_time = Some(Utc::now());
+        self
+    }
+
+    /// Build a [`SimplifyContext`], filling in any unspecified fields with defaults.
+    pub fn build(self) -> SimplifyContext {
+        SimplifyContext {
+            schema: self.schema.unwrap_or_else(|| Arc::new(DFSchema::empty())),
+            query_execution_start_time: self.query_execution_start_time,
+            config_options: self
+                .config_options
+                .unwrap_or_else(|| Arc::new(ConfigOptions::default())),
+        }
+    }
+}
+
 /// Was the expression simplified?
 #[derive(Debug)]
 pub enum ExprSimplifyResult {
@@ -119,3 +188,38 @@ pub enum ExprSimplifyResult {
     /// are return unmodified.
     Original(Vec<Expr>),
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn simplify_context_builder_builds_default_context() {
+        let context = SimplifyContext::builder().build();
+        let default_options = ConfigOptions::default();
+
+        assert_eq!(context.schema().as_ref(), &DFSchema::empty());
+        assert_eq!(context.query_execution_start_time(), None);
+        assert_eq!(
+            context.config_options().optimizer.max_passes,
+            default_options.optimizer.max_passes
+        );
+    }
+
+    #[test]
+    fn simplify_context_builder_uses_overrides() {
+        let schema = Arc::new(DFSchema::empty());
+        let config_options = Arc::new(ConfigOptions::default());
+        let current_time = Utc::now();
+
+        let context = SimplifyContext::builder()
+            .with_schema(Arc::clone(&schema))
+            .with_config_options(Arc::clone(&config_options))
+            .with_query_execution_start_time(Some(current_time))
+            .build();
+
+        assert_eq!(context.schema().as_ref(), schema.as_ref());
+        assert_eq!(context.query_execution_start_time(), Some(current_time));
+        assert!(Arc::ptr_eq(context.config_options(), &config_options));
+    }
+}
diff --git a/datafusion/functions-nested/src/array_has.rs b/datafusion/functions-nested/src/array_has.rs
index 03ba0adde0aec..872cdc7300cbd 100644
--- a/datafusion/functions-nested/src/array_has.rs
+++ b/datafusion/functions-nested/src/array_has.rs
@@ -999,6 +999,7 @@ mod tests {
         DataFusionError, ScalarValue, config::ConfigOptions,
         utils::SingleRowListArrayBuilder,
     };
+    use datafusion_expr::simplify::SimplifyContext;
     use datafusion_expr::{
         ColumnarValue, Expr, ScalarFunctionArgs, ScalarUDFImpl, col, lit,
         simplify::ExprSimplifyResult,
@@ -1017,7 +1018,7 @@ mod tests {
         .build_list_scalar());
         let needle = col("c");
 
-        let context = datafusion_expr::simplify::SimplifyContext::default();
+        let context = SimplifyContext::default();
 
         let Ok(ExprSimplifyResult::Simplified(Expr::InList(in_list))) =
             ArrayHas::new().simplify(vec![haystack, needle.clone()], &context)
@@ -1040,7 +1041,7 @@ mod tests {
         let haystack = make_array(vec![lit(1), lit(2), lit(3)]);
         let needle = col("c");
 
-        let context = datafusion_expr::simplify::SimplifyContext::default();
+        let context = SimplifyContext::default();
 
         let Ok(ExprSimplifyResult::Simplified(Expr::InList(in_list))) =
             ArrayHas::new().simplify(vec![haystack, needle.clone()], &context)
@@ -1063,7 +1064,7 @@ mod tests {
         let haystack = Expr::Literal(ScalarValue::Null, None);
         let needle = col("c");
 
-        let context = datafusion_expr::simplify::SimplifyContext::default();
+        let context = SimplifyContext::default();
         let Ok(ExprSimplifyResult::Simplified(simplified)) =
             ArrayHas::new().simplify(vec![haystack, needle], &context)
         else {
@@ -1080,7 +1081,7 @@ mod tests {
         let haystack = Expr::Literal(ScalarValue::List(Arc::new(haystack)), None);
         let needle = col("c");
 
-        let context = datafusion_expr::simplify::SimplifyContext::default();
+        let context = SimplifyContext::default();
         let Ok(ExprSimplifyResult::Simplified(simplified)) =
             ArrayHas::new().simplify(vec![haystack, needle], &context)
         else {
@@ -1095,7 +1096,7 @@ mod tests {
         let haystack = col("c1");
         let needle = col("c2");
 
-        let context = datafusion_expr::simplify::SimplifyContext::default();
+        let context = SimplifyContext::default();
 
         let Ok(ExprSimplifyResult::Original(args)) =
             ArrayHas::new().simplify(vec![haystack, needle.clone()], &context)
diff --git a/datafusion/functions/src/datetime/current_time.rs b/datafusion/functions/src/datetime/current_time.rs
index 9b3e21d5d6a34..9f1e3ead01683 100644
--- a/datafusion/functions/src/datetime/current_time.rs
+++ b/datafusion/functions/src/datetime/current_time.rs
@@ -151,10 +151,11 @@ mod tests {
             Some(tz.to_string())
         };
         let schema = Arc::new(DFSchema::empty());
-        SimplifyContext::default()
+        SimplifyContext::builder()
             .with_schema(schema)
             .with_config_options(Arc::new(config))
             .with_query_execution_start_time(Some(start_time))
+            .build()
     }
 
     #[test]
diff --git a/datafusion/optimizer/src/decorrelate.rs b/datafusion/optimizer/src/decorrelate.rs
index 52d777f874fa8..e7bc62e8da097 100644
--- a/datafusion/optimizer/src/decorrelate.rs
+++ b/datafusion/optimizer/src/decorrelate.rs
@@ -508,7 +508,9 @@ fn agg_exprs_evaluation_result_on_empty_batch(
             .data()?;
 
         let result_expr = result_expr.unalias();
-        let info = SimplifyContext::default().with_schema(Arc::clone(schema));
+        let info = SimplifyContext::builder()
+            .with_schema(Arc::clone(schema))
+            .build();
         let simplifier = ExprSimplifier::new(info);
         let result_expr = simplifier.simplify(result_expr)?;
         expr_result_map_for_count_bug.insert(e.schema_name().to_string(), result_expr);
@@ -541,7 +543,9 @@ fn proj_exprs_evaluation_result_on_empty_batch(
             .data()?;
 
         if result_expr.ne(expr) {
-            let info = SimplifyContext::default().with_schema(Arc::clone(schema));
+            let info = SimplifyContext::builder()
+                .with_schema(Arc::clone(schema))
+                .build();
             let simplifier = ExprSimplifier::new(info);
             let result_expr = simplifier.simplify(result_expr)?;
             let expr_name = match expr {
@@ -581,7 +585,7 @@ fn filter_exprs_evaluation_result_on_empty_batch(
         .data()?;
 
     let pull_up_expr = if result_expr.ne(filter_expr) {
-        let info = SimplifyContext::default().with_schema(schema);
+        let info = SimplifyContext::builder().with_schema(schema).build();
         let simplifier = ExprSimplifier::new(info);
         let result_expr = simplifier.simplify(result_expr)?;
         match &result_expr {
diff --git a/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs b/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs
index a26ed4a85afd2..12449ed2f4d55 100644
--- a/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs
+++ b/datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs
@@ -87,7 +87,7 @@ use regex::Regex;
 ///     .unwrap();
 ///
 /// // Create the simplifier
-/// let context = SimplifyContext::default().with_schema(schema);
+/// let context = SimplifyContext::builder().with_schema(schema).build();
 /// let simplifier = ExprSimplifier::new(context);
 ///
 /// // Use the simplifier
@@ -157,7 +157,7 @@ impl ExprSimplifier {
     ///     .to_dfschema_ref()
     ///     .unwrap();
     /// // Create the simplifier
-    /// let context = SimplifyContext::default().with_schema(schema);
+    /// let context = SimplifyContext::builder().with_schema(schema).build();
     /// let simplifier = ExprSimplifier::new(context);
     ///
     /// // b < 2
@@ -285,7 +285,7 @@ impl ExprSimplifier {
     /// .unwrap();
     ///
     /// // Create the simplifier
-    /// let context = SimplifyContext::default().with_schema(schema);
+    /// let context = SimplifyContext::builder().with_schema(schema).build();
     ///
     /// // Expression: (x >= 3) AND (y + 2 < 10) AND (z > 5)
     /// let expr_x = col("x").gt_eq(lit(3_i64));
@@ -345,7 +345,7 @@ impl ExprSimplifier {
     /// .unwrap();
     ///
     /// // Create the simplifier
-    /// let context = SimplifyContext::default().with_schema(schema);
+    /// let context = SimplifyContext::builder().with_schema(schema).build();
     /// let simplifier = ExprSimplifier::new(context);
     ///
     /// // Expression: a = c AND 1 = b
@@ -399,7 +399,7 @@ impl ExprSimplifier {
     ///   .to_dfschema_ref().unwrap();
     ///
     /// // Create the simplifier
-    /// let context = SimplifyContext::default().with_schema(schema);
+    /// let context = SimplifyContext::builder().with_schema(schema).build();
     /// let simplifier = ExprSimplifier::new(context);
     ///
     /// // Expression: a IS NOT NULL
@@ -2380,8 +2380,11 @@ mod tests {
     // ------------------------------
     #[test]
     fn api_basic() {
-        let simplifier =
-            ExprSimplifier::new(SimplifyContext::default().with_schema(test_schema()));
+        let simplifier = ExprSimplifier::new(
+            SimplifyContext::builder()
+                .with_schema(test_schema())
+                .build(),
+        );
 
         let expr = lit(1) + lit(2);
         let expected = lit(3);
@@ -2392,7 +2395,9 @@ mod tests {
     fn basic_coercion() {
         let schema = test_schema();
         let simplifier = ExprSimplifier::new(
-            SimplifyContext::default().with_schema(Arc::clone(&schema)),
+            SimplifyContext::builder()
+                .with_schema(Arc::clone(&schema))
+                .build(),
         );
 
         // Note expr type is int32 (not int64)
@@ -2420,8 +2425,11 @@ mod tests {
 
     #[test]
     fn simplify_and_constant_prop() {
-        let simplifier =
-            ExprSimplifier::new(SimplifyContext::default().with_schema(test_schema()));
+        let simplifier = ExprSimplifier::new(
+            SimplifyContext::builder()
+                .with_schema(test_schema())
+                .build(),
+        );
 
         // should be able to simplify to false
         // (i * (1 - 2)) > 0
@@ -2432,8 +2440,11 @@ mod tests {
 
     #[test]
     fn simplify_and_constant_prop_with_case() {
-        let simplifier =
-            ExprSimplifier::new(SimplifyContext::default().with_schema(test_schema()));
+        let simplifier = ExprSimplifier::new(
+            SimplifyContext::builder()
+                .with_schema(test_schema())
+                .build(),
+        );
 
         //   CASE
         //     WHEN i>5 AND false THEN i > 5
@@ -3569,14 +3580,16 @@ mod tests {
     fn try_simplify(expr: Expr) -> Result<Expr> {
         let schema = expr_test_schema();
         let simplifier =
-            ExprSimplifier::new(SimplifyContext::default().with_schema(schema));
+            ExprSimplifier::new(SimplifyContext::builder().with_schema(schema).build());
         simplifier.simplify(expr)
     }
 
     fn coerce(expr: Expr) -> Expr {
         let schema = expr_test_schema();
         let simplifier = ExprSimplifier::new(
-            SimplifyContext::default().with_schema(Arc::clone(&schema)),
+            SimplifyContext::builder()
+                .with_schema(Arc::clone(&schema))
+                .build(),
         );
         simplifier.coerce(expr, schema.as_ref()).unwrap()
     }
@@ -3588,7 +3601,7 @@ mod tests {
     fn try_simplify_with_cycle_count(expr: Expr) -> Result<(Expr, u32)> {
         let schema = expr_test_schema();
         let simplifier =
-            ExprSimplifier::new(SimplifyContext::default().with_schema(schema));
+            ExprSimplifier::new(SimplifyContext::builder().with_schema(schema).build());
         let (expr, count) = simplifier.simplify_with_cycle_count_transformed(expr)?;
         Ok((expr.data, count))
     }
@@ -3603,7 +3616,7 @@ mod tests {
     ) -> Expr {
         let schema = expr_test_schema();
         let simplifier =
-            ExprSimplifier::new(SimplifyContext::default().with_schema(schema))
+            ExprSimplifier::new(SimplifyContext::builder().with_schema(schema).build())
                 .with_guarantees(guarantees);
         simplifier.simplify(expr).unwrap()
     }
@@ -4506,7 +4519,7 @@ mod tests {
     fn just_simplifier_simplify_null_in_empty_inlist() {
         let simplify = |expr: Expr| -> Expr {
             let schema = expr_test_schema();
-            let info = SimplifyContext::default().with_schema(schema);
+            let info = SimplifyContext::builder().with_schema(schema).build();
             let simplifier = &mut Simplifier::new(&info);
             expr.rewrite(simplifier)
                 .expect("Failed to simplify expression")
@@ -4874,7 +4887,7 @@ mod tests {
     fn simplify_common_factor_conjunction_in_disjunction() {
         let schema = boolean_test_schema();
         let simplifier =
-            ExprSimplifier::new(SimplifyContext::default().with_schema(schema));
+            ExprSimplifier::new(SimplifyContext::builder().with_schema(schema).build());
 
         let a = || col("A");
         let b = || col("B");
@@ -5205,7 +5218,7 @@ mod tests {
         // The simplification should now fail with an error at plan time
         let schema = test_schema();
         let simplifier =
-            ExprSimplifier::new(SimplifyContext::default().with_schema(schema));
+            ExprSimplifier::new(SimplifyContext::builder().with_schema(schema).build());
         let result = simplifier.simplify(expr);
         assert!(result.is_err(), "Expected error for invalid cast");
         let err_msg = result.unwrap_err().to_string();
@@ -5260,8 +5273,11 @@ mod tests {
 
         let expr = make_struct_cast_expr(source_fields, target_fields);
 
-        let simplifier =
-            ExprSimplifier::new(SimplifyContext::default().with_schema(test_schema()));
+        let simplifier = ExprSimplifier::new(
+            SimplifyContext::builder()
+                .with_schema(test_schema())
+                .build(),
+        );
 
         // The cast should remain unchanged since field counts differ
         let result = simplifier.simplify(expr.clone()).unwrap();
@@ -5288,8 +5304,11 @@ mod tests {
 
         let expr = make_struct_cast_expr(source_fields, target_fields);
 
-        let simplifier =
-            ExprSimplifier::new(SimplifyContext::default().with_schema(test_schema()));
+        let simplifier = ExprSimplifier::new(
+            SimplifyContext::builder()
+                .with_schema(test_schema())
+                .build(),
+        );
 
         // The cast should be simplified
         let result = simplifier.simplify(expr.clone()).unwrap();
@@ -5319,8 +5338,11 @@ mod tests {
 
         let expr = make_struct_cast_expr(source_fields, target_fields);
 
-        let simplifier =
-            ExprSimplifier::new(SimplifyContext::default().with_schema(test_schema()));
+        let simplifier = ExprSimplifier::new(
+            SimplifyContext::builder()
+                .with_schema(test_schema())
+                .build(),
+        );
 
         // The cast should remain unchanged because there is no name overlap
         let result = simplifier.simplify(expr.clone()).unwrap();
@@ -5361,8 +5383,11 @@ mod tests {
             DataType::Struct(target_fields),
         ));
 
-        let simplifier =
-            ExprSimplifier::new(SimplifyContext::default().with_schema(test_schema()));
+        let simplifier = ExprSimplifier::new(
+            SimplifyContext::builder()
+                .with_schema(test_schema())
+                .build(),
+        );
 
         // The cast should remain unchanged since the struct array is empty (0-row)
         let result = simplifier.simplify(expr.clone()).unwrap();
diff --git a/datafusion/optimizer/src/simplify_expressions/simplify_exprs.rs b/datafusion/optimizer/src/simplify_expressions/simplify_exprs.rs
index 29ee59342273e..3e495f5355103 100644
--- a/datafusion/optimizer/src/simplify_expressions/simplify_exprs.rs
+++ b/datafusion/optimizer/src/simplify_expressions/simplify_exprs.rs
@@ -98,10 +98,11 @@ impl SimplifyExpressions {
             Arc::new(DFSchema::empty())
         };
 
-        let info = SimplifyContext::default()
+        let info = SimplifyContext::builder()
             .with_schema(schema)
             .with_config_options(config.options())
-            .with_query_execution_start_time(config.query_execution_start_time());
+            .with_query_execution_start_time(config.query_execution_start_time())
+            .build();
 
         // Inputs have already been rewritten (due to bottom-up traversal handled by Optimizer)
         // Just need to rewrite our own expressions
diff --git a/datafusion/optimizer/src/simplify_expressions/simplify_literal.rs b/datafusion/optimizer/src/simplify_expressions/simplify_literal.rs
index b77240fc5343a..72e9dbc99dfae 100644
--- a/datafusion/optimizer/src/simplify_expressions/simplify_literal.rs
+++ b/datafusion/optimizer/src/simplify_expressions/simplify_literal.rs
@@ -51,8 +51,11 @@ where
 
     log::debug!("Parsing expr {:?} to type {}", expr, T::DATA_TYPE);
 
-    let simplifier =
-        ExprSimplifier::new(SimplifyContext::default().with_schema(Arc::clone(&schema)));
+    let simplifier = ExprSimplifier::new(
+        SimplifyContext::builder()
+            .with_schema(Arc::clone(&schema))
+            .build(),
+    );
 
     // Simplify and coerce expression in case of constant arithmetic operations (e.g., 10 + 5)
     let simplified_expr: Expr = simplifier
diff --git a/datafusion/optimizer/src/simplify_expressions/udf_preimage.rs b/datafusion/optimizer/src/simplify_expressions/udf_preimage.rs
index da2716d13cb47..644d9712346d2 100644
--- a/datafusion/optimizer/src/simplify_expressions/udf_preimage.rs
+++ b/datafusion/optimizer/src/simplify_expressions/udf_preimage.rs
@@ -179,7 +179,9 @@ mod test {
     }
 
     fn optimize_test(expr: Expr, schema: &DFSchemaRef) -> Expr {
-        let simplify_context = SimplifyContext::default().with_schema(Arc::clone(schema));
+        let simplify_context = SimplifyContext::builder()
+            .with_schema(Arc::clone(schema))
+            .build();
         ExprSimplifier::new(simplify_context)
             .simplify(expr)
             .unwrap()
diff --git a/datafusion/optimizer/src/simplify_expressions/unwrap_cast.rs b/datafusion/optimizer/src/simplify_expressions/unwrap_cast.rs
index acf0f32ab2234..a5b65d0d8e7a4 100644
--- a/datafusion/optimizer/src/simplify_expressions/unwrap_cast.rs
+++ b/datafusion/optimizer/src/simplify_expressions/unwrap_cast.rs
@@ -588,7 +588,9 @@ mod tests {
 
     fn optimize_test(expr: Expr, schema: &DFSchemaRef) -> Expr {
         let simplifier = ExprSimplifier::new(
-            SimplifyContext::default().with_schema(Arc::clone(schema)),
+            SimplifyContext::builder()
+                .with_schema(Arc::clone(schema))
+                .build(),
         );
 
         simplifier.simplify(expr).unwrap()