diff --git a/.changes/unreleased/Breaking Changes-20241108-215906.yaml b/.changes/unreleased/Breaking Changes-20241108-215906.yaml
new file mode 100644
index 00000000..bd9906ff
--- /dev/null
+++ b/.changes/unreleased/Breaking Changes-20241108-215906.yaml	
@@ -0,0 +1,6 @@
+kind: Breaking Changes
+body: Adding support for custom grain in windows/grain_to_dates
+time: 2024-11-08T21:59:06.162076-05:00
+custom:
+    Author: WilliamDee
+    Issue: None
diff --git a/dbt_semantic_interfaces/implementations/metric.py b/dbt_semantic_interfaces/implementations/metric.py
index 02933e5a..204337a7 100644
--- a/dbt_semantic_interfaces/implementations/metric.py
+++ b/dbt_semantic_interfaces/implementations/metric.py
@@ -71,7 +71,7 @@ class PydanticMetricTimeWindow(PydanticCustomInputParser, HashableBaseModel):
     """Describes the window of time the metric should be accumulated over, e.g., '1 day', '2 weeks', etc."""
 
     count: int
-    granularity: TimeGranularity
+    granularity: str
 
     @classmethod
     def _from_yaml_value(cls, input: PydanticParseableValueType) -> PydanticMetricTimeWindow:
@@ -80,21 +80,31 @@ def _from_yaml_value(cls, input: PydanticParseableValueType) -> PydanticMetricTi
         The MetricTimeWindow is always expected to be provided as a string in user-defined YAML configs.
         """
         if isinstance(input, str):
-            return PydanticMetricTimeWindow.parse(input)
+            return PydanticMetricTimeWindow.parse(window=input.lower(), custom_granularity_names=(), strict=False)
         else:
             raise ValueError(
                 f"MetricTimeWindow inputs from model configs are expected to always be of type string, but got "
                 f"type {type(input)} with value: {input}"
             )
 
+    @property
+    def is_standard_granularity(self) -> bool:
+        """Returns whether the window uses standard TimeGranularity."""
+        return self.granularity.casefold() in {item.value.casefold() for item in TimeGranularity}
+
+    @property
+    def window_string(self) -> str:
+        """Returns the string value of the time window."""
+        return f"{self.count} {self.granularity}"
+
     @staticmethod
-    def parse(window: str) -> PydanticMetricTimeWindow:
+    def parse(window: str, custom_granularity_names: Sequence[str], strict: bool = True) -> PydanticMetricTimeWindow:
         """Returns window values if parsing succeeds, None otherwise.
 
