diff --git a/backend/src/baserow/core/apps.py b/backend/src/baserow/core/apps.py
index 1747bc2465..db643b7141 100755
--- a/backend/src/baserow/core/apps.py
+++ b/backend/src/baserow/core/apps.py
@@ -37,13 +37,69 @@ def ready(self):
         from baserow.core.formula.registries import formula_runtime_function_registry
         from baserow.core.formula.runtime_formula_types import (
             RuntimeAdd,
+            RuntimeCapitalize,
             RuntimeConcat,
+            RuntimeDateTimeFormat,
+            RuntimeDay,
+            RuntimeDivide,
+            RuntimeEqual,
+            RuntimeGenerateUUID,
             RuntimeGet,
+            RuntimeGetProperty,
+            RuntimeGreaterThan,
+            RuntimeGreaterThanOrEqual,
+            RuntimeHour,
+            RuntimeIsEven,
+            RuntimeIsOdd,
+            RuntimeLessThan,
+            RuntimeLower,
+            RuntimeMinus,
+            RuntimeMinute,
+            RuntimeMonth,
+            RuntimeMultiply,
+            RuntimeNotEqual,
+            RuntimeNow,
+            RuntimeRandomBool,
+            RuntimeRandomFloat,
+            RuntimeRandomInt,
+            RuntimeRound,
+            RuntimeSecond,
+            RuntimeToday,
+            RuntimeUpper,
+            RuntimeYear,
         )
 
         formula_runtime_function_registry.register(RuntimeConcat())
         formula_runtime_function_registry.register(RuntimeGet())
         formula_runtime_function_registry.register(RuntimeAdd())
