diff --git a/cli-tools/altinn-app-cli/Program.cs b/cli-tools/altinn-app-cli/Program.cs
index 17a257d7a..6402f4d71 100644
--- a/cli-tools/altinn-app-cli/Program.cs
+++ b/cli-tools/altinn-app-cli/Program.cs
@@ -1,5 +1,7 @@
 using System.CommandLine;
+using System.CommandLine.Invocation;
 using System.Reflection;
+using altinn_app_cli.v7Tov8.AppSettingsRewriter;
 using altinn_app_cli.v7Tov8.CodeRewriters;
 using altinn_app_cli.v7Tov8.ProcessRewriter;
 using altinn_app_cli.v7Tov8.ProjectChecks;
@@ -18,27 +20,42 @@ static async Task<int> Main(string[] args)
         var projectFolderOption = new Option<string>(name: "--folder", description: "The project folder to read", getDefaultValue: () => "CurrentDirectory");
         var projectFileOption = new Option<string>(name: "--project", description: "The project file to read relative to --folder", getDefaultValue: () => "App/App.csproj");
         var processFileOption = new Option<string>(name: "--process", description: "The process file to read relative to --folder", getDefaultValue: () => "App/config/process/process.bpmn");
+        var appSettingsFolderOption = new Option<string>(name: "--appsettings-folder", description: "The folder where the appsettings.*.json files are located", getDefaultValue: () => "App");
         var targetVersionOption = new Option<string>(name: "--target-version", description: "The target version to upgrade to", getDefaultValue: () => "8.0.0-preview.9");
         var skipCsprojUpgradeOption = new Option<bool>(name: "--skip-csproj-upgrade", description: "Skip csproj file upgrade", getDefaultValue: () => false);
         var skipCodeUpgradeOption = new Option<bool>(name: "--skip-code-upgrade", description: "Skip code upgrade", getDefaultValue: () => false);
         var skipProcessUpgradeOption = new Option<bool>(name: "--skip-process-upgrade", description: "Skip process file upgrade", getDefaultValue: () => false);
+        var skipAppSettingsUpgradeOption = new Option<bool>(name: "--skip-appsettings-upgrade", description: "Skip appsettings file upgrade", getDefaultValue: () => false);
         var rootCommand = new RootCommand("Command line interface for working with Altinn 3 Applications");
         var upgradeCommand = new Command("upgrade", "Upgrade an app from v7 to v8")
         {
             projectFolderOption,
             projectFileOption,
             processFileOption,
+            appSettingsFolderOption,
             targetVersionOption,
             skipCsprojUpgradeOption,
             skipCodeUpgradeOption,
             skipProcessUpgradeOption,
+            skipAppSettingsUpgradeOption,
         };
         rootCommand.AddCommand(upgradeCommand);
         var versionCommand = new Command("version", "Print version of altinn-app-cli");
         rootCommand.AddCommand(versionCommand);
 
-        upgradeCommand.SetHandler(async (projectFolder, projectFile, processFile, targetVersion, skipCodeUpgrade, skipProcessUpgrade, skipCsprojUpgrade) =>
+        upgradeCommand.SetHandler(
+            async (InvocationContext context) =>
             {
+                var projectFolder = context.ParseResult.GetValueForOption(projectFolderOption)!;
+                var projectFile = context.ParseResult.GetValueForOption(projectFileOption)!;
+                var processFile = context.ParseResult.GetValueForOption(processFileOption)!;
+                var appSettingsFolder = context.ParseResult.GetValueForOption(appSettingsFolderOption)!;
+                var targetVersion = context.ParseResult.GetValueForOption(targetVersionOption)!;
+                var skipCodeUpgrade = context.ParseResult.GetValueForOption(skipCodeUpgradeOption)!;
+                var skipProcessUpgrade = context.ParseResult.GetValueForOption(skipProcessUpgradeOption)!;
+                var skipCsprojUpgrade = context.ParseResult.GetValueForOption(skipCsprojUpgradeOption)!;
+                var skipAppSettingsUpgrade = context.ParseResult.GetValueForOption(skipAppSettingsUpgradeOption)!;
+
                 if (projectFolder == "CurrentDirectory")
                 {
                     projectFolder = Directory.GetCurrentDirectory();
@@ -63,11 +80,13 @@ static async Task<int> Main(string[] args)
                 {
                     projectFile = Path.Combine(Directory.GetCurrentDirectory(), projectFolder, projectFile);
                     processFile = Path.Combine(Directory.GetCurrentDirectory(), projectFolder, processFile);
+                    appSettingsFolder = Path.Combine(Directory.GetCurrentDirectory(), projectFolder, appSettingsFolder);
                 }
                 else
                 {
                     projectFile = Path.Combine(projectFolder, projectFile);
                     processFile = Path.Combine(projectFolder, processFile);
+                    appSettingsFolder = Path.Combine(projectFolder, appSettingsFolder);
                 }
 
                 var projectChecks = new ProjectChecks(projectFile);
@@ -77,6 +96,7 @@ static async Task<int> Main(string[] args)
                     returnCode = 2;
                     return;
                 }
+
                 if (!skipCsprojUpgrade)
                 {
                     returnCode = await UpgradeNugetVersions(projectFile, targetVersion);
@@ -92,6 +112,11 @@ static async Task<int> Main(string[] args)
                     returnCode = await UpgradeProcess(processFile);
                 }
 
+                if (!skipAppSettingsUpgrade && returnCode == 0)
+                {
+                    returnCode = await UpgradeAppSettings(appSettingsFolder);
+                }
+
                 if (returnCode == 0)
                 {
                     Console.WriteLine("Upgrade completed without errors. Please verify that the application is still working as expected.");
@@ -100,8 +125,9 @@ static async Task<int> Main(string[] args)
                 {
                     Console.WriteLine("Upgrade completed with errors. Please check for errors in the log above.");
                 }
-            },
-            projectFolderOption, projectFileOption, processFileOption, targetVersionOption, skipCodeUpgradeOption, skipProcessUpgradeOption, skipCsprojUpgradeOption);
+            }
+        );
+
         versionCommand.SetHandler(() =>
         {
             var version = Assembly.GetEntryAssembly()?.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion ?? "Unknown";
@@ -188,4 +214,33 @@ static async Task<int> UpgradeProcess(string processFile)
 
         return 0;
     }
+
+    static async Task<int> UpgradeAppSettings(string appSettingsFolder)
+    {
+        if (!Directory.Exists(appSettingsFolder))
+        {
+            Console.WriteLine($"App settings folder {appSettingsFolder} does not exist. Please supply location with --appsettings-folder [path/to/appsettings]");
+            return 1;
+        }
+
+        if (Directory.GetFiles(appSettingsFolder, AppSettingsRewriter.APP_SETTINGS_FILE_PATTERN).Count() == 0)
+        {
+            Console.WriteLine($"No appsettings*.json files found in {appSettingsFolder}");
+            return 1;
+        }
+
+        Console.WriteLine("Trying to upgrade appsettings*.json files");
+        AppSettingsRewriter rewriter = new(appSettingsFolder);
+        rewriter.Upgrade();
+        await rewriter.Write();
+        var warnings = rewriter.GetWarnings();
+        foreach (var warning in warnings)
+        {
+            Console.WriteLine(warning);
+        }
+
+        Console.WriteLine(warnings.Any() ? "AppSettings files upgraded with warnings. Review the warnings above and make sure that the appsettings files are still valid." : "AppSettings files upgraded");
+
+        return 0;
+    }
 }
diff --git a/cli-tools/altinn-app-cli/v7Tov8/AppSettingsRewriter/AppSettingsRewriter.cs b/cli-tools/altinn-app-cli/v7Tov8/AppSettingsRewriter/AppSettingsRewriter.cs
new file mode 100644
index 000000000..860d2b1b3
--- /dev/null
+++ b/cli-tools/altinn-app-cli/v7Tov8/AppSettingsRewriter/AppSettingsRewriter.cs
@@ -0,0 +1,110 @@
+
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace altinn_app_cli.v7Tov8.AppSettingsRewriter;
+
+
+/// <summary>
+/// Rewrites the appsettings.*.json files
+/// </summary>
+public class AppSettingsRewriter
+{
+    /// <summary>
+    /// The pattern used to search for appsettings.*.json files
+    /// </summary>
+    public static readonly string APP_SETTINGS_FILE_PATTERN = "appsettings*.json";
+
+    private Dictionary<string, JsonObject> appSettingsJsonCollection;
+
+    private readonly IList<string> warnings = new List<string>();
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AppSettingsRewriter"/> class.
+    /// </summary>
+    public AppSettingsRewriter(string appSettingsFolder)
+    {
+        appSettingsJsonCollection = new Dictionary<string, JsonObject>();
+        foreach (var file in Directory.GetFiles(appSettingsFolder, APP_SETTINGS_FILE_PATTERN))
+        {
+            var json = File.ReadAllText(file);
+            var appSettingsJson = JsonNode.Parse(json);
+            if (appSettingsJson is not JsonObject appSettingsJsonObject)
+            {
+                warnings.Add($"Unable to parse AppSettings file {file} as a json object, skipping");
+                continue;
+            }
+
+            this.appSettingsJsonCollection.Add(file, appSettingsJsonObject);
+        }
+    }
+
+    /// <summary>
+    /// Gets the warnings
+    /// </summary>
+    public IList<string> GetWarnings()
+    {
+        return warnings;
+    }
+
+    /// <summary>
+    /// Upgrades the appsettings.*.json files
+    /// </summary>
+    public void Upgrade()
+    {
+        foreach ((var fileName, var appSettingsJson) in appSettingsJsonCollection)
+        {
+            RewriteRemoveHiddenDataSetting(fileName, appSettingsJson);
+        }
+    }
+
+    /// <summary>
+    /// Writes the appsettings.*.json files
+    /// </summary>
+    public async Task Write()
+    {
+        var tasks = appSettingsJsonCollection.Select(async appSettingsFiles =>
+        {
+            appSettingsFiles.Deconstruct(out var fileName, out var appSettingsJson);
+
+            JsonSerializerOptions options = new JsonSerializerOptions
+            {
+                WriteIndented = true,
+            };
+            await File.WriteAllTextAsync(fileName, appSettingsJson.ToJsonString(options));
+        });
+
+        await Task.WhenAll(tasks);
+    }
+
+    private void RewriteRemoveHiddenDataSetting(string fileName, JsonObject settings)
+    {
+        // Look for "AppSettings" object
+        settings.TryGetPropertyValue("AppSettings", out var appSettingsNode);
+        if (appSettingsNode is not JsonObject appSettingsObject)
+        {
+            // No "AppSettings" object found, nothing to change
+            return;
+        }
+
+        // Look for "RemoveHiddenDataPreview" property
+        appSettingsObject.TryGetPropertyValue("RemoveHiddenDataPreview", out var removeHiddenDataPreviewNode);
+        if (removeHiddenDataPreviewNode is not JsonValue removeHiddenDataPreviewValue)
+        {
+            // No "RemoveHiddenDataPreview" property found, nothing to change
+            return;
+        }
+
+        // Get value of "RemoveHiddenDataPreview" property
+        if (!removeHiddenDataPreviewValue.TryGetValue<bool>(out var removeHiddenDataValue))
+        {
+            warnings.Add($"RemoveHiddenDataPreview has unexpected value {removeHiddenDataPreviewValue.ToJsonString()} in {fileName}, expected a boolean");
+            return;
+        }
+
+        appSettingsObject.Remove("RemoveHiddenDataPreview");
+        appSettingsObject.Add("RemoveHiddenData", removeHiddenDataValue);
+        appSettingsObject.Add("RequiredValidation", removeHiddenDataValue);
+
+    }
+}
diff --git a/src/Altinn.App.Api/Controllers/ResourceController.cs b/src/Altinn.App.Api/Controllers/ResourceController.cs
index df01f78c1..7029e3b5e 100644
--- a/src/Altinn.App.Api/Controllers/ResourceController.cs
+++ b/src/Altinn.App.Api/Controllers/ResourceController.cs
@@ -265,8 +265,23 @@ public async Task<ActionResult> GetFooterLayout(string org, string app)
             {
                 return NoContent();
             }