-        Output of the form: (<time unit count>, <time granularity>, <error message>) - error message is None if window
-        is formatted properly
+        If strict=True, then the granularity in the window must exist as a valid granularity.
+        Use strict=True for when you have all valid granularities, otherwise use strict=False.
         """
-        parts = window.split(" ")
+        parts = window.lower().split(" ")
         if len(parts) != 2:
             raise ParsingException(
                 f"Invalid window ({window}) in cumulative metric. Should be of the form `<count> <granularity>`, "
@@ -102,14 +112,21 @@ def parse(window: str) -> PydanticMetricTimeWindow:
             )
 
         granularity = parts[1]
+
+        valid_time_granularities = {item.value.lower() for item in TimeGranularity} | set(
+            c.lower() for c in custom_granularity_names
+        )
+
         # if we switched to python 3.9 this could just be `granularity = parts[0].removesuffix('s')
-        if granularity.endswith("s"):
+        if granularity.endswith("s") and granularity[:-1] in valid_time_granularities:
             # months -> month
             granularity = granularity[:-1]
-        if granularity not in [item.value for item in TimeGranularity]:
+
+        if strict and granularity not in valid_time_granularities:
             raise ParsingException(
-                f"Invalid time granularity {granularity} in cumulative metric window string: ({window})",
+                f"Invalid time granularity {granularity} in metric window string: ({window})",
             )
+        # If not strict and not standard granularity, it may be a custom grain, so validations happens later
 
         count = parts[0]
         if not count.isdigit():
@@ -117,7 +134,7 @@ def parse(window: str) -> PydanticMetricTimeWindow:
 
         return PydanticMetricTimeWindow(
             count=int(count),
-            granularity=TimeGranularity(granularity),
+            granularity=granularity,
         )
 
 
@@ -135,7 +152,7 @@ class PydanticMetricInput(HashableBaseModel):
     filter: Optional[PydanticWhereFilterIntersection]
     alias: Optional[str]
     offset_window: Optional[PydanticMetricTimeWindow]
-    offset_to_grain: Optional[TimeGranularity]
+    offset_to_grain: Optional[str]
 
     @property
     def as_reference(self) -> MetricReference:
@@ -163,7 +180,7 @@ class PydanticCumulativeTypeParams(HashableBaseModel):
     """Type params to provide context for cumulative metrics properties."""
 
     window: Optional[PydanticMetricTimeWindow]
-    grain_to_date: Optional[TimeGranularity]
+    grain_to_date: Optional[str]
     period_agg: PeriodAggregation = PeriodAggregation.FIRST
 
 
@@ -174,7 +191,9 @@ class PydanticMetricTypeParams(HashableBaseModel):
     numerator: Optional[PydanticMetricInput]
     denominator: Optional[PydanticMetricInput]
     expr: Optional[str]
+    # Legacy, supports custom grain through PydanticMetricTimeWindow changes (should deprecate though)
     window: Optional[PydanticMetricTimeWindow]
+    # Legacy, will not support custom granularity
     grain_to_date: Optional[TimeGranularity]
     metrics: Optional[List[PydanticMetricInput]]
     conversion_type_params: Optional[PydanticConversionTypeParams]
@@ -206,7 +225,7 @@ def _implements_protocol(self) -> Metric:  # noqa: D
     metadata: Optional[PydanticMetadata]
     label: Optional[str] = None
     config: Optional[PydanticMetricConfig]
-    time_granularity: Optional[TimeGranularity] = None
+    time_granularity: Optional[str] = None
 
     @property
     def input_measures(self) -> Sequence[PydanticMetricInputMeasure]:
diff --git a/dbt_semantic_interfaces/parsing/generated_json_schemas/default_explicit_schema.json b/dbt_semantic_interfaces/parsing/generated_json_schemas/default_explicit_schema.json
index 613bffd7..62b682a6 100644
--- a/dbt_semantic_interfaces/parsing/generated_json_schemas/default_explicit_schema.json
+++ b/dbt_semantic_interfaces/parsing/generated_json_schemas/default_explicit_schema.json
@@ -77,30 +77,7 @@
             "additionalProperties": false,
             "properties": {
                 "grain_to_date": {
-                    "enum": [
-                        "NANOSECOND",
-                        "MICROSECOND",
-                        "MILLISECOND",
-                        "SECOND",
-                        "MINUTE",
-                        "HOUR",
-                        "DAY",
-                        "WEEK",
-                        "MONTH",
-                        "QUARTER",
-                        "YEAR",
-                        "nanosecond",
-                        "microsecond",
-                        "millisecond",
-                        "second",
-                        "minute",
-                        "hour",
-                        "day",
-                        "week",
-                        "month",
-                        "quarter",
-                        "year"
-                    ]
+                    "type": "string"
                 },
                 "period_agg": {
                     "enum": [
@@ -488,30 +465,7 @@
                     "type": "string"
                 },
                 "time_granularity": {
-                    "enum": [
-                        "NANOSECOND",
-                        "MICROSECOND",
-                        "MILLISECOND",
-                        "SECOND",
-                        "MINUTE",
-                        "HOUR",
-                        "DAY",
-                        "WEEK",
-                        "MONTH",
-                        "QUARTER",
-                        "YEAR",
-                        "nanosecond",
-                        "microsecond",
-                        "millisecond",
-                        "second",
-                        "minute",
-                        "hour",
-                        "day",
-                        "week",
-                        "month",
-                        "quarter",
-                        "year"
-                    ]
+                    "type": "string"
                 },
                 "type": {
                     "enum": [
diff --git a/dbt_semantic_interfaces/parsing/schemas.py b/dbt_semantic_interfaces/parsing/schemas.py
index 66652535..16d1e8bd 100644
--- a/dbt_semantic_interfaces/parsing/schemas.py
+++ b/dbt_semantic_interfaces/parsing/schemas.py
@@ -123,7 +123,7 @@
     "type": "object",
     "properties": {
         "window": {"type": "string"},
-        "grain_to_date": {"enum": time_granularity_values},
+        "grain_to_date": {"type": "string"},
         "period_agg": {"enum": period_agg_values},
     },
     "additionalProperties": False,
@@ -304,7 +304,7 @@
         "description": {"type": "string"},
         "label": {"type": "string"},
         "config": {"$ref": "metric_config_schema"},
-        "time_granularity": {"enum": time_granularity_values},
+        "time_granularity": {"type": "string"},
     },
     "additionalProperties": False,
     "required": ["name", "type", "type_params"],
diff --git a/dbt_semantic_interfaces/protocols/metric.py b/dbt_semantic_interfaces/protocols/metric.py
index 9ccf931e..a53d4102 100644
--- a/dbt_semantic_interfaces/protocols/metric.py
+++ b/dbt_semantic_interfaces/protocols/metric.py
@@ -72,7 +72,17 @@ def count(self) -> int:  # noqa: D
 
     @property
     @abstractmethod
-    def granularity(self) -> TimeGranularity:  # noqa: D
+    def granularity(self) -> str:  # noqa: D
+        pass
+
+    @property
+    @abstractmethod
+    def window_string(self) -> str:  # noqa: D
+        pass
+
+    @property
+    @abstractmethod
+    def is_standard_granularity(self) -> bool:  # noqa: D
         pass
 
 
@@ -102,7 +112,7 @@ def offset_window(self) -> Optional[MetricTimeWindow]:  # noqa: D
 
     @property
     @abstractmethod
-    def offset_to_grain(self) -> Optional[TimeGranularity]:  # noqa: D
+    def offset_to_grain(self) -> Optional[str]:  # noqa: D
         pass
 
     @property
@@ -189,7 +199,7 @@ def window(self) -> Optional[MetricTimeWindow]:  # noqa: D
 
     @property
     @abstractmethod
-    def grain_to_date(self) -> Optional[TimeGranularity]:  # noqa: D
+    def grain_to_date(self) -> Optional[str]:  # noqa: D
         pass
 
     @property
@@ -328,7 +338,7 @@ def label(self) -> Optional[str]:
 
     @property
     @abstractmethod
-    def time_granularity(self) -> Optional[TimeGranularity]:
+    def time_granularity(self) -> Optional[str]:
         """Default grain used for the metric.
 
         This will be used in a couple of circumstances:
diff --git a/dbt_semantic_interfaces/test_utils.py b/dbt_semantic_interfaces/test_utils.py
index fc9a01b2..a6912fac 100644
--- a/dbt_semantic_interfaces/test_utils.py
+++ b/dbt_semantic_interfaces/test_utils.py
@@ -24,7 +24,7 @@
     PydanticSemanticModel,
 )
 from dbt_semantic_interfaces.parsing.objects import YamlConfigFile
