diff --git a/backend/src/Designer/Controllers/AppDevelopmentController.cs b/backend/src/Designer/Controllers/AppDevelopmentController.cs
index 714114556bb..c94aa1d0291 100644
--- a/backend/src/Designer/Controllers/AppDevelopmentController.cs
+++ b/backend/src/Designer/Controllers/AppDevelopmentController.cs
@@ -515,7 +515,7 @@ public ActionResult GetOptionListIds(string org, string app)
             {
                 string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
                 AltinnAppGitRepository altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, app, developer);
-                string[] optionListIds = altinnAppGitRepository.GetOptionListIds();
+                string[] optionListIds = altinnAppGitRepository.GetOptionsListIds();
                 return Ok(optionListIds);
             }
             catch (LibGit2Sharp.NotFoundException)
diff --git a/backend/src/Designer/Controllers/OptionsController.cs b/backend/src/Designer/Controllers/OptionsController.cs
new file mode 100644
index 00000000000..b11d7cc2c26
--- /dev/null
+++ b/backend/src/Designer/Controllers/OptionsController.cs
@@ -0,0 +1,127 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Helpers;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Services.Interfaces;
+using LibGit2Sharp;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Altinn.Studio.Designer.Controllers;
+
+/// <summary>
+/// Controller containing actions related to options (code lists).
+/// </summary>
+[ApiController]
+[Authorize]
+[AutoValidateAntiforgeryToken]
+[Route("designer/api/{org}/{repo:regex(^(?!datamodels$)[[a-z]][[a-z0-9-]]{{1,28}}[[a-z0-9]]$)}/options")]
+public class OptionsController : ControllerBase
+{
+    private readonly IOptionsService _optionsService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="OptionsController"/> class.
+    /// </summary>
+    /// <param name="optionsService">The options service.</param>
+    public OptionsController(IOptionsService optionsService)
+    {
+        _optionsService = optionsService;
+    }
+
+    /// <summary>
+    /// Fetches the IDs of the options lists belonging to the app.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
+    /// <param name="repo">Application identifier which is unique within an organisation.</param>
+    /// <returns>Array of options list's IDs. Empty array if none are found</returns>
+    [HttpGet]
+    [Produces("application/json")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public ActionResult<string[]> GetOptionsListIds(string org, string repo)
+    {
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        string[] optionsListIds = _optionsService.GetOptionsListIds(org, repo, developer);
+
+        return Ok(optionsListIds);
+    }
+
+    /// <summary>
+    /// Fetches a specific option list.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
+    /// <param name="repo">Application identifier which is unique within an organisation.</param>
+    /// <param name="optionsListId">Name of the option list.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    [HttpGet]
+    [Produces("application/json")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [Route("{optionsListId}")]
+    public async Task<ActionResult<List<Option>>> GetOptionsList(string org, string repo, [FromRoute] string optionsListId, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        try
+        {
+            List<Option> optionsList = await _optionsService.GetOptionsList(org, repo, developer, optionsListId, cancellationToken);
+            return Ok(optionsList);
+        }
+        catch (NotFoundException ex)
+        {
+            return NotFound(ex.Message);
+        }
+    }
+
+    /// <summary>
+    /// Creates or overwrites an options list.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
+    /// <param name="repo">Application identifier which is unique within an organisation.</param>
+    /// <param name="optionsListId">Name of the options list.</param>
+    /// <param name="payload">Contents of the options list.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    [HttpPut]
+    [Produces("application/json")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [Route("{optionsListId}")]
+    public async Task<ActionResult> CreateOrOverwriteOptionsList(string org, string repo, [FromRoute] string optionsListId, [FromBody] List<Option> payload, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        var newOptionsList = await _optionsService.CreateOrOverwriteOptionsList(org, repo, developer, optionsListId, payload, cancellationToken);
+
+        return Ok(newOptionsList);
+    }
+
+    /// <summary>
+    /// Deletes an option list.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation responsible for the app.</param>
+    /// <param name="repo">Application identifier which is unique within an organisation.</param>
+    /// <param name="optionsListId">Name of the option list.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    [HttpDelete]
+    [Produces("application/json")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [Route("{optionsListId}")]
+    public async Task<ActionResult> DeleteOptionsList(string org, string repo, [FromRoute] string optionsListId, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        bool optionsListExists = await _optionsService.OptionsListExists(org, repo, developer, optionsListId, cancellationToken);
+        if (optionsListExists)
+        {
+            _optionsService.DeleteOptionsList(org, repo, developer, optionsListId);
+        }
+
+        return Ok($"The options file {optionsListId}.json has been deleted.");
+    }
+}
diff --git a/backend/src/Designer/Controllers/PreviewController.cs b/backend/src/Designer/Controllers/PreviewController.cs
index 80e226e0e9f..63978096f8b 100644
--- a/backend/src/Designer/Controllers/PreviewController.cs
+++ b/backend/src/Designer/Controllers/PreviewController.cs
@@ -854,7 +854,7 @@ public async Task<ActionResult<string>> GetOptions(string org, string app, strin
             {
                 string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
                 AltinnAppGitRepository altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, app, developer);
-                string options = await altinnAppGitRepository.GetOptions(optionListId, cancellationToken);
+                string options = await altinnAppGitRepository.GetOptionsList(optionListId, cancellationToken);
                 return Ok(options);
             }
             catch (NotFoundException)
@@ -883,7 +883,7 @@ public async Task<ActionResult<string>> GetOptionsForInstance(string org, string
                 // TODO: Need code to get dynamic options list based on language and source?
                 string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
                 AltinnAppGitRepository altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, app, developer);
-                string options = await altinnAppGitRepository.GetOptions(optionListId, cancellationToken);
+                string options = await altinnAppGitRepository.GetOptionsList(optionListId, cancellationToken);
                 return Ok(options);
             }
             catch (NotFoundException)
diff --git a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
index 5f06370e4bd..fa95f9c563a 100644
--- a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
+++ b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
@@ -703,17 +703,41 @@ public async Task<string> GetAppFrontendCshtml(CancellationToken cancellationTok
         }
 
         /// <summary>
-        /// Gets the options list with the provided id.
-        /// <param name="optionsListId">The id of the options list to fetch.</param>
+        /// Gets a list of file names from the Options folder representing the available options lists.
+        /// </summary>
+        /// <returns>A list of option list names.</returns>
+        public string[] GetOptionsListIds()
+        {
+            string optionsFolder = Path.Combine(OptionsFolderPath);
+            if (!DirectoryExistsByRelativePath(optionsFolder))
+            {
+                throw new NotFoundException("Options folder not found.");
+            }
+
+            string[] fileNames = GetFilesByRelativeDirectory(optionsFolder);
+            List<string> optionsListIds = [];
+            foreach (string fileName in fileNames.Select(Path.GetFileNameWithoutExtension))
+            {
+                optionsListIds.Add(fileName);
+            }
+
+            return optionsListIds.ToArray();
+        }
+
+        /// <summary>
+        /// Gets a specific options list with the provided id.
+        /// </summary>
+        /// <param name="optionsListId">The name of the options list to fetch.</param>
         /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
         /// <returns>The options list as a string.</returns>
-        /// </summary>
-        public async Task<string> GetOptions(string optionsListId, CancellationToken cancellationToken = default)
+        public async Task<string> GetOptionsList(string optionsListId, CancellationToken cancellationToken = default)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionsListId}.json");
             if (!FileExistsByRelativePath(optionsFilePath))
             {
-                throw new NotFoundException("Options file not found.");
+                throw new NotFoundException($"Options file {optionsListId}.json was not found.");
             }
             string fileContent = await ReadTextByRelativePathAsync(optionsFilePath, cancellationToken);
 
@@ -721,24 +745,37 @@ public async Task<string> GetOptions(string optionsListId, CancellationToken can
         }
 
         /// <summary>
-        /// Gets a list of file names from the Options folder representing the available options lists.
-        /// <returns>A list of option list names.</returns>
+        /// Creates or overwrites the options list with the provided id.
+        /// If the options list already exists, it will be overwritten.
         /// </summary>
-        public string[] GetOptionListIds()
+        /// <param name="optionsListId">The name of the options list to create.</param>
+        /// <param name="payload">The contents of the new options list as a string</param>
+        /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+        /// <returns>The new options list as a string.</returns>
+        public async Task<string> CreateOrOverwriteOptionsList(string optionsListId, string payload, CancellationToken cancellationToken = default)
         {
-            string optionsFolder = Path.Combine(OptionsFolderPath);
-            if (!DirectoryExistsByRelativePath(optionsFolder))
-            {
-                throw new NotFoundException("Options folder not found.");
-            }
-            string[] fileNames = GetFilesByRelativeDirectory(optionsFolder);
-            List<string> optionListIds = new();
-            foreach (string fileName in fileNames.Select(Path.GetFileNameWithoutExtension))
+            cancellationToken.ThrowIfCancellationRequested();
+
+            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionsListId}.json");
+            await WriteTextByRelativePathAsync(optionsFilePath, payload, true, cancellationToken);
+            string fileContent = await ReadTextByRelativePathAsync(optionsFilePath, cancellationToken);
+
+            return fileContent;
+        }
+
+        /// <summary>
+        /// Deletes the option list with the provided id.
+        /// </summary>
+        /// <param name="optionsListId">The name of the option list to create.</param>
+        public void DeleteOptionsList(string optionsListId)
+        {
+            string optionsFilePath = Path.Combine(OptionsFolderPath, $"{optionsListId}.json");
+            if (!FileExistsByRelativePath(optionsFilePath))
             {
-                optionListIds.Add(fileName);
+                throw new NotFoundException($"Options file {optionsListId}.json was not found.");
             }
 
-            return optionListIds.ToArray();
+            DeleteFileByRelativePath(optionsFilePath);
         }
 
         /// <summary>
diff --git a/backend/src/Designer/Infrastructure/ServiceRegistration.cs b/backend/src/Designer/Infrastructure/ServiceRegistration.cs
index 6dff9d1a9e4..03c2cac117e 100644
--- a/backend/src/Designer/Infrastructure/ServiceRegistration.cs
+++ b/backend/src/Designer/Infrastructure/ServiceRegistration.cs
@@ -66,6 +66,7 @@ public static IServiceCollection RegisterServiceImplementations(this IServiceCol
             services.AddTransient<ISigningCredentialsResolver, SigningCredentialsResolver>();
             services.AddTransient<ILanguagesService, LanguagesService>();
             services.AddTransient<ITextsService, TextsService>();
+            services.AddTransient<IOptionsService, OptionsService>();
             services.AddTransient<IEnvironmentsService, EnvironmentsService>();
             services.AddHttpClient<IOrgService, OrgService>();
             services.AddTransient<IAppDevelopmentService, AppDevelopmentService>();
diff --git a/backend/src/Designer/Models/Option.cs b/backend/src/Designer/Models/Option.cs
new file mode 100644
index 00000000000..57be499f414
--- /dev/null
+++ b/backend/src/Designer/Models/Option.cs
@@ -0,0 +1,37 @@
+using System.ComponentModel.DataAnnotations;
+using System.Text.Json.Serialization;
+using Microsoft.CodeAnalysis;
+
+namespace Altinn.Studio.Designer.Models;
+
+/// <summary>
+/// Options used in checkboxes, radio buttons and dropdowns.
+/// </summary>
+public class Option
+{
+    /// <summary>
+    /// Value that connects the option to the data model.
+    /// </summary>
+    [Required]
+    [JsonPropertyName("value")]
+    public string Value { get; set; }
+
+    /// <summary>
+    /// Label to present to the user.
+    /// </summary>
+    [Required]
+    [JsonPropertyName("label")]
+    public string Label { get; set; }
+
+    /// <summary>
+    /// Description, typically displayed below the label.
+    /// </summary>
+    [JsonPropertyName("description")]
+    public Optional<string> Description { get; set; }
+
+    /// <summary>
+    /// Help text, typically wrapped inside a popover.
+    /// </summary>
+    [JsonPropertyName("helpText")]
+    public Optional<string> HelpText { get; set; }
+}
diff --git a/backend/src/Designer/Services/Implementation/OptionsService.cs b/backend/src/Designer/Services/Implementation/OptionsService.cs
new file mode 100644
index 00000000000..2f976f22d4b
--- /dev/null
+++ b/backend/src/Designer/Services/Implementation/OptionsService.cs
@@ -0,0 +1,93 @@
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Services.Interfaces;
+using LibGit2Sharp;
+
+namespace Altinn.Studio.Designer.Services.Implementation;
+
+/// <summary>
+/// Service for handling options lists (code lists).
+/// </summary>
+public class OptionsService : IOptionsService
+{
+    private readonly IAltinnGitRepositoryFactory _altinnGitRepositoryFactory;
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="altinnGitRepositoryFactory">IAltinnGitRepository</param>
+    public OptionsService(IAltinnGitRepositoryFactory altinnGitRepositoryFactory)
+    {
+        _altinnGitRepositoryFactory = altinnGitRepositoryFactory;
+    }
+
+    /// <inheritdoc />
+    public string[] GetOptionsListIds(string org, string repo, string developer)
+    {
+        var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
+
+        try
+        {
+            string[] optionsLists = altinnAppGitRepository.GetOptionsListIds();
+            return optionsLists;
+        }
+        catch (NotFoundException) // Is raised if the Options folder does not exist
+        {
+            return [];
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task<List<Option>> GetOptionsList(string org, string repo, string developer, string optionsListId, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
+
+        string optionsListString = await altinnAppGitRepository.GetOptionsList(optionsListId, cancellationToken);
+        var optionsList = JsonSerializer.Deserialize<List<Option>>(optionsListString);
+
+        return optionsList;
+    }
+
+    /// <inheritdoc />
+    public async Task<List<Option>> CreateOrOverwriteOptionsList(string org, string repo, string developer, string optionsListId, List<Option> payload, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
+
+        var jsonOptions = new JsonSerializerOptions { WriteIndented = true };
+        string payloadString = JsonSerializer.Serialize(payload, jsonOptions);
+
+        string updatedOptionsString = await altinnAppGitRepository.CreateOrOverwriteOptionsList(optionsListId, payloadString, cancellationToken);
+        var updatedOptions = JsonSerializer.Deserialize<List<Option>>(updatedOptionsString);
+
+        return updatedOptions;
+    }
+
+    /// <inheritdoc />
+    public void DeleteOptionsList(string org, string repo, string developer, string optionsListId)
+    {
+        var altinnAppGitRepository = _altinnGitRepositoryFactory.GetAltinnAppGitRepository(org, repo, developer);
+
+        altinnAppGitRepository.DeleteOptionsList(optionsListId);
+    }
+
+    /// <inheritdoc />
+    public async Task<bool> OptionsListExists(string org, string repo, string developer, string optionsListId, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        try
+        {
+            await GetOptionsList(org, repo, developer, optionsListId, cancellationToken);
+            return true;
+        }
+        catch (NotFoundException)
+        {
+            return false;
+        }
+    }
+}
diff --git a/backend/src/Designer/Services/Implementation/TextsService.cs b/backend/src/Designer/Services/Implementation/TextsService.cs
index 84d2e240f48..680db08331e 100644
--- a/backend/src/Designer/Services/Implementation/TextsService.cs
+++ b/backend/src/Designer/Services/Implementation/TextsService.cs
@@ -14,7 +14,7 @@
 namespace Altinn.Studio.Designer.Services.Implementation
 {
     /// <summary>
-    /// Interface for dealing with texts in new format in an app repository.
+    /// Service for handling texts in new format in an app repository.
     /// </summary>
     public class TextsService : ITextsService
     {
diff --git a/backend/src/Designer/Services/Interfaces/IOptionsService.cs b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
new file mode 100644
index 00000000000..36db10f39ba
--- /dev/null
+++ b/backend/src/Designer/Services/Interfaces/IOptionsService.cs
@@ -0,0 +1,63 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
+
+namespace Altinn.Studio.Designer.Services.Interfaces;
+
+/// <summary>
+/// Interface for handling options lists.
+/// </summary>
+public interface IOptionsService
+{
+    /// <summary>
+    /// Gets a list of file names from the Options folder representing the available options lists.
+    /// </summary>
+    /// <param name="org"></param>
+    /// <param name="repo"></param>
+    /// <param name="developer"></param>
+    /// <returns></returns>
+    public string[] GetOptionsListIds(string org, string repo, string developer);
+
+    /// <summary>
+    /// Gets an options list from the app repository with the specified optionListId.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="repo">Repository</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="optionsListId">Name of the options list to fetch</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    /// <returns>The options list</returns>
+    public Task<List<Option>> GetOptionsList(string org, string repo, string developer, string optionsListId, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Creates a new options list in the app repository.
+    /// If the file already exists, it will be overwritten.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="repo">Repository</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="optionsListId">Name of the new options list</param>
+    /// <param name="payload">The options list contents</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    public Task<List<Option>> CreateOrOverwriteOptionsList(string org, string repo, string developer, string optionsListId, List<Option> payload, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Deletes an options list from the app repository.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="repo">Repository</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="optionsListId">Name of the new options list</param>
+    public void DeleteOptionsList(string org, string repo, string developer, string optionsListId);
+
+    /// <summary>
+    /// Checks if an options list exists in the app repository.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="repo">Repository</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="optionsListId">Name of the options list</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    public Task<bool> OptionsListExists(string org, string repo, string developer, string optionsListId, CancellationToken cancellationToken = default);
+}
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteOptionsTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteOptionsTests.cs
new file mode 100644
index 00000000000..00a73484c29
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/DeleteOptionsTests.cs
@@ -0,0 +1,66 @@
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OptionsController;
+
+public class DeleteOptionsTests : DesignerEndpointsTestsBase<DeleteOptionsTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public DeleteOptionsTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    private const string Org = "ttd";
+    private const string Developer = "testUser";
+
+    [Fact]
+    public async Task Delete_Returns_200OK_When_Deleting_OptionsList()
+    {
+        // Arrange
+        const string repo = "app-with-options";
+        const string optionsListId = "test-options";
+
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Delete, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        JsonDocument responseDocument = JsonDocument.Parse(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Equal($"The options file {optionsListId}.json has been deleted.", responseDocument.RootElement.ToString());
+    }
+
+    [Fact]
+    public async Task Delete_Returns_200OK_When_OptionsList_Does_Not_Exist()
+    {
+        // Arrange
+        const string repo = "empty-app";
+        const string optionsListId = "non-existing-options";
+
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Delete, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        JsonDocument responseDocument = JsonDocument.Parse(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Equal($"The options file {optionsListId}.json has been deleted.", responseDocument.RootElement.ToString());
+    }
+}
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
new file mode 100644
index 00000000000..6406ed2f63f
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/GetOptionsTests.cs
@@ -0,0 +1,99 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
+using Designer.Tests.Controllers.ApiTests;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OptionsController;
+
+public class GetOptionsTests : DesignerEndpointsTestsBase<GetOptionsTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public GetOptionsTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    [Fact]
+    public async Task GetOptionsListIds_Returns200OK_WithOptionsListIds()
+    {
+        // Arrange
+        const string repo = "app-with-options";
+        string apiUrl = $"/designer/api/ttd/{repo}/options";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        string[] responseList = JsonSerializer.Deserialize<string[]>(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Contains("test-options", responseList);
+        Assert.Contains("other-options", responseList);
+    }
+
+    [Fact]
+    public async Task GetOptionsListIds_Returns200OK_WithEmptyOptionsListIdArray_WhenAppHasNoOptionsList()
+    {
+        // Arrange
+        const string repo = "empty-app";
+        string apiUrl = $"/designer/api/ttd/{repo}/options";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        string[] responseList = JsonSerializer.Deserialize<string[]>(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Empty(responseList);
+    }
+
+    [Fact]
+    public async Task GetSingleOptionsList_Returns200Ok_WithOptionsList()
+    {
+        // Arrange
+        const string repo = "app-with-options";
+        const string optionsListId = "test-options";
+
+        string apiUrl = $"/designer/api/ttd/{repo}/options/{optionsListId}";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Equal(2, responseList.Count);
+
+        Assert.Equal("label1", responseList[0].Label);
+        Assert.Equal("value1", responseList[0].Value);
+
+        Assert.Equal("label2", responseList[1].Label);
+        Assert.Equal("value2", responseList[1].Value);
+    }
+
+    [Fact]
+    public async Task GetSingleOptionsList_Returns404NotFound_WhenOptionsListDoesNotExist()
+    {
+        // Arrange
+        const string repo = "empty-app";
+        const string optionsListId = "non-existing-options";
+
+        string apiUrl = $"/designer/api/ttd/{repo}/options/{optionsListId}";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status404NotFound, (int)response.StatusCode);
+    }
+}
diff --git a/backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs b/backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs
new file mode 100644
index 00000000000..d4fe5662c27
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OptionsController/UpdateOptionsTests.cs
@@ -0,0 +1,156 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OptionsController;
+
+public class UpdateOptionsTests : DesignerEndpointsTestsBase<UpdateOptionsTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public UpdateOptionsTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    private const string Org = "ttd";
+    private const string Developer = "testUser";
+
+    [Fact]
+    public async Task Put_Returns_200OK_When_Creating_New_OptionsList()
+    {
+        // Arrange
+        const string repo = "empty-app";
+        const string optionsListId = "new-options";
+
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        var newOptionsList = new List<Option>
+        {
+            new Option
+            {
+                Label = "label1",
+                Value = "value1",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
+        };
+
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+        httpRequestMessage.Content = JsonContent.Create(newOptionsList);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Equal(newOptionsList.Count, responseList.Count);
+
+        for (int i = 0; i < newOptionsList.Count; i++)
+        {
+            Assert.Equal(newOptionsList[i].Label, responseList[i].Label);
+            Assert.Equal(newOptionsList[i].Value, responseList[i].Value);
+            Assert.Equal(newOptionsList[i].Description, responseList[i].Description);
+            Assert.Equal(newOptionsList[i].HelpText, responseList[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task Put_Returns_200OK_And_Overwrites_Existing_OptionsList()
+    {
+        // Arrange
+        const string repo = "app-with-options";
+        const string optionsListId = "test-options";
+
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        var newOptionsList = new List<Option>
+        {
+            new Option
+            {
+                Label = "aNewLabelThatDidNotExistBefore",
+                Value = "aNewValueThatDidNotExistBefore",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
+        };
+
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+        httpRequestMessage.Content = JsonContent.Create(newOptionsList);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        var responseList = JsonSerializer.Deserialize<List<Option>>(responseBody);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status200OK, (int)response.StatusCode);
+        Assert.Equal(newOptionsList.Count, responseList.Count);
+
+        for (int i = 0; i < newOptionsList.Count; i++)
+        {
+            Assert.Equal(newOptionsList[i].Label, responseList[i].Label);
+            Assert.Equal(newOptionsList[i].Value, responseList[i].Value);
+            Assert.Equal(newOptionsList[i].Description, responseList[i].Description);
+            Assert.Equal(newOptionsList[i].HelpText, responseList[i].HelpText);
+        }
+    }
+
+    [Theory]
+    [InlineData("options-missing-label")]
+    [InlineData("options-empty-json")]
+    public async Task Put_Returns_400BadRequest_When_OptionsList_Format_Is_Invalid(string optionsListId)
+    {
+        // Arrange
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await CopyRepositoryForTest(Org, "empty-app", Developer, targetRepository);
+
+        string apiUrl = $"/designer/api/{Org}/{targetRepository}/options/{optionsListId}";
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+
+        if (optionsListId == "options-missing-label")
+        {
+            var invalidOptionsList = new List<Option>
+            {
+                new Option
+                {
+                    // Missing Label
+                    Value = "value1",
+                },
+                new Option
+                {
+                    Label = "label2",
+                    Value = "value2",
+                }
+            };
+            httpRequestMessage.Content = JsonContent.Create(invalidOptionsList);
+        }
+        else if (optionsListId == "options-empty-json")
+        {
+            httpRequestMessage.Content = JsonContent.Create<List<Option>>(null);
+        }
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode);
+    }
+}
diff --git a/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs b/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs
index aa4895e86e6..321efd0fbd7 100644
--- a/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs
+++ b/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnAppGitRepositoryTests.cs
@@ -1,9 +1,12 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Threading.Tasks;
 using Altinn.Platform.Storage.Interface.Models;
 using Altinn.Studio.Designer.Infrastructure.GitRepository;
+using Altinn.Studio.Designer.Models;
 using Altinn.Studio.Designer.Models.App;
 using Designer.Tests.Utils;
 using FluentAssertions;
@@ -249,7 +252,7 @@ public async Task SaveLayout_ShouldUpdateLayoutInApp()
         }
 
         [Fact]
-        public async Task GetOptions_WithAppThatHasOptions_ShouldReturnSpecifiecOptionsList()
+        public async Task GetOptions_WithAppThatHasOptions_ShouldReturnSpecificOptionsList()
         {
             string org = "ttd";
             string repository = "app-with-options";
@@ -257,7 +260,7 @@ public async Task GetOptions_WithAppThatHasOptions_ShouldReturnSpecifiecOptionsL
             string optionsId = "test-options";
             AltinnAppGitRepository altinnAppGitRepository = PrepareRepositoryForTest(org, repository, developer);
 
-            string options = await altinnAppGitRepository.GetOptions(optionsId);
+            string options = await altinnAppGitRepository.GetOptionsList(optionsId);
             options.Should().NotBeNull();
             var optionsArray = JsonNode.Parse(options).AsArray();
             optionsArray.Count.Should().Be(2);
@@ -274,7 +277,7 @@ public async Task GetOptions_WhenSpecifiedOptionIdDoesNotExistInApp_ShouldThrowN
             string optionsId = "non-existing-test-options";
             AltinnAppGitRepository altinnAppGitRepository = PrepareRepositoryForTest(org, repository, developer);
 
-            await Assert.ThrowsAsync<LibGit2Sharp.NotFoundException>(async () => await altinnAppGitRepository.GetOptions(optionsId));
+            await Assert.ThrowsAsync<LibGit2Sharp.NotFoundException>(async () => await altinnAppGitRepository.GetOptionsList(optionsId));
         }
 
         [Fact]
@@ -285,7 +288,7 @@ public Task GetOptionListIds_WithAppThatHasOptionLists_ShouldReturnOptionListPat
             string developer = "testUser";
             AltinnAppGitRepository altinnAppGitRepository = PrepareRepositoryForTest(org, repository, developer);
 
-            string[] optionListIds = altinnAppGitRepository.GetOptionListIds();
+            string[] optionListIds = altinnAppGitRepository.GetOptionsListIds();
 
             optionListIds.Should().NotBeNull();
             optionListIds.Should().HaveCount(2);
@@ -299,10 +302,82 @@ public Task GetOptionListIds_WithAppThatHasNoOptionLists_ShouldThrowNotFoundExce
             string repository = "empty-app";
             string developer = "testUser";
             AltinnAppGitRepository altinnAppGitRepository = PrepareRepositoryForTest(org, repository, developer);
-            Assert.Throws<LibGit2Sharp.NotFoundException>(altinnAppGitRepository.GetOptionListIds);
+            Assert.Throws<LibGit2Sharp.NotFoundException>(altinnAppGitRepository.GetOptionsListIds);
             return Task.CompletedTask;
         }
 
+        [Fact]
+        public async Task CreateOrOverwriteOptions_WithAppThatHasNoOptionLists_ShouldCreateOptions()
+        {
+            // Arrange
+            string org = "ttd";
+            string repository = "empty-app";
+            string developer = "testUser";
+            string newOptionName = "new-options";
+            string targetRepository = TestDataHelper.GenerateTestRepoName();
+
+            await TestDataHelper.CopyRepositoryForTest(org, repository, developer, targetRepository);
+            AltinnAppGitRepository altinnAppGitRepository = PrepareRepositoryForTest(org, targetRepository, developer);
+
+            var newOptionsList = new List<Option>
+            {
+                new Option
+                {
+                    Label = "label1",
+                    Value = "value1",
+                },
+                new Option
+                {
+                    Label = "label2",
+                    Value = "value2",
+                }
+            };
+            var jsonOptions = new JsonSerializerOptions { WriteIndented = true };
+            string newOptionsListString = JsonSerializer.Serialize(newOptionsList, jsonOptions);
+
+            // Act
+            string savedOptionsList = await altinnAppGitRepository.CreateOrOverwriteOptionsList(newOptionName, newOptionsListString);
+
+            // Assert
+            Assert.Equal(newOptionsListString, savedOptionsList);
+        }
+
+        [Fact]
+        public async Task CreateOrOverwriteOptions_WithAppThatHasOptionLists_ShouldOverwriteOptions()
+        {
+            // Arrange
+            string org = "ttd";
+            string repository = "app-with-options";
+            string developer = "testUser";
+            string newOptionName = "test-options"; // these options already exist in this repo
+            string targetRepository = TestDataHelper.GenerateTestRepoName();
+
+            await TestDataHelper.CopyRepositoryForTest(org, repository, developer, targetRepository);
+            AltinnAppGitRepository altinnAppGitRepository = PrepareRepositoryForTest(org, targetRepository, developer);
+
+            var newOptionsList = new List<Option>
+            {
+                new Option
+                {
+                    Label = "label1",
+                    Value = "newValue1",
+                },
+                new Option
+                {
+                    Label = "label2",
+                    Value = "newValue2",
+                }
+            };
+            var jsonOptions = new JsonSerializerOptions { WriteIndented = true };
+            string newOptionsListString = JsonSerializer.Serialize(newOptionsList, jsonOptions);
+
+            // Act
+            string savedOptionsList = await altinnAppGitRepository.CreateOrOverwriteOptionsList(newOptionName, newOptionsListString);
+
+            // Assert
+            Assert.Equal(newOptionsListString, savedOptionsList);
+        }
+
         private static AltinnAppGitRepository PrepareRepositoryForTest(string org, string repository, string developer)
         {
 
diff --git a/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs b/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs
new file mode 100644
index 00000000000..2a7322f1488
--- /dev/null
+++ b/backend/tests/Designer.Tests/Services/OptionsServiceTests.cs
@@ -0,0 +1,261 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Factories;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Services.Implementation;
+using Designer.Tests.Utils;
+using LibGit2Sharp;
+using Xunit;
+
+namespace Designer.Tests.Services;
+
+public class OptionsServiceTests
+{
+    private const string Org = "ttd";
+    private const string Developer = "testUser";
+
+    [Fact]
+    public async Task GetOptionsListIds_ShouldReturnOptionsListIds_WhenOptionsListsExist()
+    {
+        // Arrange
+        const string repo = "app-with-options"; // Has 2 options lists
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        // Act
+        var optionsService = GetOptionsServiceForTest();
+        string[] optionListIds = optionsService.GetOptionsListIds(Org, targetRepository, Developer);
+
+        // Assert
+        Assert.Equal(2, optionListIds.Length);
+    }
+
+    [Fact]
+    public async Task GetOptionsListIds_ShouldReturnEmptyArray_WhenOptionsListsDoesNotExist()
+    {
+        // Arrange
+        const string repo = "empty-app"; // Has no options lists
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        // Act
+        var optionsService = GetOptionsServiceForTest();
+        string[] optionListIds = optionsService.GetOptionsListIds(Org, targetRepository, Developer);
+
+        // Assert
+        Assert.Empty(optionListIds);
+    }
+
+    [Fact]
+    public async Task GetOptionsList_ShouldReturnOptionsList_WhenOptionsExists()
+    {
+        // Arrange
+        // This  options list matches the options in 'app-with-options'
+        var expectedOptions = new List<Option>
+        {
+            new Option
+            {
+                Label = "label1",
+                Value = "value1",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
+        };
+
+        const string repo = "app-with-options";
+        const string optionListId = "test-options";
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        // Act
+        var optionsService = GetOptionsServiceForTest();
+        var fetchedOptions = await optionsService.GetOptionsList(Org, targetRepository, Developer, optionListId);
+
+        // Assert
+        Assert.Equal(expectedOptions.Count, fetchedOptions.Count);
+
+        for (int i = 0; i < expectedOptions.Count; i++)
+        {
+            Assert.Equal(expectedOptions[i].Label, fetchedOptions[i].Label);
+            Assert.Equal(expectedOptions[i].Value, fetchedOptions[i].Value);
+            Assert.Equal(expectedOptions[i].Description, fetchedOptions[i].Description);
+            Assert.Equal(expectedOptions[i].HelpText, fetchedOptions[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task GetOptionsList_ShouldThrowNotFoundException_WhenOptionsListDoesNotExist()
+    {
+        // Arrange
+        const string repo = "empty-app"; // Has no options lists
+        const string optionListId = "test-options";
+
+        var optionsService = GetOptionsServiceForTest();
+
+        // Act and assert
+        await Assert.ThrowsAsync<NotFoundException>(async () =>
+        {
+            await optionsService.GetOptionsList(Org, repo, Developer, optionListId);
+        });
+    }
+
+    [Fact]
+    public async Task CreateOrOverwriteOptionsList_ShouldReturnUpdatedOptionsList_WhenOptionsListDoesNotAlreadyExist()
+    {
+        // Arrange
+        var newOptions = new List<Option>
+        {
+            new Option
+            {
+                Label = "label1",
+                Value = "value1",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
+        };
+
+        const string repo = "empty-app"; // Has no options lists
+        const string optionListId = "test-options";
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        // Act
+        var optionsService = GetOptionsServiceForTest();
+        var updatedOptions = await optionsService.CreateOrOverwriteOptionsList(Org, targetRepository, Developer, optionListId, newOptions);
+
+        // Assert
+        Assert.Equal(newOptions.Count, updatedOptions.Count);
+
+        for (int i = 0; i < updatedOptions.Count; i++)
+        {
+            Assert.Equal(newOptions[i].Label, updatedOptions[i].Label);
+            Assert.Equal(newOptions[i].Value, updatedOptions[i].Value);
+            Assert.Equal(newOptions[i].Description, updatedOptions[i].Description);
+            Assert.Equal(newOptions[i].HelpText, updatedOptions[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task CreateOrOverwriteOptionsList_ShouldReturnUpdatedOptionsList_WhenOptionsAlreadyExist()
+    {
+        // Arrange
+        var newOptions = new List<Option>
+        {
+            new Option
+            {
+                Label = "someNewOption",
+                Value = "someNewValue",
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2",
+            }
+        };
+
+        const string repo = "app-with-options";
+        const string optionListId = "test-options"; // Name of an existing options list
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        // Act
+        var optionsService = GetOptionsServiceForTest();
+        var updatedOptions = await optionsService.CreateOrOverwriteOptionsList(Org, targetRepository, Developer, optionListId, newOptions);
+
+        // Assert
+        Assert.Equal(updatedOptions.Count, updatedOptions.Count);
+
+        for (int i = 0; i < updatedOptions.Count; i++)
+        {
+            Assert.Equal(updatedOptions[i].Label, updatedOptions[i].Label);
+            Assert.Equal(updatedOptions[i].Value, updatedOptions[i].Value);
+            Assert.Equal(updatedOptions[i].Description, updatedOptions[i].Description);
+            Assert.Equal(updatedOptions[i].HelpText, updatedOptions[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task DeleteOptionsList_ShouldDeleteOptionsList_WhenOptionsListExist()
+    {
+        // Arrange
+        const string repo = "app-with-options";
+        const string optionListId = "test-options";
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        // Act
+        var optionsService = GetOptionsServiceForTest();
+        optionsService.DeleteOptionsList(Org, targetRepository, Developer, optionListId);
+
+        // Assert
+        Assert.True(true); // No exception thrown
+    }
+
+    [Fact]
+    public async Task DeleteOptions_ShouldThrowNotFoundException_WhenOptionsDoesNotExist()
+    {
+        // Arrange
+        const string repo = "empty-app";
+        const string optionListId = "test-options";
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        var optionsService = GetOptionsServiceForTest();
+
+        // Act and assert
+        Assert.Throws<NotFoundException>(() =>
+        {
+            optionsService.DeleteOptionsList(Org, targetRepository, Developer, optionListId);
+        });
+    }
+
+    [Fact]
+    public async Task OptionsListExists_ShouldReturnTrue_WhenOptionsListExists()
+    {
+        // Arrange
+        const string repo = "app-with-options";
+        const string optionListId = "test-options";
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        var optionsService = GetOptionsServiceForTest();
+
+        // Act
+        bool optionListExists = await optionsService.OptionsListExists(Org, targetRepository, Developer, optionListId);
+
+        // Assert
+        Assert.True(optionListExists);
+    }
+
+    [Fact]
+    public async Task OptionListsExists_ShouldReturnFalse_WhenOptionsListDoesNotExist()
+    {
+        // Arrange
+        const string repo = "empty-app";
+        const string optionListId = "test-options";
+        string targetRepository = TestDataHelper.GenerateTestRepoName();
+        await TestDataHelper.CopyRepositoryForTest(Org, repo, Developer, targetRepository);
+
+        var optionsService = GetOptionsServiceForTest();
+
+        // Act
+        bool optionListExists = await optionsService.OptionsListExists(Org, targetRepository, Developer, optionListId);
+
+        // Assert
+        Assert.False(optionListExists);
+    }
+
+    private static OptionsService GetOptionsServiceForTest()
+    {
+        AltinnGitRepositoryFactory altinnGitRepositoryFactory = new(TestDataHelper.GetTestDataRepositoriesRootDirectory());
+        OptionsService optionsService = new(altinnGitRepositoryFactory);
+
+        return optionsService;
+    }
+}