-            
+
             return Ok(layout);
         }
+
+        /// <summary>
+        /// Get validation configuration file.
+        /// </summary>
+        /// <param name="org">The application owner short name</param>
+        /// <param name="app">The application name</param>
+        /// <param name="id">Unique identifier of the model to fetch validations for.</param>
+        /// <returns>The validation configuration file as json.</returns>
+        [HttpGet]
+        [Route("{org}/{app}/api/validationconfig/{id}")]
+        public ActionResult GetValidationConfiguration(string org, string app, string id)
+        {
+            string? validationConfiguration = _appResourceService.GetValidationConfiguration(id);
+            return Ok(validationConfiguration);
+        }
     }
 }
diff --git a/src/Altinn.App.Core/Configuration/AppSettings.cs b/src/Altinn.App.Core/Configuration/AppSettings.cs
index 9974f7960..ab34f341d 100644
--- a/src/Altinn.App.Core/Configuration/AppSettings.cs
+++ b/src/Altinn.App.Core/Configuration/AppSettings.cs
@@ -23,6 +23,11 @@ public class AppSettings
         /// </summary>
         public const string JSON_SCHEMA_FILENAME = "schema.json";
 
+        /// <summary>
+        /// Constant for the location of validation configuration file
+        /// </summary>
+        public const string VALIDATION_CONFIG_FILENAME = "validation.json";
+
         /// <summary>
         /// The app configuration baseUrl where files are stored in the container
         /// </summary>
@@ -83,7 +88,7 @@ public class AppSettings
         /// </summary>
         public string LayoutSetsFileName { get; set; } = "layout-sets.json";
 
-                /// <summary>
+        /// <summary>
         /// Gets or sets the name of the layout setting file name
         /// </summary>
         public string FooterFileName { get; set; } = "footer.json";
@@ -103,6 +108,11 @@ public class AppSettings
         /// </summary>
         public string JsonSchemaFileName { get; set; } = JSON_SCHEMA_FILENAME;
 
+        /// <summary>
+        /// Gets or sets The JSON schema file name
+        /// </summary>
+        public string ValidationConfigurationFileName { get; set; } = VALIDATION_CONFIG_FILENAME;
+
         /// <summary>
         /// Gets or sets the filename for application meta data
         /// </summary>
@@ -214,8 +224,18 @@ public string GetResourceFolder()
         public string AppVersion { get; set; }
 
         /// <summary>
-        /// Enable the preview functionality to load layout in backend and remove data from hidden components before validation and task completion
+        /// Enable the functionality to load layout in backend and remove data from hidden components before task completion
+        /// </summary>
+        public bool RemoveHiddenData { get; set; } = false;
+
+        /// <summary>
+        /// Enable the functionality to load layout in backend and validate required fields as defined in the layout
+        /// </summary>
+        public bool RequiredValidation { get; set; } = false;
+
+        /// <summary>
+        /// Enable the functionality to run expression validation in backend
         /// </summary>
-        public bool RemoveHiddenDataPreview { get; set; } = false;
+        public bool ExpressionValidation { get; set; } = false;
     }
 }
diff --git a/src/Altinn.App.Core/Features/Validation/ExpressionValidator.cs b/src/Altinn.App.Core/Features/Validation/ExpressionValidator.cs
new file mode 100644
index 000000000..28fbeb047
--- /dev/null
+++ b/src/Altinn.App.Core/Features/Validation/ExpressionValidator.cs
@@ -0,0 +1,276 @@
+using System.Text.Json;
+using Altinn.App.Core.Helpers;
+using Altinn.App.Core.Internal.App;
+using Altinn.App.Core.Internal.Expressions;
+using Altinn.App.Core.Models.Validation;
+using Microsoft.Extensions.Logging;
+
+
+namespace Altinn.App.Core.Features.Validation
+{
+    /// <summary>
+    /// Validates form data against expression validations
+    /// </summary>
+    public static class ExpressionValidator
+    {
+        /// <inheritdoc />
+        public static IEnumerable<ValidationIssue> Validate(string dataType, IAppResources appResourceService, IDataModelAccessor dataModel, LayoutEvaluatorState evaluatorState, ILogger logger)
+        {
+            var rawValidationConfig = appResourceService.GetValidationConfiguration(dataType);
+            if (rawValidationConfig == null)
+            {
+                // No validation configuration exists for this data type
+                return new List<ValidationIssue>();
+            }
+
+            var validationConfig = JsonDocument.Parse(rawValidationConfig).RootElement;
+            return Validate(validationConfig, dataModel, evaluatorState, logger);
+        }
+
+        /// <inheritdoc />
+        public static IEnumerable<ValidationIssue> Validate(JsonElement validationConfig, IDataModelAccessor dataModel, LayoutEvaluatorState evaluatorState, ILogger logger)
+        {
+            var validationIssues = new List<ValidationIssue>();
+            var expressionValidations = ParseExpressionValidationConfig(validationConfig, logger);
+            foreach (var validationObject in expressionValidations)
+            {
+                var baseField = validationObject.Key;
+                var resolvedFields = dataModel.GetResolvedKeys(baseField);
+                var validations = validationObject.Value;
+                foreach (var resolvedField in resolvedFields)
+                {
+                    var positionalArguments = new[] { resolvedField };
+                    foreach (var validation in validations)
+                    {
+                        try
+                        {
+                            if (validation.Condition == null)
+                            {
+                                continue;
+                            }
+
+                            var isInvalid = ExpressionEvaluator.EvaluateExpression(evaluatorState, validation.Condition, null, positionalArguments);
+                            if (isInvalid is not bool)
+                            {
+                                throw new ArgumentException($"Validation condition for {resolvedField} did not evaluate to a boolean");
+                            }
+                            if ((bool)isInvalid)
+                            {
+                                var validationIssue = new ValidationIssue
+                                {
+                                    Field = resolvedField,
+                                    Severity = validation.Severity ?? ValidationIssueSeverity.Error,
+                                    CustomTextKey = validation.Message,
+                                    Code = validation.Message,
+                                    Source = ValidationIssueSources.Expression,
+                                };
+                                validationIssues.Add(validationIssue);
+                            }
+                        }
+                        catch
+                        {
+                            logger.LogError($"Error while evaluating expression validation for {resolvedField}");
+                            throw;
+                        }
+                    }
+                }
+            }
+
+
+            return validationIssues;
+        }
+
+        private static RawExpressionValidation? ResolveValidationDefinition(string name, JsonElement definition, Dictionary<string, RawExpressionValidation> resolvedDefinitions, ILogger logger)
+        {
+            var resolvedDefinition = new RawExpressionValidation();
+            var rawDefinition = definition.Deserialize<RawExpressionValidation>(new JsonSerializerOptions
+            {
+                ReadCommentHandling = JsonCommentHandling.Skip,
+                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+            });
+            if (rawDefinition == null)
+            {
+                logger.LogError($"Validation definition {name} could not be parsed");
+                return null;
+            }
+            if (rawDefinition.Ref != null)
+            {
+                var reference = resolvedDefinitions.GetValueOrDefault(rawDefinition.Ref);
+                if (reference == null)
+                {
+                    logger.LogError($"Could not resolve reference {rawDefinition.Ref} for validation {name}");
+                    return null;
+
+                }
+                resolvedDefinition.Message = reference.Message;
+                resolvedDefinition.Condition = reference.Condition;
+                resolvedDefinition.Severity = reference.Severity;
+            }
+
+            if (rawDefinition.Message != null)
+            {
+                resolvedDefinition.Message = rawDefinition.Message;
+            }
+
+            if (rawDefinition.Condition != null)
+            {
+                resolvedDefinition.Condition = rawDefinition.Condition;
+            }
+
+            if (rawDefinition.Severity != null)
+            {
+                resolvedDefinition.Severity = rawDefinition.Severity;
+            }
+
+            if (resolvedDefinition.Message == null)
+            {
+                logger.LogError($"Validation {name} is missing message");
+                return null;
+            }
+
+            if (resolvedDefinition.Condition == null)
+            {
+                logger.LogError($"Validation {name} is missing condition");
+                return null;
+            }
+
+            return resolvedDefinition;
+        }
+
+        private static ExpressionValidation? ResolveExpressionValidation(string field, JsonElement definition, Dictionary<string, RawExpressionValidation> resolvedDefinitions, ILogger logger)
+        {
+
+            var rawExpressionValidatıon = new RawExpressionValidation();
+
+            if (definition.ValueKind == JsonValueKind.String)
+            {
+                var stringReference = definition.GetString();
+                if (stringReference == null)
+                {
+                    logger.LogError($"Could not resolve null reference for validation for field {field}");
+                    return null;
+                }
+                var reference = resolvedDefinitions.GetValueOrDefault(stringReference);
+                if (reference == null)
+                {
+                    logger.LogError($"Could not resolve reference {stringReference} for validation for field {field}");
+                    return null;
+                }
+                rawExpressionValidatıon.Message = reference.Message;
+                rawExpressionValidatıon.Condition = reference.Condition;
+                rawExpressionValidatıon.Severity = reference.Severity;
+            }
+            else
+            {
+                var expressionDefinition = definition.Deserialize<RawExpressionValidation>(new JsonSerializerOptions
+                {
+                    ReadCommentHandling = JsonCommentHandling.Skip,
+                    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+                });
+                if (expressionDefinition == null)
+                {
+                    logger.LogError($"Validation for field {field} could not be parsed");
+                    return null;
+                }
+
+                if (expressionDefinition.Ref != null)
+                {
+                    var reference = resolvedDefinitions.GetValueOrDefault(expressionDefinition.Ref);
+                    if (reference == null)
+                    {
+                        logger.LogError($"Could not resolve reference {expressionDefinition.Ref} for validation for field {field}");
+                        return null;
+
+                    }
+                    rawExpressionValidatıon.Message = reference.Message;
+                    rawExpressionValidatıon.Condition = reference.Condition;
+                    rawExpressionValidatıon.Severity = reference.Severity;
+                }
+
+                if (expressionDefinition.Message != null)
+                {
+                    rawExpressionValidatıon.Message = expressionDefinition.Message;
+                }
+
+                if (expressionDefinition.Condition != null)
+                {
+                    rawExpressionValidatıon.Condition = expressionDefinition.Condition;
+                }
+
+                if (expressionDefinition.Severity != null)
+                {
+                    rawExpressionValidatıon.Severity = expressionDefinition.Severity;
+                }
+            }
+
+            if (rawExpressionValidatıon.Message == null)
+            {
+                logger.LogError($"Validation for field {field} is missing message");
+                return null;
+            }
+
+            if (rawExpressionValidatıon.Condition == null)
+            {
+                logger.LogError($"Validation for field {field} is missing condition");
+                return null;
+            }
+
+            var expressionValidation = new ExpressionValidation
+            {
+                Message = rawExpressionValidatıon.Message,
+                Condition = rawExpressionValidatıon.Condition,
+                Severity = rawExpressionValidatıon.Severity ?? ValidationIssueSeverity.Error,
+            };
+
+            return expressionValidation;
+        }
+
+        private static Dictionary<string, List<ExpressionValidation>> ParseExpressionValidationConfig(JsonElement expressionValidationConfig, ILogger logger)
+        {
+            var expressionValidationDefinitions = new Dictionary<string, RawExpressionValidation>();
+            JsonElement definitionsObject;
+            var hasDefinitions = expressionValidationConfig.TryGetProperty("definitions", out definitionsObject);
+            if (hasDefinitions)
+            {
+                foreach (var definitionObject in definitionsObject.EnumerateObject())
+                {
+                    var name = definitionObject.Name;
+                    var definition = definitionObject.Value;
+                    var resolvedDefinition = ResolveValidationDefinition(name, definition, expressionValidationDefinitions, logger);
+                    if (resolvedDefinition == null)
+                    {
+                        logger.LogError($"Validation definition {name} could not be resolved");
+                        continue;
+                    }
+                    expressionValidationDefinitions[name] = resolvedDefinition;
+                }
+            }
+            var expressionValidations = new Dictionary<string, List<ExpressionValidation>>();
+            JsonElement validationsObject;
+            var hasValidations = expressionValidationConfig.TryGetProperty("validations", out validationsObject);
+            if (hasValidations)
+            {
+                foreach (var validationArray in validationsObject.EnumerateObject())
+                {
+                    var field = validationArray.Name;
+                    var validations = validationArray.Value;
+                    foreach (var validation in validations.EnumerateArray())
+                    {
+                        if (!expressionValidations.ContainsKey(field))
+                        {
+                            expressionValidations[field] = new List<ExpressionValidation>();
+                        }
+                        var resolvedExpressionValidation = ResolveExpressionValidation(field, validation, expressionValidationDefinitions, logger);
+                        if (resolvedExpressionValidation == null)
+                        {
+                            logger.LogError($"Validation for field {field} could not be resolved");
+                            continue;
+                        }
+                        expressionValidations[field].Add(resolvedExpressionValidation);
+                    }
+                }
+            }
+            return expressionValidations;
+        }
+    }
+}
diff --git a/src/Altinn.App.Core/Features/Validation/ValidationAppSI.cs b/src/Altinn.App.Core/Features/Validation/ValidationAppSI.cs
index 55a85a6a1..cfb9028e1 100644
--- a/src/Altinn.App.Core/Features/Validation/ValidationAppSI.cs
+++ b/src/Altinn.App.Core/Features/Validation/ValidationAppSI.cs
@@ -1,4 +1,5 @@
 using Altinn.App.Core.Configuration;