-from dbt_semantic_interfaces.type_enums import MetricType, TimeGranularity
+from dbt_semantic_interfaces.type_enums import MetricType
 from dbt_semantic_interfaces.validations.validator_helpers import (
     SemanticManifestValidationResults,
     ValidationIssue,
@@ -127,7 +127,7 @@ def metric_with_guaranteed_meta(
     type_params: PydanticMetricTypeParams,
     metadata: PydanticMetadata = default_meta(),
     description: str = "adhoc metric",
-    time_granularity: Optional[TimeGranularity] = None,
+    time_granularity: Optional[str] = None,
 ) -> PydanticMetric:
     """Creates a metric with the given input.
 
diff --git a/dbt_semantic_interfaces/transformations/cumulative_type_params.py b/dbt_semantic_interfaces/transformations/cumulative_type_params.py
index 7526aaca..2a40ff4c 100644
--- a/dbt_semantic_interfaces/transformations/cumulative_type_params.py
+++ b/dbt_semantic_interfaces/transformations/cumulative_type_params.py
@@ -36,6 +36,6 @@ def transform_model(semantic_manifest: PydanticSemanticManifest) -> PydanticSema
                 if metric.type_params.window and not metric.type_params.cumulative_type_params.window:
                     metric.type_params.cumulative_type_params.window = metric.type_params.window
                 if metric.type_params.grain_to_date and not metric.type_params.cumulative_type_params.grain_to_date:
-                    metric.type_params.cumulative_type_params.grain_to_date = metric.type_params.grain_to_date
+                    metric.type_params.cumulative_type_params.grain_to_date = metric.type_params.grain_to_date.value
 
         return semantic_manifest
diff --git a/dbt_semantic_interfaces/transformations/pydantic_rule_set.py b/dbt_semantic_interfaces/transformations/pydantic_rule_set.py
index 7c2f4568..f8cf43ff 100644
--- a/dbt_semantic_interfaces/transformations/pydantic_rule_set.py
+++ b/dbt_semantic_interfaces/transformations/pydantic_rule_set.py
@@ -22,6 +22,9 @@
 )
 from dbt_semantic_interfaces.transformations.names import LowerCaseNamesRule
 from dbt_semantic_interfaces.transformations.proxy_measure import CreateProxyMeasureRule
+from dbt_semantic_interfaces.transformations.remove_plural_from_window_granularity import (
+    RemovePluralFromWindowGranularityRule,
+)
 from dbt_semantic_interfaces.transformations.rule_set import (
     SemanticManifestTransformRuleSet,
 )
@@ -54,6 +57,7 @@ def secondary_rules(self) -> Sequence[SemanticManifestTransformRule[PydanticSema
             ConvertMedianToPercentileRule(),
             AddInputMetricMeasuresRule(),
             SetCumulativeTypeParamsRule(),
+            RemovePluralFromWindowGranularityRule(),
         )
 
     @property
diff --git a/dbt_semantic_interfaces/transformations/remove_plural_from_window_granularity.py b/dbt_semantic_interfaces/transformations/remove_plural_from_window_granularity.py
new file mode 100644
index 00000000..9e5fb5f4
--- /dev/null
+++ b/dbt_semantic_interfaces/transformations/remove_plural_from_window_granularity.py
@@ -0,0 +1,89 @@
+from typing import Sequence
+
+from typing_extensions import override
+
+from dbt_semantic_interfaces.enum_extension import assert_values_exhausted
+from dbt_semantic_interfaces.errors import ModelTransformError
+from dbt_semantic_interfaces.implementations.metric import PydanticMetricTimeWindow
+from dbt_semantic_interfaces.implementations.semantic_manifest import (
+    PydanticSemanticManifest,
+)
+from dbt_semantic_interfaces.protocols import ProtocolHint
+from dbt_semantic_interfaces.transformations.transform_rule import (
+    SemanticManifestTransformRule,
+)
+from dbt_semantic_interfaces.type_enums import MetricType
+
+
+class RemovePluralFromWindowGranularityRule(ProtocolHint[SemanticManifestTransformRule[PydanticSemanticManifest]]):
+    """Remove trailing s from granularity in MetricTimeWindow.
+
+    During parsing, MetricTimeWindow.granularity can still contain he trailing 's' (ie., 3 days).
+    This is because with the introduction of custom granularities, we don't have access to the valid
+    custom grains during parsing. This transformation rule is introduced to remove the trailing 's'
+    from `MetricTimeWindow.granularity` if necessary.
+    """
+
+    @override
+    def _implements_protocol(self) -> SemanticManifestTransformRule[PydanticSemanticManifest]:  # noqa: D
+        return self
+
+    @staticmethod
+    def _update_metric(
+        semantic_manifest: PydanticSemanticManifest, metric_name: str, custom_granularity_names: Sequence[str]
+    ) -> None:
+        """Mutates all the MetricTimeWindow by reparsing to remove the trailing 's'."""
+
+        def reparse_window(window: PydanticMetricTimeWindow) -> PydanticMetricTimeWindow:
+            """Reparse the window to remove the trailing 's'."""
+            return PydanticMetricTimeWindow.parse(
+                window=window.window_string, custom_granularity_names=custom_granularity_names
+            )
+
+        matched_metric = next(
+            iter((metric for metric in semantic_manifest.metrics if metric.name == metric_name)), None
+        )
+        if matched_metric:
+            if matched_metric.type is MetricType.CUMULATIVE:
+                if (
+                    matched_metric.type_params.cumulative_type_params
+                    and matched_metric.type_params.cumulative_type_params.window
+                ):
+                    matched_metric.type_params.cumulative_type_params.window = reparse_window(
+                        matched_metric.type_params.cumulative_type_params.window
+                    )
+            elif matched_metric.type is MetricType.CONVERSION:
+                if (
+                    matched_metric.type_params.conversion_type_params
+                    and matched_metric.type_params.conversion_type_params.window
+                ):
+                    matched_metric.type_params.conversion_type_params.window = reparse_window(
+                        matched_metric.type_params.conversion_type_params.window
+                    )
+
+            elif matched_metric.type is MetricType.DERIVED or matched_metric.type is MetricType.RATIO:
+                for input_metric in matched_metric.input_metrics:
+                    if input_metric.offset_window:
+                        input_metric.offset_window = reparse_window(input_metric.offset_window)
+            elif matched_metric.type is MetricType.SIMPLE:
+                pass
+            else:
+                assert_values_exhausted(matched_metric.type)
+        else:
+            raise ModelTransformError(f"Metric '{metric_name}' is not configured as a metric in the model.")
+
+    @staticmethod
+    def transform_model(semantic_manifest: PydanticSemanticManifest) -> PydanticSemanticManifest:  # noqa: D
+        custom_granularity_names = [
+            granularity.name
+            for time_spine in semantic_manifest.project_configuration.time_spines
+            for granularity in time_spine.custom_granularities
+        ]
+
+        for metric in semantic_manifest.metrics:
+            RemovePluralFromWindowGranularityRule._update_metric(
+                semantic_manifest=semantic_manifest,
+                metric_name=metric.name,
+                custom_granularity_names=custom_granularity_names,
+            )
+        return semantic_manifest
diff --git a/dbt_semantic_interfaces/validations/metrics.py b/dbt_semantic_interfaces/validations/metrics.py
index 80278a51..83c9b0ee 100644
--- a/dbt_semantic_interfaces/validations/metrics.py
+++ b/dbt_semantic_interfaces/validations/metrics.py
@@ -51,6 +51,12 @@ class CumulativeMetricRule(SemanticManifestValidationRule[SemanticManifestT], Ge
     def validate_manifest(semantic_manifest: SemanticManifestT) -> Sequence[ValidationIssue]:  # noqa: D
         issues: List[ValidationIssue] = []
 
+        custom_granularity_names = [
+            granularity.name
+            for time_spine in semantic_manifest.project_configuration.time_spines
+            for granularity in time_spine.custom_granularities
+        ]
+
         for metric in semantic_manifest.metrics or []:
             if metric.type != MetricType.CUMULATIVE:
                 continue
@@ -90,7 +96,7 @@ def validate_manifest(semantic_manifest: SemanticManifestT) -> Sequence[Validati
             window = metric.type_params.window
             if metric.type_params.cumulative_type_params and metric.type_params.cumulative_type_params.window:
                 window = metric.type_params.cumulative_type_params.window
-            grain_to_date = metric.type_params.grain_to_date
+            grain_to_date = metric.type_params.grain_to_date.value if metric.type_params.grain_to_date else None
             if metric.type_params.cumulative_type_params and metric.type_params.cumulative_type_params.grain_to_date:
                 grain_to_date = metric.type_params.cumulative_type_params.grain_to_date
             if window and grain_to_date:
@@ -103,9 +109,10 @@ def validate_manifest(semantic_manifest: SemanticManifestT) -> Sequence[Validati
 
             if window:
                 try:
-                    window_str = f"{window.count} {window.granularity.value}"
                     # TODO: Should not call an implementation class.
-                    PydanticMetricTimeWindow.parse(window_str)
+                    PydanticMetricTimeWindow.parse(
+                        window=window.window_string, custom_granularity_names=custom_granularity_names
+                    )
                 except ParsingException as e:
                     issues.append(
                         ValidationError(
@@ -252,14 +259,16 @@ class ConversionMetricRule(SemanticManifestValidationRule[SemanticManifestT], Ge
 
     @staticmethod
     @validate_safely(whats_being_done="checking that the params of metric are valid if it is a conversion metric")
-    def _validate_type_params(metric: Metric, conversion_type_params: ConversionTypeParams) -> List[ValidationIssue]:
+    def _validate_type_params(
+        metric: Metric, conversion_type_params: ConversionTypeParams, custom_granularity_names: Sequence[str]
+    ) -> List[ValidationIssue]:
         issues: List[ValidationIssue] = []
 
         window = conversion_type_params.window
         if window:
             try:
-                window_str = f"{window.count} {window.granularity.value}"
-                PydanticMetricTimeWindow.parse(window_str)
+                window_str = f"{window.count} {window.granularity}"
+                PydanticMetricTimeWindow.parse(window=window_str, custom_granularity_names=custom_granularity_names)
             except ParsingException as e:
                 issues.append(
                     ValidationError(
@@ -421,6 +430,12 @@ def _get_semantic_model_from_measure(
     def validate_manifest(semantic_manifest: SemanticManifestT) -> Sequence[ValidationIssue]:  # noqa: D
         issues: List[ValidationIssue] = []
 
+        custom_granularity_names = [
+            granularity.name
+            for time_spine in semantic_manifest.project_configuration.time_spines
+            for granularity in time_spine.custom_granularities
+        ]
+
         for metric in semantic_manifest.metrics or []:
             if metric.type == MetricType.CONVERSION:
                 # Validates that the measure exists and corresponds to a semantic model
@@ -461,7 +476,9 @@ def validate_manifest(semantic_manifest: SemanticManifestT) -> Sequence[Validati
                     conversion_semantic_model=conversion_semantic_model,
                 )
                 issues += ConversionMetricRule._validate_type_params(
-                    metric=metric, conversion_type_params=metric.type_params.conversion_type_params
+                    metric=metric,
+                    conversion_type_params=metric.type_params.conversion_type_params,
+                    custom_granularity_names=custom_granularity_names,
                 )
                 issues += ConversionMetricRule._validate_constant_properties(
                     metric=metric,
@@ -532,11 +549,11 @@ def _validate_metric(
                 )
                 return issues
             valid_granularities = [
-                granularity.name
+                granularity.value
                 for granularity in TimeGranularity
                 if granularity.to_int() >= min_queryable_granularity.to_int()
             ]
-            if metric.time_granularity.name not in valid_granularities:
+            if metric.time_granularity not in valid_granularities:
                 issues.append(
                     ValidationError(
                         context=context,
@@ -544,7 +561,7 @@ def _validate_metric(
                             f"`time_granularity` for metric '{metric.name}' must be >= "
                             f"{min_queryable_granularity.name}. Valid options are those that are >= the largest "
                             f"granularity defined for the metric's measures' agg_time_dimensions. Got: "
-                            f"{metric.time_granularity.name}. Valid options: {valid_granularities}"
+                            f"{metric.time_granularity}. Valid options: {valid_granularities}"
                         ),
                     )
                 )
diff --git a/tests/parsing/test_metric_parsing.py b/tests/parsing/test_metric_parsing.py
index f35262b5..79064519 100644
--- a/tests/parsing/test_metric_parsing.py
+++ b/tests/parsing/test_metric_parsing.py
@@ -212,7 +212,7 @@ def test_cumulative_window_metric_parsing() -> None:
           type_params:
             measure:
               name: cumulative_measure
-            window: "7 days"
+            window: "7 Days"
         """
     )
     file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