+        formula_runtime_function_registry.register(RuntimeMinus())
+        formula_runtime_function_registry.register(RuntimeMultiply())
+        formula_runtime_function_registry.register(RuntimeDivide())
+        formula_runtime_function_registry.register(RuntimeEqual())
+        formula_runtime_function_registry.register(RuntimeNotEqual())
+        formula_runtime_function_registry.register(RuntimeGreaterThan())
+        formula_runtime_function_registry.register(RuntimeLessThan())
+        formula_runtime_function_registry.register(RuntimeGreaterThanOrEqual())
+        formula_runtime_function_registry.register(RuntimeUpper())
+        formula_runtime_function_registry.register(RuntimeLower())
+        formula_runtime_function_registry.register(RuntimeCapitalize())
+        formula_runtime_function_registry.register(RuntimeRound())
+        formula_runtime_function_registry.register(RuntimeIsEven())
+        formula_runtime_function_registry.register(RuntimeIsOdd())
+        formula_runtime_function_registry.register(RuntimeDateTimeFormat())
+        formula_runtime_function_registry.register(RuntimeDay())
+        formula_runtime_function_registry.register(RuntimeMonth())
+        formula_runtime_function_registry.register(RuntimeYear())
+        formula_runtime_function_registry.register(RuntimeHour())
+        formula_runtime_function_registry.register(RuntimeMinute())
+        formula_runtime_function_registry.register(RuntimeSecond())
+        formula_runtime_function_registry.register(RuntimeNow())
+        formula_runtime_function_registry.register(RuntimeToday())
+        formula_runtime_function_registry.register(RuntimeGetProperty())
+        formula_runtime_function_registry.register(RuntimeRandomInt())
+        formula_runtime_function_registry.register(RuntimeRandomFloat())
+        formula_runtime_function_registry.register(RuntimeRandomBool())
+        formula_runtime_function_registry.register(RuntimeGenerateUUID())
 
         from baserow.core.permission_manager import (
             AllowIfTemplatePermissionManagerType,
diff --git a/backend/src/baserow/core/formula/argument_types.py b/backend/src/baserow/core/formula/argument_types.py
index 979ac47289..ac6d40c97f 100644
--- a/backend/src/baserow/core/formula/argument_types.py
+++ b/backend/src/baserow/core/formula/argument_types.py
@@ -1,3 +1,13 @@
+from django.core.exceptions import ValidationError
+
+from baserow.core.formula.validator import (
+    ensure_datetime,
+    ensure_numeric,
+    ensure_object,
+    ensure_string,
+)
+
+
 class BaserowRuntimeFormulaArgumentType:
     def test(self, value):
         return True
@@ -9,22 +19,62 @@ def parse(self, value):
 class NumberBaserowRuntimeFormulaArgumentType(BaserowRuntimeFormulaArgumentType):
     def test(self, value):
         try:
-            float(value)
+            ensure_numeric(value)
             return True
-        except ValueError:
+        except ValidationError:
             return False
 
     def parse(self, value):
-        return float(value)
+        return ensure_numeric(value)
 
 
 class TextBaserowRuntimeFormulaArgumentType(BaserowRuntimeFormulaArgumentType):
     def test(self, value):
         try:
-            str(value)
+            ensure_string(value)
+            return True
+        except ValidationError:
+            return False
+
+    def parse(self, value):
+        return ensure_string(value)
+
+
+class AddableBaserowRuntimeFormulaArgumentType(BaserowRuntimeFormulaArgumentType):
+    def test(self, value):
+        return hasattr(value, "__add__")
+
+    def parse(self, value):
+        return value
+
+
+class SubtractableBaserowRuntimeFormulaArgumentType(BaserowRuntimeFormulaArgumentType):
+    def test(self, value):
+        return hasattr(value, "__sub__")
+
+    def parse(self, value):
+        return value
+
+
+class DateTimeBaserowRuntimeFormulaArgumentType(BaserowRuntimeFormulaArgumentType):
+    def test(self, value):
+        try:
+            ensure_datetime(value)
+            return True
+        except ValidationError:
+            return False
+
+    def parse(self, value):
+        return ensure_datetime(value)
+
+
+class DictBaserowRuntimeFormulaArgumentType(BaserowRuntimeFormulaArgumentType):
+    def test(self, value):
+        try:
+            ensure_object(value)
             return True
-        except TypeError:
+        except ValidationError:
             return False
 
     def parse(self, value):
-        return str(value)
+        return ensure_object(value)
diff --git a/backend/src/baserow/core/formula/runtime_formula_types.py b/backend/src/baserow/core/formula/runtime_formula_types.py
index 95b762bf4b..1dcf91b592 100644
--- a/backend/src/baserow/core/formula/runtime_formula_types.py
+++ b/backend/src/baserow/core/formula/runtime_formula_types.py
@@ -1,20 +1,40 @@
+import operator
+import random
+import uuid
+from functools import reduce
+from typing import Optional
+from zoneinfo import ZoneInfo
+
+from django.utils import timezone
+
 from baserow.core.formula.argument_types import (
+    AddableBaserowRuntimeFormulaArgumentType,
+    DateTimeBaserowRuntimeFormulaArgumentType,
+    DictBaserowRuntimeFormulaArgumentType,
     NumberBaserowRuntimeFormulaArgumentType,
+    SubtractableBaserowRuntimeFormulaArgumentType,
     TextBaserowRuntimeFormulaArgumentType,
 )
 from baserow.core.formula.registries import RuntimeFormulaFunction
-from baserow.core.formula.types import FormulaArgs, FormulaContext
+from baserow.core.formula.types import FormulaArg, FormulaArgs, FormulaContext
 from baserow.core.formula.validator import ensure_string
 
 
 class RuntimeConcat(RuntimeFormulaFunction):
     type = "concat"
 
-    def execute(self, context: FormulaContext, args: FormulaArgs):
-        return "".join([ensure_string(a) for a in args])
+    def validate_type_of_args(self, args) -> Optional[FormulaArg]:
+        arg_type = AddableBaserowRuntimeFormulaArgumentType()
+        return next(
+            (arg for arg in args if not arg_type.test(arg)),
+            None,
+        )
 
     def validate_number_of_args(self, args):
-        return len(args) >= 2
+        return len(args) > 1
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return "".join([ensure_string(a) for a in args])
 
 
 class RuntimeGet(RuntimeFormulaFunction):
@@ -27,10 +47,352 @@ def execute(self, context: FormulaContext, args: FormulaArgs):
 
 class RuntimeAdd(RuntimeFormulaFunction):
     type = "add"
+
+    def validate_type_of_args(self, args) -> Optional[FormulaArg]:
+        arg_type = AddableBaserowRuntimeFormulaArgumentType()
+        return next(
+            (arg for arg in args if not arg_type.test(arg)),
+            None,
+        )
+
+    def validate_number_of_args(self, args):
+        return len(args) >= 1
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return reduce(operator.add, args)
+
+
+class RuntimeMinus(RuntimeFormulaFunction):
+    type = "minus"
+
+    def validate_type_of_args(self, args) -> Optional[FormulaArg]:
+        arg_type = SubtractableBaserowRuntimeFormulaArgumentType()
+        return next(
+            (arg for arg in args if not arg_type.test(arg)),
+            None,
+        )
+
+    def validate_number_of_args(self, args):
+        return len(args) > 1
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return reduce(operator.sub, args)
+
+
+class RuntimeMultiply(RuntimeFormulaFunction):
+    type = "multiply"
+    args = [
+        NumberBaserowRuntimeFormulaArgumentType(),
+        NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+
+    def validate_number_of_args(self, args):
+        return len(args) == 2
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0] * args[1]
+
+
+class RuntimeDivide(RuntimeFormulaFunction):
+    type = "divide"
+    args = [
+        NumberBaserowRuntimeFormulaArgumentType(),
+        NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+
+    def validate_number_of_args(self, args):
+        return len(args) == 2
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0] / args[1]
+
+
+class RuntimeEqual(RuntimeFormulaFunction):
+    type = "equal"
     args = [
         NumberBaserowRuntimeFormulaArgumentType(),
         NumberBaserowRuntimeFormulaArgumentType(),
     ]
 
+    def validate_number_of_args(self, args):
+        return len(args) == 2
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0] == args[1]
+
+
+class RuntimeNotEqual(RuntimeFormulaFunction):
+    type = "not_equal"
+    args = [
+        NumberBaserowRuntimeFormulaArgumentType(),
+        NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+
+    def validate_number_of_args(self, args):
+        return len(args) == 2
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0] != args[1]
+
+
+class RuntimeGreaterThan(RuntimeFormulaFunction):
+    type = "greater_than"
+    args = [
+        NumberBaserowRuntimeFormulaArgumentType(),
+        NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+
+    def validate_number_of_args(self, args):
+        return len(args) == 2
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0] > args[1]
+
+
+class RuntimeLessThan(RuntimeFormulaFunction):
+    type = "less_than"
+    args = [
+        NumberBaserowRuntimeFormulaArgumentType(),
+        NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+
+    def validate_number_of_args(self, args):
+        return len(args) == 2
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0] < args[1]
+
+
+class RuntimeGreaterThanOrEqual(RuntimeFormulaFunction):
+    type = "greater_than_or_equal"
+    args = [
+        NumberBaserowRuntimeFormulaArgumentType(),
+        NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+
+    def validate_number_of_args(self, args):
+        return len(args) == 2
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0] >= args[1]
+
+
+class RuntimeLessThanOrEqual(RuntimeFormulaFunction):
+    type = "less_than_or_equal"
+    args = [
+        NumberBaserowRuntimeFormulaArgumentType(),
+        NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+
+    def validate_number_of_args(self, args):
+        return len(args) == 2
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0] <= args[1]
+
+
+class RuntimeUpper(RuntimeFormulaFunction):
+    type = "upper"
+
+    args = [TextBaserowRuntimeFormulaArgumentType()]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0].upper()
+
+
+class RuntimeLower(RuntimeFormulaFunction):
+    type = "lower"
+
+    args = [TextBaserowRuntimeFormulaArgumentType()]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0].lower()
+
+
+class RuntimeCapitalize(RuntimeFormulaFunction):
+    type = "capitalize"
+
+    args = [TextBaserowRuntimeFormulaArgumentType()]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0].capitalize()
+
+
+class RuntimeRound(RuntimeFormulaFunction):
+    type = "round"
+
+    args = [
+        NumberBaserowRuntimeFormulaArgumentType(),
+        NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        # Default to 2 places
+        decimal_places = 2
+
+        if len(args) == 2:
+            # Avoid negative numbers
+            decimal_places = max(args[1], 0)
+
+        return round(args[0], decimal_places)
+
+
+class RuntimeIsEven(RuntimeFormulaFunction):
+    type = "is_even"
+
+    args = [NumberBaserowRuntimeFormulaArgumentType()]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0] % 2 == 0
+
+
+class RuntimeIsOdd(RuntimeFormulaFunction):
+    type = "is_odd"
+
+    args = [NumberBaserowRuntimeFormulaArgumentType()]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0] % 2 != 0
+
+
+class RuntimeDateTimeFormat(RuntimeFormulaFunction):
+    type = "datetime_format"
+
+    args = [
+        DateTimeBaserowRuntimeFormulaArgumentType(),
+        TextBaserowRuntimeFormulaArgumentType(),
+        TextBaserowRuntimeFormulaArgumentType(),
+    ]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        tz_name = None
+        tz_format = "%Y-%m-%d %H:%M:%S"
+
+        if len(args) == 3:
+            tz_name = args[2]
+            tz_format = args[1]
+        elif len(args) == 2:
+            tz_format = args[1]
+
+        if tz_name:
+            return args[0].replace(tzinfo=ZoneInfo(tz_name)).strftime(tz_format)
+
+        return args[0].strftime(tz_format)
+
+
+class RuntimeDay(RuntimeFormulaFunction):
+    type = "day"
+
+    args = [DateTimeBaserowRuntimeFormulaArgumentType()]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0].day
+
+
+class RuntimeMonth(RuntimeFormulaFunction):
+    type = "month"
+
+    args = [DateTimeBaserowRuntimeFormulaArgumentType()]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0].month
+
+
+class RuntimeYear(RuntimeFormulaFunction):
+    type = "year"
+
+    args = [DateTimeBaserowRuntimeFormulaArgumentType()]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0].year
+
+
+class RuntimeHour(RuntimeFormulaFunction):
+    type = "hour"
+
+    args = [DateTimeBaserowRuntimeFormulaArgumentType()]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0].hour
+
+
+class RuntimeMinute(RuntimeFormulaFunction):
+    type = "minute"
+
+    args = [DateTimeBaserowRuntimeFormulaArgumentType()]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0].minute
+
+
+class RuntimeSecond(RuntimeFormulaFunction):
+    type = "second"
+
+    args = [DateTimeBaserowRuntimeFormulaArgumentType()]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0].second
+
+
+class RuntimeNow(RuntimeFormulaFunction):
+    type = "now"
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return timezone.now()
+
+
+class RuntimeToday(RuntimeFormulaFunction):
+    type = "today"
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return timezone.localdate()
+
+
+class RuntimeGetProperty(RuntimeFormulaFunction):
+    type = "get_property"
+
+    args = [
+        DictBaserowRuntimeFormulaArgumentType(),
+        TextBaserowRuntimeFormulaArgumentType(),
+    ]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return args[0].get(args[1])
+
+
+class RuntimeRandomInt(RuntimeFormulaFunction):
+    type = "random_int"
+
+    args = [
+        NumberBaserowRuntimeFormulaArgumentType(),
+        NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return random.randint(int(args[0]), int(args[1]))  # nosec: B311
+
+
+class RuntimeRandomFloat(RuntimeFormulaFunction):
+    type = "random_float"
+
+    args = [
+        NumberBaserowRuntimeFormulaArgumentType(),
+        NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return random.uniform(float(args[0]), float(args[1]))  # nosec: B311
+
+
+class RuntimeRandomBool(RuntimeFormulaFunction):
+    type = "random_bool"
+
+    def execute(self, context: FormulaContext, args: FormulaArgs):
+        return random.choice([True, False])  # nosec: B311
+
+
+class RuntimeGenerateUUID(RuntimeFormulaFunction):
+    type = "generate_uuid"
+
     def execute(self, context: FormulaContext, args: FormulaArgs):
-        return args[0] + args[1]
+        return str(uuid.uuid4())
diff --git a/backend/src/baserow/core/formula/validator.py b/backend/src/baserow/core/formula/validator.py
index 46f55d443e..7144995a28 100644
--- a/backend/src/baserow/core/formula/validator.py
+++ b/backend/src/baserow/core/formula/validator.py
@@ -2,6 +2,7 @@
 import re
 from datetime import date, datetime
 from decimal import Decimal
+from json.decoder import JSONDecodeError
 from typing import Any, List, Optional, Union
 
 from django.core.exceptions import ValidationError
@@ -215,3 +216,24 @@ def ensure_datetime(value: Any) -> Optional[datetime]:
         return FormattedDateTime(value).datetime if value is not None else None
     except (ValueError, TypeError) as exc:
         raise ValidationError("Value cannot be converted to a datetime.") from exc
+
+
+def ensure_object(value: Any) -> Optional[dict]:
+    """
+    Ensures that the value is a dict or can be converted to a dict.
+    :param value: The value to ensure as a dict.
+    :return: The value as a dict.
+    :raises ValidationError: If the value is not a valid dict or convertible to a
+        dict.
+    """
+
+    if isinstance(value, dict):
+        return value
+
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except (TypeError, JSONDecodeError) as exc:
+            raise ValidationError("Value is not a JSON.") from exc
+
+    raise ValidationError("Value cannot be converted to a dict.")
diff --git a/backend/tests/baserow/core/formula/test_argument_types.py b/backend/tests/baserow/core/formula/test_argument_types.py
new file mode 100644
index 0000000000..cf830bc5b2
--- /dev/null
+++ b/backend/tests/baserow/core/formula/test_argument_types.py
@@ -0,0 +1,255 @@
+from datetime import date, datetime
+
+import pytest
+
+from baserow.core.formula.argument_types import (
+    AddableBaserowRuntimeFormulaArgumentType,
+    DateTimeBaserowRuntimeFormulaArgumentType,
+    DictBaserowRuntimeFormulaArgumentType,
+    NumberBaserowRuntimeFormulaArgumentType,
+    SubtractableBaserowRuntimeFormulaArgumentType,
+    TextBaserowRuntimeFormulaArgumentType,
+)
+
+
+@pytest.mark.parametrize(
+    "value,expected",
+    [
+        (-5, True),
+        (-5.5, True),
+        ("-5.5", True),
+        (0, True),
+        (10, True),
+        ("10", True),
+        (16.25, True),
+        ("16.25", True),
+        ("foo", False),
+        (" 1 ", False),
+        ("", False),
+        (None, False),
+    ],
+)
+def test_number_test_method(value, expected):
+    assert NumberBaserowRuntimeFormulaArgumentType().test(value) is expected
+
+
+@pytest.mark.parametrize(
+    "value,expected",
+    [
+        (-5, -5),
+        ("-5", -5),
+        (0, 0),
+        ("0", 0),
+        (15.6, 15.6),
+        ("15.6", 15.6),
+    ],
+)
+def test_number_parse_method(value, expected):
+    assert NumberBaserowRuntimeFormulaArgumentType().parse(value) == expected
+
+
+@pytest.mark.parametrize(
+    "value,expected",
+    [
+        (-5, True),
+        (-5.5, True),
+        ("-5.5", True),
+        (0, True),
+        (10, True),
+        ("10", True),
+        (16.25, True),
+        ("16.25", True),
+        ("", True),
+        ({}, True),
+        ([], True),
+        (None, True),
+    ],
+)
+def test_text_test_method(value, expected):
+    assert TextBaserowRuntimeFormulaArgumentType().test(value) is expected
+
+
+@pytest.mark.parametrize(
+    "value,expected",
+    [
+        (-5, "-5"),
+        ("-5", "-5"),
+        (0, "0"),
+        ("0", "0"),
+        (15.6, "15.6"),
+        ("15.6", "15.6"),
+        ({"foo": "bar"}, '{"foo": "bar"}'),
+        (["a", "b"], "a,b"),
+        (None, ""),
+    ],
+)
+def test_text_parse_method(value, expected):
+    assert TextBaserowRuntimeFormulaArgumentType().parse(value) == expected
+
+
+@pytest.mark.parametrize(
+    "value,expected",
+    [
+        (-5, True),
+        (-5.5, True),
+        ("-5.5", True),
+        (0, True),
+        (10, True),
+        ("10", True),
+        (16.25, True),
+        ("16.25", True),
+        ([], True),
+        ("", True),
+        ({}, False),
+        (None, False),
+    ],
+)
+def test_addable_test_method(value, expected):
+    assert AddableBaserowRuntimeFormulaArgumentType().test(value) == expected
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        -5,
+        -5.5,
+        "-5.5",
+        0,
+        10,
+        "10",
+        16.25,
+        "16.25",
+        [],
+        "",
+        {},
+    ],
+)
+def test_addable_parse_method(value):
+    assert AddableBaserowRuntimeFormulaArgumentType().parse(value) == value
+
+
+@pytest.mark.parametrize(
+    "value,expected",
+    [
+        (-5, True),
+        (-5.5, True),
+        (0, True),
+        (10, True),
+        (16.25, True),
+        ([], False),
+        ("", False),
+        ("-5.5", False),
+        ("10", False),
+        ("16.25", False),
+        ({}, False),
+        (None, False),
+    ],
+)
+def test_subtractable_test_method(value, expected):
+    assert SubtractableBaserowRuntimeFormulaArgumentType().test(value) == expected
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        -5,
+        -5.5,
+        0,
+        10,
+        16.25,
+    ],
+)
+def test_subtractable_parse_method(value):
+    assert SubtractableBaserowRuntimeFormulaArgumentType().parse(value) == value
+
+
+@pytest.mark.parametrize(
+    "value,expected",
+    [
+        ("2025-12-31", True),
+        ("2025-12-31 14:22", True),
+        ("2025-12-31 14:22:11", True),
+        (date.today(), True),
+        (datetime.now(), True),
+        # None just returns True
+        (None, True),
+        # Invalid date format
+        ("31-12-2025 14:22:11", False),
+        (-5, False),
+        (-5.5, False),
+        (0, False),
+        (10, False),
+        (16.25, False),
+        ("", False),
+        ("-5.5", False),
+        ("10", False),
+        ("16.25", False),
+        ([], False),
+        ({}, False),
+    ],
+)
+def test_datetime_test_method(value, expected):
+    assert DateTimeBaserowRuntimeFormulaArgumentType().test(value) == expected
+
+
+@pytest.mark.parametrize(
+    "value,expected",
+    [
+        # A date is converted to datetime with hour/minute/second to 0
+        (
+            "2025-12-31",
+            datetime(year=2025, month=12, day=31, hour=0, minute=0, second=0),
+        ),
+        (
+            "2025-12-31 14:22",
+            datetime(year=2025, month=12, day=31, hour=14, minute=22, second=0),
+        ),
+        (
+            "2025-12-31 14:22:11",
+            datetime(year=2025, month=12, day=31, hour=14, minute=22, second=11),
+        ),
+        (
+            date(year=2025, month=10, day=22),
+            datetime(year=2025, month=10, day=22, hour=0, minute=0, second=0),
+        ),
+        (
+            datetime(year=2025, month=10, day=22, hour=1, minute=2, second=3),
+            datetime(year=2025, month=10, day=22, hour=1, minute=2, second=3),
+        ),
+        (None, None),
+    ],
+)
+def test_datetime_parse_method(value, expected):
+    assert DateTimeBaserowRuntimeFormulaArgumentType().parse(value) == expected
+
+
+@pytest.mark.parametrize(
+    "value,expected",
+    [
+        ({}, True),
+        ("{}", True),
+        ('{"foo": "bar"}', True),
+        # Invalid JSON due to single quotes
+        ("{'foo': 'bar'}", False),
+        ("", False),
+        ([], False),
+        (0, False),
+        (100, False),
+        ("foo", False),
+        (None, False),
+    ],
+)
+def test_dict_test_method(value, expected):
+    assert DictBaserowRuntimeFormulaArgumentType().test(value) == expected
+
+
+@pytest.mark.parametrize(
+    "value,expected",
+    [
+        ({}, {}),
+        ('{"foo": "bar"}', {"foo": "bar"}),
+        ({"foo": "bar"}, {"foo": "bar"}),
+    ],
+)
+def test_dict_parse_method(value, expected):
+    assert DictBaserowRuntimeFormulaArgumentType().parse(value) == expected
diff --git a/backend/tests/baserow/core/test_core_formula_runtime_formula_types.py b/backend/tests/baserow/core/formula/test_runtime_formula_types.py
similarity index 100%
rename from backend/tests/baserow/core/test_core_formula_runtime_formula_types.py
rename to backend/tests/baserow/core/formula/test_runtime_formula_types.py
diff --git a/web-frontend/locales/en.json b/web-frontend/locales/en.json
index ff06422aca..4a52b13a26 100644
--- a/web-frontend/locales/en.json
+++ b/web-frontend/locales/en.json
@@ -639,5 +639,37 @@
   },
   "assistantMessageSources": {
     "sources": "{count} source | {count} sources"
+  },
+  "runtimeFormulaTypes": {
+    "concatDescription": "Joined arguments together as a single text.",
+    "getDescription": "Returns the resolved value of a Baserow formula.",
+    "addDescription": "Adds two arguments together.",
+    "minusDescription": "Subtracts the second argument from the first.",
+    "multiplyDescription": "Multiplies the two arguments.",
+    "divideDescription": "Divides the first argument from the second.",
+    "equalDescription": "Checks if both arguments are equal.",
+    "notEqualDescription": "Checks if both arguments are not equal.",
+    "greaterThanDescription": "Checks if the first argument is greater than the second.",
+    "lessThanDescription": "Checks if the first argument is less than the second.",
+    "greaterThanOrEqualDescription": "Checks if the first argument is greater than or equal to the second.",
+    "upperDescription": "Converts the argument to upper case.",
+    "lowerDescription": "Converts the argument to lower case.",
+    "capitalizeDescription": "Capitalizes the argument's first letter.",
+    "roundDescription": "Rounds the first argument to the number of decimal places specified by the second argument.",
+    "evenDescription": "Return true if the argument is even, false otherwise.",
+    "oddDescription": "Return true if the argument is odd, false otherwise.",
+    "dateTimeDescription": "Formats the date time argument using the format and timezone arguments.",
+    "dayDescription": "Returns the day from the date time argument.",
+    "monthDescription": "Returns the month from the date time argument.",
+    "yearDescription": "Returns the year from the date time argument.",
+    "hourDescription": "Returns the hour from the date time argument.",
+    "minuteDescription": "Returns the minute from the date time argument.",
+    "secondDescription": "Returns the second from the date time argument.",
+    "todayDescription": "Returns the current date.",
+    "getPropertyDescription": "Returns the property from the object.",
+    "randomIntDescription": "Returns a random integer from the range specified by the arguments.",
+    "randomFloatDescription": "Returns a random float from the range specified by the arguments.",
+    "randomBoolDescription": "Returns a random boolean of true or false.",
+    "generateUUIDDescription": "Returns a random UUID4 string."
   }
 }