+using Altinn.App.Core.Helpers.DataModel;
 using Altinn.App.Core.Helpers;
 using Altinn.App.Core.Internal.App;
 using Altinn.App.Core.Internal.AppModel;
@@ -228,18 +229,32 @@ public async Task<List<ValidationIssue>> ValidateDataElement(Instance instance,
                 object data = await _dataClient.GetFormData(
                     instanceGuid, modelType, instance.Org, app, instanceOwnerPartyId, Guid.Parse(dataElement.Id));
 
-                if (_appSettings.RemoveHiddenDataPreview)
+                LayoutEvaluatorState? evaluationState = null;
+
+                // Remove hidden data before validation
+                if (_appSettings.RequiredValidation || _appSettings.ExpressionValidation)
                 {
+
                     var layoutSet = _appResourcesService.GetLayoutSetForTask(dataType.TaskId);
-                    var evaluationState = await _layoutEvaluatorStateInitializer.Init(instance, data, layoutSet?.Id);
-                    // Remove hidden data before validation, set rows to null to preserve indices
+                    evaluationState = await _layoutEvaluatorStateInitializer.Init(instance, data, layoutSet?.Id);
                     LayoutEvaluator.RemoveHiddenData(evaluationState, RowRemovalOption.SetToNull);
-                    // Evaluate expressions in layout and validate that all required data is included and that maxLength
-                    // is respected on groups
-                    var layoutErrors = LayoutEvaluator.RunLayoutValidationsForRequired(evaluationState, dataElement.Id);
+                }
+
+                // Evaluate expressions in layout and validate that all required data is included and that maxLength
+                // is respected on groups
+                if (_appSettings.RequiredValidation)
+                {
+                    var layoutErrors = LayoutEvaluator.RunLayoutValidationsForRequired(evaluationState!, dataElement.Id);
                     messages.AddRange(layoutErrors);
                 }
 
+                // Run expression validations
+                if (_appSettings.ExpressionValidation)
+                {
+                    var expressionErrors = ExpressionValidator.Validate(dataType.Id, _appResourcesService, new DataModel(data), evaluationState!, _logger);
+                    messages.AddRange(expressionErrors);
+                }
+
                 // Run Standard mvc validation using the System.ComponentModel.DataAnnotations
                 ModelStateDictionary dataModelValidationResults = new ModelStateDictionary();
                 var actionContext = new ActionContext(
diff --git a/src/Altinn.App.Core/Helpers/DataModel/DataModel.cs b/src/Altinn.App.Core/Helpers/DataModel/DataModel.cs
index 9aed92f8d..ec45626c9 100644
--- a/src/Altinn.App.Core/Helpers/DataModel/DataModel.cs
+++ b/src/Altinn.App.Core/Helpers/DataModel/DataModel.cs
@@ -90,6 +90,80 @@ public DataModel(object serviceModel)
         return GetModelDataRecursive(keys, index + 1, elementAt, indicies.Length > 0 ? indicies.Slice(1) : indicies);
     }
 
+    /// <inheritdoc />
+    public string[] GetResolvedKeys(string key)
+    {
+        if (_serviceModel is null)
+        {
+            return new string[0];
+        }
+
+        var keyParts = key.Split('.');
+        return GetResolvedKeysRecursive(keyParts, _serviceModel);
+    }
+
+    internal static string JoinFieldKeyParts(string? currentKey, string? key)
+    {
+        if (String.IsNullOrEmpty(currentKey))
+        {
+            return key ?? "";
+        }
+        if (String.IsNullOrEmpty(key))
+        {
+            return currentKey ?? "";
+        }
+
+        return currentKey + "." + key;
+    }
+
+    private string[] GetResolvedKeysRecursive(string[] keyParts, object currentModel, int currentIndex = 0, string currentKey = "")
+    {
+        if (currentModel is null)
+        {
+            return new string[0];
+        }
+
+        if (currentIndex == keyParts.Length)
+        {
+            return new[] { currentKey };
+        }
+
+        var (key, groupIndex) = ParseKeyPart(keyParts[currentIndex]);
+        var prop = currentModel?.GetType().GetProperties().FirstOrDefault(p => IsPropertyWithJsonName(p, key));
+        var childModel = prop?.GetValue(currentModel);
+        if (childModel is null)
+        {
+            return new string[0];
+        }
+
+        if (childModel is not string && childModel is System.Collections.IEnumerable childModelList)
+        {
+            // childModel is an array
+            if (groupIndex is null)
+            {
+                // Index not specified, recurse on all elements
+                int i = 0;
+                var resolvedKeys = new List<string>();
+                foreach (var child in childModelList)
+                {
+                    var newResolvedKeys = GetResolvedKeysRecursive(keyParts, child, currentIndex + 1, JoinFieldKeyParts(currentKey, key + "[" + i + "]"));
+                    resolvedKeys.AddRange(newResolvedKeys);
+                    i++;
+                }
+                return resolvedKeys.ToArray();
+            }
+            else
+            {
+                // Index specified, recurse on that element
+                return GetResolvedKeysRecursive(keyParts, childModel, currentIndex + 1, JoinFieldKeyParts(currentKey, key + "[" + groupIndex + "]"));
+            }
+        }
+
+        // Otherwise, just recurse
+        return GetResolvedKeysRecursive(keyParts, childModel, currentIndex + 1, JoinFieldKeyParts(currentKey, key));
+
+    }
+
     private static object? GetElementAt(System.Collections.IEnumerable enumerable, int index)
     {
         // Return the element with index = groupIndex (could not find anohter way to get the n'th element in non generic enumerable)
diff --git a/src/Altinn.App.Core/Helpers/IDataModel.cs b/src/Altinn.App.Core/Helpers/IDataModel.cs
index 2f267da9e..9d720b1aa 100644
--- a/src/Altinn.App.Core/Helpers/IDataModel.cs
+++ b/src/Altinn.App.Core/Helpers/IDataModel.cs
@@ -26,6 +26,11 @@ public interface IDataModelAccessor
     /// </summary>
     int? GetModelDataCount(string key, ReadOnlySpan<int> indicies = default);
 
+    /// <summary>
+    /// Get all of the resoved keys (including all possible indexes) from a data model key
+    /// </summary>
+    string[] GetResolvedKeys(string key);
+
     /// <summary>
     /// Return a full dataModelBiding from a context aware binding by adding indicies
     /// </summary>
diff --git a/src/Altinn.App.Core/Implementation/AppResourcesSI.cs b/src/Altinn.App.Core/Implementation/AppResourcesSI.cs
index 4d5a33dcc..980d1ebfb 100644
--- a/src/Altinn.App.Core/Implementation/AppResourcesSI.cs
+++ b/src/Altinn.App.Core/Implementation/AppResourcesSI.cs
@@ -119,7 +119,7 @@ public Application GetApplication()
                         Show = applicationMetadata.OnEntry.Show
                     };
                 }
-                
+
                 return application;
             }
             catch (AggregateException ex)
@@ -463,5 +463,21 @@ private byte[] ReadFileContentsFromLegalPath(string legalPath, string filePath)
 
             return filedata;
         }