@@ -224,7 +224,7 @@ def test_cumulative_window_metric_parsing() -> None:
     assert metric.name == "cumulative_test"
     assert metric.type is MetricType.CUMULATIVE
     assert metric.type_params.measure == PydanticMetricInputMeasure(name="cumulative_measure")
-    assert metric.type_params.window == PydanticMetricTimeWindow(count=7, granularity=TimeGranularity.DAY)
+    assert metric.type_params.window == PydanticMetricTimeWindow(count=7, granularity=TimeGranularity.DAY.value)
 
 
 def test_grain_to_date_metric_parsing() -> None:
@@ -237,7 +237,7 @@ def test_grain_to_date_metric_parsing() -> None:
           type_params:
             measure:
               name: cumulative_measure
-            grain_to_date: "week"
+            grain_to_date: "weEk"
         """
     )
     file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
@@ -281,7 +281,7 @@ def test_derived_metric_offset_window_parsing() -> None:
     assert metric.type_params.metrics and len(metric.type_params.metrics) == 2
     metric1, metric2 = metric.type_params.metrics
     assert metric1.offset_window is None
-    assert metric2.offset_window == PydanticMetricTimeWindow(count=14, granularity=TimeGranularity.DAY)
+    assert metric2.offset_window == PydanticMetricTimeWindow(count=14, granularity=TimeGranularity.DAY.value)
     assert metric1.alias is None
     assert metric2.alias == "bookings_2_weeks_ago"
     assert metric.type_params.expr == "bookings / bookings_2_weeks_ago"
@@ -315,7 +315,7 @@ def test_derive_metric_offset_to_grain_parsing() -> None:
     assert metric.type_params.metrics and len(metric.type_params.metrics) == 2
     metric1, metric2 = metric.type_params.metrics
     assert metric1.offset_to_grain is None
-    assert metric2.offset_to_grain == TimeGranularity.MONTH
+    assert metric2.offset_to_grain == TimeGranularity.MONTH.value
     assert metric1.alias is None
     assert metric2.alias == "bookings_at_start_of_month"
     assert metric.type_params.expr == "bookings / bookings_at_start_of_month"
@@ -449,7 +449,7 @@ def test_conversion_metric_parsing() -> None:
         name="conversions"
     )
     assert metric.type_params.conversion_type_params.window == PydanticMetricTimeWindow(
-        count=7, granularity=TimeGranularity.DAY
+        count=7, granularity=TimeGranularity.DAY.value
     )
     assert metric.type_params.conversion_type_params.entity == "user"
     assert metric.type_params.conversion_type_params.calculation == ConversionCalculationType.CONVERSION_RATE
@@ -538,26 +538,6 @@ def test_invalid_cumulative_metric_window_format_parsing_error() -> None:
     assert "Invalid window" in str(SemanticManifestValidationException(build_result.issues.all_issues))
 
 
-def test_invalid_cumulative_metric_window_granularity_parsing_error() -> None:
-    """Test for errror detection when parsing malformed cumulative metric window entries."""
-    yaml_contents = textwrap.dedent(
-        """\
-        metric:
-          name: invalid_cumulative_granularity_test
-          type: cumulative
-          type_params:
-            measure:
-              name: cumulative_measure
-            window: "7 moons"
-        """
-    )
-    file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
-
-    build_result = parse_yaml_files_to_semantic_manifest(files=[file, EXAMPLE_PROJECT_CONFIGURATION_YAML_CONFIG_FILE])
-    assert build_result.issues.has_blocking_issues
-    assert "Invalid time granularity" in str(SemanticManifestValidationException(build_result.issues.all_issues))
-
-
 def test_invalid_cumulative_metric_window_count_parsing_error() -> None:
     """Test for errror detection when parsing malformed cumulative metric window entries."""
     yaml_contents = textwrap.dedent(
diff --git a/tests/parsing/test_metric_parsing_with_custom_grain.py b/tests/parsing/test_metric_parsing_with_custom_grain.py
new file mode 100644
index 00000000..2100829e
--- /dev/null
+++ b/tests/parsing/test_metric_parsing_with_custom_grain.py
@@ -0,0 +1,262 @@
+import textwrap
+
+from dbt_semantic_interfaces.parsing.dir_to_model import (
+    parse_yaml_files_to_validation_ready_semantic_manifest,
+)
+from dbt_semantic_interfaces.parsing.objects import YamlConfigFile
+from dbt_semantic_interfaces.test_utils import base_semantic_manifest_file
+from tests.example_project_configuration import (
+    EXAMPLE_PROJECT_CONFIGURATION_YAML_CONFIG_FILE,
+)
+
+
+def test_cumulative_metric_with_custom_grain_to_date() -> None:  # noqa: D
+    yaml_contents = textwrap.dedent(
+        """\
+        semantic_model:
+          name: booking_source
+          node_relation:
+            schema_name: some_schema
+            alias: some_alias
+          primary_entity: booking
+
+          entities:
+            - name: user
+              type: foreign
+              expr: user_id
+          dimensions:
+            - name: is_instant
+              type: categorical
+          measures:
+            - name: bookings
+              expr: "1"
+              agg: sum
+        ---
+        metric:
+          name: "bookings"
+          description: "bookings metric"
+          label: "Bookings"
+          type: simple
+          type_params:
+            measure:
+              name: bookings
+        ---
+        metric:
+          name: "test_cumulative_metric_with_custom_grain_to_date"
+          description: "Test cumulative grain to date with custom granularity"
+          type: cumulative
+          type_params:
+            measure:
+              name: bookings
+            cumulative_type_params:
+              grain_to_date: martian_week
+        """
+    )
+    metric_file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
+    model = parse_yaml_files_to_validation_ready_semantic_manifest(
+        [EXAMPLE_PROJECT_CONFIGURATION_YAML_CONFIG_FILE, base_semantic_manifest_file(), metric_file]
+    )
+    assert not model.issues.has_blocking_issues
+    semantic_manifest = model.semantic_manifest
+    assert len(semantic_manifest.metrics) == 3
+
+    metric = next(
+        (m for m in semantic_manifest.metrics if m.name == "test_cumulative_metric_with_custom_grain_to_date"), None
+    )
+    assert metric is not None, "Can't find metric"
+    assert (
+        metric.type_params.cumulative_type_params
+        and metric.type_params.cumulative_type_params.grain_to_date == "martian_week"
+    )
+
+
+def test_cumulative_metric_with_custom_window() -> None:  # noqa: D
+    yaml_contents = textwrap.dedent(
+        """\
+        semantic_model:
+          name: booking_source
+          node_relation:
+            schema_name: some_schema
+            alias: some_alias
+          primary_entity: booking
+
+          entities:
+            - name: user
+              type: foreign
+              expr: user_id
+          dimensions:
+            - name: is_instant
+              type: categorical
+          measures:
+            - name: bookings
+              expr: "1"
+              agg: sum
+        ---
+        metric:
+          name: "bookings"
+          description: "bookings metric"
+          label: "Bookings"
+          type: simple
+          type_params:
+            measure:
+              name: bookings
+        ---
+        metric:
+          name: "test_cumulative_metric_with_custom_window"
+          description: "Test cumulative window with custom granularity"
+          type: cumulative
+          time_granularity: martian_week
+          type_params:
+            measure:
+              name: bookings
+            cumulative_type_params:
+              window: 5 martian_weeks
+        """
+    )
+    metric_file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
+    model = parse_yaml_files_to_validation_ready_semantic_manifest(
+        [EXAMPLE_PROJECT_CONFIGURATION_YAML_CONFIG_FILE, base_semantic_manifest_file(), metric_file]
+    )
+    assert not model.issues.has_blocking_issues
+    semantic_manifest = model.semantic_manifest
+    assert len(semantic_manifest.metrics) == 3
+
+    metric = next((m for m in semantic_manifest.metrics if m.name == "test_cumulative_metric_with_custom_window"), None)
+    assert metric is not None, "Can't find metric"
+    # Should have gotten rid of the trailing 's' from the transformations
+    assert (
+        metric.type_params.cumulative_type_params
+        and metric.type_params.cumulative_type_params.window
+        and metric.type_params.cumulative_type_params.window.window_string == "5 martian_week"
+    )
+
+
+def test_conversion_metric_with_custom_grain_window() -> None:  # noqa: D
+    yaml_contents = textwrap.dedent(
+        """\
+        semantic_model:
+          name: booking_source
+          node_relation:
+            schema_name: some_schema
+            alias: some_alias
+          primary_entity: booking
+
+          entities:
+            - name: user
+              type: foreign
+              expr: user_id
+          dimensions:
+            - name: is_instant
+              type: categorical
+          measures:
+            - name: bookings
+              expr: "1"
+              agg: sum
+        ---
+        metric:
+          name: "bookings"
+          description: "bookings metric"
+          label: "Bookings"
+          type: simple
+          type_params:
+            measure:
+              name: bookings
+        ---
+        metric:
+          name: "test_conversion_metric_with_custom_grain_window"
+          description: "Test conversion metric window with custom granularity"
+          type: conversion
+          type_params:
+            conversion_type_params:
+              base_measure: bookings
+              conversion_measure: bookings
+              window: 7 martian_weeks
+              entity: user
+              calculation: conversion_rate
+        """
+    )
+    metric_file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
+    model = parse_yaml_files_to_validation_ready_semantic_manifest(
+        [EXAMPLE_PROJECT_CONFIGURATION_YAML_CONFIG_FILE, base_semantic_manifest_file(), metric_file]
+    )
+    assert not model.issues.has_blocking_issues
+    semantic_manifest = model.semantic_manifest
+    assert len(semantic_manifest.metrics) == 3
+
+    metric = next(
+        (m for m in semantic_manifest.metrics if m.name == "test_conversion_metric_with_custom_grain_window"), None
+    )
+    assert metric is not None, "Can't find metric"
+    # Should have gotten rid of the trailing 's' from the transformations
+    assert (
+        metric.type_params.conversion_type_params
+        and metric.type_params.conversion_type_params.window
+        and metric.type_params.conversion_type_params.window.window_string == "7 martian_week"
+    )
+
+
+def test_input_metric_custom_grains() -> None:  # noqa: D
+    yaml_contents = textwrap.dedent(
+        """\
+        semantic_model:
+          name: booking_source
+          node_relation:
+            schema_name: some_schema
+            alias: some_alias
+          primary_entity: booking
+
+          entities:
+            - name: user
+              type: foreign
+              expr: user_id
+          dimensions:
+            - name: is_instant
+              type: categorical
+          measures:
+            - name: bookings
+              expr: "1"
+              agg: sum
+        ---
+        metric:
+          name: "bookings"
+          description: "bookings metric"
+          label: "Bookings"
+          type: simple
+          type_params:
+            measure:
+              name: bookings
+        ---
+        metric:
+          name: "test_input_metric_custom_grains"
+          description: "Test custom granularity support in input metrics"
+          type: derived
+          type_params:
+            expr: bookings_offset_to_grain - bookings_offset_window
+            metrics:
+              - name: bookings
+                offset_to_grain: martian_week
+                alias: bookings_offset_to_grain
+              - name: bookings
+                offset_window: 14 martian_weeks
+                alias: bookings_offset_window
+        """
+    )
+
+    metric_file = YamlConfigFile(filepath="inline_for_test", contents=yaml_contents)
+    model = parse_yaml_files_to_validation_ready_semantic_manifest(
+        [EXAMPLE_PROJECT_CONFIGURATION_YAML_CONFIG_FILE, base_semantic_manifest_file(), metric_file]
+    )
+    assert not model.issues.has_blocking_issues
+    semantic_manifest = model.semantic_manifest
+    assert len(semantic_manifest.metrics) == 3
+
+    metric = next((m for m in semantic_manifest.metrics if m.name == "test_input_metric_custom_grains"), None)
+    assert metric is not None, "Can't find metric"
+    # Should have gotten rid of the trailing 's' from the transformations
+    assert metric.type_params.metrics and {
+        m.offset_to_grain or (m.offset_window.window_string if m.offset_window else None)
+        for m in metric.type_params.metrics
+    } == {
+        "martian_week",
+        "14 martian_week",
+    }
diff --git a/tests/validations/test_metrics.py b/tests/validations/test_metrics.py
index c96d23b3..3e02ce65 100644
--- a/tests/validations/test_metrics.py
+++ b/tests/validations/test_metrics.py
@@ -303,10 +303,13 @@ def test_derived_metric() -> None:  # noqa: D
                         expr="random_metric / random_metric3",
                         metrics=[
                             PydanticMetricInput(
-                                name="random_metric", offset_window=PydanticMetricTimeWindow.parse("3 weeks")
+                                name="random_metric",
+                                offset_window=PydanticMetricTimeWindow.parse("3 weeks", custom_granularity_names=()),
                             ),
                             PydanticMetricInput(
-                                name="random_metric", offset_to_grain=TimeGranularity.MONTH, alias="random_metric3"
+                                name="random_metric",
+                                offset_to_grain=TimeGranularity.MONTH.value,
+                                alias="random_metric3",
                             ),
                         ],
                     ),
@@ -319,8 +322,8 @@ def test_derived_metric() -> None:  # noqa: D
                         metrics=[
                             PydanticMetricInput(
                                 name="random_metric",
-                                offset_window=PydanticMetricTimeWindow.parse("3 weeks"),
-                                offset_to_grain=TimeGranularity.MONTH,
+                                offset_window=PydanticMetricTimeWindow.parse("3 weeks", custom_granularity_names=()),
+                                offset_to_grain=TimeGranularity.MONTH.value,
                             )
                         ],
                     ),
@@ -348,7 +351,7 @@ def test_conversion_metrics() -> None:  # noqa: D
     entity = "entity"
     invalid_entity = "bad"
     invalid_measure = "invalid_measure"
-    window = PydanticMetricTimeWindow.parse("7 days")
+    window = PydanticMetricTimeWindow.parse("7 days", custom_granularity_names=())
     validator = SemanticManifestValidator[PydanticSemanticManifest]([ConversionMetricRule()])
     result = validator.validate_semantic_manifest(
         PydanticSemanticManifest(
@@ -466,13 +469,59 @@ def test_conversion_metrics() -> None:  # noqa: D
                         )
                     ),
                 ),
+                metric_with_guaranteed_meta(
+                    name="bad_window",
+                    type=MetricType.CONVERSION,
+                    type_params=PydanticMetricTypeParams(
+                        conversion_type_params=PydanticConversionTypeParams(
+                            base_measure=PydanticMetricInputMeasure(name=base_measure_name),
+                            conversion_measure=PydanticMetricInputMeasure(
+                                name=conversion_measure_name,
+                            ),
+                            window=PydanticMetricTimeWindow.parse("7 moons", custom_granularity_names=(), strict=False),
+                            entity=entity,
+                        )
+                    ),
+                ),
+                metric_with_guaranteed_meta(
+                    name="custom_grain_window",
+                    type=MetricType.CONVERSION,
+                    type_params=PydanticMetricTypeParams(
+                        conversion_type_params=PydanticConversionTypeParams(
+                            base_measure=PydanticMetricInputMeasure(name=base_measure_name),
+                            conversion_measure=PydanticMetricInputMeasure(
+                                name=conversion_measure_name,
+                            ),
+                            window=PydanticMetricTimeWindow.parse(
+                                "7 martian_week", custom_granularity_names=("martian_week",)
+                            ),
+                            entity=entity,
+                        )
+                    ),
+                ),
+                metric_with_guaranteed_meta(
+                    name="custom_grain_window_plural",
+                    type=MetricType.CONVERSION,
+                    type_params=PydanticMetricTypeParams(
+                        conversion_type_params=PydanticConversionTypeParams(
+                            base_measure=PydanticMetricInputMeasure(name=base_measure_name),
+                            conversion_measure=PydanticMetricInputMeasure(
+                                name=conversion_measure_name,
+                            ),
+                            window=PydanticMetricTimeWindow.parse(
+                                "7 martian_weeks", custom_granularity_names=("martian_week",)
+                            ),
+                            entity=entity,
+                        )
+                    ),
+                ),
             ],
             project_configuration=EXAMPLE_PROJECT_CONFIGURATION,
         )
     )
 
     build_issues = result.all_issues
-    assert len(result.errors) == 5
+    assert len(result.errors) == 6
     assert len(result.warnings) == 1
 
     expected_substrings = [
@@ -482,6 +531,7 @@ def test_conversion_metrics() -> None:  # noqa: D
         "The provided constant property: bad_dim, cannot be found",
         "The provided constant property: bad_dim2, cannot be found",
         "filtering on a conversion input measure is not fully supported yet",
+        "Invalid time granularity",
     ]
     check_error_in_issues(error_substrings=expected_substrings, issues=build_issues)
 
@@ -519,7 +569,7 @@ def test_cumulative_metrics() -> None:  # noqa: D
                     type=MetricType.CUMULATIVE,
                     type_params=PydanticMetricTypeParams(
                         measure=PydanticMetricInputMeasure(name=measure_name),
-                        window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.WEEK),
+                        window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.WEEK.value),
                         cumulative_type_params=PydanticCumulativeTypeParams(period_agg=PeriodAggregation.LAST),
                     ),
                 ),
@@ -538,7 +588,7 @@ def test_cumulative_metrics() -> None:  # noqa: D
                     type_params=PydanticMetricTypeParams(
                         measure=PydanticMetricInputMeasure(name=measure_name),
                         cumulative_type_params=PydanticCumulativeTypeParams(
-                            window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.WEEK),
+                            window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.WEEK.value),
                             period_agg=PeriodAggregation.AVERAGE,
                         ),
                     ),
@@ -548,7 +598,7 @@ def test_cumulative_metrics() -> None:  # noqa: D
                     type=MetricType.CUMULATIVE,
                     type_params=PydanticMetricTypeParams(
                         measure=PydanticMetricInputMeasure(name=measure_name),
-                        cumulative_type_params=PydanticCumulativeTypeParams(grain_to_date=TimeGranularity.MONTH),
+                        cumulative_type_params=PydanticCumulativeTypeParams(grain_to_date=TimeGranularity.MONTH.value),
                     ),
                 ),
                 # Metric with both window & grain across both type_params - should get warning
@@ -559,7 +609,7 @@ def test_cumulative_metrics() -> None:  # noqa: D
                         measure=PydanticMetricInputMeasure(name=measure_name),
                         grain_to_date=TimeGranularity.MONTH,
                         cumulative_type_params=PydanticCumulativeTypeParams(
-                            window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.WEEK),
+                            window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.WEEK.value),
                             period_agg=PeriodAggregation.FIRST,
                         ),
                     ),
@@ -572,7 +622,7 @@ def test_cumulative_metrics() -> None:  # noqa: D
                         measure=PydanticMetricInputMeasure(name=measure_name),
                         grain_to_date=TimeGranularity.YEAR,
                         cumulative_type_params=PydanticCumulativeTypeParams(
-                            grain_to_date=TimeGranularity.HOUR,
+                            grain_to_date=TimeGranularity.HOUR.value,
                         ),
                     ),
                 ),
@@ -581,9 +631,9 @@ def test_cumulative_metrics() -> None:  # noqa: D
                     type=MetricType.CUMULATIVE,
                     type_params=PydanticMetricTypeParams(
                         measure=PydanticMetricInputMeasure(name=measure_name),
-                        window=PydanticMetricTimeWindow(count=2, granularity=TimeGranularity.QUARTER),
+                        window=PydanticMetricTimeWindow(count=2, granularity=TimeGranularity.QUARTER.value),
                         cumulative_type_params=PydanticCumulativeTypeParams(
-                            window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.QUARTER),
+                            window=PydanticMetricTimeWindow(count=1, granularity=TimeGranularity.QUARTER.value),
                         ),
                     ),
                 ),
@@ -596,14 +646,51 @@ def test_cumulative_metrics() -> None:  # noqa: D
                         cumulative_type_params=PydanticCumulativeTypeParams(period_agg=PeriodAggregation.FIRST),
                     ),
                 ),
+                metric_with_guaranteed_meta(
+                    name="bad_window",
+                    type=MetricType.CUMULATIVE,
+                    type_params=PydanticMetricTypeParams(
+                        measure=PydanticMetricInputMeasure(name=measure_name),
+                        cumulative_type_params=PydanticCumulativeTypeParams(
+                            window=PydanticMetricTimeWindow.parse(
+                                window="3 moons", custom_granularity_names=(), strict=False
+                            ),
+                        ),
+                    ),
+                ),
+                metric_with_guaranteed_meta(
+                    name="custom_grain_window",
+                    type=MetricType.CUMULATIVE,
+                    type_params=PydanticMetricTypeParams(
+                        measure=PydanticMetricInputMeasure(name=measure_name),
+                        cumulative_type_params=PydanticCumulativeTypeParams(
+                            window=PydanticMetricTimeWindow.parse(
+                                window="3 martian_week", custom_granularity_names=("martian_week",), strict=False
+                            ),
+                        ),
+                    ),
+                ),
+                metric_with_guaranteed_meta(
+                    name="custom_grain_window_plural",
+                    type=MetricType.CUMULATIVE,
+                    type_params=PydanticMetricTypeParams(
+                        measure=PydanticMetricInputMeasure(name=measure_name),
+                        cumulative_type_params=PydanticCumulativeTypeParams(
+                            window=PydanticMetricTimeWindow.parse(
+                                window="3 martian_weeks", custom_granularity_names=("martian_week",), strict=False
+                            ),
+                        ),
+                    ),
+                ),
             ],
             project_configuration=EXAMPLE_PROJECT_CONFIGURATION,
         )
     )
 
     build_issues = validation_results.all_issues
-    assert len(build_issues) == 3
+    assert len(build_issues) == 4
     expected_substrings = [
+        "Invalid time granularity",
         "Both window and grain_to_date set for cumulative metric. Please set one or the other.",
         "Got differing values for `window`",
         "Got differing values for `grain_to_date`",
@@ -660,7 +747,7 @@ def test_time_granularity() -> None:
                     type_params=PydanticMetricTypeParams(
                         measure=PydanticMetricInputMeasure(name=week_measure_name),
                     ),
-                    time_granularity=TimeGranularity.MONTH,
+                    time_granularity=TimeGranularity.MONTH.value,
                 ),
                 metric_with_guaranteed_meta(
                     name="month_metric_with_invalid_time_granularity",
@@ -668,7 +755,7 @@ def test_time_granularity() -> None:
                     type_params=PydanticMetricTypeParams(
                         measure=PydanticMetricInputMeasure(name=month_measure_name),
                     ),
-                    time_granularity=TimeGranularity.WEEK,
+                    time_granularity=TimeGranularity.WEEK.value,
                 ),
                 # Derived metrics
                 metric_with_guaranteed_meta(
@@ -691,7 +778,7 @@ def test_time_granularity() -> None:
                         ],
                         expr=("week_metric_with_valid_time_granularity + month_metric_with_no_time_granularity_set"),
                     ),
-                    time_granularity=TimeGranularity.YEAR,
+                    time_granularity=TimeGranularity.YEAR.value,
                 ),
                 metric_with_guaranteed_meta(
                     name="derived_metric_with_invalid_time_granularity",
@@ -703,7 +790,7 @@ def test_time_granularity() -> None:
                         ],
                         expr=("week_metric_with_valid_time_granularity + month_metric_with_no_time_granularity_set"),
                     ),
-                    time_granularity=TimeGranularity.DAY,
+                    time_granularity=TimeGranularity.DAY.value,
                 ),
             ],
             project_configuration=EXAMPLE_PROJECT_CONFIGURATION,