diff --git a/compactor/src/components/namespaces_source/mock.rs b/compactor/src/components/namespaces_source/mock.rs
index 9a8f412528..acce99f164 100644
--- a/compactor/src/components/namespaces_source/mock.rs
+++ b/compactor/src/components/namespaces_source/mock.rs
@@ -49,7 +49,10 @@ impl NamespacesSource for MockNamespacesSource {
 mod tests {
     use std::collections::BTreeMap;
 
-    use data_types::{Column, ColumnId, ColumnType, ColumnsByName, TableId, TableSchema};
+    use data_types::{
+        Column, ColumnId, ColumnType, ColumnsByName, MaxColumnsPerTable, MaxTables, TableId,
+        TableSchema,
+    };
 
     use super::*;
 
@@ -182,8 +185,8 @@ mod tests {
                     ns: Namespace {
                         id,
                         name: "ns".to_string(),
-                        max_tables: 10,
-                        max_columns_per_table: 10,
+                        max_tables: MaxTables::new(10),
+                        max_columns_per_table: MaxColumnsPerTable::new(10),
                         retention_period_ns: None,
                         deleted_at: None,
                         partition_template: Default::default(),
@@ -191,8 +194,8 @@ mod tests {
                     schema: NamespaceSchema {
                         id,
                         tables,
-                        max_columns_per_table: 10,
-                        max_tables: 42,
+                        max_columns_per_table: MaxColumnsPerTable::new(10),
+                        max_tables: MaxTables::new(42),
                         retention_period_ns: None,
                         partition_template: Default::default(),
                     },
diff --git a/data_types/src/lib.rs b/data_types/src/lib.rs
index 83e67d5fb3..f441e48be1 100644
--- a/data_types/src/lib.rs
+++ b/data_types/src/lib.rs
@@ -273,6 +273,50 @@ impl std::fmt::Display for ParquetFileId {
     }
 }
 
+/// Max tables allowed in a namespace.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, sqlx::Type)]
+#[sqlx(transparent)]
+pub struct MaxTables(i32);
+
+#[allow(missing_docs)]
+impl MaxTables {
+    pub const fn new(v: i32) -> Self {
+        Self(v)
+    }
+
+    pub fn get(&self) -> i32 {
+        self.0
+    }
+}
+
+impl std::fmt::Display for MaxTables {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+/// Max columns per table allowed in a namespace.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, sqlx::Type)]
+#[sqlx(transparent)]
+pub struct MaxColumnsPerTable(i32);
+
+#[allow(missing_docs)]
+impl MaxColumnsPerTable {
+    pub const fn new(v: i32) -> Self {
+        Self(v)
+    }
+
+    pub fn get(&self) -> i32 {
+        self.0
+    }
+}
+
+impl std::fmt::Display for MaxColumnsPerTable {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 /// Data object for a namespace
 #[derive(Debug, Clone, PartialEq, sqlx::FromRow)]
 pub struct Namespace {
@@ -283,9 +327,9 @@ pub struct Namespace {
     /// The retention period in ns. None represents infinite duration (i.e. never drop data).
     pub retention_period_ns: Option<i64>,
     /// The maximum number of tables that can exist in this namespace
-    pub max_tables: i32,
+    pub max_tables: MaxTables,
     /// The maximum number of columns per table in this namespace
-    pub max_columns_per_table: i32,
+    pub max_columns_per_table: MaxColumnsPerTable,
     /// When this file was marked for deletion.
     pub deleted_at: Option<Timestamp>,
     /// The partition template to use for new tables in this namespace either created implicitly or
@@ -326,9 +370,9 @@ pub struct NamespaceSchema {
     /// the tables in the namespace by name
     pub tables: BTreeMap<String, TableSchema>,
     /// the number of columns per table this namespace allows
-    pub max_columns_per_table: usize,
+    pub max_columns_per_table: MaxColumnsPerTable,
     /// The maximum number of tables permitted in this namespace.
-    pub max_tables: usize,
+    pub max_tables: MaxTables,
     /// The retention period in ns.
     /// None represents infinite duration (i.e. never drop data).
     pub retention_period_ns: Option<i64>,
@@ -353,8 +397,8 @@ impl NamespaceSchema {
         Self {
             id,
             tables: BTreeMap::new(),
-            max_columns_per_table: max_columns_per_table as usize,
-            max_tables: max_tables as usize,
+            max_columns_per_table,
+            max_tables,
             retention_period_ns,
             partition_template: partition_template.clone(),
         }
@@ -2670,8 +2714,8 @@ mod tests {
         let schema1 = NamespaceSchema {
             id: NamespaceId::new(1),
             tables: BTreeMap::from([]),
-            max_columns_per_table: 4,
-            max_tables: 42,
+            max_columns_per_table: MaxColumnsPerTable::new(4),
+            max_tables: MaxTables::new(42),
             retention_period_ns: None,
             partition_template: Default::default(),
         };
@@ -2685,8 +2729,8 @@ mod tests {
                     partition_template: Default::default(),
                 },
             )]),
-            max_columns_per_table: 4,
-            max_tables: 42,
+            max_columns_per_table: MaxColumnsPerTable::new(4),
+            max_tables: MaxTables::new(42),
             retention_period_ns: None,
             partition_template: Default::default(),
         };
diff --git a/ingester_test_ctx/src/lib.rs b/ingester_test_ctx/src/lib.rs
index 57cba40b4b..557be032e8 100644
--- a/ingester_test_ctx/src/lib.rs
+++ b/ingester_test_ctx/src/lib.rs
@@ -23,7 +23,8 @@ use arrow::record_batch::RecordBatch;
 use arrow_flight::{decode::FlightRecordBatchStream, flight_service_server::FlightService, Ticket};
 use data_types::{
     partition_template::{NamespacePartitionTemplateOverride, TablePartitionTemplateOverride},
-    Namespace, NamespaceId, NamespaceSchema, ParquetFile, PartitionKey, SequenceNumber, TableId,
+    MaxColumnsPerTable, MaxTables, Namespace, NamespaceId, NamespaceSchema, ParquetFile,
+    PartitionKey, SequenceNumber, TableId,
 };
 use dml::{DmlMeta, DmlWrite};
 use futures::{stream::FuturesUnordered, FutureExt, StreamExt, TryStreamExt};
@@ -236,8 +237,10 @@ where
                     NamespaceSchema {
                         id: ns.id,
                         tables: Default::default(),
-                        max_columns_per_table: iox_catalog::DEFAULT_MAX_COLUMNS_PER_TABLE as usize,
-                        max_tables: iox_catalog::DEFAULT_MAX_TABLES as usize,
+                        max_columns_per_table: MaxColumnsPerTable::new(
+                            iox_catalog::DEFAULT_MAX_COLUMNS_PER_TABLE
+                        ),
+                        max_tables: MaxTables::new(iox_catalog::DEFAULT_MAX_TABLES),
                         retention_period_ns,
                         partition_template: partition_template.unwrap_or_default(),
                     },
diff --git a/iox_catalog/src/interface.rs b/iox_catalog/src/interface.rs
index 8c81d2922f..dfe8c2c4a6 100644
--- a/iox_catalog/src/interface.rs
+++ b/iox_catalog/src/interface.rs
@@ -843,9 +843,9 @@ pub(crate) mod test_helpers {
         assert_eq!(namespace, lookup_namespace);
 
         // Assert default values for service protection limits.
-        assert_eq!(namespace.max_tables, DEFAULT_MAX_TABLES);
+        assert_eq!(namespace.max_tables.get(), DEFAULT_MAX_TABLES);
         assert_eq!(
-            namespace.max_columns_per_table,
+            namespace.max_columns_per_table.get(),
             DEFAULT_MAX_COLUMNS_PER_TABLE
         );
 
@@ -903,7 +903,7 @@ pub(crate) mod test_helpers {
             .update_table_limit(namespace_name.as_str(), NEW_TABLE_LIMIT)
             .await
             .expect("namespace should be updateable");
-        assert_eq!(NEW_TABLE_LIMIT, modified.max_tables);
+        assert_eq!(NEW_TABLE_LIMIT, modified.max_tables.get());
 
         const NEW_COLUMN_LIMIT: i32 = 1500;
         let modified = repos
@@ -911,7 +911,7 @@ pub(crate) mod test_helpers {
             .update_column_limit(namespace_name.as_str(), NEW_COLUMN_LIMIT)
             .await
             .expect("namespace should be updateable");
-        assert_eq!(NEW_COLUMN_LIMIT, modified.max_columns_per_table);
+        assert_eq!(NEW_COLUMN_LIMIT, modified.max_columns_per_table.get());
 
         const NEW_RETENTION_PERIOD_NS: i64 = 5 * 60 * 60 * 1000 * 1000 * 1000;
         let modified = repos
diff --git a/iox_catalog/src/mem.rs b/iox_catalog/src/mem.rs
index 37dde46210..7e87017cb0 100644
--- a/iox_catalog/src/mem.rs
+++ b/iox_catalog/src/mem.rs
@@ -17,10 +17,10 @@ use data_types::{
     partition_template::{
         NamespacePartitionTemplateOverride, TablePartitionTemplateOverride, TemplatePart,
     },
-    Column, ColumnId, ColumnType, CompactionLevel, Namespace, NamespaceId, NamespaceName,
-    NamespaceServiceProtectionLimitsOverride, ParquetFile, ParquetFileId, ParquetFileParams,
-    Partition, PartitionHashId, PartitionId, PartitionKey, SkippedCompaction, Table, TableId,
-    Timestamp, TransitionPartitionId,
+    Column, ColumnId, ColumnType, CompactionLevel, MaxColumnsPerTable, MaxTables, Namespace,
+    NamespaceId, NamespaceName, NamespaceServiceProtectionLimitsOverride, ParquetFile,
+    ParquetFileId, ParquetFileParams, Partition, PartitionHashId, PartitionId, PartitionKey,
+    SkippedCompaction, Table, TableId, Timestamp, TransitionPartitionId,
 };
 use iox_time::{SystemProvider, TimeProvider};
 use snafu::ensure;
@@ -166,8 +166,10 @@ impl NamespaceRepo for MemTxn {
         let namespace = Namespace {
             id: NamespaceId::new(stage.namespaces.len() as i64 + 1),
             name: name.to_string(),
-            max_tables: max_tables.unwrap_or(DEFAULT_MAX_TABLES),
-            max_columns_per_table: max_columns_per_table.unwrap_or(DEFAULT_MAX_COLUMNS_PER_TABLE),
+            max_tables: MaxTables::new(max_tables.unwrap_or(DEFAULT_MAX_TABLES)),
+            max_columns_per_table: MaxColumnsPerTable::new(
+                max_columns_per_table.unwrap_or(DEFAULT_MAX_COLUMNS_PER_TABLE),
+            ),
             retention_period_ns,
             deleted_at: None,
             partition_template: partition_template.unwrap_or_default(),
@@ -229,7 +231,7 @@ impl NamespaceRepo for MemTxn {
         let stage = self.stage();
         match stage.namespaces.iter_mut().find(|n| n.name == name) {
             Some(n) => {
-                n.max_tables = new_max;
+                n.max_tables = MaxTables::new(new_max);
                 Ok(n.clone())
             }
             None => Err(Error::NamespaceNotFoundByName {
@@ -242,7 +244,7 @@ impl NamespaceRepo for MemTxn {
         let stage = self.stage();
         match stage.namespaces.iter_mut().find(|n| n.name == name) {
             Some(n) => {
-                n.max_columns_per_table = new_max;
+                n.max_columns_per_table = MaxColumnsPerTable::new(new_max);
                 Ok(n.clone())
             }
             None => Err(Error::NamespaceNotFoundByName {
@@ -299,7 +301,7 @@ impl TableRepo for MemTxn {
                         .iter()
                         .filter(|t| t.namespace_id == namespace_id)
                         .count();
-                    if tables_count >= max_tables.try_into().unwrap() {
+                    if tables_count >= max_tables.get().try_into().unwrap() {
                         return Err(Error::TableCreateLimitError {
                             table_name: name.to_string(),
                             namespace_id,
@@ -423,7 +425,7 @@ impl ColumnRepo for MemTxn {
                             .iter()
                             .filter(|t| t.table_id == table_id)
                             .count();
-                        if columns_count >= max_columns_per_table.try_into().unwrap() {
+                        if columns_count >= max_columns_per_table.get().try_into().unwrap() {
                             return Err(Error::ColumnCreateLimitError {
                                 column_name: name.to_string(),
                                 table_id,
diff --git a/ioxd_querier/src/rpc/namespace.rs b/ioxd_querier/src/rpc/namespace.rs
index c63ca9a309..c6ed2479ba 100644
--- a/ioxd_querier/src/rpc/namespace.rs
+++ b/ioxd_querier/src/rpc/namespace.rs
@@ -36,8 +36,8 @@ fn namespace_to_proto(namespace: Namespace) -> proto::Namespace {
         id: namespace.id.get(),
         name: namespace.name,
         retention_period_ns: namespace.retention_period_ns,
-        max_tables: namespace.max_tables,
-        max_columns_per_table: namespace.max_columns_per_table,
+        max_tables: namespace.max_tables.get(),
+        max_columns_per_table: namespace.max_columns_per_table.get(),
         partition_template: namespace.partition_template.as_proto().cloned(),
     }
 }
diff --git a/router/benches/namespace_schema_cache.rs b/router/benches/namespace_schema_cache.rs
index f4be57c003..74138845e1 100644
--- a/router/benches/namespace_schema_cache.rs
+++ b/router/benches/namespace_schema_cache.rs
@@ -6,7 +6,8 @@ use criterion::{
 };
 use data_types::{
     partition_template::{NamespacePartitionTemplateOverride, TablePartitionTemplateOverride},
-    ColumnId, ColumnSchema, NamespaceId, NamespaceName, NamespaceSchema, TableId, TableSchema,
+    ColumnId, ColumnSchema, MaxColumnsPerTable, MaxTables, NamespaceId, NamespaceName,
+    NamespaceSchema, TableId, TableSchema,
 };
 use iox_catalog::{interface::Catalog, mem::MemCatalog};
 use once_cell::sync::Lazy;
@@ -155,8 +156,8 @@ fn generate_namespace_schema(tables: usize, columns_per_table: usize) -> Namespa
                 (format!("table{i}"), schema)
             })
             .collect::<BTreeMap<_, _>>(),
-        max_columns_per_table: usize::MAX,
-        max_tables: usize::MAX,
+        max_columns_per_table: MaxColumnsPerTable::new(i32::MAX),
+        max_tables: MaxTables::new(i32::MAX),
         retention_period_ns: None,
         partition_template,
     }
diff --git a/router/benches/partitioner.rs b/router/benches/partitioner.rs
index 9638b3143d..f9f2373639 100644
--- a/router/benches/partitioner.rs
+++ b/router/benches/partitioner.rs
@@ -6,7 +6,7 @@ use criterion::{
 };
 use data_types::{
     partition_template::{NamespacePartitionTemplateOverride, TablePartitionTemplateOverride},
-    NamespaceId, NamespaceName, NamespaceSchema, TableId,
+    MaxColumnsPerTable, MaxTables, NamespaceId, NamespaceName, NamespaceSchema, TableId,
 };
 use generated_types::influxdata::iox::partition_template::v1 as proto;
 use hashbrown::HashMap;
@@ -166,8 +166,8 @@ fn bench(
     let schema = Arc::new(NamespaceSchema {
         id: NamespaceId::new(42),
         tables: Default::default(),
-        max_columns_per_table: 1000,
-        max_tables: 1000,
+        max_columns_per_table: MaxColumnsPerTable::new(1000),
+        max_tables: MaxTables::new(1000),
         retention_period_ns: None,
         partition_template: partition_template.clone(),
     });
diff --git a/router/benches/schema_validator.rs b/router/benches/schema_validator.rs
index 49bbe49fd1..19c3a24a8d 100644
--- a/router/benches/schema_validator.rs
+++ b/router/benches/schema_validator.rs
@@ -4,7 +4,7 @@ use criterion::{
     criterion_group, criterion_main, measurement::WallTime, BatchSize, BenchmarkGroup, Criterion,
     Throughput,
 };
-use data_types::{NamespaceId, NamespaceName, NamespaceSchema};
+use data_types::{MaxColumnsPerTable, MaxTables, NamespaceId, NamespaceName, NamespaceSchema};
 use hashbrown::HashMap;
 use iox_catalog::{interface::Catalog, mem::MemCatalog};
 use mutable_batch::MutableBatch;
@@ -51,8 +51,8 @@ fn bench(group: &mut BenchmarkGroup<WallTime>, tables: usize, columns_per_table:
     let namespace_schema = NamespaceSchema {
         id: NamespaceId::new(42),
         tables: Default::default(),
-        max_columns_per_table: 42,
-        max_tables: 42,
+        max_columns_per_table: MaxColumnsPerTable::new(42),
+        max_tables: MaxTables::new(42),
         retention_period_ns: None,
         partition_template: Default::default(),
     };
diff --git a/router/src/dml_handlers/schema_validation.rs b/router/src/dml_handlers/schema_validation.rs
index 8a0655c2f0..298195b62e 100644
--- a/router/src/dml_handlers/schema_validation.rs
+++ b/router/src/dml_handlers/schema_validation.rs
@@ -362,7 +362,7 @@ fn validate_schema_limits(
         // Get the column set for this table from the schema.
         let mut existing_columns = match schema.tables.get(table_name) {
             Some(v) => v.column_names(),
-            None if batch.columns().len() > schema.max_columns_per_table => {
+            None if batch.columns().len() > schema.max_columns_per_table.get() as usize => {
                 // The table does not exist, therefore all the columns in this
                 // write must be created - there's no need to perform a set
                 // union to discover the distinct column count.
@@ -370,7 +370,7 @@ fn validate_schema_limits(
                     table_name: table_name.into(),
                     merged_column_count: batch.columns().len(),
                     existing_column_count: 0,
-                    max_columns_per_table: schema.max_columns_per_table,
+                    max_columns_per_table: schema.max_columns_per_table.get() as usize,
                 });
             }
             None => {
@@ -387,11 +387,11 @@ fn validate_schema_limits(
                 // submitted to multiple router instances, exceeding the schema
                 // limit by some degree (eventual enforcement).
                 let merged_table_count = schema.tables.len() + new_tables;
-                if merged_table_count > schema.max_tables {
+                if merged_table_count > schema.max_tables.get() as usize {
                     return Err(CachedServiceProtectionLimit::Table {
                         existing_table_count: schema.tables.len(),
                         merged_table_count,
-                        table_count_limit: schema.max_tables,
+                        table_count_limit: schema.max_tables.get() as usize,
                     });
                 }
 
@@ -415,14 +415,15 @@ fn validate_schema_limits(
         // includes existing columns and doesn't exceed the limit more, this is
         // allowed.
         let columns_were_added_in_this_batch = merged_column_count > existing_column_count;
-        let column_limit_exceeded = merged_column_count > schema.max_columns_per_table;
+        let column_limit_exceeded =
+            merged_column_count > schema.max_columns_per_table.get() as usize;
 
         if columns_were_added_in_this_batch && column_limit_exceeded {
             return Err(CachedServiceProtectionLimit::Column {
                 table_name: table_name.into(),
                 merged_column_count,
                 existing_column_count,
-                max_columns_per_table: schema.max_columns_per_table,
+                max_columns_per_table: schema.max_columns_per_table.get() as usize,
             });
         }
     }
@@ -692,7 +693,7 @@ mod tests {
         {
             let schema = namespace.schema().await;
             assert_eq!(schema.tables.len(), 2);
-            assert_eq!(schema.max_tables, 1);
+            assert_eq!(schema.max_tables.get(), 1);
 
             let batches = lp_to_writes("bananas val=2 42\nplatanos val=2 42");
             assert_matches!(validate_schema_limits(&batches, &schema), Ok(()));
diff --git a/router/src/gossip/anti_entropy/mst/mod.rs b/router/src/gossip/anti_entropy/mst/mod.rs
index 131ebc613d..240abe9d59 100644
--- a/router/src/gossip/anti_entropy/mst/mod.rs
+++ b/router/src/gossip/anti_entropy/mst/mod.rs
@@ -16,8 +16,8 @@ mod tests {
     };
 
     use data_types::{
-        ColumnId, ColumnSchema, ColumnType, ColumnsByName, NamespaceId, NamespaceName,
-        NamespaceSchema, TableId, TableSchema,
+        ColumnId, ColumnSchema, ColumnType, ColumnsByName, MaxColumnsPerTable, MaxTables,
+        NamespaceId, NamespaceName, NamespaceSchema, TableId, TableSchema,
     };
     use proptest::prelude::*;
 
@@ -91,8 +91,8 @@ mod tests {
             NamespaceSchema {
                 id: NamespaceId::new(namespace_id),
                 tables,
-                max_columns_per_table,
-                max_tables,
+                max_columns_per_table: MaxColumnsPerTable::new(max_columns_per_table as i32),
+                max_tables: MaxTables::new(max_tables as i32),
                 retention_period_ns,
                 partition_template: Default::default(),
             }
diff --git a/router/src/gossip/mod.rs b/router/src/gossip/mod.rs
index 502ea29c0a..a0cdf2ceb3 100644
--- a/router/src/gossip/mod.rs
+++ b/router/src/gossip/mod.rs
@@ -64,8 +64,8 @@ pub(crate) fn namespace_created(
         namespace_name: namespace_name.into(),
         namespace_id: schema.id.get(),
         partition_template: schema.partition_template.as_proto().cloned(),
-        max_columns_per_table: schema.max_columns_per_table as u64,
-        max_tables: schema.max_tables as u64,
+        max_columns_per_table: schema.max_columns_per_table.get() as u64,
+        max_tables: schema.max_tables.get() as u64,
         retention_period_ns: schema.retention_period_ns,
     }
 }
diff --git a/router/src/gossip/namespace_cache.rs b/router/src/gossip/namespace_cache.rs
index 9e668883a4..d116276f58 100644
--- a/router/src/gossip/namespace_cache.rs
+++ b/router/src/gossip/namespace_cache.rs
@@ -5,8 +5,8 @@ use std::{borrow::Cow, collections::BTreeMap, fmt::Debug};
 use async_trait::async_trait;
 use data_types::{
     partition_template::{NamespacePartitionTemplateOverride, TablePartitionTemplateOverride},
-    ColumnSchema, ColumnsByName, NamespaceId, NamespaceName, NamespaceNameError, NamespaceSchema,
-    TableId, TableSchema,
+    ColumnSchema, ColumnsByName, MaxColumnsPerTable, MaxTables, NamespaceId, NamespaceName,
+    NamespaceNameError, NamespaceSchema, TableId, TableSchema,
 };
 use generated_types::influxdata::iox::gossip::v1::{
     schema_message::Event, NamespaceCreated, TableCreated, TableUpdated,
@@ -180,8 +180,10 @@ where
                     NamespaceSchema {
                         id: NamespaceId::new(note.namespace_id),
                         tables: Default::default(),
-                        max_columns_per_table: note.max_columns_per_table as _,
-                        max_tables: note.max_tables as _,
+                        max_columns_per_table: MaxColumnsPerTable::new(
+                            note.max_columns_per_table as i32,
+                        ),
+                        max_tables: MaxTables::new(note.max_tables as i32),
                         retention_period_ns: note.retention_period_ns,
                         partition_template,
                     },
diff --git a/router/src/lib.rs b/router/src/lib.rs
index 2a9e2b0bdc..adc0d57d1f 100644
--- a/router/src/lib.rs
+++ b/router/src/lib.rs
@@ -142,7 +142,8 @@ pub mod server;
 #[cfg(test)]
 pub(crate) mod test_helpers {
     use data_types::{
-        partition_template::NamespacePartitionTemplateOverride, NamespaceId, NamespaceSchema,
+        partition_template::NamespacePartitionTemplateOverride, MaxColumnsPerTable, MaxTables,
+        NamespaceId, NamespaceSchema,
     };
     use std::collections::BTreeMap;
 
@@ -159,8 +160,10 @@ pub(crate) mod test_helpers {
         NamespaceSchema {
             id: NamespaceId::new(id),
             tables: BTreeMap::new(),
-            max_columns_per_table: iox_catalog::DEFAULT_MAX_COLUMNS_PER_TABLE as usize,
-            max_tables: iox_catalog::DEFAULT_MAX_TABLES as usize,
+            max_columns_per_table: MaxColumnsPerTable::new(
+                iox_catalog::DEFAULT_MAX_COLUMNS_PER_TABLE,
+            ),
+            max_tables: MaxTables::new(iox_catalog::DEFAULT_MAX_TABLES),
             retention_period_ns: None,
             partition_template: DEFAULT_NAMESPACE_PARTITION_TEMPLATE,
         }
diff --git a/router/src/namespace_cache/memory.rs b/router/src/namespace_cache/memory.rs
index 5f714b6904..4bfcf0393c 100644
--- a/router/src/namespace_cache/memory.rs
+++ b/router/src/namespace_cache/memory.rs
@@ -172,8 +172,8 @@ mod tests {
 
     use assert_matches::assert_matches;
     use data_types::{
-        Column, ColumnId, ColumnSchema, ColumnType, ColumnsByName, NamespaceId, TableId,
-        TableSchema,
+        Column, ColumnId, ColumnSchema, ColumnType, ColumnsByName, MaxColumnsPerTable, MaxTables,
+        NamespaceId, TableId, TableSchema,
     };
     use proptest::{prelude::*, prop_compose, proptest};
 
@@ -186,8 +186,8 @@ mod tests {
         NamespaceSchema {
             id: TEST_NAMESPACE_ID,
             tables: Default::default(),
-            max_columns_per_table: 50,
-            max_tables: 24,
+            max_columns_per_table: MaxColumnsPerTable::new(50),
+            max_tables: MaxTables::new(24),
             retention_period_ns: Some(876),
             partition_template: Default::default(),
         }
@@ -198,8 +198,8 @@ mod tests {
         NamespaceSchema {
             id: TEST_NAMESPACE_ID,
             tables: Default::default(),
-            max_columns_per_table: 10,
-            max_tables: 42,
+            max_columns_per_table: MaxColumnsPerTable::new(10),
+            max_tables: MaxTables::new(42),
             retention_period_ns: Some(876),
             partition_template: Default::default(),
         }
@@ -492,8 +492,8 @@ mod tests {
             NamespaceSchema {
                 id: TEST_NAMESPACE_ID,
                 tables,
-                max_columns_per_table,
-                max_tables,
+                max_columns_per_table: MaxColumnsPerTable::new(max_columns_per_table as i32),
+                max_tables: MaxTables::new(max_tables as i32),
                 retention_period_ns,
                 partition_template: Default::default(),
             }
diff --git a/router/src/namespace_cache/metrics.rs b/router/src/namespace_cache/metrics.rs
index b0ad316017..aa3249d5fe 100644
--- a/router/src/namespace_cache/metrics.rs
+++ b/router/src/namespace_cache/metrics.rs
@@ -125,7 +125,8 @@ where
 mod tests {
     use assert_matches::assert_matches;
     use data_types::{
-        Column, ColumnId, ColumnType, ColumnsByName, NamespaceId, TableId, TableSchema,
+        Column, ColumnId, ColumnType, ColumnsByName, MaxColumnsPerTable, MaxTables, NamespaceId,
+        TableId, TableSchema,
     };
     use metric::{Attributes, MetricObserver, Observation};
 
@@ -163,8 +164,8 @@ mod tests {
         NamespaceSchema {
             id: NamespaceId::new(42),
             tables,
-            max_columns_per_table: 100,
-            max_tables: 42,
+            max_columns_per_table: MaxColumnsPerTable::new(100),
+            max_tables: MaxTables::new(42),
             retention_period_ns: None,
             partition_template: Default::default(),
         }
diff --git a/router/src/namespace_resolver/ns_autocreation.rs b/router/src/namespace_resolver/ns_autocreation.rs
index 60887873b8..eb4e15ec6f 100644
--- a/router/src/namespace_resolver/ns_autocreation.rs
+++ b/router/src/namespace_resolver/ns_autocreation.rs
@@ -137,7 +137,7 @@ mod tests {
     use std::sync::Arc;
 
     use assert_matches::assert_matches;
-    use data_types::{Namespace, NamespaceId};
+    use data_types::{MaxColumnsPerTable, MaxTables, Namespace, NamespaceId};
     use iox_catalog::{interface::SoftDeletedRows, mem::MemCatalog};
 
     use super::*;
@@ -228,8 +228,10 @@ mod tests {
             Namespace {
                 id: NamespaceId::new(1),
                 name: ns.to_string(),
-                max_tables: iox_catalog::DEFAULT_MAX_TABLES,
-                max_columns_per_table: iox_catalog::DEFAULT_MAX_COLUMNS_PER_TABLE,
+                max_tables: MaxTables::new(iox_catalog::DEFAULT_MAX_TABLES),
+                max_columns_per_table: MaxColumnsPerTable::new(
+                    iox_catalog::DEFAULT_MAX_COLUMNS_PER_TABLE
+                ),
                 retention_period_ns: TEST_RETENTION_PERIOD_NS,
                 deleted_at: None,
                 partition_template: Default::default(),
diff --git a/service_grpc_namespace/src/lib.rs b/service_grpc_namespace/src/lib.rs
index 1af5658486..72bc172ebb 100644
--- a/service_grpc_namespace/src/lib.rs
+++ b/service_grpc_namespace/src/lib.rs
@@ -266,8 +266,8 @@ pub fn namespace_to_proto(namespace: &CatalogNamespace) -> Namespace {
         id: namespace.id.get(),
         name: namespace.name.clone(),
         retention_period_ns: namespace.retention_period_ns,
-        max_tables: namespace.max_tables,
-        max_columns_per_table: namespace.max_columns_per_table,
+        max_tables: namespace.max_tables.get(),
+        max_columns_per_table: namespace.max_columns_per_table.get(),
         partition_template: namespace.partition_template.as_proto().cloned(),
     }
 }