+
+        /// <inheritdoc />
+        public string? GetValidationConfiguration(string modelId)
+        {
+            string legalPath = $"{_settings.AppBasePath}{_settings.ModelsFolder}";
+            string filename = $"{legalPath}{modelId}.{_settings.ValidationConfigurationFileName}";
+            PathHelper.EnsureLegalPath(legalPath, filename);
+
+            string? filedata = null;
+            if (File.Exists(filename))
+            {
+                filedata = File.ReadAllText(filename, Encoding.UTF8);
+            }
+
+            return filedata;
+        }
     }
 }
diff --git a/src/Altinn.App.Core/Implementation/DefaultTaskEvents.cs b/src/Altinn.App.Core/Implementation/DefaultTaskEvents.cs
index c5759b312..5e09d3e4c 100644
--- a/src/Altinn.App.Core/Implementation/DefaultTaskEvents.cs
+++ b/src/Altinn.App.Core/Implementation/DefaultTaskEvents.cs
@@ -165,7 +165,7 @@ public async Task OnEndProcessTask(string endEvent, Instance instance)
 
     private async Task RunRemoveHiddenData(Instance instance, Guid instanceGuid, List<DataType>? dataTypesToLock)
     {
-        if (_appSettings?.RemoveHiddenDataPreview == true)
+        if (_appSettings?.RemoveHiddenData == true)
         {
             await RemoveHiddenData(instance, instanceGuid, dataTypesToLock);
         }
@@ -269,7 +269,7 @@ private async Task RemoveHiddenData(Instance instance, Guid instanceGuid, List<D
                 object data = await _dataClient.GetFormData(
                     instanceGuid, modelType, instance.Org, app, instanceOwnerPartyId, dataElementId);
 
-                if (_appSettings?.RemoveHiddenDataPreview == true)
+                if (_appSettings?.RemoveHiddenData == true)
                 {
                     // Remove hidden data before validation, ignore hidden rows. TODO: Determine how hidden rows should be handled going forward.
                     var layoutSet = _appResources.GetLayoutSetForTask(dataType.TaskId);
diff --git a/src/Altinn.App.Core/Internal/App/IAppResources.cs b/src/Altinn.App.Core/Internal/App/IAppResources.cs
index 0f1d5d9e7..69cf19c57 100644
--- a/src/Altinn.App.Core/Internal/App/IAppResources.cs
+++ b/src/Altinn.App.Core/Internal/App/IAppResources.cs
@@ -170,5 +170,11 @@ public interface IAppResources
         /// </summary>
         /// <returns>The layout settings</returns>
         byte[] GetRuleHandlerForSet(string id);
+
+        /// <summary>
+        /// Gets the the rule handler for a layoutset
+        /// </summary>
+        /// <returns>The layout settings</returns>
+        string? GetValidationConfiguration(string modelId);
     }
 }
diff --git a/src/Altinn.App.Core/Internal/Expressions/ExpressionEvaluator.cs b/src/Altinn.App.Core/Internal/Expressions/ExpressionEvaluator.cs
index 1fa7f0038..86bb9fcda 100644
--- a/src/Altinn.App.Core/Internal/Expressions/ExpressionEvaluator.cs
+++ b/src/Altinn.App.Core/Internal/Expressions/ExpressionEvaluator.cs
@@ -47,7 +47,7 @@ public static bool EvaluateBooleanExpression(LayoutEvaluatorState state, Compone
     /// <summary>
     /// Evaluate a <see cref="Expression" /> from a given <see cref="LayoutEvaluatorState" /> in a <see cref="ComponentContext" />
     /// </summary>
-    public static object? EvaluateExpression(LayoutEvaluatorState state, Expression expr, ComponentContext context)
+    public static object? EvaluateExpression(LayoutEvaluatorState state, Expression expr, ComponentContext? context, object[]? positionalArguments = null)
     {
         if (expr is null)
         {
@@ -58,10 +58,10 @@ public static bool EvaluateBooleanExpression(LayoutEvaluatorState state, Compone
             return expr.Value;
         }
 
-        var args = expr.Args.Select(a => EvaluateExpression(state, a, context)).ToArray();
+        var args = expr.Args.Select(a => EvaluateExpression(state, a, context, positionalArguments)).ToArray();
         var ret = expr.Function switch
         {
-            ExpressionFunction.dataModel => state.GetModelData(args.First()?.ToString(), context),
+            ExpressionFunction.dataModel => DataModel(args.First()?.ToString(), context, state),
             ExpressionFunction.component => Component(args, context, state),
             ExpressionFunction.instanceContext => state.GetInstanceContext(args.First()?.ToString()!),
             ExpressionFunction.@if => IfImpl(args),
@@ -85,13 +85,27 @@ public static bool EvaluateBooleanExpression(LayoutEvaluatorState state, Compone
             ExpressionFunction.round => Round(args),
             ExpressionFunction.upperCase => UpperCase(args),
             ExpressionFunction.lowerCase => LowerCase(args),
+            ExpressionFunction.argv => Argv(args, positionalArguments),
             ExpressionFunction.gatewayAction => state.GetGatewayAction(),
             _ => throw new ExpressionEvaluatorTypeErrorException($"Function \"{expr.Function}\" not implemented"),
         };
         return ret;
     }
 
-    private static object? Component(object?[] args, ComponentContext context, LayoutEvaluatorState state)
+    private static object? DataModel(string? key, ComponentContext? context, LayoutEvaluatorState state)
+    {
+        var data = state.GetModelData(key, context);
+
+        // Only allow IConvertible types to be returned from data model
+        // Objects and arrays should return null
+        return data switch
+        {
+            IConvertible c => c,
+            _ => null,
+        };
+    }
+
+    private static object? Component(object?[] args, ComponentContext? context, LayoutEvaluatorState state)
     {
         var componentId = args.First()?.ToString();
         if (componentId is null)
@@ -99,6 +113,11 @@ public static bool EvaluateBooleanExpression(LayoutEvaluatorState state, Compone
             throw new ArgumentException("Cannot lookup component null");
         }
 
+        if (context is null)
+        {
+            throw new ArgumentException("The component expression requires a component context");
+        }
+
         var targetContext = state.GetComponentContext(context.Component.PageId, componentId, context.RowIndices);
 
         if (targetContext.Component is GroupComponent)
@@ -121,7 +140,7 @@ public static bool EvaluateBooleanExpression(LayoutEvaluatorState state, Compone
             parent = parent.Parent;
         }
 
-        return state.GetModelData(binding, context);
+        return DataModel(binding, context, state);
     }
 
     private static string? Concat(object?[] args)
@@ -332,9 +351,7 @@ private static (double?, double?) PrepareNumericArgs(object?[] args)
         {
             bool ab => throw new ExpressionEvaluatorTypeErrorException($"Expected number, got value {(ab ? "true" : "false")}"),
             string s => parseNumber(s),
-            int i => Convert.ToDouble(i),
-            decimal d => Convert.ToDouble(d),
-            object o => o as double?, // assume all relevant numbers are representable as double (as in frontend)
+            IConvertible c => Convert.ToDouble(c),
             _ => null
         };
     }
@@ -470,5 +487,30 @@ private static (double?, double?) PrepareNumericArgs(object?[] args)
 
         return string.Equals(ToStringForEquals(args[0]), ToStringForEquals(args[1]), StringComparison.InvariantCulture);
     }
+
+    private static object Argv(object?[] args, object[]? positionalArguments)
+    {
+        if (args.Length != 1)
+        {
+            throw new ExpressionEvaluatorTypeErrorException($"Expected 1 argument(s), got {args.Length}");
+        }
+
+        var index = (int?)PrepareNumericArg(args[0]);
+        if (!index.HasValue)
+        {
+            throw new ExpressionEvaluatorTypeErrorException($"Expected number, got value \"{args[0]}\"");
+        }
+
+        if (positionalArguments == null)
+        {
+            throw new ExpressionEvaluatorTypeErrorException("No positional arguments available");
+        }
+        if (index < 0 || index >= positionalArguments.Length)
+        {
+            throw new ExpressionEvaluatorTypeErrorException($"Index {index} out of range");
+        }
+
+        return positionalArguments[index.Value];
+    }
 }
 
diff --git a/src/Altinn.App.Core/Models/Expressions/ExpressionFunctionEnum.cs b/src/Altinn.App.Core/Models/Expressions/ExpressionFunctionEnum.cs
index 41ffb6f41..a3097aebd 100644
--- a/src/Altinn.App.Core/Models/Expressions/ExpressionFunctionEnum.cs
+++ b/src/Altinn.App.Core/Models/Expressions/ExpressionFunctionEnum.cs
@@ -106,7 +106,11 @@ public enum ExpressionFunction
     /// </summary>
     not,
     /// <summary>
+    /// Returns a positional argument
+    /// </summary>
+    argv,
+    /// <summary>
     /// Get the action performed in task prior to bpmn gateway
     /// </summary>
     gatewayAction,
-}
\ No newline at end of file
+}
diff --git a/src/Altinn.App.Core/Models/Validation/ExpressionValidation.cs b/src/Altinn.App.Core/Models/Validation/ExpressionValidation.cs
new file mode 100644
index 000000000..b88b2af6d
--- /dev/null
+++ b/src/Altinn.App.Core/Models/Validation/ExpressionValidation.cs
@@ -0,0 +1,41 @@
+using System.Text.Json.Serialization;
+using Altinn.App.Core.Models.Expressions;
+
+
+namespace Altinn.App.Core.Models.Validation
+{
+
+    /// <summary>
+    /// Resolved expression validation
+    /// </summary>
+    public class ExpressionValidation
+    {
+        /// <inheritdoc/>
+        public string? Message { get; set; }
+
+        /// <inheritdoc/>
+        public Expression? Condition { get; set; }
+
+        /// <inheritdoc/>
+        public ValidationIssueSeverity? Severity { get; set; }
+    }
+
+    /// <summary>
+    /// Raw expression validation or definition from the validation configuration file
+    /// </summary>
+    public class RawExpressionValidation
+    {
+        /// <inheritdoc/>
+        public string? Message { get; set; }
+
+        /// <inheritdoc/>
+        public Expression? Condition { get; set; }
+
+        /// <inheritdoc/>
+        [JsonConverter(typeof(FrontendSeverityConverter))]
+        public ValidationIssueSeverity? Severity { get; set; }
+
+        /// <inheritdoc/>
+        public string? Ref { get; set; }
+    }
+}
diff --git a/src/Altinn.App.Core/Models/Validation/FrontendSeverityConverter.cs b/src/Altinn.App.Core/Models/Validation/FrontendSeverityConverter.cs
new file mode 100644
index 000000000..2db22f938
--- /dev/null
+++ b/src/Altinn.App.Core/Models/Validation/FrontendSeverityConverter.cs
@@ -0,0 +1,42 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Altinn.App.Core.Models.Validation
+{
+    /// <inheritdoc />
+    public class FrontendSeverityConverter : JsonConverter<ValidationIssueSeverity>
+    {
+        /// <inheritdoc />
+        public override ValidationIssueSeverity Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType != JsonTokenType.String)
+            {
+                throw new JsonException();
+            }
+
+            return reader.GetString() switch
+            {
+                "errors" => ValidationIssueSeverity.Error,
+                "warnings" => ValidationIssueSeverity.Warning,
+                "info" => ValidationIssueSeverity.Informational,
+                "success" => ValidationIssueSeverity.Success,
+                _ => throw new JsonException(),
+            };
+        }
+
+        /// <inheritdoc />
+        public override void Write(Utf8JsonWriter writer, ValidationIssueSeverity value, JsonSerializerOptions options)
+        {
+            string output = value switch
+            {
+                ValidationIssueSeverity.Error => "errors",
+                ValidationIssueSeverity.Warning => "warnings",
+                ValidationIssueSeverity.Informational => "info",
+                ValidationIssueSeverity.Success => "success",
+                _ => throw new JsonException(),
+            };
+
+            JsonSerializer.Serialize(writer, output, options);
+        }
+    }
+}
diff --git a/src/Altinn.App.Core/Models/Validation/ValidationIssueSource.cs b/src/Altinn.App.Core/Models/Validation/ValidationIssueSource.cs
index 532119033..45054aa97 100644
--- a/src/Altinn.App.Core/Models/Validation/ValidationIssueSource.cs
+++ b/src/Altinn.App.Core/Models/Validation/ValidationIssueSource.cs
@@ -25,5 +25,10 @@ public static class ValidationIssueSources
         /// Required field validation
         /// </summary>
         public static readonly string Custom = nameof(Custom);