diff --git a/web-frontend/modules/automation/components/AutomationBuilderFormulaInput.vue b/web-frontend/modules/automation/components/AutomationBuilderFormulaInput.vue
index ad0837c92c..65ac6297a6 100644
--- a/web-frontend/modules/automation/components/AutomationBuilderFormulaInput.vue
+++ b/web-frontend/modules/automation/components/AutomationBuilderFormulaInput.vue
@@ -5,11 +5,15 @@
     :value="formulaStr"
     :data-providers="dataProviders"
     :application-context="applicationContext"
+    enable-advanced-mode
+    :mode="currentMode"
     @input="updatedFormulaStr"
+    @mode-changed="updateMode"
   />
 </template>
 
 <script setup>
+import { ref, watch } from 'vue'
 import { inject, computed, useContext } from '@nuxtjs/composition-api'
 import FormulaInputField from '@baserow/modules/core/components/formula/FormulaInputField'
 
@@ -19,6 +23,16 @@ const props = defineProps({
 })
 
 const applicationContext = inject('applicationContext')
+const currentMode = ref(props.value.mode)
+
+watch(
+  () => props.value.mode,
+  (newMode) => {
+    if (newMode) {
+      currentMode.value = newMode
+    }
+  }
+)
 
 const { app } = useContext()
 const dataProviders = computed(() => {
@@ -43,6 +57,14 @@ const formulaStr = computed(() => {
  */
 const emit = defineEmits(['input'])
 const updatedFormulaStr = (newFormulaStr) => {
-  emit('input', { ...props.value, formula: newFormulaStr })
+  emit('input', {
+    ...props.value,
+    formula: newFormulaStr,
+    mode: currentMode.value,
+  })
+}
+
+const updateMode = (newMode) => {
+  currentMode.value = newMode
 }
 </script>
diff --git a/web-frontend/modules/builder/components/ApplicationBuilderFormulaInput.vue b/web-frontend/modules/builder/components/ApplicationBuilderFormulaInput.vue
index 0cbb5eed74..a46ce174d2 100644
--- a/web-frontend/modules/builder/components/ApplicationBuilderFormulaInput.vue
+++ b/web-frontend/modules/builder/components/ApplicationBuilderFormulaInput.vue
@@ -2,11 +2,14 @@
   <FormulaInputField
     v-bind="$attrs"
     required
+    enable-advanced-mode
     :value="formulaStr"
+    :mode="formulaMode"
     :data-explorer-loading="dataExplorerLoading"
     :data-providers="dataProviders"
     :application-context="applicationContext"
     @input="updatedFormulaStr"
+    @mode-changed="updateMode"
   />
 </template>
 
@@ -51,6 +54,9 @@ export default {
     formulaStr() {
       return this.value.formula
     },
+    formulaMode() {
+      return this.value.mode
+    },
     dataSourceLoading() {
       return this.$store.getters['dataSource/getLoading'](this.elementPage)
     },
@@ -91,6 +97,9 @@ export default {
     updatedFormulaStr(newFormulaStr) {
       this.$emit('input', { ...this.value, formula: newFormulaStr })
     },
+    updateMode(newMode) {
+      this.$emit('input', { ...this.value, mode: newMode })
+    },
   },
 }
 </script>
diff --git a/web-frontend/modules/core/assets/scss/components/form.scss b/web-frontend/modules/core/assets/scss/components/form.scss
index e12ce36b07..76b561fdb6 100644
--- a/web-frontend/modules/core/assets/scss/components/form.scss
+++ b/web-frontend/modules/core/assets/scss/components/form.scss
@@ -33,7 +33,7 @@
 
 .control__elements--flex {
   display: flex;
-  align-items: center;
+  align-items: flex-start;
   gap: 5px;
 }
 
diff --git a/web-frontend/modules/core/assets/scss/components/formula_input_field.scss b/web-frontend/modules/core/assets/scss/components/formula_input_field.scss
index 9b1a8c72d9..794e80ec33 100644
--- a/web-frontend/modules/core/assets/scss/components/formula_input_field.scss
+++ b/web-frontend/modules/core/assets/scss/components/formula_input_field.scss
@@ -39,3 +39,13 @@
   pointer-events: none;
   height: 0;
 }
+
+.formula-input-field__advanced-input {
+  width: 100%;
+  padding: 12px 16px;
+  line-height: 100%;
+
+  &::placeholder {
+    color: $color-neutral-500;
+  }
+}
diff --git a/web-frontend/modules/core/components/formula/FormulaInputField.vue b/web-frontend/modules/core/components/formula/FormulaInputField.vue
index 143e3adb24..8abb09db6a 100644
--- a/web-frontend/modules/core/components/formula/FormulaInputField.vue
+++ b/web-frontend/modules/core/components/formula/FormulaInputField.vue
@@ -1,5 +1,5 @@
 <template>
-  <Alert v-if="isFormulaInvalid" type="error">
+  <Alert v-if="isFormulaInvalid && mode == 'simple'" type="error">
     <p>
       {{ $t('formulaInputField.errorInvalidFormula') }}
     </p>
@@ -11,6 +11,7 @@
   </Alert>
   <div v-else>
     <EditorContent
+      v-if="!isAdvancedMode"
       :id="forInput"
       ref="editor"
       class="form-input formula-input-field"
@@ -19,8 +20,31 @@
       :editor="editor"
       @data-component-clicked="dataComponentClicked"
     />
+    <FormInput
+      v-else
+      v-model="advancedFormulaValue"
+      type="text"
+      :class="classes"
+      role="textbox"
+      :disabled="disabled"
+      :placeholder="placeholder"
+      @input="emitAdvancedChange"
+    />
+
+    <div v-if="enableAdvancedMode" class="margin-top-1">
+      <label class="checkbox">
+        <Checkbox
+          :checked="isAdvancedMode"
+          :disabled="disabled"
+          @input="toggleMode()"
+        >
+          {{ $t('formulaInputField.advancedFormulaMode') }}
+        </Checkbox>
+      </label>
+    </div>
+
     <DataExplorer
-      v-if="isFocused"
+      v-if="isFocused && !isAdvancedMode"
       ref="dataExplorer"
       :nodes="nodes"
       :node-selected="nodeSelected"
@@ -47,6 +71,7 @@ import { mergeAttributes } from '@tiptap/core'
 import DataExplorer from '@baserow/modules/core/components/dataExplorer/DataExplorer'
 import { RuntimeGet } from '@baserow/modules/core/runtimeFormulaTypes'
 import { isElement, onClickOutside } from '@baserow/modules/core/utils/dom'
+import { isFormulaValid } from '@baserow/modules/core/formula'
 
 export default {
   name: 'FormulaInputField',
@@ -97,6 +122,16 @@ export default {
       required: false,
       default: false,
     },
+    enableAdvancedMode: {
+      type: Boolean,
+      required: false,
+      default: false,
+    },
+    mode: {
+      type: String,
+      required: false,
+      default: 'simple',
+    },
   },
   data() {
     return {
@@ -106,12 +141,17 @@ export default {
       dataNodeSelected: null,
       isFocused: false,
       ignoreNextBlur: false,
+      advancedFormulaValue: this.value,
     }
   },
   computed: {
+    isAdvancedMode() {
+      return this.mode === 'advanced'
+    },
     classes() {
       return {
         'form-input--disabled': this.disabled,
+        'form-input--error': this.isFormulaInvalid,
         'formula-input-field--small': this.small,
         'formula-input-field--focused': !this.disabled && this.isFocused,
         'formula-input-field--disabled': this.disabled,
@@ -153,7 +193,14 @@ export default {
       ]
     },
     htmlContent() {
+      if (this.isAdvancedMode) {
+        return ''
+      }
+
       try {
+        if (!this.content) {
+          return generateHTML(this.toContent(''), this.extensions)
+        }
         return generateHTML(this.content, this.extensions)
       } catch (e) {
         console.error('Error while parsing formula content', this.value)
@@ -162,6 +209,9 @@ export default {
       }
     },
     wrapperContent() {
+      if (this.isAdvancedMode || !this.editor) {
+        return null
+      }
       return this.editor.getJSON()
     },
     nodes() {
@@ -182,6 +232,11 @@ export default {
         this.$refs.dataExplorer?.hide()
         this.unSelectNode()
       } else {
+        // Don't show data explorer in Advanced mode
+        if (this.isAdvancedMode) {
+          return
+        }
+
         // Wait for the data explorer to appear in the DOM.
         await this.$nextTick()
 
@@ -218,6 +273,12 @@ export default {
       }
     },
     value(value) {
+      // In advanced mode, just update the value directly
+      if (this.isAdvancedMode) {
+        this.advancedFormulaValue = value
+        return
+      }
+
       if (!_.isEqual(value, this.toFormula(this.wrapperContent))) {
         const content = this.toContent(value)
 
@@ -236,9 +297,24 @@ export default {
       },
       deep: true,
     },
+
+    isAdvancedMode(newValue) {
+      if (newValue) {
+        // When switching to advanced mode, preserve current value
+        this.advancedFormulaValue = this.value
+        this.isFormulaInvalid = false
+      } else {
+        // When switching to simple mode, clear the value to avoid formula parsing errors
+        this.advancedFormulaValue = ''
+        this.$emit('input', this.advancedFormulaValue)
+      }
+    },
   },
   mounted() {
-    this.content = this.toContent(this.value)
+    if (!this.isAdvancedMode) {
+      this.content = this.toContent(this.value)
+    }
+
     this.editor = new Editor({
       content: this.htmlContent,
       editable: !this.disabled,
@@ -263,9 +339,15 @@ export default {
       this.$emit('input', '')
     },
     emitChange() {
-      if (!this.isFormulaInvalid) {
-        this.$emit('input', this.toFormula(this.wrapperContent))
+      if (this.isFormulaInvalid) {
+        return
       }
+
+      const formulaValue = this.toFormula(this.wrapperContent)
+      this.$emit('input', formulaValue)
+    },
+    toggleMode() {
+      this.$emit('mode-changed', this.mode === 'simple' ? 'advanced' : 'simple')
     },
     onUpdate() {
       this.unSelectNode()
@@ -359,6 +441,14 @@ export default {
         this.dataNodeSelected = null
       }
     },
+    emitAdvancedChange() {
+      if (isFormulaValid(this.advancedFormulaValue)) {
+        this.isFormulaInvalid = false
+        this.$emit('input', this.advancedFormulaValue)
+      } else {
+        this.isFormulaInvalid = true
+      }
+    },
   },
 }
 </script>
diff --git a/web-frontend/modules/core/formula/index.js b/web-frontend/modules/core/formula/index.js
index 2e83599741..007a4e25fe 100644
--- a/web-frontend/modules/core/formula/index.js
+++ b/web-frontend/modules/core/formula/index.js
@@ -27,3 +27,16 @@ export const resolveFormula = (
     return ''
   }
 }
+
+export const isFormulaValid = (formula) => {
+  if (!formula) {
+    return true
+  }
+
+  try {
+    parseBaserowFormula(formula)
+    return true
+  } catch (err) {
+    return false
+  }
+}
diff --git a/web-frontend/modules/core/locales/en.json b/web-frontend/modules/core/locales/en.json
index ecc64ca083..6c3aab3deb 100644
--- a/web-frontend/modules/core/locales/en.json
+++ b/web-frontend/modules/core/locales/en.json
@@ -755,7 +755,8 @@
     "submitButton": "Update frequency"
   },
   "formulaInputField": {
-    "errorInvalidFormula": "The formula is invalid."
+    "errorInvalidFormula": "The formula is invalid.",
+    "advancedFormulaMode": "Advanced formula mode"
   },
   "dataExplorer": {
     "noMatchingNodesText": "No matching results were found.",
diff --git a/web-frontend/modules/core/plugin.js b/web-frontend/modules/core/plugin.js
index fa8830fb5d..a0164078f5 100644
--- a/web-frontend/modules/core/plugin.js
+++ b/web-frontend/modules/core/plugin.js
@@ -91,8 +91,37 @@ import ko from '@baserow/modules/core/locales/ko.json'
 import { DefaultErrorPageType } from '@baserow/modules/core/errorPageTypes'
 import {
   RuntimeAdd,
+  RuntimeMinus,
+  RuntimeMultiply,
+  RuntimeDivide,
+  RuntimeGreaterThan,
+  RuntimeGreaterThanOrEqual,
+  RuntimeLessThan,
+  RuntimeLessThanOrEqual,
   RuntimeConcat,
   RuntimeGet,
+  RuntimeEqual,
+  RuntimeNotEqual,
+  RuntimeUpper,
+  RuntimeLower,
+  RuntimeCapitalize,
+  RuntimeRound,
+  RuntimeIsEven,
+  RuntimeIsOdd,
+  RuntimeDateTimeFormat,
+  RuntimeDay,
+  RuntimeMonth,
+  RuntimeYear,
+  RuntimeHour,
+  RuntimeMinute,
+  RuntimeSecond,
+  RuntimeNow,
+  RuntimeToday,
+  RuntimeGetProperty,
+  RuntimeRandomInt,
+  RuntimeRandomFloat,
+  RuntimeRandomBool,
+  RuntimeGenerateUUID,
 } from '@baserow/modules/core/runtimeFormulaTypes'
 
 import priorityBus from '@baserow/modules/core/plugins/priorityBus'
@@ -232,6 +261,44 @@ export default (context, inject) => {
   registry.register('runtimeFormulaFunction', new RuntimeConcat(context))
   registry.register('runtimeFormulaFunction', new RuntimeGet(context))
   registry.register('runtimeFormulaFunction', new RuntimeAdd(context))
+  registry.register('runtimeFormulaFunction', new RuntimeMinus(context))
+  registry.register('runtimeFormulaFunction', new RuntimeMultiply(context))
+  registry.register('runtimeFormulaFunction', new RuntimeDivide(context))
+  registry.register('runtimeFormulaFunction', new RuntimeGreaterThan(context))
+  registry.register(
+    'runtimeFormulaFunction',
+    new RuntimeGreaterThanOrEqual(context)
+  )
+  registry.register('runtimeFormulaFunction', new RuntimeLessThan(context))
+  registry.register(
+    'runtimeFormulaFunction',
+    new RuntimeLessThanOrEqual(context)
+  )
+  registry.register('runtimeFormulaFunction', new RuntimeEqual(context))
+  registry.register('runtimeFormulaFunction', new RuntimeNotEqual(context))
+  registry.register('runtimeFormulaFunction', new RuntimeUpper(context))
+  registry.register('runtimeFormulaFunction', new RuntimeLower(context))
+  registry.register('runtimeFormulaFunction', new RuntimeCapitalize(context))
+  registry.register('runtimeFormulaFunction', new RuntimeRound(context))
+  registry.register('runtimeFormulaFunction', new RuntimeIsEven(context))
+  registry.register('runtimeFormulaFunction', new RuntimeIsOdd(context))
+  registry.register(
+    'runtimeFormulaFunction',
+    new RuntimeDateTimeFormat(context)
+  )
+  registry.register('runtimeFormulaFunction', new RuntimeDay(context))
+  registry.register('runtimeFormulaFunction', new RuntimeMonth(context))
+  registry.register('runtimeFormulaFunction', new RuntimeYear(context))
+  registry.register('runtimeFormulaFunction', new RuntimeHour(context))
+  registry.register('runtimeFormulaFunction', new RuntimeMinute(context))
+  registry.register('runtimeFormulaFunction', new RuntimeSecond(context))
+  registry.register('runtimeFormulaFunction', new RuntimeNow(context))
+  registry.register('runtimeFormulaFunction', new RuntimeToday(context))
+  registry.register('runtimeFormulaFunction', new RuntimeGetProperty(context))
+  registry.register('runtimeFormulaFunction', new RuntimeRandomInt(context))
+  registry.register('runtimeFormulaFunction', new RuntimeRandomFloat(context))
+  registry.register('runtimeFormulaFunction', new RuntimeRandomBool(context))
+  registry.register('runtimeFormulaFunction', new RuntimeGenerateUUID(context))
 
   registry.register('roles', new AdminRoleType(context))
   registry.register('roles', new MemberRoleType(context))
diff --git a/web-frontend/modules/core/runtimeFormulaArgumentTypes.js b/web-frontend/modules/core/runtimeFormulaArgumentTypes.js
index 48d58a1bdb..8ffa70f379 100644
--- a/web-frontend/modules/core/runtimeFormulaArgumentTypes.js
+++ b/web-frontend/modules/core/runtimeFormulaArgumentTypes.js
@@ -1,3 +1,10 @@
+import {
+  ensureString,
+  ensureNumeric,
+  ensureDateTime,
+  ensureObject,
+} from '@baserow/modules/core/utils/validator'
+
 export class BaserowRuntimeFormulaArgumentType {
   /**
    * This function tests if a given value is compatible with its type
@@ -28,7 +35,7 @@ export class NumberBaserowRuntimeFormulaArgumentType extends BaserowRuntimeFormu
   }
 
   parse(value) {
-    return parseFloat(value)
+    return ensureNumeric(value)
   }
 }
 
@@ -38,6 +45,26 @@ export class TextBaserowRuntimeFormulaArgumentType extends BaserowRuntimeFormula
   }
 
   parse(value) {
-    return value.toString()
+    return ensureString(value)
+  }
+}
+
+export class DateTimeBaserowRuntimeFormulaArgumentType extends BaserowRuntimeFormulaArgumentType {
+  test(value) {
+    return value instanceof Date
+  }
+
+  parse(value) {
+    return ensureDateTime(value)
+  }
+}
+
+export class ObjectBaserowRuntimeFormulaArgumentType extends BaserowRuntimeFormulaArgumentType {
+  test(value) {
+    return value instanceof Object
+  }
+
+  parse(value) {
+    return ensureObject(value)
   }
 }
diff --git a/web-frontend/modules/core/runtimeFormulaTypes.js b/web-frontend/modules/core/runtimeFormulaTypes.js
index 54c8b2e196..07fbecacac 100644
--- a/web-frontend/modules/core/runtimeFormulaTypes.js
+++ b/web-frontend/modules/core/runtimeFormulaTypes.js
@@ -2,6 +2,8 @@ import { Registerable } from '@baserow/modules/core/registry'
 import {
   NumberBaserowRuntimeFormulaArgumentType,
   TextBaserowRuntimeFormulaArgumentType,
+  DateTimeBaserowRuntimeFormulaArgumentType,
+  ObjectBaserowRuntimeFormulaArgumentType,
 } from '@baserow/modules/core/runtimeFormulaArgumentTypes'
 import {
   InvalidFormulaArgumentType,
@@ -132,6 +134,19 @@ export class RuntimeFormulaFunction extends Registerable {
       type: this.formulaComponentType,
     }
   }
+
+  getDescription() {
+    throw new Error(
+      'Not implemented error. This method should return the functions description.'
+    )
+  }
+
+  getExamples() {
+    throw new Error(
+      'Not implemented error. This method should return list of strings showing ' +
+        'example usage of the function.'
+    )
+  }
 }
 
 export class RuntimeConcat extends RuntimeFormulaFunction {
@@ -156,6 +171,15 @@ export class RuntimeConcat extends RuntimeFormulaFunction {
     }
     return { type: 'wrapper', content: args }
   }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.concatDescription')
+  }
+
+  getExamples() {
+    return ["concat('Hello,', ' World!') = 'Hello, world!'"]
+  }
 }
 
 export class RuntimeGet extends RuntimeFormulaFunction {
@@ -224,6 +248,15 @@ export class RuntimeGet extends RuntimeFormulaFunction {
   fromNodeToFormula(node) {
     return `get('${node.attrs.path}')`
   }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.getDescription')
+  }
+
+  getExamples() {
+    return ["get('previous_node.1.body')"]
+  }
 }
 
 export class RuntimeAdd extends RuntimeFormulaFunction {
@@ -241,4 +274,719 @@ export class RuntimeAdd extends RuntimeFormulaFunction {
   execute(context, [a, b]) {
     return a + b
   }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.addDescription')
+  }
+
+  getExamples() {
+    return ['1+1+1 = 3', "'a' + 'b' = 'ab'"]
+  }
+}
+
+export class RuntimeMinus extends RuntimeFormulaFunction {
+  static getType() {
+    return 'minus'
+  }
+
+  get args() {
+    return [
+      new NumberBaserowRuntimeFormulaArgumentType(),
+      new NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, [a, b]) {
+    return a - b
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.minusDescription')
+  }
+
+  getExamples() {
+    return ['3-1 = 2']
+  }
+}
+
+export class RuntimeMultiply extends RuntimeFormulaFunction {
+  static getType() {
+    return 'multiply'
+  }
+
+  get args() {
+    return [
+      new NumberBaserowRuntimeFormulaArgumentType(),
+      new NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, [a, b]) {
+    return a * b
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.multiplyDescription')
+  }
+
+  getExamples() {
+    return ['2*3 = 6', "'a' * 3 = 'aaa'"]
+  }
+}
+
+export class RuntimeDivide extends RuntimeFormulaFunction {
+  static getType() {
+    return 'divide'
+  }
+
+  get args() {
+    return [
+      new NumberBaserowRuntimeFormulaArgumentType(),
+      new NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, [a, b]) {
+    return a * b
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.divideDescription')
+  }
+
+  getExamples() {
+    return ['6/3 = 2']
+  }
+}
+
+export class RuntimeEqual extends RuntimeFormulaFunction {
+  static getType() {
+    return 'equal'
+  }
+
+  get args() {
+    return [
+      new NumberBaserowRuntimeFormulaArgumentType(),
+      new NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, [a, b]) {
+    return a === b
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.equalDescription')
+  }
+
+  getExamples() {
+    return ['2=3 = false']
+  }
+}
+
+export class RuntimeNotEqual extends RuntimeFormulaFunction {
+  static getType() {
+    return 'not_equal'
+  }
+
+  get args() {
+    return [
+      new NumberBaserowRuntimeFormulaArgumentType(),
+      new NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, [a, b]) {
+    return a !== b
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.notEqualDescription')
+  }
+
+  getExamples() {
+    return ['2!=3 = true']
+  }
+}
+
+export class RuntimeGreaterThan extends RuntimeFormulaFunction {
+  static getType() {
+    return 'greater_than'
+  }
+
+  get args() {
+    return [
+      new NumberBaserowRuntimeFormulaArgumentType(),
+      new NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, [a, b]) {
+    return a > b
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.greaterThanDescription')
+  }
+
+  getExamples() {
+    return ['3>2 = true']
+  }
+}
+
+export class RuntimeLessThan extends RuntimeFormulaFunction {
+  static getType() {
+    return 'less_than'
+  }
+
+  get args() {
+    return [
+      new NumberBaserowRuntimeFormulaArgumentType(),
+      new NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, [a, b]) {
+    return a < b
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.lessThanDescription')
+  }
+
+  getExamples() {
+    return ['2<3 = true']
+  }
+}
+
+export class RuntimeGreaterThanOrEqual extends RuntimeFormulaFunction {
+  static getType() {
+    return 'greater_than_or_equal'
+  }
+
+  get args() {
+    return [
+      new NumberBaserowRuntimeFormulaArgumentType(),
+      new NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, [a, b]) {
+    return a < b
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.greaterThanOrEqualDescription')
+  }
+
+  getExamples() {
+    return ['3>=3 = true']
+  }
+}
+
+export class RuntimeLessThanOrEqual extends RuntimeFormulaFunction {
+  static getType() {
+    return 'less_than'
+  }
+
+  get args() {
+    return [
+      new NumberBaserowRuntimeFormulaArgumentType(),
+      new NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, [a, b]) {
+    return a <= b
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.lessThanDescription')
+  }
+
+  getExamples() {
+    return ['3<=3 = true']
+  }
+}
+
+export class RuntimeUpper extends RuntimeFormulaFunction {
+  static getType() {
+    return 'upper'
+  }
+
+  get args() {
+    return [new TextBaserowRuntimeFormulaArgumentType()]
+  }
+
+  execute(context, [s]) {
+    return s.toUpperCase()
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.upperDescription')
+  }
+
+  getExamples() {
+    return ["upper('Hello, World!') = 'HELLO, WORLD!'"]
+  }
+}
+
+export class RuntimeLower extends RuntimeFormulaFunction {
+  static getType() {
+    return 'lower'
+  }
+
+  get args() {
+    return [new TextBaserowRuntimeFormulaArgumentType()]
+  }
+
+  execute(context, [s]) {
+    return s.toLowerCase()
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.lowerDescription')
+  }
+
+  getExamples() {
+    return ["lower('Hello, World!') = 'hello, world!'"]
+  }
+}
+
+export class RuntimeCapitalize extends RuntimeFormulaFunction {
+  static getType() {
+    return 'capitalize'
+  }
+
+  get args() {
+    return [new TextBaserowRuntimeFormulaArgumentType()]
+  }
+
+  capitalize(str) {
+    if (!str) return ''
+    const [firstChar, ...remainingChars] = [...str]
+    return firstChar.toUpperCase() + remainingChars.join('').toLowerCase()
+  }
+
+  execute(context, [s]) {
+    return this.capitalize(s)
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.capitalizeDescription')
+  }
+
+  getExamples() {
+    return ["capitalize('hello, world!') = 'Hello, world!'"]
+  }
+}
+
+export class RuntimeRound extends RuntimeFormulaFunction {
+  static getType() {
+    return 'round'
+  }
+
+  get args() {
+    return [
+      new NumberBaserowRuntimeFormulaArgumentType(),
+      new NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, args) {
+    // Default to 2 decimal places?
+    let decimalPlaces = 2
+
+    if (args.length === 2) {
+      // Avoid negative numbers
+      decimalPlaces = Math.max(args[1], 0)
+    }
+
+    return args[0].toFixed(decimalPlaces)
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.roundDescription')
+  }
+
+  getExamples() {
+    return ["round('12.345', 2) = '12.35'"]
+  }
+}
+
+export class RuntimeIsEven extends RuntimeFormulaFunction {
+  static getType() {
+    return 'is_even'
+  }
+
+  get args() {
+    return [new NumberBaserowRuntimeFormulaArgumentType()]
+  }
+
+  execute(context, [n]) {
+    return n % 2 === 0
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.evenDescription')
+  }
+
+  getExamples() {
+    return ['even(12) = true']
+  }
+}
+
+export class RuntimeIsOdd extends RuntimeFormulaFunction {
+  static getType() {
+    return 'is_odd'
+  }
+
+  get args() {
+    return [new NumberBaserowRuntimeFormulaArgumentType()]
+  }
+
+  execute(context, [n]) {
+    return n % 2 !== 0
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.oddDescription')
+  }
+
+  getExamples() {
+    return ['odd(11) = true']
+  }
+}
+
+export class RuntimeDateTimeFormat extends RuntimeFormulaFunction {
+  static getType() {
+    return 'datetime_format'
+  }
+
+  get args() {
+    return [
+      new DateTimeBaserowRuntimeFormulaArgumentType(),
+      new TextBaserowRuntimeFormulaArgumentType(),
+      new TextBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, args) {
+    // Backend uses Python's datetime formatting syntax, e.g. `%Y-%m-%d %H:%M:%S`
+    // but I haven't yet found a way to replicate this in pure JS. Maybe
+    // we can rely on a 3rd party lib?
+    return 'TODO'
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.dateTimeDescription')
+  }
+
+  getExamples() {
+    return [
+      "datetime_format('2025-10-16 11:05:38.547989', '%Y-%m-%d', 'Asia/Dubai') = '2025-10-16'",
+    ]
+  }
+}
+
+export class RuntimeDay extends RuntimeFormulaFunction {
+  static getType() {
+    return 'day'
+  }
+
+  get args() {
+    return [new DateTimeBaserowRuntimeFormulaArgumentType()]
+  }
+
+  execute(context, [datetime]) {
+    return datetime.getDate()
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.dayDescription')
+  }
+
+  getExamples() {
+    return ["day('2025-10-16 11:05:38') = '16'"]
+  }
+}
+
+export class RuntimeMonth extends RuntimeFormulaFunction {
+  static getType() {
+    return 'month'
+  }
+
+  get args() {
+    return [new DateTimeBaserowRuntimeFormulaArgumentType()]
+  }
+
+  execute(context, [datetime]) {
+    return datetime.getMonth()
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.monthDescription')
+  }
+
+  getExamples() {
+    return ["month('2025-10-16 11:05:38') = '10'"]
+  }
+}
+
+export class RuntimeYear extends RuntimeFormulaFunction {
+  static getType() {
+    return 'year'
+  }
+
+  get args() {
+    return [new DateTimeBaserowRuntimeFormulaArgumentType()]
+  }
+
+  execute(context, [datetime]) {
+    return datetime.getFullYear()
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.yearDescription')
+  }
+
+  getExamples() {
+    return ["year('2025-10-16 11:05:38') = '2025'"]
+  }
+}
+
+export class RuntimeHour extends RuntimeFormulaFunction {
+  static getType() {
+    return 'hour'
+  }
+
+  get args() {
+    return [new DateTimeBaserowRuntimeFormulaArgumentType()]
+  }
+
+  execute(context, [datetime]) {
+    return datetime.getHours()
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.hourDescription')
+  }
+
+  getExamples() {
+    return ["hour('2025-10-16 11:05:38') = '11'"]
+  }
+}
+
+export class RuntimeMinute extends RuntimeFormulaFunction {
+  static getType() {
+    return 'minute'
+  }
+
+  get args() {
+    return [new DateTimeBaserowRuntimeFormulaArgumentType()]
+  }
+
+  execute(context, [datetime]) {
+    return datetime.getMinutes()
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.minuteDescription')
+  }
+
+  getExamples() {
+    return ["minute('2025-10-16 11:05:38') = '05'"]
+  }
+}
+
+export class RuntimeSecond extends RuntimeFormulaFunction {
+  static getType() {
+    return 'second'
+  }
+
+  get args() {
+    return [new DateTimeBaserowRuntimeFormulaArgumentType()]
+  }
+
+  execute(context, [datetime]) {
+    return datetime.getSeconds()
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.secondDescription')
+  }
+
+  getExamples() {
+    return ["second('2025-10-16 11:05:38') = '38'"]
+  }
+}
+
+export class RuntimeNow extends RuntimeFormulaFunction {
+  static getType() {
+    return 'now'
+  }
+
+  execute(context, args) {
+    return new Date()
+  }
+}
+
+export class RuntimeToday extends RuntimeFormulaFunction {
+  static getType() {
+    return 'today'
+  }
+
+  execute(context, args) {
+    return new Date().toISOString().split('T')[0]
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.todayDescription')
+  }
+
+  getExamples() {
+    return ["today() = '2025-10-16'"]
+  }
+}
+
+export class RuntimeGetProperty extends RuntimeFormulaFunction {
+  static getType() {
+    return 'get_property'
+  }
+
+  get args() {
+    return [
+      new ObjectBaserowRuntimeFormulaArgumentType(),
+      new TextBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, args) {
+    return new args[0][args[1]]()
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.getPropertyDescription')
+  }
+
+  getExamples() {
+    return ['get_property(\'{"cherry": "red"}\', "fruit")']
+  }
+}
+
+export class RuntimeRandomInt extends RuntimeFormulaFunction {
+  static getType() {
+    return 'random_int'
+  }
+
+  get args() {
+    return [
+      new NumberBaserowRuntimeFormulaArgumentType(),
+      new NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, args) {
+    const min = Math.ceil(args[0])
+    const max = Math.floor(args[1])
+    return Math.floor(Math.random() * (max - min) + min)
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.randomIntDescription')
+  }
+
+  getExamples() {
+    return ['random_int(10, 20) = 17']
+  }
+}
+
+export class RuntimeRandomFloat extends RuntimeFormulaFunction {
+  static getType() {
+    return 'random_float'
+  }
+
+  get args() {
+    return [
+      new NumberBaserowRuntimeFormulaArgumentType(),
+      new NumberBaserowRuntimeFormulaArgumentType(),
+    ]
+  }
+
+  execute(context, args) {
+    return Math.random() * (args[1] - args[0]) + args[0]
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.randomFloatDescription')
+  }
+
+  getExamples() {
+    return ['random_float(10, 20) = 18.410550297490616']
+  }
+}
+
+export class RuntimeRandomBool extends RuntimeFormulaFunction {
+  static getType() {
+    return 'random_bool'
+  }
+
+  execute(context, args) {
+    return Math.random() < 0.5
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.randomBoolDescription')
+  }
+
+  getExamples() {
+    return ['random_bool() = true']
+  }
+}
+
+export class RuntimeGenerateUUID extends RuntimeFormulaFunction {
+  static getType() {
+    return 'generate_uuid'
+  }
+
+  execute(context, args) {
+    return crypto.randomUUID()
+  }
+
+  getDescription() {
+    const { i18n } = this.app
+    return i18n.t('runtimeFormulaTypes.generateUUIDDescription')
+  }
+
+  getExamples() {
+    return ["generate_uuid() = '9b772ad6-08bc-4d19-958d-7f1c21a4f4ef'"]
+  }
 }
diff --git a/web-frontend/modules/core/utils/validator.js b/web-frontend/modules/core/utils/validator.js
index 6797ee54a5..135ea061d1 100644
--- a/web-frontend/modules/core/utils/validator.js
+++ b/web-frontend/modules/core/utils/validator.js
@@ -246,3 +246,27 @@ export const ensureDateTime = (
     return parsed.toDate()
   }
 }
+
+/**
+ * Ensures that the value is a valid object or convert it.
+ * @param {*} value - The value to ensure as an object
+ * @returns {Object} - The converted value as an object.
+ * @throws {Error} if `value` is not convertable to an object.
+ */
+export const ensureObject = (value) => {
+  if (value !== null && typeof value !== 'object') {
+    throw new TypeError(
+      'Value is not a valid object or convertible to an object.'
+    )
+  }
+
+  if (value instanceof Object) {
+    return value
+  } else {
+    try {
+      return JSON.parse(value)
+    } catch {
+      throw new TypeError('Value is not a valid JSON.')
+    }
+  }
+}
diff --git a/web-frontend/modules/integrations/core/serviceTypes.js b/web-frontend/modules/integrations/core/serviceTypes.js
index d45d4cb837..86f178df13 100644
--- a/web-frontend/modules/integrations/core/serviceTypes.js
+++ b/web-frontend/modules/integrations/core/serviceTypes.js
@@ -112,7 +112,7 @@ export class CoreRouterServiceType extends WorkflowActionServiceTypeMixin(
   getEdgeErrorMessage(edge) {
     if (!edge.label.length) {
       return this.app.i18n.t('serviceType.coreRouterEdgeLabelRequired')
-    } else if (!edge.condition.length) {
+    } else if (!edge.condition.formula.length) {
       return this.app.i18n.t('serviceType.coreRouterEdgeConditionRequired')
     }
     return null