+
+        /// <summary>
+        /// Expression validation
+        /// </summary>
+        public static readonly string Expression = nameof(Expression);
     }
 }
diff --git a/test/Altinn.App.Core.Tests/Altinn.App.Core.Tests.csproj b/test/Altinn.App.Core.Tests/Altinn.App.Core.Tests.csproj
index c12a59850..f3156bb10 100644
--- a/test/Altinn.App.Core.Tests/Altinn.App.Core.Tests.csproj
+++ b/test/Altinn.App.Core.Tests/Altinn.App.Core.Tests.csproj
@@ -13,6 +13,8 @@
     <Compile Remove="Implementation\AppBaseTests.cs" />
     <Content Include="LayoutExpressions/**/*.json" CopyToOutputDirectory="Always" CopyToPublishDirectory="Always" />
     <Watch Include="LayoutExpressions/**/*.json" />
+    <Content Include="Features/Validators/**/*.json" CopyToOutputDirectory="Always" CopyToPublishDirectory="Always" />
+    <Watch Include="Features/Validators/**/*.json" />
     <Content Include="Models/**/*.json" CopyToOutputDirectory="Always" CopyToPublishDirectory="Always" />
     <Watch Include="Models/**/*.json" />
     <Watch Include="**/*.cs" />
diff --git a/test/Altinn.App.Core.Tests/Features/Validators/ExpressionValidationTests.cs b/test/Altinn.App.Core.Tests/Features/Validators/ExpressionValidationTests.cs
new file mode 100644
index 000000000..19d23481d
--- /dev/null
+++ b/test/Altinn.App.Core.Tests/Features/Validators/ExpressionValidationTests.cs
@@ -0,0 +1,96 @@
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
+using Altinn.App.Core.Features.Validation;
+using Altinn.App.Core.Helpers;
+using Altinn.App.Core.Internal.Expressions;
+using Altinn.App.Core.Models.Layout;
+using Altinn.App.Core.Models.Validation;
+using Altinn.App.Core.Tests.Helpers;
+using Altinn.App.Core.Tests.LayoutExpressions;
+using FluentAssertions;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Xunit;
+using Xunit.Sdk;
+
+namespace Altinn.App.Core.Tests.Features.Validators;
+
+public class ExpressionValidationTests
+{
+    [Theory]
+    [ExpressionTest]
+    public void RunExpressionValidationTest(ExpressionValidationTestModel testCase)
+    {
+        var logger = Mock.Of<ILogger<ValidationAppSI>>();
+        var dataModel = new JsonDataModel(testCase.FormData);
+        var evaluatorState = new LayoutEvaluatorState(dataModel, testCase.Layouts, new(), new());
+
+        LayoutEvaluator.RemoveHiddenData(evaluatorState, RowRemovalOption.SetToNull);
+        var validationIssues = ExpressionValidator.Validate(testCase.ValidationConfig, dataModel, evaluatorState, logger).ToArray();
+
+        var result = validationIssues.Select(i => new
+        {
+            Message = i.CustomTextKey,
+            Severity = i.Severity,
+            Field = i.Field,
+        });
+
+        var expected = testCase.Expects.Select(e => new
+        {
+            Message = e.Message,
+            Severity = e.Severity,
+            Field = e.Field,
+        });
+
+        result.Should().BeEquivalentTo(expected);
+    }
+}
+
+public class ExpressionTestAttribute : DataAttribute
+{
+    public override IEnumerable<object[]> GetData(MethodInfo methodInfo)
+    {
+        var files = Directory.GetFiles(Path.Join("Features", "Validators", "shared-expression-validation-tests"));
+
+        foreach (var file in files)
+        {
+            var data = File.ReadAllText(file);
+            ExpressionValidationTestModel testCase = JsonSerializer.Deserialize<ExpressionValidationTestModel>(
+                data,
+                new JsonSerializerOptions
+                {
+                    ReadCommentHandling = JsonCommentHandling.Skip,
+                    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+                })!;
+            yield return new object[] { testCase };
+        }
+    }
+}
+
+public class ExpressionValidationTestModel
+{
+    public string Name { get; set; }
+
+    public ExpectedObject[] Expects { get; set; }
+
+    public JsonElement ValidationConfig { get; set; }
+
+    public JsonObject FormData { get; set; }
+
+    [JsonConverter(typeof(LayoutModelConverterFromObject))]
+    public LayoutModel Layouts { get; set; }
+
+    public class ExpectedObject
+    {
+        public string Message { get; set; }
+
+        [JsonConverter(typeof(FrontendSeverityConverter))]
+        public ValidationIssueSeverity Severity { get; set; }
+
+        public string Field { get; set; }
+
+        public string ComponentId { get; set; }
+    }
+}
diff --git a/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/hidden-field.json b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/hidden-field.json
new file mode 100644
index 000000000..9ab1af8d5
--- /dev/null
+++ b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/hidden-field.json
@@ -0,0 +1,39 @@
+{
+  "name": "Should not return an error if component is hidden",
+  "expects": [],
+  "validationConfig": {
+    "$schema": "https://altinncdn.no/schemas/json/validation/validation.schema.v1.json",
+    "validations": {
+      "form.name": ["none-is-not-allowed"]
+    },
+    "definitions": {
+      "none-is-not-allowed": {
+        "message": "none is not allowed",
+        "severity": "errors",
+        "condition": ["equals", ["dataModel", ["argv", 0]], "none"]
+      }
+    }
+  },
+  "formData": {
+    "form": {
+      "name": "none"
+    }
+  },
+  "layouts": {
+    "Page": {
+      "$schema": "https://altinncdn.no/schemas/json/layout/layout.schema.v1.json",
+      "data": {
+        "layout": [
+          {
+            "id": "name-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.name"
+            },
+            "hidden": true
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/hidden-page.json b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/hidden-page.json
new file mode 100644
index 000000000..57fd62f00
--- /dev/null
+++ b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/hidden-page.json
@@ -0,0 +1,39 @@
+{
+  "name": "Should not return an error if page is hidden",
+  "expects": [],
+  "validationConfig": {
+    "$schema": "https://altinncdn.no/schemas/json/validation/validation.schema.v1.json",
+    "validations": {
+      "form.name": ["none-is-not-allowed"]
+    },
+    "definitions": {
+      "none-is-not-allowed": {
+        "message": "none is not allowed",
+        "severity": "errors",
+        "condition": ["equals", ["dataModel", ["argv", 0]], "none"]
+      }
+    }
+  },
+  "formData": {
+    "form": {
+      "name": "none"
+    }
+  },
+  "layouts": {
+    "Page": {
+      "$schema": "https://altinncdn.no/schemas/json/layout/layout.schema.v1.json",
+      "data": {
+        "hidden": true,
+        "layout": [
+          {
+            "id": "name-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.name"
+            }
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/many-errors.json b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/many-errors.json
new file mode 100644
index 000000000..33f9604c7
--- /dev/null
+++ b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/many-errors.json
@@ -0,0 +1,101 @@
+{
+  "name": "Should return all of the correct errors",
+  "expects": [
+    {
+      "message": "none is not allowed",
+      "severity": "errors",
+      "field": "form.name",
+      "componentId": "name-input"
+    },
+    {
+      "message": "string is too short",
+      "severity": "errors",
+      "field": "form.name",
+      "componentId": "name-input"
+    },
+    {
+      "message": "email must be real",
+      "severity": "errors",
+      "field": "form.email",
+      "componentId": "email-input"
+    },
+    {
+      "message": "string is too short",
+      "severity": "errors",
+      "field": "form.email",
+      "componentId": "email-input"
+    }
+  ],
+  "validationConfig": {
+    "$schema": "https://altinncdn.no/schemas/json/validation/validation.schema.v1.json",
+    "validations": {
+      "form.name": [
+        "none-is-not-allowed",
+        "str-len",
+        {
+          "message": "this should not be shown",
+          "severity": "warnings",
+          "condition": ["startsWith", ["dataModel", ["argv", 0]], "a"]
+        }
+      ],
+      "form.email": [
+        "none-is-not-allowed",
+        {
+          "message": "email must be real",
+          "severity": "errors",
+          "condition": ["contains", ["dataModel", ["argv", 0]], "fake"]
+        },
+        {
+          "ref": "str-len",
+          "condition": ["lessThan", ["stringLength", ["dataModel", ["argv", 0]]], 20]
+        },
+        {
+          "message": "email must contain @",
+          "severity": "errors",
+          "condition": ["notContains", ["dataModel", ["argv", 0]], "@"]
+        }
+      ]
+    },
+    "definitions": {
+      "none-is-not-allowed": {
+        "message": "none is not allowed",
+        "severity": "errors",
+        "condition": ["equals", ["dataModel", ["argv", 0]], "none"]
+      },
+      "str-len": {
+        "message": "string is too short",
+        "severity": "errors",
+        "condition": ["lessThan", ["stringLength", ["dataModel", ["argv", 0]]], 5]
+      }
+    }
+  },
+  "formData": {
+    "form": {
+      "name": "none",
+      "email": "fake@email.com"
+    }
+  },
+  "layouts": {
+    "Page": {
+      "$schema": "https://altinncdn.no/schemas/json/layout/layout.schema.v1.json",
+      "data": {
+        "layout": [
+          {
+            "id": "name-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.name"
+            }
+          },
+          {
+            "id": "email-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.email"
+            }
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/nested-repeating-hidden-row.json b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/nested-repeating-hidden-row.json
new file mode 100644
index 000000000..607327509
--- /dev/null
+++ b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/nested-repeating-hidden-row.json
@@ -0,0 +1,179 @@
+{
+  "name": "Should work in nested repeating groups with some hidden rows",
+  "expects": [
+    {
+      "message": "zero is not allowed",
+      "severity": "errors",
+      "field": "form.people[1].number",
+      "componentId": "number-input-1"
+    },
+    {
+      "message": "none is not allowed",
+      "severity": "errors",
+      "field": "form.people[1].names[2].name",
+      "componentId": "name-input-1-2"
+    },
+    {
+      "message": "none is not allowed",
+      "severity": "errors",
+      "field": "form.people[2].names[2].name",
+      "componentId": "name-input-2-2"
+    }
+  ],
+  "validationConfig": {
+    "$schema": "https://altinncdn.no/schemas/json/validation/validation.schema.v1.json",
+    "validations": {
+      "form.people.number": ["zero-is-not-allowed"],
+      "form.people.names.name": ["none-is-not-allowed"]
+    },
+    "definitions": {
+      "zero-is-not-allowed": {
+        "message": "zero is not allowed",
+        "severity": "errors",
+        "condition": ["equals", ["dataModel", ["argv", 0]], 0]
+      },
+      "none-is-not-allowed": {
+        "message": "none is not allowed",
+        "severity": "errors",
+        "condition": ["equals", ["dataModel", ["argv", 0]], "none"]
+      }
+    }
+  },
+  "formData": {
+    "form": {
+      "people": [
+        {
+          "number": "0",
+          "hidden": true,
+          "names": [
+            {
+              "name": "none",
+              "hidden": true
+            },
+            {
+              "name": "John",
+              "hidden": false
+            },
+            {
+              "name": "none",
+              "hidden": false
+            },
+            {
+              "name": "Jane",
+              "hidden": true
+            }
+          ]
+        },
+        {
+          "number": "0",
+          "hidden": false,
+          "names": [
+            {
+              "name": "none",
+              "hidden": true
+            },
+            {
+              "name": "John",
+              "hidden": false
+            },
+            {
+              "name": "none",
+              "hidden": false
+            },
+            {
+              "name": "Jane",
+              "hidden": true
+            }
+          ]
+        },
+        {
+          "number": "1234",
+          "hidden": false,
+          "names": [
+            {
+              "name": "none",
+              "hidden": true
+            },
+            {
+              "name": "John",
+              "hidden": false
+            },
+            {
+              "name": "none",
+              "hidden": false
+            },
+            {
+              "name": "Jane",
+              "hidden": true
+            }
+          ]
+        },
+        {
+          "number": "5678",
+          "hidden": true,
+          "names": [
+            {
+              "name": "none",
+              "hidden": true
+            },
+            {
+              "name": "John",
+              "hidden": false
+            },
+            {
+              "name": "none",
+              "hidden": false
+            },
+            {
+              "name": "Jane",
+              "hidden": true
+            }
+          ]
+        }
+      ]
+    }
+  },
+  "layouts": {
+    "Page": {
+      "$schema": "https://altinncdn.no/schemas/json/layout/layout.schema.v1.json",
+      "data": {
+        "layout": [
+          {
+            "id": "people-group",
+            "type": "Group",
+            "dataModelBindings": {
+              "group": "form.people"
+            },
+            "maxCount": 99,
+            "children": ["number-input", "names-group"],
+            "hiddenRow": ["dataModel", "form.people.hidden"]
+          },
+          {
+            "id": "number-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.people.number"
+            }
+          },
+          {
+            "id": "names-group",
+            "type": "Group",
+            "dataModelBindings": {
+              "group": "form.people.names"
+            },
+            "maxCount": 99,
+            "children": ["name-input"],
+            "hiddenRow": ["dataModel", "form.people.names.hidden"]
+          },
+          {
+            "id": "name-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.people.names.name"
+            }
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/nested-repeating-hidden.json b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/nested-repeating-hidden.json
new file mode 100644
index 000000000..574a00eed
--- /dev/null
+++ b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/nested-repeating-hidden.json
@@ -0,0 +1,191 @@
+{
+  "name": "Should work in nested repeating groups with hidden fields in some rows",
+  "expects": [
+    {
+      "message": "none is not allowed",
+      "severity": "errors",
+      "field": "form.people[0].names[2].name",
+      "componentId": "name-input-0-2"
+    },
+    {
+      "message": "zero is not allowed",
+      "severity": "errors",
+      "field": "form.people[1].number",
+      "componentId": "number-input-1"
+    },
+    {
+      "message": "none is not allowed",
+      "severity": "errors",
+      "field": "form.people[1].names[2].name",
+      "componentId": "name-input-1-2"
+    },
+    {
+      "message": "none is not allowed",
+      "severity": "errors",
+      "field": "form.people[2].names[2].name",
+      "componentId": "name-input-2-2"
+    },
+    {
+      "message": "none is not allowed",
+      "severity": "errors",
+      "field": "form.people[3].names[2].name",
+      "componentId": "name-input-3-2"
+    }
+  ],
+  "validationConfig": {
+    "$schema": "https://altinncdn.no/schemas/json/validation/validation.schema.v1.json",
+    "validations": {
+      "form.people.number": ["zero-is-not-allowed"],
+      "form.people.names.name": ["none-is-not-allowed"]
+    },
+    "definitions": {
+      "zero-is-not-allowed": {
+        "message": "zero is not allowed",
+        "severity": "errors",
+        "condition": ["equals", ["dataModel", ["argv", 0]], 0]
+      },
+      "none-is-not-allowed": {
+        "message": "none is not allowed",
+        "severity": "errors",
+        "condition": ["equals", ["dataModel", ["argv", 0]], "none"]
+      }
+    }
+  },
+  "formData": {
+    "form": {
+      "people": [
+        {
+          "number": "0",
+          "hidden": true,
+          "names": [
+            {
+              "name": "none",
+              "hidden": true
+            },
+            {
+              "name": "John",
+              "hidden": false
+            },
+            {
+              "name": "none",
+              "hidden": false
+            },
+            {
+              "name": "Jane",
+              "hidden": true
+            }
+          ]
+        },
+        {
+          "number": "0",
+          "hidden": false,
+          "names": [
+            {
+              "name": "none",
+              "hidden": true
+            },
+            {
+              "name": "John",
+              "hidden": false
+            },
+            {
+              "name": "none",
+              "hidden": false
+            },
+            {
+              "name": "Jane",
+              "hidden": true
+            }
+          ]
+        },
+        {
+          "number": "1234",
+          "hidden": false,
+          "names": [
+            {
+              "name": "none",
+              "hidden": true
+            },
+            {
+              "name": "John",
+              "hidden": false
+            },
+            {
+              "name": "none",
+              "hidden": false
+            },
+            {
+              "name": "Jane",
+              "hidden": true
+            }
+          ]
+        },
+        {
+          "number": "5678",
+          "hidden": true,
+          "names": [
+            {
+              "name": "none",
+              "hidden": true
+            },
+            {
+              "name": "John",
+              "hidden": false
+            },
+            {
+              "name": "none",
+              "hidden": false
+            },
+            {
+              "name": "Jane",
+              "hidden": true
+            }
+          ]
+        }
+      ]
+    }
+  },
+  "layouts": {
+    "Page": {
+      "$schema": "https://altinncdn.no/schemas/json/layout/layout.schema.v1.json",
+      "data": {
+        "layout": [
+          {
+            "id": "people-group",
+            "type": "Group",
+            "dataModelBindings": {
+              "group": "form.people"
+            },
+            "maxCount": 99,
+            "children": ["number-input", "names-group"]
+          },
+          {
+            "id": "number-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.people.number"
+            },
+            "hidden": ["dataModel", "form.people.hidden"]
+          },
+          {
+            "id": "names-group",
+            "type": "Group",
+            "dataModelBindings": {
+              "group": "form.people.names"
+            },
+            "maxCount": 99,
+            "children": ["name-input"]
+          },
+          {
+            "id": "name-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.people.names.name"
+            },
+            "hidden": ["dataModel", "form.people.names.hidden"]
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/override.json b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/override.json
new file mode 100644
index 000000000..299cf4d14
--- /dev/null
+++ b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/override.json
@@ -0,0 +1,51 @@
+{
+  "name": "Should return correct values when overriding a definition",
+  "expects": [
+    {
+      "message": "this value could be wrong",
+      "severity": "warnings",
+      "field": "form.name",
+      "componentId": "name-input"
+    }
+  ],
+  "validationConfig": {
+    "$schema": "https://altinncdn.no/schemas/json/validation/validation.schema.v1.json",
+    "validations": {
+      "form.name": [
+        {
+          "ref": "none-is-not-allowed",
+          "message": "this value could be wrong",
+          "severity": "warnings"
+        }
+      ]
+    },
+    "definitions": {
+      "none-is-not-allowed": {
+        "message": "none is not allowed",
+        "severity": "errors",
+        "condition": ["equals", ["dataModel", ["argv", 0]], "none"]
+      }
+    }
+  },
+  "formData": {
+    "form": {
+      "name": "none"
+    }
+  },
+  "layouts": {
+    "Page": {
+      "$schema": "https://altinncdn.no/schemas/json/layout/layout.schema.v1.json",
+      "data": {
+        "layout": [
+          {
+            "id": "name-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.name"
+            }
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/repeating-hidden-row.json b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/repeating-hidden-row.json
new file mode 100644
index 000000000..65c0b1231
--- /dev/null
+++ b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/repeating-hidden-row.json
@@ -0,0 +1,72 @@
+{
+  "name": "Should work in repeating groups with some hidden rows",
+  "expects": [
+    {
+      "message": "none is not allowed",
+      "severity": "errors",
+      "field": "form.names[2].name",
+      "componentId": "name-input-2"
+    }
+  ],
+  "validationConfig": {
+    "$schema": "https://altinncdn.no/schemas/json/validation/validation.schema.v1.json",
+    "validations": {
+      "form.names.name": ["none-is-not-allowed"]
+    },
+    "definitions": {
+      "none-is-not-allowed": {
+        "message": "none is not allowed",
+        "severity": "errors",
+        "condition": ["equals", ["dataModel", ["argv", 0]], "none"]
+      }
+    }
+  },
+  "formData": {
+    "form": {
+      "names": [
+        {
+          "name": "none",
+          "hidden": true
+        },
+        {
+          "name": "John",
+          "hidden": false
+        },
+        {
+          "name": "none",
+          "hidden": false
+        },
+        {
+          "name": "Jane",
+          "hidden": true
+        }
+      ]
+    }
+  },
+  "layouts": {
+    "Page": {
+      "$schema": "https://altinncdn.no/schemas/json/layout/layout.schema.v1.json",
+      "data": {
+        "layout": [
+          {
+            "id": "names-group",
+            "type": "Group",
+            "dataModelBindings": {
+              "group": "form.names"
+            },
+            "maxCount": 99,
+            "children": ["name-input"],
+            "hiddenRow": ["dataModel", "form.names.hidden"]
+          },
+          {
+            "id": "name-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.names.name"
+            }
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/repeating-hidden.json b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/repeating-hidden.json
new file mode 100644
index 000000000..7c5608637
--- /dev/null
+++ b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/repeating-hidden.json
@@ -0,0 +1,72 @@
+{
+  "name": "Should work in repeating groups with hidden fields in some rows",
+  "expects": [
+    {
+      "message": "none is not allowed",
+      "severity": "errors",
+      "field": "form.names[2].name",
+      "componentId": "name-input-2"
+    }
+  ],
+  "validationConfig": {
+    "$schema": "https://altinncdn.no/schemas/json/validation/validation.schema.v1.json",
+    "validations": {
+      "form.names.name": ["none-is-not-allowed"]
+    },
+    "definitions": {
+      "none-is-not-allowed": {
+        "message": "none is not allowed",
+        "severity": "errors",
+        "condition": ["equals", ["dataModel", ["argv", 0]], "none"]
+      }
+    }
+  },
+  "formData": {
+    "form": {
+      "names": [
+        {
+          "name": "none",
+          "hidden": true
+        },
+        {
+          "name": "John",
+          "hidden": false
+        },
+        {
+          "name": "none",
+          "hidden": false
+        },
+        {
+          "name": "Jane",
+          "hidden": true
+        }
+      ]
+    }
+  },
+  "layouts": {
+    "Page": {
+      "$schema": "https://altinncdn.no/schemas/json/layout/layout.schema.v1.json",
+      "data": {
+        "layout": [
+          {
+            "id": "names-group",
+            "type": "Group",
+            "dataModelBindings": {
+              "group": "form.names"
+            },
+            "maxCount": 99,
+            "children": ["name-input"]
+          },
+          {
+            "id": "name-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.names.name"
+            },
+            "hidden": ["dataModel", "form.names.hidden"]
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/repeating.json b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/repeating.json
new file mode 100644
index 000000000..35be8f0e3
--- /dev/null
+++ b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/repeating.json
@@ -0,0 +1,73 @@
+{
+  "name": "Should work in repeating groups",
+  "expects": [
+    {
+      "message": "none is not allowed",
+      "severity": "errors",
+      "field": "form.names[0].name",
+      "componentId": "name-input-0"
+    },
+    {
+      "message": "none is not allowed",
+      "severity": "errors",
+      "field": "form.names[2].name",
+      "componentId": "name-input-2"
+    }
+  ],
+  "validationConfig": {
+    "$schema": "https://altinncdn.no/schemas/json/validation/validation.schema.v1.json",
+    "validations": {
+      "form.names.name": ["none-is-not-allowed"]
+    },
+    "definitions": {
+      "none-is-not-allowed": {
+        "message": "none is not allowed",
+        "severity": "errors",
+        "condition": ["equals", ["dataModel", ["argv", 0]], "none"]
+      }
+    }
+  },
+  "formData": {
+    "form": {
+      "names": [
+        {
+          "name": "none"
+        },
+        {
+          "name": "John"
+        },
+        {
+          "name": "none"
+        },
+        {
+          "name": "Jane"
+        }
+      ]
+    }
+  },
+  "layouts": {
+    "Page": {
+      "$schema": "https://altinncdn.no/schemas/json/layout/layout.schema.v1.json",
+      "data": {
+        "layout": [
+          {
+            "id": "names-group",
+            "type": "Group",
+            "dataModelBindings": {
+              "group": "form.names"
+            },
+            "maxCount": 99,
+            "children": ["name-input"]
+          },
+          {
+            "id": "name-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.names.name"
+            }
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/single-field-equals.json b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/single-field-equals.json
new file mode 100644
index 000000000..0c4d725cf
--- /dev/null
+++ b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/single-field-equals.json
@@ -0,0 +1,54 @@
+{
+  "name": "Should return an error if equals condition is met",
+  "expects": [
+    {
+      "message": "none is not allowed",
+      "severity": "errors",
+      "field": "form.name",
+      "componentId": "name-input"
+    }
+  ],
+  "validationConfig": {
+    "$schema": "https://altinncdn.no/schemas/json/validation/validation.schema.v1.json",
+    "validations": {
+      "form.name": ["none-is-not-allowed"],
+      "form.email": ["none-is-not-allowed"]
+    },
+    "definitions": {
+      "none-is-not-allowed": {
+        "message": "none is not allowed",
+        "severity": "errors",
+        "condition": ["equals", ["dataModel", ["argv", 0]], "none"]
+      }
+    }
+  },
+  "formData": {
+    "form": {
+      "name": "none",
+      "email": "email@address.com"
+    }
+  },
+  "layouts": {
+    "Page": {
+      "$schema": "https://altinncdn.no/schemas/json/layout/layout.schema.v1.json",
+      "data": {
+        "layout": [
+          {
+            "id": "name-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.name"
+            }
+          },
+          {
+            "id": "email-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.email"
+            }
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/warning.json b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/warning.json
new file mode 100644
index 000000000..3e5a1bcbd
--- /dev/null
+++ b/test/Altinn.App.Core.Tests/Features/Validators/shared-expression-validation-tests/warning.json
@@ -0,0 +1,44 @@
+{
+  "name": "Should return a warning",
+  "expects": [
+    {
+      "message": "none is not allowed",
+      "severity": "warnings",
+      "field": "form.name",
+      "componentId": "name-input"
+    }
+  ],
+  "validationConfig": {
+    "$schema": "https://altinncdn.no/schemas/json/validation/validation.schema.v1.json",
+    "validations": {
+      "form.name": [
+        {
+          "message": "none is not allowed",
+          "severity": "warnings",
+          "condition": ["equals", ["dataModel", ["argv", 0]], "none"]
+        }
+      ]
+    }
+  },
+  "formData": {
+    "form": {
+      "name": "none"
+    }
+  },
+  "layouts": {
+    "Page": {
+      "$schema": "https://altinncdn.no/schemas/json/layout/layout.schema.v1.json",
+      "data": {
+        "layout": [
+          {
+            "id": "name-input",
+            "type": "Input",
+            "dataModelBindings": {
+              "simpleBinding": "form.name"
+            }
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/test/Altinn.App.Core.Tests/Helpers/JsonDataModel.cs b/test/Altinn.App.Core.Tests/Helpers/JsonDataModel.cs
index f5bd722dd..6ba3888eb 100644
--- a/test/Altinn.App.Core.Tests/Helpers/JsonDataModel.cs
+++ b/test/Altinn.App.Core.Tests/Helpers/JsonDataModel.cs
@@ -1,12 +1,13 @@
 #nullable enable
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using Altinn.App.Core.Helpers;
 using Altinn.App.Core.Helpers.DataModel;
 
 namespace Altinn.App.Core.Tests.Helpers;
 
 /// <summary>
-/// Implementation of <see cref="IDataModelAccessor" /> for data models based on JsonElement (mainliy for testing )
+/// Implementation of <see cref="IDataModelAccessor" /> for data models based on JsonObject (mainliy for testing )
 /// </summary>
 /// <remarks>
 /// This class is written to enable the use of shared tests (with frontend) where the datamodel is defined
@@ -14,12 +15,12 @@ namespace Altinn.App.Core.Tests.Helpers;
 /// </remarks>
 public class JsonDataModel : IDataModelAccessor
 {
-    private readonly JsonElement? _modelRoot;
+    private readonly JsonObject? _modelRoot;
 
     /// <summary>
-    /// Constructor that creates a JsonDataModel based on a JsonElement
+    /// Constructor that creates a JsonDataModel based on a JsonObject
     /// </summary>
-    public JsonDataModel(JsonElement? modelRoot)
+    public JsonDataModel(JsonObject? modelRoot)
     {
         _modelRoot = modelRoot;
     }
@@ -32,34 +33,43 @@ public JsonDataModel(JsonElement? modelRoot)
             return null;
         }
 
-        return GetModelDataRecursive(key.Split('.'), 0, _modelRoot.Value, indicies);
+        return GetModelDataRecursive(key.Split('.'), 0, _modelRoot, indicies);
     }
 
-    private object? GetModelDataRecursive(string[] keys, int index, JsonElement currentModel, ReadOnlySpan<int> indicies)
+    private object? GetModelDataRecursive(string[] keys, int index, JsonNode? currentModel, ReadOnlySpan<int> indicies)
     {
+        if (currentModel is null)
+        {
+            return null;
+        }
+
         if (index == keys.Length)
         {
-            return currentModel.ValueKind switch
+            return currentModel switch
             {
-                JsonValueKind.String => currentModel.GetString(),
-                JsonValueKind.Number => currentModel.GetDouble(),
-                JsonValueKind.True => true,
-                JsonValueKind.False => false,
-                JsonValueKind.Object => null,
-                JsonValueKind.Array => null,
-                JsonValueKind.Null => null,
-                _ => throw new NotImplementedException($"Get Data is not implemented for {currentModel.ValueKind}"),
+                JsonValue jsonValue => jsonValue.GetValue<JsonElement>().ValueKind switch
+                {
+                    JsonValueKind.String => jsonValue.GetValue<string>(),
+                    JsonValueKind.Number => jsonValue.GetValue<double>(),
+                    JsonValueKind.True => true,
+                    JsonValueKind.False => false,
+                    JsonValueKind.Null => null,
+                    _ => throw new NotImplementedException($"Get Data is not implemented for {jsonValue.GetType()}"),
+                },
+                JsonObject obj => obj,
+                JsonArray arr => arr,
+                _ => throw new NotImplementedException($"Get Data is not implemented for {currentModel.GetType()}"),
             };
         }
 
         var (key, groupIndex) = DataModel.ParseKeyPart(keys[index]);
 
-        if (currentModel.ValueKind != JsonValueKind.Object || !currentModel.TryGetProperty(key, out JsonElement childModel))
+        if (currentModel is not JsonObject || !currentModel.AsObject().TryGetPropertyValue(key, out JsonNode? childModel))
         {
             return null;
         }
 
-        if (childModel.ValueKind == JsonValueKind.Array)
+        if (childModel is JsonArray childArray)
         {
             if (groupIndex is null)
             {
@@ -75,7 +85,7 @@ public JsonDataModel(JsonElement? modelRoot)
                 indicies = default; // when you use a literal index, the context indecies are not to be used later.
             }
 
-            var arrayElement = childModel.EnumerateArray().ElementAt((int)groupIndex);
+            var arrayElement = childArray.ElementAt((int)groupIndex);
             return GetModelDataRecursive(keys, index + 1, arrayElement, indicies.Length > 0 ? indicies.Slice(1) : indicies);
         }
 
@@ -90,28 +100,28 @@ public JsonDataModel(JsonElement? modelRoot)
             return null;
         }
 
-        return GetModelDataCountRecurs(key.Split('.'), 0, _modelRoot.Value, indicies);
+        return GetModelDataCountRecurs(key.Split('.'), 0, _modelRoot, indicies);
     }
 
-    private int? GetModelDataCountRecurs(string[] keys, int index, JsonElement currentModel, ReadOnlySpan<int> indicies)
+    private int? GetModelDataCountRecurs(string[] keys, int index, JsonNode? currentModel, ReadOnlySpan<int> indicies)
     {
-        if (index == keys.Length)
+        if (index == keys.Length || currentModel is null)
         {
             return null; // Last key part was not an JsonValueKind.Array
         }
 
         var (key, groupIndex) = DataModel.ParseKeyPart(keys[index]);
 
-        if (currentModel.ValueKind != JsonValueKind.Object || !currentModel.TryGetProperty(key, out JsonElement childModel))
+        if (currentModel is not JsonObject || !currentModel.AsObject().TryGetPropertyValue(key, out JsonNode? childModel))
         {
             return null;
         }
 
-        if (childModel.ValueKind == JsonValueKind.Array)
+        if (childModel is JsonArray childArray)
         {
             if (index == keys.Length - 1)
             {
-                return childModel.GetArrayLength();
+                return childArray.Count;
             }
 
             if (groupIndex is null)
@@ -128,24 +138,162 @@ public JsonDataModel(JsonElement? modelRoot)
                 indicies = default; // when you use a literal index, the context indecies are not to be used later.
             }
 
-            var arrayElement = childModel.EnumerateArray().ElementAt((int)groupIndex);
+            var arrayElement = childArray.ElementAt((int)groupIndex);
             return GetModelDataCountRecurs(keys, index + 1, arrayElement, indicies.Length > 0 ? indicies.Slice(1) : indicies);
         }
 
         return GetModelDataCountRecurs(keys, index + 1, childModel, indicies);
     }
 
+    /// <inheritdoc />
+    public string[] GetResolvedKeys(string key)
+    {
+        if (_modelRoot is null)
+        {
+            return new string[0];
+        }
+
+        var keyParts = key.Split('.');
+        return GetResolvedKeysRecursive(keyParts, _modelRoot);
+    }
+
+    private string[] GetResolvedKeysRecursive(string[] keyParts, JsonNode? currentModel, int currentIndex = 0, string currentKey = "")
+    {
+        if (currentModel is null)
+        {
+            return new string[0];
+        }
+
+        if (currentIndex == keyParts.Length)
+        {
+            return new[] { currentKey };
+        }
+
+        var (key, groupIndex) = DataModel.ParseKeyPart(keyParts[currentIndex]);
+        if (currentModel is not JsonObject || !currentModel.AsObject().TryGetPropertyValue(key, out JsonNode? childModel))
+        {
+            return new string[0];
+        }
+
+        if (childModel is JsonArray childArray)
+        {
+            // childModel is an array
+            if (groupIndex is null)
+            {
+                // Index not specified, recurse on all elements
+                int i = 0;
+                var resolvedKeys = new List<string>();
+                foreach (var child in childArray)
+                {
+                    var newResolvedKeys = GetResolvedKeysRecursive(keyParts, child, currentIndex + 1, DataModel.JoinFieldKeyParts(currentKey, key + "[" + i + "]"));
+                    resolvedKeys.AddRange(newResolvedKeys);
+                    i++;
+                }
+
+                return resolvedKeys.ToArray();
+            }
+            else
+            {
+                // Index specified, recurse on that element
+                return GetResolvedKeysRecursive(keyParts, childModel, currentIndex + 1, DataModel.JoinFieldKeyParts(currentKey, key + "[" + groupIndex + "]"));
+            }
+        }
+
+        // Otherwise, just recurse
+        return GetResolvedKeysRecursive(keyParts, childModel, currentIndex + 1, DataModel.JoinFieldKeyParts(currentKey, key));
+
+    }
+
     /// <inheritdoc />
     public string AddIndicies(string key, ReadOnlySpan<int> indicies = default)
     {
-        // We don't have a schema for the datamodel in Json
-        throw new NotImplementedException();
+        if (indicies.Length == 0)
+        {
+            return key;
+        }
+
+        var keys = key.Split('.');
+        var outputKey = string.Empty;
+        JsonNode? currentModel = _modelRoot;
+
+        foreach (var keyPart in keys)
+        {
+            var (currentKey, groupIndex) = DataModel.ParseKeyPart(keyPart);
+            var currentIndex = groupIndex ?? (indicies.Length > 0 ? indicies[0] : null);
+
+            if (currentModel is not JsonObject currentObject)
+            {
+                throw new DataModelException("Cannot access property of a JsonValue or JsonArray");
+            }
+
+            if (!currentObject.TryGetPropertyValue(currentKey, out JsonNode? childModel))
+            {
+                throw new DataModelException($"Cannot find property {currentKey} in {currentObject}");
+            }
+
+            if (childModel is JsonArray childArray && currentIndex is not null)
+            {
+                outputKey = DataModel.JoinFieldKeyParts(outputKey, currentKey + "[" + currentIndex + "]");
+                currentModel = childArray.ElementAt((int)currentIndex);
+                if (indicies.Length > 0)
+                {
+                    indicies = indicies.Slice(1);
+                }
+            }
+            else
+            {
+                if (groupIndex is not null)
+                {
+                    throw new DataModelException("Index on non indexable property");
+                }
+
+                outputKey = DataModel.JoinFieldKeyParts(outputKey, currentKey);
+                currentModel = childModel;
+            }
+        }
+
+        return outputKey;
     }
 
     /// <inheritdoc />
     public void RemoveField(string key, RowRemovalOption rowRemovalOption)
     {
-        throw new NotImplementedException("Impossible to remove fields in a json model");
+        var keys_split = key.Split('.');
+        var keys = keys_split[0..^1];
+        var (lastKey, lastGroupIndex) = DataModel.ParseKeyPart(keys_split[^1]);
+
+        object? modelData = GetModelDataRecursive(keys, 0, _modelRoot, default);
+        if (modelData is not JsonObject containingObject)
+        {
+            return;
+        }
+
+        if (lastGroupIndex is not null)
+        {
+            // Remove row from list
+            if (!(containingObject.TryGetPropertyValue(lastKey, out JsonNode? childModel) && childModel is JsonArray childArray))
+            {
+                throw new ArgumentException($"Tried to remove row {key}, ended in a non-list");
+            }
+
+            switch (rowRemovalOption)
+            {
+                case RowRemovalOption.DeleteRow:
+                    childArray.RemoveAt((int)lastGroupIndex);
+                    break;
+                case RowRemovalOption.SetToNull:
+                    childArray[(int)lastGroupIndex] = null;
+                    break;
+                case RowRemovalOption.Ignore:
+                    return;
+            }
+        }
+        else
+        {
+            // Set the property to null
+            containingObject[lastKey] = null;
+        }
+
     }
 
     /// <inheritdoc />
diff --git a/test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/ContextListRoot.cs b/test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/ContextListRoot.cs
index 2fdf9a04b..716476377 100644
--- a/test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/ContextListRoot.cs
+++ b/test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/ContextListRoot.cs
@@ -1,5 +1,6 @@
 #nullable enable
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
 
 using Altinn.App.Core.Models.Layout;
@@ -31,7 +32,7 @@ public class ContextListRoot
     public LayoutModel ComponentModel { get; set; } = default!;
 
     [JsonPropertyName("dataModel")]
-    public JsonElement? DataModel { get; set; }
+    public JsonObject? DataModel { get; set; }
 
     [JsonPropertyName("expectedContexts")]
     public List<ComponentContextForTestSpec> Expected { get; set; } = default!;
@@ -40,4 +41,4 @@ public override string ToString()
     {
         return $"{Name} ({Folder}/{Filename})";
     }
-}
\ No newline at end of file
+}
diff --git a/test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/ExpressionTestCaseRoot.cs b/test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/ExpressionTestCaseRoot.cs
index 1e14cbc44..a7ca45c77 100644
--- a/test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/ExpressionTestCaseRoot.cs
+++ b/test/Altinn.App.Core.Tests/LayoutExpressions/CommonTests/ExpressionTestCaseRoot.cs
@@ -1,5 +1,6 @@
 #nullable enable
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
 
 using Altinn.App.Core.Configuration;
@@ -46,7 +47,7 @@ public class ExpressionTestCaseRoot
     public LayoutModel ComponentModel { get; set; } = default!;
 
     [JsonPropertyName("dataModel")]
-    public JsonElement? DataModel { get; set; }
+    public JsonObject? DataModel { get; set; }
 
     [JsonPropertyName("frontendSettings")]
     public FrontEndSettings? FrontEndSettings { get; set; }
diff --git a/test/Altinn.App.Core.Tests/LayoutExpressions/TestDataModel.cs b/test/Altinn.App.Core.Tests/LayoutExpressions/TestDataModel.cs
index f0b1c87ac..89bd65995 100644
--- a/test/Altinn.App.Core.Tests/LayoutExpressions/TestDataModel.cs
+++ b/test/Altinn.App.Core.Tests/LayoutExpressions/TestDataModel.cs
@@ -1,5 +1,6 @@
 #nullable enable
 using System.Text.Json;
+using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
 using Altinn.App.Core.Helpers;
 using Altinn.App.Core.Helpers.DataModel;
@@ -8,6 +9,7 @@
 
 using Newtonsoft.Json;
 using Xunit;
+using JsonSerializer = System.Text.Json.JsonSerializer;
 
 namespace Altinn.App.Core.Tests.LayoutExpressions.CSharpTests;
 
@@ -96,8 +98,8 @@ public void RecursiveLookup()
         modelHelper.GetModelData("friends.name.value", new int[] { 1 }).Should().Be("Dolly Duck");
 
         // Run the same tests with JsonDataModel
-        using var doc = JsonDocument.Parse(System.Text.Json.JsonSerializer.Serialize(model));
-        modelHelper = new JsonDataModel(doc.RootElement);
+        var doc = JsonSerializer.Deserialize<JsonObject>(JsonSerializer.Serialize(model));
+        modelHelper = new JsonDataModel(doc);
         modelHelper.GetModelData("friends.name.value", default).Should().BeNull();
         modelHelper.GetModelData("friends[0].name.value", default).Should().Be("Donald Duck");
         modelHelper.GetModelData("friends.name.value", new int[] { 0 }).Should().Be("Donald Duck");
@@ -176,8 +178,8 @@ public void DoubleRecursiveLookup()
         modelHelper.GetModelDataCount("friends.friends", new int[] { 1 }).Should().Be(1);
 
         // Run the same tests with JsonDataModel
-        using var doc = JsonDocument.Parse(System.Text.Json.JsonSerializer.Serialize(model));
-        modelHelper = new JsonDataModel(doc.RootElement);
+        var doc = JsonSerializer.Deserialize<JsonObject>(JsonSerializer.Serialize(model));
+        modelHelper = new JsonDataModel(doc);
         modelHelper.GetModelData("friends[1].friends[0].name.value", default).Should().Be("Onkel Skrue");
         modelHelper.GetModelData("friends[1].friends.name.value", new int[] { 0, 0 }).Should().BeNull();
         modelHelper.GetModelData("friends[1].friends.name.value", new int[] { 1, 0 }).Should().BeNull("context indexes should not be used after literal index is used");