diff --git a/backend/src/Designer/Controllers/Organisation/OrgCodeListController.cs b/backend/src/Designer/Controllers/Organisation/OrgCodeListController.cs
new file mode 100644
index 00000000000..71949cbb65a
--- /dev/null
+++ b/backend/src/Designer/Controllers/Organisation/OrgCodeListController.cs
@@ -0,0 +1,156 @@
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Helpers;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Models.Dto;
+using Altinn.Studio.Designer.Services.Interfaces;
+using Altinn.Studio.Designer.Services.Interfaces.Organisation;
+using LibGit2Sharp;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Altinn.Studio.Designer.Controllers.Organisation;
+
+/// <summary>
+/// Controller containing actions related to code lists on organisation level.
+/// </summary>
+[ApiController]
+[Authorize]
+[Route("designer/api/{org}/code-lists")]
+public class OrgCodeListController : ControllerBase
+{
+    private readonly IOrgCodeListService _orgCodeListService;
+    private readonly ISourceControl _sourceControl;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="OrgCodeListController"/> class.
+    /// </summary>
+    /// <param name="orgCodeListService">The CodeList service for organisation level</param>
+    /// <param name="sourceControl">The source control service.</param>
+    public OrgCodeListController(IOrgCodeListService orgCodeListService, ISourceControl sourceControl)
+    {
+        _orgCodeListService = orgCodeListService;
+        _sourceControl = sourceControl;
+    }
+
+    /// <summary>
+    /// Fetches the contents of all the code lists belonging to the organisation.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    /// <returns>List of <see cref="OptionListData" /> objects with all code lists belonging to the organisation with data
+    /// set if code list is valid, or hasError set if code list is invalid.</returns>
+    [HttpGet]
+    public async Task<ActionResult<List<OptionListData>>> GetCodeLists(string org, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await _sourceControl.VerifyCloneExists(org, $"{org}-content");
+            string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+            List<OptionListData> codeLists = await _orgCodeListService.GetCodeLists(org, developer, cancellationToken);
+
+            return Ok(codeLists);
+        }
+        catch (NotFoundException)
+        {
+            return NoContent();
+        }
+    }
+
+    /// <summary>
+    /// Creates or overwrites a code list.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation.</param>
+    /// <param name="codeListId">Name of the code list.</param>
+    /// <param name="codeList">Contents of the code list.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    [HttpPost]
+    [Produces("application/json")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [Route("{codeListId}")]
+    public async Task<ActionResult<List<OptionListData>>> CreateCodeList(string org, [FromRoute] string codeListId, [FromBody] List<Option> codeList, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        List<OptionListData> codeLists = await _orgCodeListService.CreateCodeList(org, developer, codeListId, codeList, cancellationToken);
+
+        return Ok(codeLists);
+    }
+
+    /// <summary>
+    /// Creates or overwrites a code list.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation.</param>
+    /// <param name="codeListId">Name of the code list.</param>
+    /// <param name="codeList">Contents of the code 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("{codeListId}")]
+    public async Task<ActionResult<List<OptionListData>>> UpdateCodeList(string org, [FromRoute] string codeListId, [FromBody] List<Option> codeList, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        List<OptionListData> codeLists = await _orgCodeListService.UpdateCodeList(org, developer, codeListId, codeList, cancellationToken);
+
+        return Ok(codeLists);
+    }
+
+    /// <summary>
+    /// Create new code list.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation.</param>
+    /// <param name="file">File being uploaded.</param>
+    /// <param name="cancellationToken"><see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    [HttpPost]
+    [Route("upload")]
+    public async Task<ActionResult<List<OptionListData>>> UploadCodeList(string org, [FromForm] IFormFile file, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        try
+        {
+            List<OptionListData> codeLists = await _orgCodeListService.UploadCodeList(org, developer, file, cancellationToken);
+            return Ok(codeLists);
+        }
+        catch (JsonException e)
+        {
+            return BadRequest(e.Message);
+        }
+    }
+
+    /// <summary>
+    /// Deletes a code list.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation.</param>
+    /// <param name="codeListId">Name of the code list.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    [HttpDelete]
+    [Produces("application/json")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [Route("{codeListId}")]
+    public async Task<ActionResult<List<OptionListData>>> DeleteCodeList(string org, [FromRoute] string codeListId, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        bool codeListExists = await _orgCodeListService.CodeListExists(org, developer, codeListId, cancellationToken);
+        if (!codeListExists)
+        {
+            return NotFound($"The code list file {codeListId}.json does not exist.");
+        }
+
+        List<OptionListData> codeLists = await _orgCodeListService.DeleteCodeList(org, developer, codeListId, cancellationToken);
+        return Ok(codeLists);
+    }
+}
diff --git a/backend/src/Designer/Controllers/Organisation/OrgTextController.cs b/backend/src/Designer/Controllers/Organisation/OrgTextController.cs
new file mode 100644
index 00000000000..252329446f4
--- /dev/null
+++ b/backend/src/Designer/Controllers/Organisation/OrgTextController.cs
@@ -0,0 +1,117 @@
+using System;
+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.Organisation;
+using LibGit2Sharp;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Altinn.Studio.Designer.Controllers.Organisation;
+
+/// <summary>
+/// Controller for text resources on organisation level
+/// </summary>
+[ApiController]
+[Authorize]
+[Route("designer/api/{org}/text")]
+public class OrgTextController : ControllerBase
+{
+    private readonly IOrgTextsService _orgTextsService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="OrgTextController"/> class.
+    /// </summary>
+    /// <param name="orgTextsService">The texts service.</param>
+    public OrgTextController(IOrgTextsService orgTextsService)
+    {
+        _orgTextsService = orgTextsService;
+    }
+
+    /// <summary>
+    /// Returns a JSON resource file for the given language code
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation.</param>
+    /// <param name="languageCode">The resource language id (for example <code>nb, en</code>)</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    /// <returns>The JSON config</returns>
+    [HttpGet]
+    [Route("language/{languageCode}")]
+    public async Task<ActionResult<TextResource>> GetResources(string org, string languageCode, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+        try
+        {
+            TextResource textResource = await _orgTextsService.GetText(org, developer, languageCode, cancellationToken);
+            return Ok(textResource);
+        }
+        catch (NotFoundException)
+        {
+            return NotFound($"Text resource, resource.{languageCode}.json, could not be found.");
+        }
+
+    }
+
+    /// <summary>
+    /// Save a resource file
+    /// </summary>
+    /// <param name="jsonData">The JSON Data</param>
+    /// <param name="languageCode">The resource language id (for example <code>nb, en</code> )</param>
+    /// <param name="org">Unique identifier of the organisation.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    /// <returns>The updated resource file</returns>
+    [HttpPost]
+    [Route("language/{languageCode}")]
+    public async Task<ActionResult<TextResource>> CreateResource([FromBody] TextResource jsonData, string languageCode, string org, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        try
+        {
+            await _orgTextsService.SaveText(org, developer, jsonData, languageCode, cancellationToken);
+            TextResource textResource = await _orgTextsService.GetText(org, developer, languageCode, cancellationToken);
+            return Ok(textResource);
+        }
+        catch (ArgumentException e)
+        {
+            return BadRequest(e.Message);
+        }
+    }
+
+    /// <summary>
+    /// Method to update multiple texts for given keys and a given
+    /// language in the text resource files.
+    /// Non-existing keys will be added.
+    /// </summary>
+    /// <param name="org">Unique identifier of the organisation.</param>
+    /// <param name="keysTexts">List of Key/Value pairs that should be updated or added if not present.</param>
+    /// <param name="languageCode">The languageCode for the text resource file that is being edited.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    /// <returns>The updated resource file</returns>
+    [HttpPut]
+    [Route("language/{languageCode}")]
+    public async Task<ActionResult<TextResource>> UpdateResource(string org, [FromBody] Dictionary<string, string> keysTexts, string languageCode, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string developer = AuthenticationHelper.GetDeveloperUserName(HttpContext);
+
+        try
+        {
+            await _orgTextsService.UpdateTextsForKeys(org, developer, keysTexts, languageCode, cancellationToken);
+            TextResource textResource = await _orgTextsService.GetText(org, developer, languageCode, cancellationToken);
+            return Ok(textResource);
+        }
+        catch (ArgumentException exception)
+        {
+            return BadRequest(exception.Message);
+        }
+        catch (NotFoundException)
+        {
+            return BadRequest($"The text resource, resource.{languageCode}.json, could not be updated.");
+        }
+    }
+}
diff --git a/backend/src/Designer/Factories/AltinnGitRepositoryFactory.cs b/backend/src/Designer/Factories/AltinnGitRepositoryFactory.cs
index b28a46e0ab2..b08495dd8f5 100644
--- a/backend/src/Designer/Factories/AltinnGitRepositoryFactory.cs
+++ b/backend/src/Designer/Factories/AltinnGitRepositoryFactory.cs
@@ -62,5 +62,15 @@ public string GetRepositoryPath(string org, string repository, string developer)
             string[] paths = { _repositoriesRootDirectory, developer.AsFileName(), org.AsFileName(), repository.AsFileName() };
             return Path.Combine(paths);
         }
+
+        /// <summary>
+        /// Creates an instance of <see cref="AltinnOrgGitRepository"/>
+        /// </summary>
+        /// <returns><see cref="AltinnOrgGitRepository"/></returns>
+        public AltinnOrgGitRepository GetAltinnOrgGitRepository(string org, string repository, string developer)
+        {
+            var repositoryDirectory = GetRepositoryPath(org, repository, developer);
+            return new AltinnOrgGitRepository(org, repository, developer, _repositoriesRootDirectory, repositoryDirectory);
+        }
     }
 }
diff --git a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
index 5336f3ea72c..cc43864643d 100644
--- a/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
+++ b/backend/src/Designer/Infrastructure/GitRepository/AltinnAppGitRepository.cs
@@ -87,7 +87,7 @@ public class AltinnAppGitRepository : AltinnGitRepository
         };
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="AltinnGitRepository"/> class.
+        /// Initializes a new instance of the <see cref="AltinnAppGitRepository"/> class.
         /// </summary>
         /// <param name="org">Organization owning the repository identified by it's short name.</param>
         /// <param name="repository">Repository name to search for schema files.</param>
@@ -997,13 +997,12 @@ public async Task<string> GetAppFrontendCshtml(
         /// <returns>A list of option list names.</returns>
         public string[] GetOptionsListIds()
         {
-            string optionsFolder = Path.Combine(OptionsFolderPath);
-            if (!DirectoryExistsByRelativePath(optionsFolder))
+            if (!DirectoryExistsByRelativePath(OptionsFolderPath))
             {
                 return [];
             }
 
-            string[] fileNames = GetFilesByRelativeDirectoryAscSorted(optionsFolder, "*.json");
+            string[] fileNames = GetFilesByRelativeDirectoryAscSorted(OptionsFolderPath, "*.json");
             IEnumerable<string> optionsListIds = fileNames.Select(Path.GetFileNameWithoutExtension);
             return optionsListIds.ToArray();
         }
@@ -1014,10 +1013,7 @@ public string[] GetOptionsListIds()
         /// <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>
-        public async Task<string> GetOptionsList(
-            string optionsListId,
-            CancellationToken cancellationToken = default
-        )
+        public async Task<string> GetOptionsList(string optionsListId, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
diff --git a/backend/src/Designer/Infrastructure/GitRepository/AltinnOrgGitRepository.cs b/backend/src/Designer/Infrastructure/GitRepository/AltinnOrgGitRepository.cs
new file mode 100644
index 00000000000..073051351f6
--- /dev/null
+++ b/backend/src/Designer/Infrastructure/GitRepository/AltinnOrgGitRepository.cs
@@ -0,0 +1,173 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
+using LibGit2Sharp;
+using JsonSerializer = System.Text.Json.JsonSerializer;
+
+namespace Altinn.Studio.Designer.Infrastructure.GitRepository;
+
+public class AltinnOrgGitRepository : AltinnGitRepository
+{
+    private const string CodeListFolderPath = "Codelists/";
+    private const string LanguageResourceFolderName = "Texts/";
+
+
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        WriteIndented = true,
+        Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true
+    };
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AltinnOrgGitRepository"/> class.
+    /// </summary>
+    /// <param name="org">Organization owning the repository identified by it's short name.</param>
+    /// <param name="repository">Repository name to search for schema files.</param>
+    /// <param name="developer">Developer that is working on the repository.</param>
+    /// <param name="repositoriesRootDirectory">Base path (full) for where the repository resides on-disk.</param>
+    /// <param name="repositoryDirectory">Full path to the root directory of this repository on-disk.</param>
+    public AltinnOrgGitRepository(string org, string repository, string developer, string repositoriesRootDirectory, string repositoryDirectory) : base(org, repository, developer, repositoriesRootDirectory, repositoryDirectory)
+    {
+    }
+
+    /// <summary>
+    /// Returns a specific text resource based on language code.
+    /// </summary>
+    /// <param name="languageCode">Language code</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    /// <returns>The text file as a <see cref="TextResource"/></returns>
+    /// <remarks>
+    /// Format of the <see cref="TextResource"/> is: &lt;textResourceElementId &lt;language, textResourceElement&gt;&gt;
+    /// </remarks>
+    public async Task<TextResource> GetText(string languageCode, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string resourcePath = GetPathToJsonTextsFile($"resource.{languageCode}.json");
+        if (!FileExistsByRelativePath(resourcePath))
+        {
+            throw new NotFoundException("Text resource file not found.");
+        }
+        string fileContent = await ReadTextByRelativePathAsync(resourcePath, cancellationToken);
+        TextResource textResource = JsonSerializer.Deserialize<TextResource>(fileContent, JsonOptions);
+
+        return textResource;
+    }
+
+    /// <summary>
+    /// Saves the text resource based on language code.
+    /// </summary>
+    /// <param name="languageCode">Language code</param>
+    /// <param name="jsonTexts">text resource</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    public async Task SaveText(string languageCode, TextResource jsonTexts, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string fileName = $"resource.{languageCode}.json";
+        string textsFileRelativeFilePath = GetPathToJsonTextsFile(fileName);
+        string texts = JsonSerializer.Serialize(jsonTexts, JsonOptions);
+        await WriteTextByRelativePathAsync(textsFileRelativeFilePath, texts, true, cancellationToken);
+    }
+
+    /// <summary>
+    /// Gets all code list Ids
+    /// </summary>
+    /// <returns>A list of code list Ids</returns>
+    public string[] GetCodeListIds(CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        string codeListFolder = Path.Combine(CodeListFolderPath);
+        if (!DirectoryExistsByRelativePath(codeListFolder))
+        {
+            return [];
+        }
+
+        string[] fileNames = GetFilesByRelativeDirectoryAscSorted(codeListFolder, "*.json");
+        IEnumerable<string> codeListIds = fileNames.Select(Path.GetFileNameWithoutExtension);
+        return codeListIds.ToArray();
+    }
+
+    /// <summary>
+    /// Gets a specific code list with the provided id.
+    /// </summary>
+    /// <param name="codeListId">The name of the code list to fetch.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    /// <returns>The code list as a string.</returns>
+    public async Task<List<Option>> GetCodeList(string codeListId, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        string codeListFilePath = Path.Combine(CodeListFolderPath, $"{codeListId}.json");
+        if (!FileExistsByRelativePath(codeListFilePath))
+        {
+            throw new NotFoundException($"code list file {codeListId}.json was not found.");
+        }
+        string fileContent = await ReadTextByRelativePathAsync(codeListFilePath, cancellationToken);
+        List<Option> codeList = JsonSerializer.Deserialize<List<Option>>(fileContent, JsonOptions);
+
+        return codeList;
+    }
+
+    /// <summary>
+    /// Creates a code list with the provided id.
+    /// </summary>
+    /// <param name="codeListId">The name of the code list to create.</param>
+    /// <param name="codeList">The code list contents.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    public async Task CreateCodeList(string codeListId, List<Option> codeList, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        string payloadString = JsonSerializer.Serialize(codeList, JsonOptions);
+
+        string codeListFilePath = Path.Combine(CodeListFolderPath, $"{codeListId}.json");
+        await WriteTextByRelativePathAsync(codeListFilePath, payloadString, true, cancellationToken);
+    }
+
+    /// <summary>
+    /// Updates a code list with the provided id.
+    /// </summary>
+    /// <param name="codeListId">The name of the cost list to update.</param>
+    /// <param name="codeList">The code list contents.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    public async Task UpdateCodeList(string codeListId, List<Option> codeList, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        string codeListString = JsonSerializer.Serialize(codeList, JsonOptions);
+
+        string codeListFilePath = Path.Combine(CodeListFolderPath, $"{codeListId}.json");
+        await WriteTextByRelativePathAsync(codeListFilePath, codeListString, false, cancellationToken);
+    }
+
+    /// <summary>
+    /// Deletes a code list with the provided id.
+    /// </summary>
+    /// <param name="codeListId">The name of the cost list to be deleted.</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    public void DeleteCodeList(string codeListId, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        string codeListFilePath = Path.Combine(CodeListFolderPath, $"{codeListId}.json");
+        if (!FileExistsByRelativePath(codeListFilePath))
+        {
+            throw new NotFoundException($"code list file {codeListId}.json was not found.");
+        }
+
+        DeleteFileByRelativePath(codeListFilePath);
+    }
+
+    private static string GetPathToJsonTextsFile(string fileName)
+    {
+        return string.IsNullOrEmpty(fileName) ? LanguageResourceFolderName : Path.Combine(LanguageResourceFolderName, fileName);
+    }
+}
diff --git a/backend/src/Designer/Infrastructure/ServiceRegistration.cs b/backend/src/Designer/Infrastructure/ServiceRegistration.cs
index b62029148b7..b1302beef3b 100644
--- a/backend/src/Designer/Infrastructure/ServiceRegistration.cs
+++ b/backend/src/Designer/Infrastructure/ServiceRegistration.cs
@@ -12,9 +12,11 @@
 using Altinn.Studio.Designer.Repository.ORMImplementation;
 using Altinn.Studio.Designer.Repository.ORMImplementation.Data;
 using Altinn.Studio.Designer.Services.Implementation;
+using Altinn.Studio.Designer.Services.Implementation.Organisation;
 using Altinn.Studio.Designer.Services.Implementation.Preview;
 using Altinn.Studio.Designer.Services.Implementation.ProcessModeling;
 using Altinn.Studio.Designer.Services.Interfaces;
+using Altinn.Studio.Designer.Services.Interfaces.Organisation;
 using Altinn.Studio.Designer.Services.Interfaces.Preview;
 using Altinn.Studio.Designer.TypedHttpClients.ImageClient;
 using Microsoft.EntityFrameworkCore;
@@ -67,6 +69,7 @@ public static IServiceCollection RegisterServiceImplementations(this IServiceCol
             services.AddTransient<ISigningCredentialsResolver, SigningCredentialsResolver>();
             services.AddTransient<ITextsService, TextsService>();
             services.AddTransient<IOptionsService, OptionsService>();
+            services.AddTransient<IOrgCodeListService, OrgCodeListService>();
             services.AddTransient<IEnvironmentsService, EnvironmentsService>();
             services.AddHttpClient<IOrgService, OrgService>();
             services.AddHttpClient<ImageClient>();
@@ -77,6 +80,7 @@ public static IServiceCollection RegisterServiceImplementations(this IServiceCol
             services.AddTransient<IProcessModelingService, ProcessModelingService>();
             services.AddTransient<IImagesService, ImagesService>();
             services.AddTransient<ILayoutService, LayoutService>();
+            services.AddTransient<IOrgTextsService, OrgTextsService>();
             services.RegisterDatamodeling(configuration);
             services.RegisterSettingsSingleton<KafkaSettings>(configuration);
             services.AddTransient<IKafkaProducer, KafkaProducer>();
diff --git a/backend/src/Designer/Services/Implementation/Organisation/OrgCodeListService.cs b/backend/src/Designer/Services/Implementation/Organisation/OrgCodeListService.cs
new file mode 100644
index 00000000000..5e32aeb4c4f
--- /dev/null
+++ b/backend/src/Designer/Services/Implementation/Organisation/OrgCodeListService.cs
@@ -0,0 +1,190 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Exceptions.Options;
+using Altinn.Studio.Designer.Infrastructure.GitRepository;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Models.Dto;
+using Altinn.Studio.Designer.Services.Interfaces;
+using Altinn.Studio.Designer.Services.Interfaces.Organisation;
+using LibGit2Sharp;
+using Microsoft.AspNetCore.Http;
+
+namespace Altinn.Studio.Designer.Services.Implementation.Organisation;
+
+public class OrgCodeListService : IOrgCodeListService
+{
+    private readonly IAltinnGitRepositoryFactory _altinnGitRepositoryFactory;
+    private const string Repo = "content";
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="altinnGitRepositoryFactory">IAltinnGitRepository</param>
+    public OrgCodeListService(IAltinnGitRepositoryFactory altinnGitRepositoryFactory)
+    {
+        _altinnGitRepositoryFactory = altinnGitRepositoryFactory;
+    }
+
+    /// <inheritdoc />
+    public async Task<List<OptionListData>> GetCodeLists(string org, string developer, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        string[] codeListIds = GetCodeListIds(org, developer);
+        List<OptionListData> codeLists = [];
+        foreach (string codeListId in codeListIds)
+        {
+            try
+            {
+                List<Option> codeList = await GetCodeList(org, developer, codeListId, cancellationToken);
+                OptionListData codeListData = new()
+                {
+                    Title = codeListId,
+                    Data = codeList,
+                    HasError = false
+                };
+                codeLists.Add(codeListData);
+            }
+            catch (InvalidOptionsFormatException)
+            {
+                OptionListData codeListData = new()
+                {
+                    Title = codeListId,
+                    Data = null,
+                    HasError = true
+                };
+                codeLists.Add(codeListData);
+            }
+        }
+
+        return codeLists;
+    }
+
+    /// <inheritdoc />
+    public async Task<List<OptionListData>> CreateCodeList(string org, string developer, string codeListId, List<Option> codeList, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string repo = GetStaticContentRepo(org);
+        AltinnOrgGitRepository altinnOrgGitRepository = _altinnGitRepositoryFactory.GetAltinnOrgGitRepository(org, repo, developer);
+
+        await altinnOrgGitRepository.CreateCodeList(codeListId, codeList, cancellationToken);
+
+        List<OptionListData> codeLists = await GetCodeLists(org, developer, cancellationToken);
+        return codeLists;
+    }
+
+    /// <inheritdoc />
+    public async Task<List<OptionListData>> UpdateCodeList(string org, string developer, string codeListId, List<Option> codeList, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string repo = GetStaticContentRepo(org);
+        AltinnOrgGitRepository altinnOrgGitRepository = _altinnGitRepositoryFactory.GetAltinnOrgGitRepository(org, repo, developer);
+
+        await altinnOrgGitRepository.UpdateCodeList(codeListId, codeList, cancellationToken);
+
+        List<OptionListData> codeLists = await GetCodeLists(org, developer, cancellationToken);
+        return codeLists;
+    }
+
+    /// <inheritdoc />
+    public async Task<List<OptionListData>> UploadCodeList(string org, string developer, IFormFile payload, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string repo = GetStaticContentRepo(org);
+        string codeListId = payload.FileName.Replace(".json", "");
+
+        List<Option> deserializedCodeList = JsonSerializer.Deserialize<List<Option>>(payload.OpenReadStream(),
+            new JsonSerializerOptions { WriteIndented = true, AllowTrailingCommas = true });
+
+        bool codeListHasInvalidNullFields = deserializedCodeList.Exists(codeListItem => codeListItem.Value == null || codeListItem.Label == null);
+        if (codeListHasInvalidNullFields)
+        {
+            throw new InvalidOptionsFormatException("Uploaded file is missing one of the following attributes for an option: value or label.");
+        }
+
+        AltinnOrgGitRepository altinnOrgGitRepository = _altinnGitRepositoryFactory.GetAltinnOrgGitRepository(org, repo, developer);
+        await altinnOrgGitRepository.CreateCodeList(codeListId, deserializedCodeList, cancellationToken);
+
+        List<OptionListData> codeLists = await GetCodeLists(org, developer, cancellationToken);
+        return codeLists;
+    }
+
+    /// <inheritdoc />
+    public async Task<List<OptionListData>> DeleteCodeList(string org, string developer, string codeListId, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string repo = GetStaticContentRepo(org);
+        AltinnOrgGitRepository altinnOrgGitRepository = _altinnGitRepositoryFactory.GetAltinnOrgGitRepository(org, repo, developer);
+
+        altinnOrgGitRepository.DeleteCodeList(codeListId, cancellationToken);
+
+        List<OptionListData> codeLists = await GetCodeLists(org, developer, cancellationToken);
+        return codeLists;
+    }
+
+    /// <inheritdoc />
+    public async Task<bool> CodeListExists(string org, string developer, string codeListId, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        try
+        {
+            await GetCodeList(org, developer, codeListId, cancellationToken);
+            return true;
+        }
+        catch (NotFoundException)
+        {
+            return false;
+        }
+    }
+
+    private string[] GetCodeListIds(string org, string developer, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string repo = GetStaticContentRepo(org);
+        AltinnOrgGitRepository altinnOrgGitRepository = _altinnGitRepositoryFactory.GetAltinnOrgGitRepository(org, repo, developer);
+
+        try
+        {
+            string[] codeListIds = altinnOrgGitRepository.GetCodeListIds();
+            return codeListIds;
+        }
+        catch (NotFoundException) // Is raised if the Options folder does not exist
+        {
+            return [];
+        }
+    }
+
+    private async Task<List<Option>> GetCodeList(string org, string developer, string codeListId, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string repo = GetStaticContentRepo(org);
+        AltinnOrgGitRepository altinnOrgGitRepository = _altinnGitRepositoryFactory.GetAltinnOrgGitRepository(org, repo, developer);
+
+        try
+        {
+            List<Option> codeList = await altinnOrgGitRepository.GetCodeList(codeListId, cancellationToken);
+            codeList.ForEach(ValidateOption);
+            return codeList;
+        }
+        catch (Exception ex) when (ex is ValidationException || ex is JsonException)
+        {
+            throw new InvalidOptionsFormatException($"One or more of the options have an invalid format in code list: {codeListId}.");
+        }
+    }
+
+    private void ValidateOption(Option option)
+    {
+        var validationContext = new ValidationContext(option);
+        Validator.ValidateObject(option, validationContext, validateAllProperties: true);
+    }
+
+    private static string GetStaticContentRepo(string org)
+    {
+        return $"{org}-{Repo}";
+    }
+}
diff --git a/backend/src/Designer/Services/Implementation/Organisation/OrgTextsService.cs b/backend/src/Designer/Services/Implementation/Organisation/OrgTextsService.cs
new file mode 100644
index 00000000000..9fe731442ae
--- /dev/null
+++ b/backend/src/Designer/Services/Implementation/Organisation/OrgTextsService.cs
@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Infrastructure.GitRepository;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Services.Interfaces;
+using Altinn.Studio.Designer.Services.Interfaces.Organisation;
+
+namespace Altinn.Studio.Designer.Services.Implementation.Organisation;
+
+public class OrgTextsService : IOrgTextsService
+{
+    private readonly IAltinnGitRepositoryFactory _altinnGitRepositoryFactory;
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="altinnGitRepositoryFactory">altinnGitRepositoryFactory</param>
+    public OrgTextsService(IAltinnGitRepositoryFactory altinnGitRepositoryFactory)
+    {
+        _altinnGitRepositoryFactory = altinnGitRepositoryFactory;
+    }
+
+    /// <inheritdoc />
+    public async Task<TextResource> GetText(string org, string developer, string languageCode, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string repo = GetStaticContentRepo(org);
+        AltinnOrgGitRepository altinnOrgGitRepository = _altinnGitRepositoryFactory.GetAltinnOrgGitRepository(org, repo, developer);
+
+        TextResource texts = await altinnOrgGitRepository.GetText(languageCode, cancellationToken);
+
+        return texts;
+    }
+
+    /// <inheritdoc />
+    public async Task SaveText(string org, string developer, TextResource textResource, string languageCode, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string repo = GetStaticContentRepo(org);
+        AltinnOrgGitRepository altinnOrgGitRepository = _altinnGitRepositoryFactory.GetAltinnOrgGitRepository(org, repo, developer);
+
+        string[] duplicateKeys = textResource.Resources.GroupBy(tre => tre.Id).Where(grp => grp.Count() > 1).Select(grp => grp.Key).ToArray();
+        if (duplicateKeys.Length > 0)
+        {
+            throw new ArgumentException(
+                $"Text keys must be unique. Please review keys: {string.Join(", ", duplicateKeys)}");
+        }
+
+        await altinnOrgGitRepository.SaveText(languageCode, textResource, cancellationToken);
+    }
+
+
+    /// <inheritdoc />
+    public async Task UpdateTextsForKeys(string org, string developer, Dictionary<string, string> keysTexts, string languageCode, CancellationToken cancellationToken = default)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        string repo = GetStaticContentRepo(org);
+        AltinnOrgGitRepository altinnOrgGitRepository = _altinnGitRepositoryFactory.GetAltinnOrgGitRepository(org, repo, developer);
+
+        TextResource textResourceObject = await altinnOrgGitRepository.GetText(languageCode, cancellationToken);
+
+        // handle if file not already exist
+        foreach (KeyValuePair<string, string> kvp in keysTexts)
+        {
+            TextResourceElement textResourceContainsKey = textResourceObject.Resources.Find(textResourceElement => textResourceElement.Id == kvp.Key);
+            if (textResourceContainsKey is null)
+            {
+                textResourceObject.Resources.Insert(0, new TextResourceElement() { Id = kvp.Key, Value = kvp.Value });
+            }
+            else
+            {
+                int indexTextResourceElementUpdateKey = textResourceObject.Resources.IndexOf(textResourceContainsKey);
+                if (textResourceContainsKey.Variables == null)
+                {
+                    textResourceObject.Resources[indexTextResourceElementUpdateKey] = new TextResourceElement { Id = kvp.Key, Value = kvp.Value };
+                }
+                else
+                {
+                    List<TextResourceVariable> variables = textResourceContainsKey.Variables;
+                    textResourceObject.Resources[indexTextResourceElementUpdateKey] = new TextResourceElement { Id = kvp.Key, Value = kvp.Value, Variables = variables };
+                }
+            }
+        }
+
+        await altinnOrgGitRepository.SaveText(languageCode, textResourceObject, cancellationToken);
+    }
+
+    private static string GetStaticContentRepo(string org)
+    {
+        return $"{org}-content";
+    }
+}
diff --git a/backend/src/Designer/Services/Interfaces/IAltinnGitRepositoryFactory.cs b/backend/src/Designer/Services/Interfaces/IAltinnGitRepositoryFactory.cs
index d1590ffd096..ce1e385e3dd 100644
--- a/backend/src/Designer/Services/Interfaces/IAltinnGitRepositoryFactory.cs
+++ b/backend/src/Designer/Services/Interfaces/IAltinnGitRepositoryFactory.cs
@@ -9,18 +9,26 @@ public interface IAltinnGitRepositoryFactory
     {
         /// <summary>
         /// Creates an instance of <see cref="AltinnGitRepository"/>
-        /// </summary>        
-        /// <param name="org">The organization owning the repository identfied by it's short name as defined in Gitea.</param>
+        /// </summary>
+        /// <param name="org">The organization owning the repository identified by its short name as defined in Gitea.</param>
         /// <param name="repository">The name of the repository as specified in Gitea.</param>
         /// <param name="developer">The user name of the developer working on the repository.</param>
         AltinnGitRepository GetAltinnGitRepository(string org, string repository, string developer);
 
         /// <summary>
         /// Creates an instance of <see cref="AltinnAppGitRepository"/>
-        /// </summary>        
-        /// <param name="org">The organization owning the repository identfied by it's short name as defined in Gitea.</param>
+        /// </summary>
+        /// <param name="org">The organization owning the repository identified by its short name as defined in Gitea.</param>
         /// <param name="repository">The name of the repository as specified in Gitea.</param>
         /// <param name="developer">The user name of the developer working on the repository.</param>
         AltinnAppGitRepository GetAltinnAppGitRepository(string org, string repository, string developer);
+
+        /// <summary>
+        /// Creates an instance of <see cref="AltinnOrgGitRepository"/>
+        /// </summary>
+        /// <param name="org">The organization owning the repository identified by its short name as defined in Gitea.</param>
+        /// <param name="repository">The name of the repository as specified in Gitea.</param>
+        /// <param name="developer">The user name of the developer working on the repository.</param>
+        AltinnOrgGitRepository GetAltinnOrgGitRepository(string org, string repository, string developer);
     }
 }
diff --git a/backend/src/Designer/Services/Interfaces/Organisation/IOrgCodeListService.cs b/backend/src/Designer/Services/Interfaces/Organisation/IOrgCodeListService.cs
new file mode 100644
index 00000000000..8d0ea0822d8
--- /dev/null
+++ b/backend/src/Designer/Services/Interfaces/Organisation/IOrgCodeListService.cs
@@ -0,0 +1,70 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Models.Dto;
+using Microsoft.AspNetCore.Http;
+
+namespace Altinn.Studio.Designer.Services.Interfaces.Organisation;
+
+public interface IOrgCodeListService
+{
+    /// <summary>
+    /// Gets a code list from the org repository with the specified codeListId.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    /// <returns>The code list</returns>
+    public Task<List<OptionListData>> GetCodeLists(string org, string developer, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Creates a new code list in the org repository.
+    /// If the file already exists, it will be overwritten.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="codeListId">Name of the new code list</param>
+    /// <param name="codeList">The code list contents</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    public Task<List<OptionListData>> CreateCodeList(string org, string developer, string codeListId, List<Option> codeList, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Updates an existing code list with new contents.
+    /// If the file already exists, it will be overwritten.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="codeListId">Name of the new code list</param>
+    /// <param name="codeList">The code list contents</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    public Task<List<OptionListData>> UpdateCodeList(string org, string developer, string codeListId, List<Option> codeList, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Creates a new code list in the org repository.
+    /// If the file already exists, it will be overwritten.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="payload">The code list contents</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    public Task<List<OptionListData>> UploadCodeList(string org, string developer, IFormFile payload, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Deletes an code list from the org repository.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="codeListId">Name of the code list</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    public Task<List<OptionListData>> DeleteCodeList(string org, string developer, string codeListId, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Checks if a code list exists in the org repository.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="codeListId">Name of the code list</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    public Task<bool> CodeListExists(string org, string developer, string codeListId, CancellationToken cancellationToken = default);
+}
diff --git a/backend/src/Designer/Services/Interfaces/Organisation/IOrgTextsService.cs b/backend/src/Designer/Services/Interfaces/Organisation/IOrgTextsService.cs
new file mode 100644
index 00000000000..984462528cb
--- /dev/null
+++ b/backend/src/Designer/Services/Interfaces/Organisation/IOrgTextsService.cs
@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
+
+namespace Altinn.Studio.Designer.Services.Interfaces.Organisation;
+
+public interface IOrgTextsService
+{
+    /// <summary>
+    /// Gets texts file in organisation repository according to specified language Code.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="languageCode">LanguageCode</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    /// <returns>The text file</returns>
+    public Task<TextResource> GetText(string org, string developer, string languageCode, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Saves text resource.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="textResource">The text resource to be saved</param>
+    /// <param name="languageCode">LanguageCode</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    /// <returns></returns>
+    public Task SaveText(string org, string developer, TextResource textResource, string languageCode, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Updates values for specified keys in the text resouce.
+    /// </summary>
+    /// <param name="org">Organisation</param>
+    /// <param name="developer">Username of developer</param>
+    /// <param name="keysTexts">KeysTexts</param>
+    /// <param name="languageCode">LanguageCode</param>
+    /// <param name="cancellationToken">A <see cref="CancellationToken"/> that observes if operation is cancelled.</param>
+    /// <returns></returns>
+    public Task UpdateTextsForKeys(string org, string developer, Dictionary<string, string> keysTexts, string languageCode, CancellationToken cancellationToken = default);
+}
diff --git a/backend/tests/Designer.Tests/Controllers/ApiTests/DesignerEndpointsTestsBase.cs b/backend/tests/Designer.Tests/Controllers/ApiTests/DesignerEndpointsTestsBase.cs
index 6d52054892c..f5b5e622fc3 100644
--- a/backend/tests/Designer.Tests/Controllers/ApiTests/DesignerEndpointsTestsBase.cs
+++ b/backend/tests/Designer.Tests/Controllers/ApiTests/DesignerEndpointsTestsBase.cs
@@ -30,6 +30,8 @@ public abstract class DesignerEndpointsTestsBase<TControllerTest> : ApiTestsBase
 
         protected string RemoteTestRepoPath { get; private set; }
 
+        protected string TestOrgPath { get; private set; }
+
         // Most common tests configuration used. If needed override this method in the test class.
         protected override void ConfigureTestServices(IServiceCollection services)
         {
@@ -95,6 +97,27 @@ protected async Task CopyRemoteRepositoryForTest(string org, string repo, string
             RemoteTestRepoPath = await TestDataHelper.CopyRemoteRepositoryForTest(org, repo, targetRepository);
         }
 
+        /// <summary>
+        /// Copies a organization and repository from the test repositories to a temporary location for testing.
+        /// Ensures that created Folder is deleted after test.
+        /// Value of created org path is stored in <see cref="TestOrgPath"/> property.
+        /// Limitation is that only one org can be cloned.
+        /// </summary>
+        /// <param name="developer"></param>
+        /// <param name="org"></param>
+        /// <param name="repo"></param>
+        /// <param name="targetOrg"></param>
+        /// <param name="targetRepository"></param>
+        /// <exception cref="InvalidOperationException"></exception>
+        protected async Task CopyOrgRepositoryForTest(string developer, string org, string repo, string targetOrg, string targetRepository)
+        {
+            if (TestOrgPath is not null)
+            {
+                throw new InvalidOperationException("Organization already created for test.");
+            }
+            TestOrgPath = await TestDataHelper.CopyOrgForTest(developer, org, repo, targetOrg, targetRepository);
+        }
+
         protected override void Dispose(bool disposing)
         {
             base.Dispose(disposing);
@@ -110,6 +133,10 @@ protected override void Dispose(bool disposing)
             {
                 Directory.Delete(RemoteTestRepoPath, true);
             }
+            if (!string.IsNullOrWhiteSpace(TestOrgPath))
+            {
+                Directory.Delete(TestOrgPath, true);
+            }
         }
     }
 }
diff --git a/backend/tests/Designer.Tests/Controllers/OrgCodeListController/CreateCodeListTests.cs b/backend/tests/Designer.Tests/Controllers/OrgCodeListController/CreateCodeListTests.cs
new file mode 100644
index 00000000000..0d7061f3203
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OrgCodeListController/CreateCodeListTests.cs
@@ -0,0 +1,206 @@
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Filters;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Models.Dto;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OrgCodeListController;
+
+public class CreateCodeListTests : DesignerEndpointsTestsBase<CreateCodeListTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public CreateCodeListTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    private const string Org = "ttd";
+    private const string Repo = "org-content-empty";
+    private const string Developer = "testUser";
+    private const string CodeListId = "some_code_list_id";
+
+    [Fact]
+    public async Task Post_Returns_200OK_When_Creating_New_Code_List()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        const string codeListJson = @"[
+            { ""label"": ""label1"", ""value"": ""value1"" },
+            { ""label"": ""label2"", ""value"": ""value2"" }
+        ]";
+        httpRequestMessage.Content = new StringContent(codeListJson, Encoding.UTF8, "application/json");
+        List<Option> codeListToCreate = JsonSerializer.Deserialize<List<Option>>(codeListJson);
+        List<OptionListData> expectedResponse = new([
+            new OptionListData {Title = CodeListId, Data = codeListToCreate, HasError = false}
+        ]);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        List<OptionListData> responseList = JsonSerializer.Deserialize<List<OptionListData>>(responseBody);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        Assert.Equal(expectedResponse.Count, responseList.Count);
+
+        var expectedData = expectedResponse[0].Data;
+        var actualData = responseList[0].Data;
+        for (int i = 0; i < expectedData?.Count; i++)
+        {
+            Assert.Equal(expectedData[i].Label, actualData?[i].Label);
+            Assert.Equal(expectedData[i].Value, actualData?[i].Value);
+            Assert.Equal(expectedData[i].Description, actualData?[i].Description);
+            Assert.Equal(expectedData[i].HelpText, actualData?[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task Post_Returns_200OK_When_CodeList_Values_Are_Bool_String_Numbers()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        const string stringBoolNumbersCodeList = @"[
+            { ""label"": ""StringValue"", ""value"": ""value"" },
+            { ""label"": ""BoolValue"", ""value"": true },
+            { ""label"": ""NumberValue"", ""value"": 3.1415 },
+            { ""label"": ""NumberValue"", ""value"": 1024 },
+        ]";
+        httpRequestMessage.Content = new StringContent(stringBoolNumbersCodeList, Encoding.UTF8, "application/json");
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task Post_Returns_200OK_When_CodeList_Values_Are_Empty_Strings()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        const string emptyStringCodeList = @"[
+            { ""label"": """", ""value"": """" },
+        ]";
+        httpRequestMessage.Content = new StringContent(emptyStringCodeList, Encoding.UTF8, "application/json");
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task Post_Returns_400BadRequest_When_CodeList_Is_Empty()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        httpRequestMessage.Content = new StringContent("null", Encoding.UTF8, "application/json");
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseContent = await response.Content.ReadAsStringAsync();
+        var responseObject = JsonSerializer.Deserialize<JsonElement>(responseContent);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        Assert.True(responseObject.TryGetProperty("errors", out JsonElement errors));
+        Assert.True(errors.TryGetProperty("", out JsonElement labelErrors));
+        Assert.Contains("A non-empty request body is required.", labelErrors[0].GetString());
+    }
+
+    [Fact]
+    public async Task Post_Returns_400BadRequest_When_CodeList_Has_Invalid_Format()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        const string invalidCodeList = @"[
+            { ""value"": {}, ""label"": ""label2"" },
+        ]";
+        httpRequestMessage.Content = new StringContent(invalidCodeList, Encoding.UTF8, "application/json");
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        var problemDetails = JsonSerializer.Deserialize<ProblemDetails>(await response.Content.ReadAsStringAsync());
+
+        // Assert
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        Assert.NotNull(problemDetails);
+        JsonElement errorCode = (JsonElement)problemDetails.Extensions[ProblemDetailsExtensionsCodes.ErrorCode];
+        Assert.Equal("InvalidOptionsFormat", errorCode.ToString());
+    }
+
+    [Fact]
+    public async Task Post_Returns_400BadRequest_When_CodeList_Has_Missing_Required_Fields()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        const string codeListWithMissingFields = @"[
+            { ""value"": ""value1"" },
+            { ""label"": ""label2"" },
+            { ""value"": null, ""label"": null },
+        ]";
+        httpRequestMessage.Content = new StringContent(codeListWithMissingFields, Encoding.UTF8, "application/json");
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseContent = await response.Content.ReadAsStringAsync();
+        var responseObject = JsonSerializer.Deserialize<JsonElement>(responseContent);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        Assert.True(responseObject.TryGetProperty("errors", out JsonElement errors));
+
+        Assert.True(errors.TryGetProperty("[0].Label", out JsonElement labelErrors));
+        Assert.Contains("The field is required.", labelErrors[0].GetString());
+
+        Assert.True(errors.TryGetProperty("[1].Value", out JsonElement valueErrors));
+        Assert.Contains("The field is required.", valueErrors[0].GetString());
+
+        Assert.True(errors.TryGetProperty("[2].Value", out JsonElement valueNullErrors));
+        Assert.Contains("The field is required.", valueNullErrors[0].GetString());
+
+        Assert.True(errors.TryGetProperty("[2].Label", out JsonElement labelNullErrors));
+        Assert.Contains("The field is required.", labelNullErrors[0].GetString());
+    }
+
+    private static string ApiUrl(string targetOrg) => $"designer/api/{targetOrg}/code-lists/{CodeListId}";
+}
diff --git a/backend/tests/Designer.Tests/Controllers/OrgCodeListController/DeleteCodeListTests.cs b/backend/tests/Designer.Tests/Controllers/OrgCodeListController/DeleteCodeListTests.cs
new file mode 100644
index 00000000000..bc31991f8f1
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OrgCodeListController/DeleteCodeListTests.cs
@@ -0,0 +1,70 @@
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models.Dto;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OrgCodeListController;
+
+public class DeleteCodeListTests : DesignerEndpointsTestsBase<DeleteCodeListTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public DeleteCodeListTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    private const string Org = "ttd";
+    private const string Repo = "org-content";
+    private const string Developer = "testUser";
+
+    [Fact]
+    public async Task Delete_Returns_200OK_When_Deleting_CodeList()
+    {
+        // Arrange
+        const string codeListId = "codeListNumber";
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg, codeListId);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Delete, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        List<OptionListData> responseList = JsonSerializer.Deserialize<List<OptionListData>>(responseBody);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        Assert.Equal(5, responseList.Count);
+        Assert.DoesNotContain(responseList, e => e.Title == codeListId);
+    }
+
+    [Fact]
+    public async Task Delete_Returns_404NotFound_When_CodeList_Does_Not_Exist()
+    {
+        // Arrange
+        const string codeListId = "non-existing-code-list";
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg, codeListId);
+        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(HttpStatusCode.NotFound, response.StatusCode);
+        Assert.Equal($"The code list file {codeListId}.json does not exist.", responseDocument.RootElement.ToString());
+    }
+
+    private static string ApiUrl(string targetOrg, string codeListId) => $"designer/api/{targetOrg}/code-lists/{codeListId}";
+}
diff --git a/backend/tests/Designer.Tests/Controllers/OrgCodeListController/GetCodeListsTests.cs b/backend/tests/Designer.Tests/Controllers/OrgCodeListController/GetCodeListsTests.cs
new file mode 100644
index 00000000000..c0a8dc8c138
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OrgCodeListController/GetCodeListsTests.cs
@@ -0,0 +1,88 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models.Dto;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OrgCodeListController;
+
+public class GetCodeListsTests : DesignerEndpointsTestsBase<GetCodeListsTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public GetCodeListsTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    private const string Org = "ttd";
+    private const string Developer = "testUser";
+
+    [Fact]
+    public async Task GetCodeLists_Returns200Ok_With_CodeLists()
+    {
+        // Arrange
+        const string repo = "org-content";
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, repo, targetOrg, targetRepository);
+
+        string codeListLabelWithObject = @"[{ ""value"": ""someValue"", ""label"": {}}]";
+        string codeListLabelWithNumber = @"[{ ""value"": ""someValue"", ""label"": 12345}]";
+        string codeListLabelWithBool = @"[{ ""value"": ""someValue"", ""label"": true}]";
+        string repoPath = TestDataHelper.GetOrgRepositoryDirectory(Developer, targetOrg, targetRepository);
+        string filePath = Path.Combine(repoPath, "Codelists/");
+        await File.WriteAllTextAsync(Path.Combine(filePath, "codeListLabelWithObject.json"), codeListLabelWithObject);
+        await File.WriteAllTextAsync(Path.Combine(filePath, "codeListLabelWithNumber.json"), codeListLabelWithNumber);
+        await File.WriteAllTextAsync(Path.Combine(filePath, "codeListLabelWithBool.json"), codeListLabelWithBool);
+
+        string apiUrl = ApiUrl(targetOrg);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        List<OptionListData> responseList = JsonSerializer.Deserialize<List<OptionListData>>(responseBody);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        Assert.Equal(9, responseList.Count);
+        Assert.Single(responseList, e => e.Title == "codeListNumber" && e.HasError == false);
+        Assert.Single(responseList, e => e.Title == "codeListString" && e.HasError == false);
+        Assert.Single(responseList, e => e.Title == "codeListBoolean" && e.HasError == false);
+        Assert.Single(responseList, e => e.Title == "codeListMissingValue" && e.HasError == true);
+        Assert.Single(responseList, e => e.Title == "codeListMissingLabel" && e.HasError == true);
+        Assert.Single(responseList, e => e.Title == "codeListTrailingComma" && e.HasError == true);
+        Assert.Single(responseList, e => e.Title == "codeListLabelWithBool" && e.HasError == true);
+        Assert.Single(responseList, e => e.Title == "codeListLabelWithNumber" && e.HasError == true);
+        Assert.Single(responseList, e => e.Title == "codeListLabelWithObject" && e.HasError == true);
+    }
+
+    [Fact]
+    public async Task GetCodeLists_Returns200Ok_With_No_CodeLists()
+    {
+        // Arrange
+        const string repo = "org-content-empty";
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        List<OptionListData> responseList = JsonSerializer.Deserialize<List<OptionListData>>(responseBody);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        Assert.Empty(responseList);
+        Assert.IsType<List<OptionListData>>(responseList);
+    }
+
+    private static string ApiUrl(string targetOrg) => $"designer/api/{targetOrg}/code-lists";
+}
diff --git a/backend/tests/Designer.Tests/Controllers/OrgCodeListController/UpdateCodeListTests.cs b/backend/tests/Designer.Tests/Controllers/OrgCodeListController/UpdateCodeListTests.cs
new file mode 100644
index 00000000000..8901d7eef39
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OrgCodeListController/UpdateCodeListTests.cs
@@ -0,0 +1,194 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Filters;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Models.Dto;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OrgCodeListController;
+
+public class UpdateCodeListTests : DesignerEndpointsTestsBase<UpdateCodeListTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public UpdateCodeListTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    private const string Org = "ttd";
+    private const string Repo = "org-content-empty";
+    private const string Developer = "testUser";
+    private const string CodeListId = "test-code-list";
+
+    [Fact]
+    public async Task Put_Returns_200OK_When_Updating_Code_List()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        const string stringBoolNumbersCodeList = @"[
+            { ""label"": ""StringValue"", ""value"": ""value"" },
+            { ""label"": ""BoolValue"", ""value"": true },
+            { ""label"": ""NumberValue"", ""value"": 3.1415 },
+            { ""label"": ""NumberValue"", ""value"": 1024 },
+        ]";
+        string repoPath = TestDataHelper.GetOrgRepositoryDirectory(Developer, targetOrg, targetRepository);
+        await File.WriteAllTextAsync(Path.Combine(repoPath, "Codelists", $"{CodeListId}.json"), stringBoolNumbersCodeList);
+
+        string apiUrl = ApiUrl(targetOrg);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+        const string codeListWithAnUpdate = @"[
+            { ""label"": ""aNewLabelThatDidNotExistBefore"", ""value"": ""aNewValueThatDidNotExistBefore"" },
+            { ""label"": ""label2"", ""value"": ""value2"" }
+        ]";
+        httpRequestMessage.Content = new StringContent(codeListWithAnUpdate, Encoding.UTF8, "application/json");
+        List<Option> codeList = JsonSerializer.Deserialize<List<Option>>(codeListWithAnUpdate);
+        List<OptionListData> expectedResponse = new([
+            new OptionListData {Title = CodeListId, Data = codeList, HasError = false}
+        ]);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        List<OptionListData> responseList = JsonSerializer.Deserialize<List<OptionListData>>(responseBody);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        Assert.Equal(expectedResponse[0].Data?.Count, responseList[0].Data?.Count);
+
+        var expectedData = expectedResponse[0].Data;
+        var actualData = responseList.Find(e => e.Title == expectedResponse[0].Title).Data;
+        for (int i = 0; i < expectedData?.Count; i++)
+        {
+            Assert.Equal(expectedData[i].Label, actualData?[i].Label);
+            Assert.Equal(expectedData[i].Value, actualData?[i].Value);
+            Assert.Equal(expectedData[i].Description, actualData?[i].Description);
+            Assert.Equal(expectedData[i].HelpText, actualData?[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task Put_Returns_200OK_When_CodeList_Values_Are_Bool_String_Numbers()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+        const string stringBoolNumbersCodeList = @"[
+            { ""label"": ""StringValue"", ""value"": ""value"" },
+            { ""label"": ""BoolValue"", ""value"": true },
+            { ""label"": ""NumberValue"", ""value"": 3.1415 },
+            { ""label"": ""NumberValue"", ""value"": 1024 },
+        ]";
+        httpRequestMessage.Content = new StringContent(stringBoolNumbersCodeList, Encoding.UTF8, "application/json");
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task Put_Returns_400BadRequest_When_CodeList_Is_Empty()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+        httpRequestMessage.Content = new StringContent("null", Encoding.UTF8, "application/json");
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseContent = await response.Content.ReadAsStringAsync();
+        var responseObject = JsonSerializer.Deserialize<JsonElement>(responseContent);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        Assert.True(responseObject.TryGetProperty("errors", out JsonElement errors));
+        Assert.True(errors.TryGetProperty("", out JsonElement labelErrors));
+        Assert.Contains("A non-empty request body is required.", labelErrors[0].GetString());
+    }
+
+    [Fact]
+    public async Task Put_Returns_400BadRequest_When_CodeList_Has_Invalid_Format()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+        const string invalidCodeList = @"[
+            { ""value"": {}, ""label"": ""label2"" },
+        ]";
+        httpRequestMessage.Content = new StringContent(invalidCodeList, Encoding.UTF8, "application/json");
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        var problemDetails = JsonSerializer.Deserialize<ProblemDetails>(await response.Content.ReadAsStringAsync());
+
+        // Assert
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        Assert.NotNull(problemDetails);
+        JsonElement errorCode = (JsonElement)problemDetails.Extensions[ProblemDetailsExtensionsCodes.ErrorCode];
+        Assert.Equal("InvalidOptionsFormat", errorCode.ToString());
+    }
+
+    [Fact]
+    public async Task Put_Returns_400BadRequest_When_CodeList_Has_Missing_Required_Fields()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Put, apiUrl);
+        const string codeListWithMissingFields = @"[
+            { ""value"": ""value1"" },
+            { ""label"": ""label2"" },
+            { ""value"": null, ""label"": null },
+        ]";
+        httpRequestMessage.Content = new StringContent(codeListWithMissingFields, Encoding.UTF8, "application/json");
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseContent = await response.Content.ReadAsStringAsync();
+        var responseObject = JsonSerializer.Deserialize<JsonElement>(responseContent);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+        Assert.True(responseObject.TryGetProperty("errors", out JsonElement errors));
+
+        Assert.True(errors.TryGetProperty("[0].Label", out JsonElement labelErrors));
+        Assert.Contains("The field is required.", labelErrors[0].GetString());
+
+        Assert.True(errors.TryGetProperty("[1].Value", out JsonElement valueErrors));
+        Assert.Contains("The field is required.", valueErrors[0].GetString());
+
+        Assert.True(errors.TryGetProperty("[2].Value", out JsonElement valueNullErrors));
+        Assert.Contains("The field is required.", valueNullErrors[0].GetString());
+
+        Assert.True(errors.TryGetProperty("[2].Label", out JsonElement labelNullErrors));
+        Assert.Contains("The field is required.", labelNullErrors[0].GetString());
+    }
+
+    private static string ApiUrl(string targetOrg) => $"designer/api/{targetOrg}/code-lists/{CodeListId}";
+}
diff --git a/backend/tests/Designer.Tests/Controllers/OrgCodeListController/UploadCodeListTests.cs b/backend/tests/Designer.Tests/Controllers/OrgCodeListController/UploadCodeListTests.cs
new file mode 100644
index 00000000000..659586092e3
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OrgCodeListController/UploadCodeListTests.cs
@@ -0,0 +1,145 @@
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models.Dto;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OrgCodeListController;
+
+public class UploadCodeListTests : DesignerEndpointsTestsBase<UploadCodeListTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public UploadCodeListTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    private const string Org = "ttd";
+    private const string Repo = "org-content-empty";
+    private const string Developer = "testUser";
+    private const string CodeListFileName = "codeList.json";
+
+    [Fact]
+    public async Task Post_Returns_200OK_When_Uploading_New_CodeList()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        const string jsonCodeList = @"[
+            {""label"": ""Label1"", ""value"": ""Value1"", ""description"": ""Description1"", ""helpText"": ""helpText"" },
+            {""label"": ""Label2"", ""value"": ""Value2"" }
+        ]";
+        var httpRequestMessage = CreateTestFile(jsonCodeList, targetOrg);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+        string responseBody = await response.Content.ReadAsStringAsync();
+        List<OptionListData> responseList = JsonSerializer.Deserialize<List<OptionListData>>(responseBody);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        Assert.NotEmpty(responseList);
+        Assert.Equal(2, responseList[0].Data?.Count);
+    }
+
+    [Fact]
+    public async Task Post_Retuns_200OK_When_Uploading_New_CodeList_With_Empty_Strings()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        const string jsonCodeList = @"[
+            {""label"": """", ""value"": """" },
+        ]";
+        var httpRequestMessage = CreateTestFile(jsonCodeList, targetOrg);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task Post_Returns_400BadRequest_When_Uploading_New_CodeList_with_Missing_Fields()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        const string jsonCodeList = @"[
+            {""label"": """" },
+            {""value"": """" },
+        ]";
+        var httpRequestMessage = CreateTestFile(jsonCodeList, targetOrg);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task Post_Returns_400BadRequest_When_Uploading_New_CodeList_With_Null_Values()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        const string jsonCodeList = @"[
+            {""label"": null, ""value"": null }
+        ]";
+        var httpRequestMessage = CreateTestFile(jsonCodeList, targetOrg);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+    }
+
+    [Fact]
+    public async Task Post_Returns_400BadRequest_When_Uploading_New_CodeList_With_Invalid_Format()
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(Developer, Org, Repo, targetOrg, targetRepository);
+
+        const string jsonCodeList = @"[{""value"": {}, ""label"": """"}]";
+        var httpRequestMessage = CreateTestFile(jsonCodeList, targetOrg);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+    }
+
+    private static HttpRequestMessage CreateTestFile(string jsonCodeList, string targetOrg)
+    {
+        string apiUrl = $"designer/api/{targetOrg}/code-lists/upload";
+        byte[] codeListBytes = Encoding.UTF8.GetBytes(jsonCodeList);
+        var content = new MultipartFormDataContent();
+        var codeListContent = new ByteArrayContent(codeListBytes);
+        codeListContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
+        content.Add(codeListContent, "file", CodeListFileName);
+        HttpRequestMessage requestMessage = new(HttpMethod.Post, apiUrl)
+        {
+            Content = content
+        };
+        return requestMessage;
+    }
+}
diff --git a/backend/tests/Designer.Tests/Controllers/OrgTextController/CreateResourceTests.cs b/backend/tests/Designer.Tests/Controllers/OrgTextController/CreateResourceTests.cs
new file mode 100644
index 00000000000..5a33f9b6583
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OrgTextController/CreateResourceTests.cs
@@ -0,0 +1,44 @@
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Mvc.Testing;
+using SharedResources.Tests;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OrgTextController;
+
+public class CreateResourceTests : DesignerEndpointsTestsBase<CreateResourceTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public CreateResourceTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    [Theory]
+    [InlineData("ttd", "testUser", "org-content-empty", "nb", "{\"language\": \"sr\",\"resources\": [{\"id\": \"ServiceName\",\"value\": \"ko-je-ko\"}]}")]
+    public async Task CreateResource_Returns200Ok_WithValidInput(string org, string developer, string repo, string lang, string payload)
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(developer, org, repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg, lang);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Post, apiUrl);
+        httpRequestMessage.Content = new StringContent(payload, Encoding.UTF8, "application/json");
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        Assert.True(TestDataHelper.FileExistsInRepo(targetOrg, targetRepository, developer, RelativePath(lang)));
+        Assert.True(JsonUtils.DeepEquals(payload, TestDataHelper.GetFileFromRepo(targetOrg, targetRepository, developer, RelativePath(lang))));
+    }
+
+    private static string ApiUrl(string org, string languageCode) => $"/designer/api/{org}/text/language/{languageCode}";
+
+    private static string RelativePath(string language) => $"Texts/resource.{language}.json";
+}
diff --git a/backend/tests/Designer.Tests/Controllers/OrgTextController/GetResourcesTests.cs b/backend/tests/Designer.Tests/Controllers/OrgTextController/GetResourcesTests.cs
new file mode 100644
index 00000000000..d9386266980
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OrgTextController/GetResourcesTests.cs
@@ -0,0 +1,63 @@
+using System.Net;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Mvc.Testing;
+using SharedResources.Tests;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OrgTextController;
+
+public class GetResourcesTests : DesignerEndpointsTestsBase<GetResourcesTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public GetResourcesTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    [Theory]
+    [InlineData("ttd", "testUser", "org-content", "nb")]
+    public async Task GetResources_Returns200OK_WithValidInput(string org, string developer, string repo, string lang)
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(developer, org, repo, targetOrg, targetRepository);
+
+        string expectedContent = TestDataHelper.GetFileFromRepo(targetOrg, targetRepository, developer, RelativePath(lang));
+
+        string apiUrl = ApiUrl(targetOrg, lang);
+        using HttpRequestMessage requestMessage = new(HttpMethod.Get, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(requestMessage);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        Assert.True(JsonUtils.DeepEquals(expectedContent, await response.Content.ReadAsStringAsync()));
+    }
+
+    [Theory]
+    [InlineData("ttd", "testUser", "org-content-empty", "sr")]
+    public async Task GetResources_Returns404NotFound_WithNonExistingLang(string org, string developer, string repo, string languageCode)
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(developer, org, repo, targetOrg, targetRepository);
+
+        string apiUrl = ApiUrl(targetOrg, languageCode);
+        using HttpRequestMessage httpRequestMessage = new(HttpMethod.Get, apiUrl);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(httpRequestMessage);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
+        Assert.Equal($"Text resource, resource.{languageCode}.json, could not be found.", await response.Content.ReadAsStringAsync());
+    }
+
+    private static string ApiUrl(string org, string languageCode) => $"/designer/api/{org}/text/language/{languageCode}";
+
+    private static string RelativePath(string language) => $"Texts/resource.{language}.json";
+}
diff --git a/backend/tests/Designer.Tests/Controllers/OrgTextController/UpdateResourceTests.cs b/backend/tests/Designer.Tests/Controllers/OrgTextController/UpdateResourceTests.cs
new file mode 100644
index 00000000000..33ae241263e
--- /dev/null
+++ b/backend/tests/Designer.Tests/Controllers/OrgTextController/UpdateResourceTests.cs
@@ -0,0 +1,125 @@
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Net.Mime;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Models;
+using Designer.Tests.Controllers.ApiTests;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Mvc.Testing;
+using SharedResources.Tests;
+using Xunit;
+
+namespace Designer.Tests.Controllers.OrgTextController;
+
+public class UpdateResourceTests : DesignerEndpointsTestsBase<UpdateResourceTests>, IClassFixture<WebApplicationFactory<Program>>
+{
+    public UpdateResourceTests(WebApplicationFactory<Program> factory) : base(factory)
+    {
+    }
+
+    [Theory]
+    [MemberData(nameof(Data))]
+    public async Task UpdateResource_Returns200OK_WithValidInput(string org, string developer, string repo, string lang, Dictionary<string, string> updateDictionary)
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(developer, org, repo, targetOrg, targetRepository);
+
+        string file = TestDataHelper.GetFileFromRepo(targetOrg, targetRepository, developer, RelativePath(lang));
+        TextResource expectedResource = JsonSerializer.Deserialize<TextResource>(file, _jsonOptions);
+        PrepareExpectedResourceWithoutVariables(expectedResource, updateDictionary);
+
+        string apiUrl = ApiUrl(targetOrg, lang);
+        using HttpRequestMessage requestMessage = new(HttpMethod.Put, apiUrl);
+        requestMessage.Content = new StringContent(JsonSerializer.Serialize(updateDictionary), Encoding.UTF8, MediaTypeNames.Application.Json);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(requestMessage);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        string actualContent = TestDataHelper.GetFileFromRepo(targetOrg, targetRepository, developer, RelativePath(lang));
+        Assert.True(JsonUtils.DeepEquals(JsonSerializer.Serialize(expectedResource, _jsonOptions), actualContent));
+    }
+
+    [Theory]
+    [MemberData(nameof(DataForTextWithVariables))]
+    public async Task UpdateResource_Returns200OK_ForTextsThatHaveVariables(string org, string developer, string repo, string lang, Dictionary<string, string> updateDictionary)
+    {
+        // Arrange
+        string targetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(targetOrg);
+        await CopyOrgRepositoryForTest(developer, org, repo, targetOrg, targetRepository);
+
+        string originalFile = TestDataHelper.GetFileFromRepo(targetOrg, targetRepository, developer, RelativePath(lang));
+        TextResource originalResource = JsonSerializer.Deserialize<TextResource>(originalFile, _jsonOptions);
+        List<TextResourceVariable> expectedVariables = originalResource.Resources.Find(e => e.Id == "TextUsingVariables").Variables;
+
+        string apiUrl = ApiUrl(targetOrg, lang);
+        using HttpRequestMessage requestMessage = new(HttpMethod.Put, apiUrl);
+        requestMessage.Content = new StringContent(JsonSerializer.Serialize(updateDictionary), Encoding.UTF8, MediaTypeNames.Application.Json);
+
+        // Act
+        using HttpResponseMessage response = await HttpClient.SendAsync(requestMessage);
+
+        // Assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        string actualContent = TestDataHelper.GetFileFromRepo(targetOrg, targetRepository, developer, RelativePath(lang));
+        TextResource actualResource = JsonSerializer.Deserialize<TextResource>(actualContent, _jsonOptions);
+        List<TextResourceVariable> actualVariables = actualResource.Resources.Find(e => e.Id == "TextUsingVariables").Variables;
+        Assert.NotNull(actualVariables);
+        Assert.Equal(expectedVariables.Count, actualVariables.Count);
+    }
+
+    private static string ApiUrl(string org, string languageCode) => $"/designer/api/{org}/text/language/{languageCode}";
+
+    private static string RelativePath(string language) => $"Texts/resource.{language}.json";
+
+    private static readonly JsonSerializerOptions _jsonOptions = new()
+    {
+        WriteIndented = true,
+        Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase
+    };
+
+    private static void PrepareExpectedResourceWithoutVariables(TextResource resource, Dictionary<string, string> updateDictionary)
+    {
+        foreach ((string key, string value) in updateDictionary)
+        {
+            var textResourceContainsKey = resource.Resources.Find(textResourceElement => textResourceElement.Id == key);
+            if (textResourceContainsKey is null)
+            {
+                resource.Resources.Insert(0, new TextResourceElement { Id = key, Value = value });
+                continue;
+            }
+
+            int indexTextResourceElementUpdateKey = resource.Resources.IndexOf(textResourceContainsKey);
+            resource.Resources[indexTextResourceElementUpdateKey] = new TextResourceElement { Id = key, Value = value };
+        }
+    }
+
+    public static IEnumerable<object[]> Data =>
+        new List<object[]>
+        {
+            new object[] { "ttd", "testUser", "org-content", "nb", new Dictionary<string,string>
+            {
+                {"Email", "new"},
+                {"nonExistingKey", "new value"}
+            }}
+        };
+
+    public static IEnumerable<object[]> DataForTextWithVariables =>
+        new List<object[]>
+        {
+            new object[] { "ttd", "testUser", "org-content", "nb", new Dictionary<string,string>()
+            {
+                {"TextUsingVariables", "Dette er den nye teksten og variablene {0} og {1} har ikke blitt borte eller endret"},
+            }}
+        };
+}
diff --git a/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnOrgGitRepositoryTests.cs b/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnOrgGitRepositoryTests.cs
new file mode 100644
index 00000000000..ace2727fd12
--- /dev/null
+++ b/backend/tests/Designer.Tests/Infrastructure/GitRepository/AltinnOrgGitRepositoryTests.cs
@@ -0,0 +1,206 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Infrastructure.GitRepository;
+using Altinn.Studio.Designer.Models;
+using Designer.Tests.Utils;
+using SharedResources.Tests;
+using Xunit;
+
+namespace Designer.Tests.Infrastructure.GitRepository;
+
+public class AltinnOrgGitRepositoryTests : IDisposable
+{
+    private string TargetOrg { get; set; }
+
+    private const string Org = "ttd";
+    private const string Developer = "testUser";
+
+    [Theory]
+    [InlineData("org-content", "nb")]
+    public async Task GetText_WithRepoThatHasTextResources_ShouldReturnTexts(string repository, string language)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        AltinnOrgGitRepository altinnOrgGitRepository = await PrepareRepositoryForTest(repository);
+
+        // Act
+        TextResource textResource = await altinnOrgGitRepository.GetText(language);
+
+        // Assert
+        string fileContent = TestDataHelper.GetFileFromRepo(Org, repository, Developer, RelativePathText(language));
+        string textResourceString = JsonSerializer.Serialize(textResource, _jsonOptions);
+        Assert.True(JsonUtils.DeepEquals(fileContent, textResourceString));
+    }
+
+    [Theory]
+    [InlineData("org-content-empty", "nb")]
+    public async Task SaveText_WithEmptyRepo_ShouldSaveTexts(string repository, string language)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        AltinnOrgGitRepository altinnOrgGitRepository = await PrepareRepositoryForTest(repository);
+        TextResource textResource = new() { Language = language, Resources = [new() { Id = "someId", Value = "someValue" }] };
+
+        // Act
+        await altinnOrgGitRepository.SaveText(language, textResource);
+
+        // Assert
+        string fileContent = TestDataHelper.GetFileFromRepo(TargetOrg, targetRepository, Developer, RelativePathText(language));
+        Assert.False(string.IsNullOrEmpty(fileContent));
+    }
+
+    [Theory]
+    [InlineData("org-content")]
+    public async Task GetCodeListIds_WithRepoThatHasCodeLists_ShouldReturnCodeListPathNames(string repository)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        AltinnOrgGitRepository altinnOrgGitRepository = await PrepareRepositoryForTest(repository);
+
+        // Act
+        string[] codeListIds = altinnOrgGitRepository.GetCodeListIds();
+
+        // Assert
+        Assert.NotNull(codeListIds);
+        Assert.Equal(6, codeListIds.Length);
+    }
+
+    [Theory]
+    [InlineData("org-content-empty")]
+    public async Task GetCodeListIds_WithRepoThatHasNoCodeLists_ShouldReturnEmptyList(string repository)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        AltinnOrgGitRepository altinnOrgGitRepository = await PrepareRepositoryForTest(repository);
+
+        // Act
+        string[] codeListIds = altinnOrgGitRepository.GetCodeListIds();
+
+        // Assert
+        Assert.Empty(codeListIds);
+    }
+
+    [Theory]
+    [InlineData("org-content", "codeListString")]
+    public async Task GetCodeList_WithRepoThatHasCodeLists_ShouldReturnACodeListsWithCorrectValues(string repository, string codeListId)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        AltinnOrgGitRepository altinnOrgGitRepository = await PrepareRepositoryForTest(repository);
+
+        // Act
+        List<Option> codeLists = await altinnOrgGitRepository.GetCodeList(codeListId);
+
+        // Assert
+        Assert.NotNull(codeLists);
+        Assert.Equal(3, codeLists.Count);
+        Assert.Equal("norway", codeLists[0].Value);
+        Assert.Equal("denmark", codeLists[1].Value);
+        Assert.Equal("sweden", codeLists[2].Value);
+    }
+
+    [Theory]
+    [InlineData("org-content", "none-existing-code-list")]
+    public async Task GetCodeLists_WithSpecifiedCodeListIdDoesNotExistInOrg_ShouldThrowNotFoundException(string repository, string codeListId)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        AltinnOrgGitRepository altinnOrgGitRepository = await PrepareRepositoryForTest(repository);
+
+        // Act and assert
+        await Assert.ThrowsAsync<LibGit2Sharp.NotFoundException>(async () => await altinnOrgGitRepository.GetCodeList(codeListId));
+    }
+
+    [Theory]
+    [InlineData("org-content-empty", "newId")]
+    public async Task CreatCodeList_WithEmptyRepo_ShouldCreateCodeList(string repository, string codeListId)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        AltinnOrgGitRepository altinnOrgGitRepository = await PrepareRepositoryForTest(repository);
+        List<Option> newCodeList = [new() { Label = "someLabel", Value = "someValue", }];
+        string expectedCodeList = JsonSerializer.Serialize(newCodeList, _jsonOptions);
+
+        // Act
+        await altinnOrgGitRepository.CreateCodeList(codeListId, newCodeList);
+
+        // Assert
+        string fileContent = TestDataHelper.GetFileFromRepo(TargetOrg, targetRepository, Developer, RelativePathCodeList(codeListId));
+        Assert.True(JsonUtils.DeepEquals(expectedCodeList, fileContent));
+    }
+
+    [Theory]
+    [InlineData("org-content", "codeListString")]
+    public async Task UpdateCodeList_WithExistingCodeList_ShouldUpdateCodeList(string repository, string codeListId)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        AltinnOrgGitRepository altinnOrgGitRepository = await PrepareRepositoryForTest(repository);
+        List<Option> updatedCodeList = [new() { Label = "someLabel", Value = "updated Value!", }];
+        string expectedCodeList = JsonSerializer.Serialize(updatedCodeList, _jsonOptions);
+
+        // Act
+        await altinnOrgGitRepository.UpdateCodeList(codeListId, updatedCodeList);
+
+        // Assert
+        string fileContent = TestDataHelper.GetFileFromRepo(TargetOrg, targetRepository, Developer, RelativePathCodeList(codeListId));
+        Assert.True(JsonUtils.DeepEquals(expectedCodeList, fileContent));
+    }
+
+    [Theory]
+    [InlineData("org-content", "codeListTrailingComma")]
+    public async Task DeleteCodeList_WithExistingCodeList_ShouldDeleteCodeList(string repository, string codeListId)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        AltinnOrgGitRepository altinnOrgGitRepository = await PrepareRepositoryForTest(repository);
+
+        // Act
+        altinnOrgGitRepository.DeleteCodeList(codeListId);
+
+        // Assert
+        string repositoryDir = TestDataHelper.GetTestDataRepositoryDirectory(TargetOrg, targetRepository, Developer);
+        string codeListFilePath = Path.Combine(repositoryDir, RelativePathCodeList(codeListId));
+        Assert.False(File.Exists(codeListFilePath));
+    }
+
+    private static string RelativePathCodeList(string codeListId) => $"Codelists/{codeListId}.json";
+
+    private static string RelativePathText(string lang) => $"Texts/resource.{lang}.json";
+
+    private async Task<AltinnOrgGitRepository> PrepareRepositoryForTest(string repository)
+    {
+        string repositoriesRootDirectory = TestDataHelper.GetTestDataRepositoriesRootDirectory();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, repository, TargetOrg, targetRepository);
+        string repositoryDirectory = TestDataHelper.GetTestDataRepositoryDirectory(TargetOrg, targetRepository, Developer);
+        var altinnOrgGitRepository = new AltinnOrgGitRepository(TargetOrg, targetRepository, Developer, repositoriesRootDirectory, repositoryDirectory);
+
+        return altinnOrgGitRepository;
+    }
+
+    private static readonly JsonSerializerOptions _jsonOptions = new()
+    {
+        WriteIndented = true,
+        Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true
+    };
+
+    public void Dispose()
+    {
+        if (!string.IsNullOrEmpty(TargetOrg))
+        {
+            TestDataHelper.DeleteOrgDirectory(Developer, TargetOrg);
+        }
+    }
+}
diff --git a/backend/tests/Designer.Tests/Services/OrgCodeListServiceTests.cs b/backend/tests/Designer.Tests/Services/OrgCodeListServiceTests.cs
new file mode 100644
index 00000000000..3baca42dd2c
--- /dev/null
+++ b/backend/tests/Designer.Tests/Services/OrgCodeListServiceTests.cs
@@ -0,0 +1,268 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Factories;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Services.Implementation.Organisation;
+using Designer.Tests.Utils;
+using Microsoft.AspNetCore.Http;
+using Xunit;
+
+namespace Designer.Tests.Services;
+
+public class OrgCodeListServiceTests : IDisposable
+{
+    private string TargetOrg { get; set; }
+
+    private const string Org = "ttd";
+    private const string Repo = "org-content";
+    private const string Developer = "testUser";
+
+    [Fact]
+    public async Task GetCodeLists_ShouldReturnAllCodeLists()
+    {
+        // Arrange
+        List<Option> expectedCodeList = new()
+        {
+            new Option
+            {
+                Label = "En",
+                Value = 1.05
+            },
+            new Option
+            {
+                Label = "To",
+                Value = 2.01
+            },
+            new Option
+            {
+                Label = "Tre",
+                Value = 3.1
+            }
+        };
+
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, Repo, TargetOrg, targetRepository);
+        var service = GetOrgCodeListService();
+
+        // Act
+        var fetchedCodeLists = await service.GetCodeLists(TargetOrg, Developer);
+        List<Option> fetchedCodeListData = fetchedCodeLists.Find(e => e.Title == "codeListNumber").Data;
+
+        // Assert
+        Assert.Equal(expectedCodeList.Count, fetchedCodeListData?.Count);
+
+        for (int i = 0; i < fetchedCodeListData?.Count; i++)
+        {
+            Assert.Equal(expectedCodeList[i].Label, fetchedCodeListData[i].Label);
+            Assert.Equal(expectedCodeList[i].Value, fetchedCodeListData[i].Value);
+            Assert.Equal(expectedCodeList[i].Description, fetchedCodeListData[i].Description);
+            Assert.Equal(expectedCodeList[i].HelpText, fetchedCodeListData[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task CreateCodeList_ShouldReturnAllCodeListsAfterCreation()
+    {
+        // Arrange
+        List<Option> newCodeList = new()
+        {
+            new Option
+            {
+                Label = "label1",
+                Value = "value1"
+            },
+            new Option
+            {
+                Label = "label2",
+                Value = "value2"
+            }
+        };
+
+        const string codeListId = "newCoodeList";
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, Repo, TargetOrg, targetRepository);
+        var service = GetOrgCodeListService();
+
+        // Act
+        var codeListData = await service.CreateCodeList(TargetOrg, Developer, codeListId, newCodeList);
+        List<Option> codeList = codeListData.Find(e => e.Title == codeListId).Data;
+
+        // Assert
+        Assert.Equal(7, codeListData.Count);
+        Assert.Equal(newCodeList.Count, codeList?.Count);
+
+        for (int i = 0; i < codeList?.Count; i++)
+        {
+            Assert.Equal(newCodeList[i].Label, codeList[i].Label);
+            Assert.Equal(newCodeList[i].Value, codeList[i].Value);
+            Assert.Equal(newCodeList[i].Description, codeList[i].Description);
+            Assert.Equal(newCodeList[i].HelpText, codeList[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task UpdateCodeList_ShouldReturnAllCodeListAfterUpdate()
+    {
+        // Arrange
+        List<Option> newCodeList = new()
+        {
+            new Option
+            {
+                Label = "someLabel",
+                Value = "Updated value"
+            }
+        };
+        const string codeListId = "codeListTrailingComma";
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, Repo, TargetOrg, targetRepository);
+        var service = GetOrgCodeListService();
+
+        // Act
+        var codeListData = await service.UpdateCodeList(TargetOrg, Developer, codeListId, newCodeList);
+        List<Option> codeList = codeListData.Find(e => e.Title == codeListId).Data;
+
+        // Assert
+        Assert.Equal(6, codeListData.Count);
+        Assert.Equal(newCodeList.Count, codeList?.Count);
+
+        for (int i = 0; i < codeList?.Count; i++)
+        {
+            Assert.Equal(newCodeList[i].Label, codeList[i].Label);
+            Assert.Equal(newCodeList[i].Value, codeList[i].Value);
+            Assert.Equal(newCodeList[i].Description, codeList[i].Description);
+            Assert.Equal(newCodeList[i].HelpText, codeList[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task UploadCodeList_ShouldReturnAllCodeListsAfterUploading()
+    {
+        // Arrange
+        const string codeListId = "newCodeList";
+        const string fileName = $"{codeListId}.json";
+        const string jsonCodeList = @"[
+            {""label"": ""someLabel"",""value"": ""someValue"" },
+        ]";
+        List<Option> expectedCodeList = new()
+        {
+            new Option
+            {
+                Label = "someLabel",
+                Value = "someValue"
+            }
+        };
+        byte[] codeListBytes = Encoding.UTF8.GetBytes(jsonCodeList);
+        var stream = new MemoryStream(codeListBytes);
+        IFormFile file = new FormFile(stream, 0, codeListBytes.Length, fileName, fileName);
+
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, Repo, TargetOrg, targetRepository);
+        var service = GetOrgCodeListService();
+
+        // Act
+        var codeListData = await service.UploadCodeList(TargetOrg, Developer, file);
+        stream.Close();
+        List<Option> codeList = codeListData.Find(e => e.Title == codeListId).Data;
+
+        // Assert
+        Assert.Equal(7, codeListData.Count);
+        Assert.Equal(expectedCodeList.Count, codeList?.Count);
+
+        for (int i = 0; i < codeList?.Count; i++)
+        {
+            Assert.Equal(expectedCodeList[i].Label, codeList[i].Label);
+            Assert.Equal(expectedCodeList[i].Value, codeList[i].Value);
+            Assert.Equal(expectedCodeList[i].Description, codeList[i].Description);
+            Assert.Equal(expectedCodeList[i].HelpText, codeList[i].HelpText);
+        }
+    }
+
+    [Fact]
+    public async Task DeleteCodeList_ShouldReturnAllCodeListsAfterDeletion()
+    {
+        // Arrange
+        const string codeListId = "codeListNumber";
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, Repo, TargetOrg, targetRepository);
+        var service = GetOrgCodeListService();
+
+        // Act
+        var codeListData = await service.DeleteCodeList(TargetOrg, Developer, codeListId);
+
+        // Assert
+        Assert.Equal(5, codeListData.Count);
+    }
+
+    [Fact]
+    public async Task DeleteCodeList_ShouldThrowExceptionIfCodeListDoesNotExist()
+    {
+        // Arrange
+        const string codeListId = "codeListWhichDoesNotExist";
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, Repo, TargetOrg, targetRepository);
+        var service = GetOrgCodeListService();
+
+        // Act and assert
+        await Assert.ThrowsAsync<LibGit2Sharp.NotFoundException>(async () => await service.DeleteCodeList(TargetOrg, Developer, codeListId));
+    }
+
+    [Fact]
+    public async Task CodeListExists_ShouldReturnTrue_WhenCodeListExists()
+    {
+        // Arrange
+        const string codeListId = "codeListNumber";
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, Repo, TargetOrg, targetRepository);
+        var service = GetOrgCodeListService();
+
+        // Act
+        bool codeListExists = await service.CodeListExists(TargetOrg, Developer, codeListId);
+
+        // Assert
+        Assert.True(codeListExists);
+    }
+
+    [Fact]
+    public async Task CodeListExists_ShouldReturnFalse_WhenCodeListDoesNotExists()
+    {
+        // Arrange
+        const string codeListId = "codeListWhichDoesNotExist";
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepository = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, Repo, TargetOrg, targetRepository);
+        var service = GetOrgCodeListService();
+
+        // Act
+        bool codeListExists = await service.CodeListExists(TargetOrg, Developer, codeListId);
+
+        // Assert
+        Assert.False(codeListExists);
+    }
+
+    private static OrgCodeListService GetOrgCodeListService()
+    {
+        AltinnGitRepositoryFactory altinnGitRepositoryFactory =
+            new(TestDataHelper.GetTestDataRepositoriesRootDirectory());
+        OrgCodeListService service = new(altinnGitRepositoryFactory);
+
+        return service;
+    }
+
+    public void Dispose()
+    {
+        if (!string.IsNullOrEmpty(TargetOrg))
+        {
+            TestDataHelper.DeleteOrgDirectory(Developer, TargetOrg);
+        }
+    }
+}
diff --git a/backend/tests/Designer.Tests/Services/OrgTextsServiceTests.cs b/backend/tests/Designer.Tests/Services/OrgTextsServiceTests.cs
new file mode 100644
index 00000000000..88c392f62d9
--- /dev/null
+++ b/backend/tests/Designer.Tests/Services/OrgTextsServiceTests.cs
@@ -0,0 +1,230 @@
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using Altinn.Studio.Designer.Factories;
+using Altinn.Studio.Designer.Models;
+using Altinn.Studio.Designer.Services.Implementation.Organisation;
+using Designer.Tests.Utils;
+using LibGit2Sharp;
+using SharedResources.Tests;
+using Xunit;
+using TextResource = Altinn.Studio.Designer.Models.TextResource;
+
+namespace Designer.Tests.Services;
+
+public class OrgTextsServiceTests : IDisposable
+{
+    private string TargetOrg { get; set; }
+
+    private const string Org = "ttd";
+    private const string Developer = "testUser";
+
+    [Theory]
+    [InlineData("org-content", "nb")]
+    public async Task GetText_ShouldReturnAllTexts(string repo, string lang)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepo = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, repo, TargetOrg, targetRepo);
+        var service = GetOrgTextsService();
+
+        TextResource expectedTextResource = GetInitialTextResources();
+        string expectedTextResourceJson = JsonSerializer.Serialize(expectedTextResource, _jsonOptions);
+
+        // Act
+        TextResource fetchedTexts = await service.GetText(TargetOrg, Developer, lang);
+
+        // Assert
+        Assert.Equal(lang, fetchedTexts.Language);
+        string actualContent = JsonSerializer.Serialize(fetchedTexts, _jsonOptions);
+        Assert.True(JsonUtils.DeepEquals(expectedTextResourceJson, actualContent));
+    }
+
+    [Theory]
+    [InlineData("org-content", "sr")]
+    public async Task GetText_ShouldReturnNotFoundException_WhenFileDoesNotExist(string repo, string lang)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepo = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, repo, TargetOrg, targetRepo);
+        var service = GetOrgTextsService();
+
+        // Act and assert
+        await Assert.ThrowsAsync<NotFoundException>(async () => await service.GetText(TargetOrg, Developer, lang));
+    }
+
+    [Theory]
+    [InlineData("org-content-empty", "nb")]
+    public async Task SaveText_ShouldCreateTextFile(string repo, string lang)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepo = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, repo, TargetOrg, targetRepo);
+        var service = GetOrgTextsService();
+
+        List<TextResourceElement> newResourceElements = [new() { Id = "newId", Value = "newValue" }];
+        TextResource newTextResource = new() { Language = lang, Resources = newResourceElements };
+
+        // Act
+        await service.SaveText(TargetOrg, Developer, newTextResource, lang);
+
+        // Assert
+        string actualContent = TestDataHelper.GetFileFromRepo(TargetOrg, targetRepo, Developer, RelativePath(lang));
+        TextResource actualResource = JsonSerializer.Deserialize<TextResource>(actualContent, _jsonOptions);
+        Assert.Equal(newTextResource.Resources[0].Id, actualResource.Resources[0].Id);
+        Assert.Equal(newTextResource.Resources[0].Value, actualResource.Resources[0].Value);
+    }
+
+    [Theory]
+    [InlineData("org-content", "nb")]
+    public async Task UpdateTextsForKeys_ShouldUpdateExistingId(string repo, string lang)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepo = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, repo, TargetOrg, targetRepo);
+        var service = GetOrgTextsService();
+
+        const string editedValue = "edited value!";
+        const string editedId = "someId";
+        Dictionary<string, string> newTextIds = new()
+        {
+            { editedId, editedValue },
+        };
+        TextResource expectedTextResources = GetInitialTextResources();
+        expectedTextResources.Resources.Find(e => e.Id == editedId).Value = editedValue;
+
+        // Act
+        await service.UpdateTextsForKeys(TargetOrg, Developer, newTextIds, lang);
+
+        // Assert
+        string actualContent = TestDataHelper.GetFileFromRepo(TargetOrg, targetRepo, Developer, RelativePath(lang));
+        TextResource actualResource = JsonSerializer.Deserialize<TextResource>(actualContent, _jsonOptions);
+        for (int i = 0; i < actualResource.Resources.Count; i++)
+        {
+            Assert.Equal(expectedTextResources.Resources[i].Id, actualResource.Resources[i].Id);
+            Assert.Equal(expectedTextResources.Resources[i].Value, actualResource.Resources[i].Value);
+        }
+    }
+
+    [Theory]
+    [InlineData("org-content", "nb")]
+    public async Task UpdateTextsForKeys_ShouldCreateNewIdWhenTextResourceDoesNotExit(string repo, string lang)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepo = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, repo, TargetOrg, targetRepo);
+        var service = GetOrgTextsService();
+
+        const string newId = "someNewId";
+        const string newValue = "someNewValue";
+        Dictionary<string, string> newTextIds = new()
+        {
+            { newId, newValue },
+        };
+        TextResource expectedTextResources = GetInitialTextResources();
+        TextResourceElement expectedResourceElement = new() { Id = newId, Value = newValue };
+        expectedTextResources.Resources.Add(expectedResourceElement);
+
+        // Act
+        await service.UpdateTextsForKeys(TargetOrg, Developer, newTextIds, lang);
+
+        // Assert
+        string actualContent = TestDataHelper.GetFileFromRepo(TargetOrg, targetRepo, Developer, RelativePath(lang));
+        TextResource actualResource = JsonSerializer.Deserialize<TextResource>(actualContent, _jsonOptions);
+        TextResourceElement newResourceElement = actualResource.Resources.Find(e => e.Id == newId);
+        Assert.Equal(expectedResourceElement.Id, newResourceElement.Id);
+        Assert.Equal(expectedResourceElement.Value, newResourceElement.Value);
+    }
+
+    [Theory]
+    [InlineData("org-content", "nb")]
+    public async Task UpdateTextsForKeys_ShouldUpdateTextWithVariables(string repo, string lang)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepo = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, repo, TargetOrg, targetRepo);
+        var service = GetOrgTextsService();
+
+        const string idOfItemToUpdate = "TextUsingVariables";
+        const string newValue = "some value with variables number 1 '{0}' and 2 '{1}'";
+        Dictionary<string, string> newTextIds = new()
+        {
+            { idOfItemToUpdate, newValue },
+        };
+        TextResource expectedTextResources = GetInitialTextResources();
+        expectedTextResources.Resources.Find(e => e.Id == idOfItemToUpdate).Value = newValue;
+        TextResourceElement expectedResourceElement = expectedTextResources.Resources.Find(e => e.Id == idOfItemToUpdate);
+
+        // Act
+        await service.UpdateTextsForKeys(TargetOrg, Developer, newTextIds, lang);
+
+        // Assert
+        string actualContent = TestDataHelper.GetFileFromRepo(TargetOrg, targetRepo, Developer, RelativePath(lang));
+        TextResource actualResource = JsonSerializer.Deserialize<TextResource>(actualContent, _jsonOptions);
+        TextResourceElement newResourceElement = actualResource.Resources.Find(e => e.Id == idOfItemToUpdate);
+        Assert.Equal(expectedResourceElement.Id, newResourceElement.Id);
+        Assert.Equal(expectedResourceElement.Value, newResourceElement.Value);
+        Assert.Equal(expectedResourceElement.Variables.Count, newResourceElement.Variables.Count);
+    }
+
+    [Theory]
+    [InlineData("org-content", "sr")]
+    public async Task UpdateTextsForKeys_ShouldThrowExceptionWhenLanguageDoesNotExist(string repo, string lang)
+    {
+        // Arrange
+        TargetOrg = TestDataHelper.GenerateTestOrgName();
+        string targetRepo = TestDataHelper.GetOrgContentRepoName(TargetOrg);
+        await TestDataHelper.CopyOrgForTest(Developer, Org, repo, TargetOrg, targetRepo);
+        var service = GetOrgTextsService();
+
+        Dictionary<string, string> newTextIds = new()
+        {
+            { "someNewId", "someNewValue" },
+        };
+
+        // Act and assert
+        await Assert.ThrowsAsync<NotFoundException>(async () => await service.UpdateTextsForKeys(TargetOrg, Developer, newTextIds, lang));
+    }
+
+    private static TextResource GetInitialTextResources(string language = "nb")
+    {
+        string fileContents = TestDataHelper.GetFileFromRepo(Org, "org-content", Developer, RelativePath(language));
+        return JsonSerializer.Deserialize<TextResource>(fileContents, _jsonOptions);
+    }
+
+    private static readonly JsonSerializerOptions _jsonOptions = new()
+    {
+        WriteIndented = true,
+        Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true
+    };
+
+    private static OrgTextsService GetOrgTextsService()
+    {
+        AltinnGitRepositoryFactory altinnGitRepositoryFactory =
+            new(TestDataHelper.GetTestDataRepositoriesRootDirectory());
+        OrgTextsService service = new(altinnGitRepositoryFactory);
+
+        return service;
+    }
+
+    private static string RelativePath(string language) => $"Texts/resource.{language}.json";
+
+    public void Dispose()
+    {
+        if (!string.IsNullOrEmpty(TargetOrg))
+        {
+            TestDataHelper.DeleteOrgDirectory(Developer, TargetOrg);
+        }
+    }
+}
diff --git a/backend/tests/Designer.Tests/Utils/TestDataHelper.cs b/backend/tests/Designer.Tests/Utils/TestDataHelper.cs
index 4fe0f07324d..93b4edb7aa7 100644
--- a/backend/tests/Designer.Tests/Utils/TestDataHelper.cs
+++ b/backend/tests/Designer.Tests/Utils/TestDataHelper.cs
@@ -138,7 +138,7 @@ public static string GenerateTestRepoName(string suffix = null, int length = 28)
             }
             if (length is < 12 or > 28)
             {
-                throw new ArgumentException("Length for test repo must be between 12 and 20.");
+                throw new ArgumentException("Length for test repo must be between 12 and 28.");
             }
 
             if ("test-repo-".Length + suffix?.Length > length)
@@ -416,5 +416,48 @@ private static byte[] ReadAllBytesWithoutLockingWithRetry(string filePath, FileA
 
             return bytes;
         }
+
+        public static string GenerateTestOrgName(int length = 27)
+        {
+            if (length is < 12 or > 27)
+            {
+                throw new ArgumentException("Length for test org must be between 12 and 27.");
+            }
+
+            return $"test-org-{Guid.NewGuid()}"[..length];
+        }
+
+        public static string GetOrgContentRepoName(string org)
+        {
+            return $"{org}-content";
+        }
+
+        public static async Task<string> CopyOrgForTest(string developer, string org, string repository, string targetOrg, string targetRepository)
+        {
+            string sourceDirectory = GetOrgRepositoryDirectory(developer, org, repository);
+            string targetOrgDirectory = GetOrgDirectory(targetOrg, developer);
+            string targetRepoDirectory = GetOrgRepositoryDirectory(developer, targetOrg, targetRepository);
+
+            CreateEmptyDirectory(targetOrgDirectory);
+            await CopyDirectory(sourceDirectory, targetRepoDirectory);
+
+            return targetOrgDirectory;
+        }
+
+        private static string GetOrgDirectory(string org, string developer)
+        {
+            return Path.Combine(GetTestDataRepositoriesRootDirectory(), developer, org);
+        }
+
+        public static string GetOrgRepositoryDirectory(string developer, string org, string repository)
+        {
+            return Path.Combine(GetTestDataRepositoriesRootDirectory(), developer, org, repository);
+        }
+
+        public static void DeleteOrgDirectory(string developer, string org)
+        {
+            string orgRepositoryDirectory = GetOrgDirectory(org, developer);
+            DeleteDirectory(orgRepositoryDirectory);
+        }
     }
 }
diff --git a/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content-empty/Codelists/.gitignore b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content-empty/Codelists/.gitignore
new file mode 100644
index 00000000000..5e7d2734cfc
--- /dev/null
+++ b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content-empty/Codelists/.gitignore
@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore
diff --git a/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content-empty/Texts/.gitignore b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content-empty/Texts/.gitignore
new file mode 100644
index 00000000000..5e7d2734cfc
--- /dev/null
+++ b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content-empty/Texts/.gitignore
@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore
diff --git a/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListBoolean.json b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListBoolean.json
new file mode 100644
index 00000000000..bc2b2f7f61c
--- /dev/null
+++ b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListBoolean.json
@@ -0,0 +1,10 @@
+[
+    {
+        "value": true,
+        "label": "Ja"
+    },
+    {
+        "value": false,
+        "label": "Nei"
+    }
+]
diff --git a/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListMissingLabel.json b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListMissingLabel.json
new file mode 100644
index 00000000000..d7fe8797ccd
--- /dev/null
+++ b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListMissingLabel.json
@@ -0,0 +1,3 @@
+[
+    { "value": "someValue"}
+]
diff --git a/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListMissingValue.json b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListMissingValue.json
new file mode 100644
index 00000000000..6c9b1df1ec4
--- /dev/null
+++ b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListMissingValue.json
@@ -0,0 +1,3 @@
+[
+    { "label": "someLabel"}
+]
diff --git a/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListNumber.json b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListNumber.json
new file mode 100644
index 00000000000..b3847bb9823
--- /dev/null
+++ b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListNumber.json
@@ -0,0 +1,14 @@
+[
+    {
+        "value": 1.05,
+        "label": "En"
+    },
+    {
+        "value": 2.01,
+        "label": "To"
+    },
+    {
+        "value": 3.1,
+        "label": "Tre"
+    }
+]
diff --git a/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListString.json b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListString.json
new file mode 100644
index 00000000000..3c050001702
--- /dev/null
+++ b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListString.json
@@ -0,0 +1,14 @@
+[
+    {
+        "value": "norway",
+        "label": "Norge"
+    },
+    {
+        "value": "denmark",
+        "label": "Danmark"
+    },
+    {
+        "value": "sweden",
+        "label": "country.label.sweden"
+    }
+]
diff --git a/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListTrailingComma.json b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListTrailingComma.json
new file mode 100644
index 00000000000..da8630d2f83
--- /dev/null
+++ b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Codelists/codeListTrailingComma.json
@@ -0,0 +1,3 @@
+[
+    { "label": "someLabel", "value":  "someValue"},
+]
diff --git a/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Texts/resource.nb.json b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Texts/resource.nb.json
new file mode 100644
index 00000000000..a5143a9f743
--- /dev/null
+++ b/backend/tests/Designer.Tests/_TestData/Repositories/testUser/ttd/org-content/Texts/resource.nb.json
@@ -0,0 +1,23 @@
+{
+    "language": "nb",
+    "resources": [
+        {
+            "id": "someId",
+            "value": "someValue"
+        },
+        {
+            "id": "TextUsingVariables",
+            "value": "Dette er en tekst som skal oppdateres, men som har variablene {0} og {1} tilknyttet seg, som IKKE skal bli borte eller endret",
+            "variables": [
+                {
+                    "key": "aFieldInTheModel",
+                    "dataSource": "dataModel.testModel"
+                },
+                {
+                    "key": "appId",
+                    "dataSource": "instanceContext"
+                }
+            ]
+        }
+    ]
+}
diff --git a/development/setup.js b/development/setup.js
index 3206cce5c94..38e14048572 100644
--- a/development/setup.js
+++ b/development/setup.js
@@ -182,7 +182,7 @@ const createContentRepo = async (user, pass, org) => {
     pass,
     body: {
       content: Buffer.from(
-        `[\n  {\n    "label": "someLabel",\n    "value": "someValue",\n  }\n]`,
+        `[\n  {\n    "label": "someLabel",\n    "value": "someValue"\n  }\n]`,
       ).toString('base64'),
     },
   });
diff --git a/frontend/dashboard/app/App.test.tsx b/frontend/dashboard/app/App.test.tsx
index 2ce3dc35105..19596cb78d5 100644
--- a/frontend/dashboard/app/App.test.tsx
+++ b/frontend/dashboard/app/App.test.tsx
@@ -1,27 +1,43 @@
 import React from 'react';
+import type { RenderResult } from '@testing-library/react';
 import { render, screen, waitForElementToBeRemoved } from '@testing-library/react';
+import type { MockServicesContextWrapperProps } from '../dashboardTestUtils';
 import { MockServicesContextWrapper } from '../dashboardTestUtils';
-
 import { App } from './App';
 import { textMock } from '@studio/testing/mocks/i18nMock';
-import type { ServicesContextProps } from 'app-shared/contexts/ServicesContext';
-
-const renderWithMockServices = (services: Partial<ServicesContextProps> = {}) => {
-  render(
-    <MockServicesContextWrapper customServices={services}>
-      <App />
-    </MockServicesContextWrapper>,
-  );
+import { createQueryClientMock } from 'app-shared/mocks/queryClientMock';
+import { QueryKey } from 'app-shared/types/QueryKey';
+import { user as userMock } from 'app-shared/mocks/mocks';
+import type { QueryClient } from '@tanstack/react-query';
+import userEvent from '@testing-library/user-event';
+import type { Organization } from 'app-shared/types/Organization';
+import { APP_DASHBOARD_BASENAME } from 'app-shared/constants';
+import { FeatureFlag } from 'app-shared/utils/featureToggleUtils';
+
+jest.mock('react-router-dom', () => jest.requireActual('react-router-dom')); // Todo: Remove this when we have removed the global mock: https://github.com/Altinn/altinn-studio/issues/14597
+
+jest.mock('app-shared/utils/featureToggleUtils', () => ({
+  ...jest.requireActual('app-shared/utils/featureToggleUtils'),
+  shouldDisplayFeature: jest.fn().mockImplementation((flag) => flag === FeatureFlag.OrgLibrary),
+}));
+
+// Test data:
+const org: Organization = {
+  avatar_url: 'data:image/svg+xml;utf8,<svg></svg>',
+  id: 1,
+  username: 'some-org',
 };
 
 describe('App', () => {
-  test('should display spinner while loading', () => {
-    renderWithMockServices();
+  beforeEach(jest.clearAllMocks);
+
+  it('should display spinner while loading', () => {
+    renderApp();
     expect(screen.getByText(textMock('dashboard.loading'))).toBeInTheDocument();
   });
 
-  test('should display error when failing to fetch current user', async () => {
-    renderWithMockServices({ getUser: () => Promise.reject() });
+  it('should display error when failing to fetch current user', async () => {
+    renderApp({ customServices: { getUser: () => Promise.reject() } });
     expect(
       await screen.findByRole('heading', {
         level: 1,
@@ -30,22 +46,72 @@ describe('App', () => {
     ).toBeInTheDocument();
   });
 
-  test('should display error when failing to fetch organizations', async () => {
-    renderWithMockServices({ getOrganizations: () => Promise.reject() });
-
+  it('should display error when failing to fetch organizations', async () => {
+    renderApp({ customServices: { getOrganizations: () => Promise.reject() } });
     expect(
       await screen.findByRole('heading', {
         level: 1,
         name: textMock('dashboard.error_getting_organization_data.title'),
       }),
-    );
+    ).toBeInTheDocument();
+  });
+
+  it('should display dashboard page when data are loaded', async () => {
+    renderApp();
+    await waitForElementToBeRemoved(querySpinner());
+    expect(screen.getByRole('link', { name: textMock('dashboard.header_item_dashboard') }));
+    expect(screen.getByRole('link', { name: textMock('dashboard.header_item_library') }));
+  });
+
+  it('should display the apps overview by default', () => {
+    const client = createQueryClientWithUserAndOrg();
+    renderApp({ client });
+    expect(getFavouriteAppListHeading()).toBeInTheDocument();
+  });
+
+  it('should display the library when the user clicks on the library link', async () => {
+    const user = userEvent.setup();
+    const client = createQueryClientWithUserAndOrg();
+    const initialEntries = [`${APP_DASHBOARD_BASENAME}/${org.username}`];
+    renderApp({ client, initialEntries });
+    await user.click(screen.getByRole('link', { name: textMock('dashboard.header_item_library') }));
+    expect(getLibraryHeading()).toBeInTheDocument();
   });
 
-  test('should display dashboard page if successfully loading data', async () => {
-    renderWithMockServices();
-    await waitForElementToBeRemoved(screen.queryByText(textMock('dashboard.loading')));
-    expect(screen.getByRole('heading', { level: 2, name: textMock('dashboard.favourites') }));
-    expect(screen.getByRole('heading', { level: 2, name: textMock('dashboard.apps') }));
-    expect(screen.getByRole('heading', { level: 2, name: textMock('dashboard.resources') }));
+  it('should display the apps overview when the user is on the library page and clicks on the apps link', async () => {
+    const user = userEvent.setup();
+    const client = createQueryClientWithUserAndOrg();
+    const initialEntries = [`${APP_DASHBOARD_BASENAME}/${org.username}`];
+    renderApp({ client, initialEntries });
+    await user.click(screen.getByRole('link', { name: textMock('dashboard.header_item_library') }));
+    await user.click(
+      screen.getByRole('link', { name: textMock('dashboard.header_item_dashboard') }),
+    );
+    expect(getFavouriteAppListHeading()).toBeInTheDocument();
   });
 });
+
+type RenderAppArgs = Omit<MockServicesContextWrapperProps, 'children'>;
+
+function renderApp(args: RenderAppArgs = {}): RenderResult {
+  return render(<App />, {
+    wrapper: ({ children }) => (
+      <MockServicesContextWrapper {...args}>{children}</MockServicesContextWrapper>
+    ),
+  });
+}
+
+const querySpinner = (): HTMLElement | null => screen.queryByTitle(textMock('dashboard.loading'));
+
+const getFavouriteAppListHeading = (): HTMLElement =>
+  screen.getByRole('heading', { name: textMock('dashboard.favourites') });
+
+const getLibraryHeading = (): HTMLElement =>
+  screen.getByRole('heading', { name: textMock('app_content_library.library_heading') });
+
+function createQueryClientWithUserAndOrg(): QueryClient {
+  const client = createQueryClientMock();
+  client.setQueryData([QueryKey.CurrentUser], userMock);
+  client.setQueryData([QueryKey.Organizations], [org]);
+  return client;
+}
diff --git a/frontend/dashboard/app/App.tsx b/frontend/dashboard/app/App.tsx
index c3a5be41e9c..5035e2fdd8e 100644
--- a/frontend/dashboard/app/App.tsx
+++ b/frontend/dashboard/app/App.tsx
@@ -9,77 +9,95 @@ import { useOrganizationsQuery } from '../hooks/queries';
 
 import './App.css';
 import { PageLayout } from 'dashboard/pages/PageLayout';
-import { Trans, useTranslation } from 'react-i18next';
-import { DASHBOARD_ROOT_ROUTE } from 'app-shared/constants';
-import { Link } from '@digdir/designsystemet-react';
+import { useTranslation } from 'react-i18next';
+import {
+  APP_DASHBOARD_BASENAME,
+  DASHBOARD_ROOT_ROUTE,
+  ORG_LIBRARY_BASENAME,
+} from 'app-shared/constants';
+import { OrgContentLibrary } from '../pages/OrgContentLibrary';
+import { useSubroute } from '../hooks/useSubRoute';
+import { mergeQueryStatuses } from 'app-shared/utils/tanstackQueryUtils';
+import type { Organization } from 'app-shared/types/Organization';
+import type { User } from 'app-shared/types/Repository';
+import type { QueryStatus } from '@tanstack/react-query';
 
-export const App = (): JSX.Element => {
+export function App(): React.ReactElement {
+  const { data: user, status: userStatus } = useUserQuery();
+  const { data: organizations, status: organizationsStatus } = useOrganizationsQuery();
+
+  const queryStatus = mergeQueryStatuses(userStatus, organizationsStatus);
+
+  switch (queryStatus) {
+    case 'pending':
+      return <PendingPage />;
+    case 'error':
+      return <ErrorMessage userStatus={userStatus} />;
+    case 'success':
+      return <AppWithData user={user} organizations={organizations} />;
+  }
+}
+
+function PendingPage(): React.ReactElement {
   const { t } = useTranslation();
+  return (
+    <div className={classes.appDashboardSpinner}>
+      <StudioPageSpinner spinnerTitle={t('dashboard.loading')} />
+    </div>
+  );
+}
 
-  const { data: user, isError: isUserError } = useUserQuery();
-  const { data: organizations, isError: isOrganizationsError } = useOrganizationsQuery();
+type ErrorMessageProps = {
+  userStatus: QueryStatus;
+};
 
-  const componentIsReady = user && organizations;
-  const componentHasError = isUserError || isOrganizationsError;
+function ErrorMessage({ userStatus }: ErrorMessageProps): React.ReactElement {
+  const { t } = useTranslation();
 
-  const getErrorMessage = () => {
-    if (isUserError) {
-      return (
-        <StudioPageError
-          title={t('dashboard.error_getting_user_data.title')}
-          message={t('dashboard.error_getting_user_data.message')}
-        />
-      );
-    }
-    if (isOrganizationsError) {
-      return (
-        <StudioPageError
-          title={t('dashboard.error_getting_organization_data.title')}
-          message={t('dashboard.error_getting_organization_data.message')}
-        />
-      );
-    }
+  if (userStatus === 'error') {
     return (
       <StudioPageError
-        title={t('dashboard.error_unknown.title')}
-        message={
-          <Trans
-            i18nKey={'dashboard.error_unknown.message'}
-            components={{
-              a: <Link href='/contact'> </Link>,
-            }}
-          />
-        }
+        title={t('dashboard.error_getting_user_data.title')}
+        message={t('dashboard.error_getting_user_data.message')}
       />
     );
-  };
-
-  if (componentHasError) {
-    return getErrorMessage();
-  }
-
-  if (componentIsReady) {
+  } else {
     return (
-      <div className={classes.root}>
-        <Routes>
-          <Route path={DASHBOARD_ROOT_ROUTE} element={<PageLayout />}>
-            <Route
-              path='/:selectedContext?'
-              element={<Dashboard user={user} organizations={organizations} />}
-            />
-            <Route
-              path='/:selectedContext/new'
-              element={<CreateService organizations={organizations} user={user} />}
-            />
-          </Route>
-        </Routes>
-      </div>
+      <StudioPageError
+        title={t('dashboard.error_getting_organization_data.title')}
+        message={t('dashboard.error_getting_organization_data.message')}
+      />
     );
   }
+}
 
+type AppWithDataProps = {
+  user: User;
+  organizations: Organization[];
+};
+
+function AppWithData(props: AppWithDataProps): React.ReactElement {
   return (
-    <div className={classes.appDashboardSpinner}>
-      <StudioPageSpinner spinnerTitle={t('dashboard.loading')} />
+    <div className={classes.root}>
+      <Routes>
+        <Route path={DASHBOARD_ROOT_ROUTE} element={<PageLayout />}>
+          <Route path='/:subroute/:selectedContext?' element={<SubrouteGuard {...props} />} />
+          <Route path='/:subroute/:selectedContext/new' element={<CreateService {...props} />} />
+        </Route>
+      </Routes>
     </div>
   );
-};
+}
+
+function SubrouteGuard(props: AppWithDataProps): React.ReactElement {
+  const subroute = useSubroute();
+  const subrouteWithLeadingSlash = '/' + subroute;
+
+  switch (subrouteWithLeadingSlash) {
+    case APP_DASHBOARD_BASENAME:
+      return <Dashboard {...props} />;
+
+    case ORG_LIBRARY_BASENAME:
+      return <OrgContentLibrary />;
+  }
+}
diff --git a/frontend/dashboard/components/NewApplicationForm/NewApplicationForm.tsx b/frontend/dashboard/components/NewApplicationForm/NewApplicationForm.tsx
index 9d4c2f2feba..82350e4947e 100644
--- a/frontend/dashboard/components/NewApplicationForm/NewApplicationForm.tsx
+++ b/frontend/dashboard/components/NewApplicationForm/NewApplicationForm.tsx
@@ -7,7 +7,7 @@ import { RepoNameInput } from '../RepoNameInput';
 import { type User } from 'app-shared/types/Repository';
 import { type Organization } from 'app-shared/types/Organization';
 import { useSelectedContext } from '../../hooks/useSelectedContext';
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import { type NewAppForm } from '../../types/NewAppForm';
 import { useCreateAppFormValidation } from './hooks/useCreateAppFormValidation';
 import { Link } from 'react-router-dom';
diff --git a/frontend/dashboard/context/HeaderContext/HeaderContext.tsx b/frontend/dashboard/context/HeaderContext/HeaderContext.tsx
index d16d8a1cd85..7c11b581160 100644
--- a/frontend/dashboard/context/HeaderContext/HeaderContext.tsx
+++ b/frontend/dashboard/context/HeaderContext/HeaderContext.tsx
@@ -2,12 +2,6 @@ import { createContext } from 'react';
 import { type Organization } from 'app-shared/types/Organization';
 import { type User } from 'app-shared/types/Repository';
 
-export enum SelectedContextType {
-  All = 'all',
-  Self = 'self',
-  None = 'none',
-}
-
 export type HeaderContextType = {
   selectableOrgs?: Organization[];
   user: User;
diff --git a/frontend/dashboard/context/HeaderContext/index.ts b/frontend/dashboard/context/HeaderContext/index.ts
index ec5587f9307..bb7f609e6e4 100644
--- a/frontend/dashboard/context/HeaderContext/index.ts
+++ b/frontend/dashboard/context/HeaderContext/index.ts
@@ -1 +1 @@
-export { HeaderContext, type HeaderContextType, SelectedContextType } from './HeaderContext';
+export { HeaderContext, type HeaderContextType } from './HeaderContext';
diff --git a/frontend/dashboard/dashboardTestUtils.tsx b/frontend/dashboard/dashboardTestUtils.tsx
index 5000df36425..ec2654a73cf 100644
--- a/frontend/dashboard/dashboardTestUtils.tsx
+++ b/frontend/dashboard/dashboardTestUtils.tsx
@@ -1,6 +1,7 @@
 import type { QueryClient } from '@tanstack/react-query';
 import type { ReactNode } from 'react';
 import React from 'react';
+import type { MemoryRouterProps } from 'react-router-dom';
 import { MemoryRouter } from 'react-router-dom';
 import type {
   ServicesContextProps,
@@ -14,12 +15,13 @@ export type MockServicesContextWrapperProps = {
   children: ReactNode;
   customServices?: Partial<ServicesContextProps>;
   client?: QueryClient;
-};
+} & Pick<MemoryRouterProps, 'initialEntries'>;
 
 export const MockServicesContextWrapper = ({
   children,
   customServices,
   client = createQueryClientMock(),
+  initialEntries,
 }: MockServicesContextWrapperProps) => {
   const queries: ServicesContextProviderProps = {
     ...queriesMock,
@@ -29,7 +31,7 @@ export const MockServicesContextWrapper = ({
   };
 
   return (
-    <MemoryRouter>
+    <MemoryRouter initialEntries={initialEntries}>
       <ServicesContextProvider {...queries}>{children}</ServicesContextProvider>
     </MemoryRouter>
   );
diff --git a/frontend/dashboard/enums/HeaderMenuItemKey.ts b/frontend/dashboard/enums/HeaderMenuItemKey.ts
new file mode 100644
index 00000000000..ac1a76fcef2
--- /dev/null
+++ b/frontend/dashboard/enums/HeaderMenuItemKey.ts
@@ -0,0 +1,4 @@
+export enum HeaderMenuItemKey {
+  OrgLibrary = 'org-library',
+  AppDashboard = 'app-dashboard',
+}
diff --git a/frontend/dashboard/enums/SelectedContextType.ts b/frontend/dashboard/enums/SelectedContextType.ts
new file mode 100644
index 00000000000..dbe1e9c483c
--- /dev/null
+++ b/frontend/dashboard/enums/SelectedContextType.ts
@@ -0,0 +1,5 @@
+export enum SelectedContextType {
+  All = 'all',
+  Self = 'self',
+  None = 'none',
+}
diff --git a/frontend/dashboard/enums/Subroute.ts b/frontend/dashboard/enums/Subroute.ts
new file mode 100644
index 00000000000..bc3e1c362dd
--- /dev/null
+++ b/frontend/dashboard/enums/Subroute.ts
@@ -0,0 +1,6 @@
+import { APP_DASHBOARD_BASENAME, ORG_LIBRARY_BASENAME } from 'app-shared/constants';
+
+export enum Subroute {
+  AppDashboard = APP_DASHBOARD_BASENAME,
+  OrgLibrary = ORG_LIBRARY_BASENAME,
+}
diff --git a/frontend/dashboard/hooks/guards/useContextRedirectionGuard.ts b/frontend/dashboard/hooks/guards/useContextRedirectionGuard.ts
index c9ffccefc75..609e105da5f 100644
--- a/frontend/dashboard/hooks/guards/useContextRedirectionGuard.ts
+++ b/frontend/dashboard/hooks/guards/useContextRedirectionGuard.ts
@@ -3,9 +3,10 @@ import { useEffect, useState } from 'react';
 import { useSelectedContext } from '../useSelectedContext';
 import type { NavigateFunction } from 'react-router-dom';
 import { useNavigate } from 'react-router-dom';
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import { typedSessionStorage } from '@studio/pure-functions';
 import { userHasAccessToSelectedContext } from 'dashboard/utils/userUtils';
+import { useSubroute } from '../useSubRoute';
 
 export type UseRedirectionGuardResult = {
   isRedirectionComplete: boolean;
@@ -14,18 +15,23 @@ export type UseRedirectionGuardResult = {
 export const useContextRedirectionGuard = (
   organizations: Organization[],
 ): UseRedirectionGuardResult => {
-  const selectedContext = useSelectedContext();
+  const selectedContextType = useSelectedContext();
+  const subroute = useSubroute();
   const navigate = useNavigate();
   const [isContextRedirectionComplete, setIsContextRedirectionComplete] = useState<boolean>(false);
 
-  if (selectedContext !== SelectedContextType.None) {
-    typedSessionStorage.setItem('dashboard::selectedContext', selectedContext);
+  if (selectedContextType !== SelectedContextType.None) {
+    typedSessionStorage.setItem('dashboard::selectedContext', selectedContextType);
   }
 
   useEffect(() => {
-    handleContextRedirection(selectedContext, organizations, navigate);
+    const dashboardRoute: DashboardRoute = {
+      selectedContextType,
+      subroute,
+    };
+    handleContextRedirection(dashboardRoute, organizations, navigate);
     setIsContextRedirectionComplete(true);
-  }, [selectedContext, organizations, navigate]);
+  }, [selectedContextType, organizations, navigate, subroute]);
 
   return {
     isRedirectionComplete: isContextRedirectionComplete,
@@ -33,43 +39,69 @@ export const useContextRedirectionGuard = (
 };
 
 const handleContextRedirection = (
-  currentContext: SelectedContextType | string,
+  dashboardRoute: DashboardRoute,
   organizations: Organization[],
   navigate: NavigateFunction,
 ): void => {
-  const targetContext = getTargetContext(currentContext);
-
-  if (!hasAccessToContext(targetContext, organizations)) {
-    navigateToContext(SelectedContextType.Self, navigate);
-    return;
+  const { selectedContextType, subroute } = dashboardRoute;
+  if (!hasAccessToTargetContext(selectedContextType, organizations)) {
+    navigateToSelf(subroute, navigate);
+  } else {
+    navigateToDifferentContext(dashboardRoute, navigate);
   }
-
-  if (targetContext === currentContext) return;
-  navigateToContext(targetContext, navigate);
 };
 
-const getTargetContext = (
-  currentContext: SelectedContextType | string,
-): SelectedContextType | string => {
-  if (currentContext === SelectedContextType.None) {
-    return typedSessionStorage.getItem('dashboard::selectedContext') || SelectedContextType.Self;
-  }
-  return currentContext;
-};
+const hasAccessToTargetContext = (
+  selectedContextType: string,
+  organizations: Organization[],
+): boolean => hasAccessToContext(getTargetContext(selectedContextType), organizations);
 
 const hasAccessToContext = (
   targetContext: SelectedContextType | string,
   organizations: Organization[],
-): boolean => {
-  return (
-    organizations &&
-    userHasAccessToSelectedContext({ selectedContext: targetContext, orgs: organizations })
-  );
+): boolean =>
+  organizations &&
+  userHasAccessToSelectedContext({ selectedContext: targetContext, orgs: organizations });
+
+const getTargetContext = (
+  currentContext: SelectedContextType | string,
+): SelectedContextType | string =>
+  currentContext === SelectedContextType.None ? getSelectedContextFromStorage() : currentContext;
+
+const getSelectedContextFromStorage = (): string => {
+  return typedSessionStorage.getItem('dashboard::selectedContext') || SelectedContextType.Self;
+};
+
+const navigateToSelf = (subroute: string, navigate: NavigateFunction): void => {
+  const dashboardRoute: DashboardRoute = {
+    selectedContextType: SelectedContextType.Self,
+    subroute,
+  };
+  navigateToContext(dashboardRoute, navigate);
 };
 
 const navigateToContext = (
-  targetContext: SelectedContextType | string,
+  { subroute, selectedContextType }: DashboardRoute,
+  navigate: NavigateFunction,
+): void => navigate(subroute + '/' + selectedContextType + location.search, { replace: true });
+
+const navigateToDifferentContext = (
+  { subroute, selectedContextType }: DashboardRoute,
   navigate: NavigateFunction,
 ): void => {
-  navigate(targetContext + location.search, { replace: true });
+  if (isTargetContextDifferent(selectedContextType)) {
+    const dashboardRoute: DashboardRoute = {
+      selectedContextType: getTargetContext(selectedContextType),
+      subroute,
+    };
+    navigateToContext(dashboardRoute, navigate);
+  }
+};
+
+const isTargetContextDifferent = (selectedContextType: string): boolean =>
+  getTargetContext(selectedContextType) !== selectedContextType;
+
+type DashboardRoute = {
+  selectedContextType: string;
+  subroute: string;
 };
diff --git a/frontend/dashboard/hooks/usePageHeaderTitle/usePageHeaderTitle.test.tsx b/frontend/dashboard/hooks/usePageHeaderTitle/usePageHeaderTitle.test.tsx
index 6ee0bd2a639..aa428165c26 100644
--- a/frontend/dashboard/hooks/usePageHeaderTitle/usePageHeaderTitle.test.tsx
+++ b/frontend/dashboard/hooks/usePageHeaderTitle/usePageHeaderTitle.test.tsx
@@ -3,7 +3,7 @@ import { usePageHeaderTitle } from './usePageHeaderTitle';
 import { HeaderContext, type HeaderContextType } from 'dashboard/context/HeaderContext';
 import { useSelectedContext } from 'dashboard/hooks/useSelectedContext';
 import { headerContextValueMock } from 'dashboard/testing/headerContextMock';
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import { mockOrg1 } from 'dashboard/testing/organizationMock';
 import { renderHookWithProviders } from 'dashboard/testing/mocks';
 
diff --git a/frontend/dashboard/hooks/usePageHeaderTitle/usePageHeaderTitle.tsx b/frontend/dashboard/hooks/usePageHeaderTitle/usePageHeaderTitle.tsx
index b46a181a5de..f725a381878 100644
--- a/frontend/dashboard/hooks/usePageHeaderTitle/usePageHeaderTitle.tsx
+++ b/frontend/dashboard/hooks/usePageHeaderTitle/usePageHeaderTitle.tsx
@@ -1,5 +1,6 @@
 import { useContext } from 'react';
-import { HeaderContext, SelectedContextType } from 'dashboard/context/HeaderContext';
+import { HeaderContext } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import { getOrgNameByUsername } from 'dashboard/utils/userUtils';
 import { useSelectedContext } from '../useSelectedContext';
 
diff --git a/frontend/dashboard/hooks/useProfileMenuTriggerButtonText/useProfileMenuTriggerButtonText.test.tsx b/frontend/dashboard/hooks/useProfileMenuTriggerButtonText/useProfileMenuTriggerButtonText.test.tsx
index b795c8202c3..ad3e20984d3 100644
--- a/frontend/dashboard/hooks/useProfileMenuTriggerButtonText/useProfileMenuTriggerButtonText.test.tsx
+++ b/frontend/dashboard/hooks/useProfileMenuTriggerButtonText/useProfileMenuTriggerButtonText.test.tsx
@@ -1,10 +1,7 @@
 import React from 'react';
 import { useProfileMenuTriggerButtonText } from './useProfileMenuTriggerButtonText';
-import {
-  HeaderContext,
-  type HeaderContextType,
-  SelectedContextType,
-} from 'dashboard/context/HeaderContext';
+import { HeaderContext, type HeaderContextType } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import { useSelectedContext } from '../useSelectedContext';
 import { userMock } from 'dashboard/testing/userMock';
 import { headerContextValueMock } from 'dashboard/testing/headerContextMock';
diff --git a/frontend/dashboard/hooks/useProfileMenuTriggerButtonText/useProfileMenuTriggerButtonText.tsx b/frontend/dashboard/hooks/useProfileMenuTriggerButtonText/useProfileMenuTriggerButtonText.tsx
index 6fb72c909fd..e56533b3882 100644
--- a/frontend/dashboard/hooks/useProfileMenuTriggerButtonText/useProfileMenuTriggerButtonText.tsx
+++ b/frontend/dashboard/hooks/useProfileMenuTriggerButtonText/useProfileMenuTriggerButtonText.tsx
@@ -1,5 +1,6 @@
 import { useContext } from 'react';
-import { HeaderContext, SelectedContextType } from 'dashboard/context/HeaderContext';
+import { HeaderContext } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import { getOrgNameByUsername } from 'dashboard/utils/userUtils';
 import { useTranslation } from 'react-i18next';
 import { useSelectedContext } from '../useSelectedContext';
diff --git a/frontend/dashboard/hooks/useSelectedContext/useSelectedContext.ts b/frontend/dashboard/hooks/useSelectedContext/useSelectedContext.ts
index adfc1be61d6..c4f596840dd 100644
--- a/frontend/dashboard/hooks/useSelectedContext/useSelectedContext.ts
+++ b/frontend/dashboard/hooks/useSelectedContext/useSelectedContext.ts
@@ -1,5 +1,5 @@
 import { useParams } from 'react-router-dom';
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 
 export const useSelectedContext = () => {
   const { selectedContext = SelectedContextType.None } = useParams();
diff --git a/frontend/dashboard/hooks/useSubRoute/index.ts b/frontend/dashboard/hooks/useSubRoute/index.ts
new file mode 100644
index 00000000000..4ca65a751db
--- /dev/null
+++ b/frontend/dashboard/hooks/useSubRoute/index.ts
@@ -0,0 +1 @@
+export * from './useSubroute';
diff --git a/frontend/dashboard/hooks/useSubRoute/useSubroute.ts b/frontend/dashboard/hooks/useSubRoute/useSubroute.ts
new file mode 100644
index 00000000000..c742e8cf65a
--- /dev/null
+++ b/frontend/dashboard/hooks/useSubRoute/useSubroute.ts
@@ -0,0 +1,10 @@
+import { useParams } from 'react-router-dom';
+import { APP_DASHBOARD_BASENAME } from 'app-shared/constants';
+import { StringUtils } from '@studio/pure-functions';
+
+export function useSubroute(): string {
+  const { subroute = defaultSubroute } = useParams();
+  return subroute;
+}
+
+const defaultSubroute = StringUtils.removeLeadingSlash(APP_DASHBOARD_BASENAME);
diff --git a/frontend/dashboard/pages/CreateService/CreateService.test.tsx b/frontend/dashboard/pages/CreateService/CreateService.test.tsx
index 5c8328adf13..2dbd88cdc4f 100644
--- a/frontend/dashboard/pages/CreateService/CreateService.test.tsx
+++ b/frontend/dashboard/pages/CreateService/CreateService.test.tsx
@@ -9,8 +9,8 @@ import { textMock } from '@studio/testing/mocks/i18nMock';
 import type { ServicesContextProps } from 'app-shared/contexts/ServicesContext';
 import { repository, user as userMock } from 'app-shared/mocks/mocks';
 import { useParams } from 'react-router-dom';
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
-import { DASHBOARD_ROOT_ROUTE } from 'app-shared/constants';
+import { Subroute } from '../../enums/Subroute';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 
 const orgMock: Organization = {
   avatar_url: '',
@@ -72,6 +72,9 @@ describe('CreateService', () => {
 
   it('should show error messages when clicking create and no owner or name is filled in', async () => {
     const user = userEvent.setup();
+    const selectedContext = SelectedContextType.None;
+    const subroute = Subroute.AppDashboard;
+    (useParams as jest.Mock).mockReturnValue({ selectedContext, subroute });
     renderWithMockServices({ user: { ...mockUser, login: '' } });
 
     const createBtn: HTMLElement = screen.getByRole('button', {
@@ -297,39 +300,42 @@ describe('CreateService', () => {
     expect(windowLocationAssignMock).toHaveBeenCalled();
   });
 
-  it('should set cancel link to / when selected context is self', async () => {
+  it('should set cancel link to /self when selected context is self', async () => {
     const selectedContext = SelectedContextType.Self;
-    (useParams as jest.Mock).mockReturnValue({ selectedContext });
+    const subroute = Subroute.AppDashboard;
+    (useParams as jest.Mock).mockReturnValue({ selectedContext, subroute });
 
     renderWithMockServices();
     const cancelLink: HTMLElement = screen.getByRole('link', {
       name: textMock('general.cancel'),
     });
 
-    expect(cancelLink.getAttribute('href')).toBe(DASHBOARD_ROOT_ROUTE);
+    expect(cancelLink.getAttribute('href')).toBe(`/${subroute}/${selectedContext}`);
   });
 
   it('should set cancel link to /all when selected context is all', async () => {
     const selectedContext = SelectedContextType.All;
-    (useParams as jest.Mock).mockReturnValue({ selectedContext });
+    const subroute = Subroute.AppDashboard;
+    (useParams as jest.Mock).mockReturnValue({ selectedContext, subroute });
 
     renderWithMockServices();
     const cancelLink: HTMLElement = screen.getByRole('link', {
       name: textMock('general.cancel'),
     });
 
-    expect(cancelLink.getAttribute('href')).toBe(DASHBOARD_ROOT_ROUTE + selectedContext);
+    expect(cancelLink.getAttribute('href')).toBe(`/${subroute}/${selectedContext}`);
   });
 
   it('should set cancel link to /org when selected context is org', async () => {
     const selectedContext = 'ttd';
-    (useParams as jest.Mock).mockReturnValue({ selectedContext });
+    const subroute = Subroute.AppDashboard;
+    (useParams as jest.Mock).mockReturnValue({ selectedContext, subroute });
 
     renderWithMockServices();
     const cancelLink: HTMLElement = screen.getByRole('link', {
       name: textMock('general.cancel'),
     });
 
-    expect(cancelLink.getAttribute('href')).toBe(DASHBOARD_ROOT_ROUTE + selectedContext);
+    expect(cancelLink.getAttribute('href')).toBe(`/${subroute}/${selectedContext}`);
   });
 });
diff --git a/frontend/dashboard/pages/CreateService/CreateService.tsx b/frontend/dashboard/pages/CreateService/CreateService.tsx
index e3cc424e787..03d19d7d392 100644
--- a/frontend/dashboard/pages/CreateService/CreateService.tsx
+++ b/frontend/dashboard/pages/CreateService/CreateService.tsx
@@ -10,9 +10,8 @@ import { ServerCodes } from 'app-shared/enums/ServerCodes';
 import { NewApplicationForm } from '../../components/NewApplicationForm';
 import { PackagesRouter } from 'app-shared/navigation/PackagesRouter';
 import { type NewAppForm } from '../../types/NewAppForm';
-import { DASHBOARD_ROOT_ROUTE } from 'app-shared/constants';
 import { useSelectedContext } from '../../hooks/useSelectedContext';
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { useSubroute } from '../../hooks/useSubRoute';
 
 const initialFormError: NewAppForm = {
   org: '',
@@ -38,6 +37,9 @@ export const CreateService = ({ user, organizations }: CreateServiceProps): JSX.
 
   const [formError, setFormError] = useState<NewAppForm>(initialFormError);
 
+  const selectedContext = useSelectedContext();
+  const subroute = useSubroute();
+
   const navigateToEditorOverview = (org: string, app: string) => {
     const packagesRouter = new PackagesRouter({
       org,
@@ -74,8 +76,6 @@ export const CreateService = ({ user, organizations }: CreateServiceProps): JSX.
     );
   };
 
-  const selectedContext = useSelectedContext();
-
   return (
     <div className={classes.wrapper}>
       <NewApplicationForm
@@ -88,7 +88,7 @@ export const CreateService = ({ user, organizations }: CreateServiceProps): JSX.
         setFormError={setFormError}
         actionableElement={{
           type: 'link',
-          href: `${DASHBOARD_ROOT_ROUTE}${selectedContext === SelectedContextType.Self ? '' : selectedContext}`,
+          href: `/${subroute}/${selectedContext}`,
         }}
       />
     </div>
diff --git a/frontend/dashboard/pages/Dashboard/Dashboard.test.tsx b/frontend/dashboard/pages/Dashboard/Dashboard.test.tsx
index a7aa682d584..da8a82bfeec 100644
--- a/frontend/dashboard/pages/Dashboard/Dashboard.test.tsx
+++ b/frontend/dashboard/pages/Dashboard/Dashboard.test.tsx
@@ -3,7 +3,7 @@ import { screen, waitForElementToBeRemoved, within } from '@testing-library/reac
 import { Dashboard } from './Dashboard';
 import { textMock } from '@studio/testing/mocks/i18nMock';
 import type { User } from 'app-shared/types/Repository';
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import type { ServicesContextProps } from 'app-shared/contexts/ServicesContext';
 import { repository, searchRepositoryResponse } from 'app-shared/mocks/mocks';
 import type { SearchRepositoryResponse } from 'app-shared/types/api';
diff --git a/frontend/dashboard/pages/Dashboard/Dashboard.tsx b/frontend/dashboard/pages/Dashboard/Dashboard.tsx
index ffffd59d42d..cb72ebe8b13 100644
--- a/frontend/dashboard/pages/Dashboard/Dashboard.tsx
+++ b/frontend/dashboard/pages/Dashboard/Dashboard.tsx
@@ -17,8 +17,10 @@ import type { User } from 'app-shared/types/Repository';
 import type { Organization } from 'app-shared/types/Organization';
 import { useSelectedContext } from 'dashboard/hooks/useSelectedContext';
 import { ResourcesRepoList } from 'dashboard/components/ResourcesRepoList/ResourcesRepoList';
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import { SafeErrorView } from '../../components/SafeErrorView';
+import { DASHBOARD_BASENAME } from 'app-shared/constants';
+import { useSubroute } from '../../hooks/useSubRoute';
 
 type DashboardProps = {
   user: User;
@@ -29,6 +31,7 @@ type DashboardProps = {
 export const Dashboard = ({ user, organizations, disableDebounce }: DashboardProps) => {
   const { t } = useTranslation();
   const selectedContext = useSelectedContext();
+  const subroute = useSubroute();
   const [searchText, setSearchText] = useState('');
   const [debouncedSearchText, setDebouncedSearchText] = useState('');
   const { debounce } = useDebounce({ debounceTimeInMs: disableDebounce ? 1 : 500 });
@@ -55,7 +58,10 @@ export const Dashboard = ({ user, organizations, disableDebounce }: DashboardPro
               onKeyDown={handleKeyDown}
               onClear={handleClearSearch}
             />
-            <Link href={'/dashboard/' + selectedContext + '/new'} className={classes.newLink}>
+            <Link
+              href={`${DASHBOARD_BASENAME}/${subroute}/${selectedContext}/new`}
+              className={classes.newLink}
+            >
               <span>{t('dashboard.new_service')}</span>
               <PlusCircleFillIcon className={classes.plusFillIcon} />
               <PlusCircleIcon className={classes.plusIcon} />
diff --git a/frontend/dashboard/pages/OrgContentLibrary/OrgContentLibrary.test.tsx b/frontend/dashboard/pages/OrgContentLibrary/OrgContentLibrary.test.tsx
new file mode 100644
index 00000000000..78cbfff8951
--- /dev/null
+++ b/frontend/dashboard/pages/OrgContentLibrary/OrgContentLibrary.test.tsx
@@ -0,0 +1,228 @@
+import React from 'react';
+import { OrgContentLibrary } from './OrgContentLibrary';
+import type { RenderResult } from '@testing-library/react';
+import { screen, waitFor } from '@testing-library/react';
+import { textMock } from '@studio/testing/mocks/i18nMock';
+import type { ProviderData } from '../../testing/mocks';
+import { renderWithProviders } from '../../testing/mocks';
+import userEvent, { type UserEvent } from '@testing-library/user-event';
+import type { QueryClient } from '@tanstack/react-query';
+import { createQueryClientMock } from 'app-shared/mocks/queryClientMock';
+import { QueryKey } from 'app-shared/types/QueryKey';
+import { org } from '@studio/testing/testids';
+import type { CodeListData } from '@studio/content-library';
+import type { CodeList } from '@studio/components';
+import { queriesMock } from 'app-shared/mocks/queriesMock';
+import { SelectedContextType } from '../../enums/SelectedContextType';
+import { Route, Routes } from 'react-router-dom';
+
+const updateCodeListButtonTextMock: string = 'Update Code List';
+const uploadCodeListButtonTextMock: string = 'Upload Code List';
+const deleteCodeListButtonTextMock: string = 'Delete Code List';
+const codeListNameMock: string = 'codeListNameMock';
+const codeListMock: CodeList = [{ value: '', label: '' }];
+const codeListsDataMock: CodeListData[] = [{ title: codeListNameMock, data: codeListMock }];
+const mockOrgPath: string = '/testOrg';
+
+jest.mock(
+  '../../../libs/studio-content-library/src/ContentLibrary/LibraryBody/pages/CodeListPage',
+  () => ({
+    CodeListPage: ({ onDeleteCodeList, onUpdateCodeList, onUploadCodeList }: any) => (
+      <div>
+        <button
+          onClick={() => onUpdateCodeList({ title: codeListNameMock, codeList: codeListMock })}
+        >
+          {updateCodeListButtonTextMock}
+        </button>
+        <button
+          onClick={() =>
+            onUploadCodeList(
+              new File(['test'], `${codeListNameMock}.json`, { type: 'application/json' }),
+            )
+          }
+        >
+          {uploadCodeListButtonTextMock}
+        </button>
+        <button onClick={() => onDeleteCodeList(codeListsDataMock[0].title)}>
+          {deleteCodeListButtonTextMock}
+        </button>
+      </div>
+    ),
+  }),
+);
+
+jest.mock('react-router-dom', () => jest.requireActual('react-router-dom')); // Todo: Remove this when we have removed the global mock: https://github.com/Altinn/altinn-studio/issues/14597
+
+describe('OrgContentLibrary', () => {
+  afterEach(jest.clearAllMocks);
+
+  it('renders a spinner when waiting for code lists', () => {
+    renderOrgContentLibrary({ initialEntries: [mockOrgPath] });
+    const spinner = screen.getByText(textMock('general.loading'));
+    expect(spinner).toBeInTheDocument();
+  });
+
+  it('Renders an error message when the code lists query fails', async () => {
+    const getCodeListsForOrg = () => Promise.reject(new Error('Test error'));
+    renderOrgContentLibrary({
+      queries: { getCodeListsForOrg },
+      queryClient: createQueryClientMock(),
+      initialEntries: [mockOrgPath],
+    });
+    await waitFor(expect(screen.queryByText(textMock('general.loading'))).not.toBeInTheDocument);
+    const errorMessage = screen.getByText(textMock('dashboard.org_library.fetch_error'));
+    expect(errorMessage).toBeInTheDocument();
+  });
+
+  it.each([SelectedContextType.None, SelectedContextType.All, SelectedContextType.Self])(
+    'renders alert and omits library content when context is %s',
+    (selectedContext) => {
+      renderOrgContentLibrary({ initialEntries: ['/' + selectedContext] });
+
+      const noOrgSelectedParagraph = screen.getByText(
+        textMock('dashboard.org_library.alert_no_org_selected'),
+      );
+      expect(noOrgSelectedParagraph).toBeInTheDocument();
+
+      const libraryTitle = screen.queryByRole('heading', {
+        name: textMock('app_content_library.library_heading'),
+      });
+      expect(libraryTitle).not.toBeInTheDocument();
+    },
+  );
+
+  it('renders the library title', async () => {
+    renderOrgContentLibrary({ initialEntries: ['/some-org'] });
+    await waitFor(expect(screen.queryByText(textMock('general.loading'))).not.toBeInTheDocument);
+    const libraryTitle = screen.getByRole('heading', {
+      name: textMock('app_content_library.library_heading'),
+    });
+    expect(libraryTitle).toBeInTheDocument();
+  });
+
+  it('renders the library landing page by default', () => {
+    renderOrgContentLibrary({ initialEntries: ['/some-org'] });
+    const landingPageTitle = screen.getByRole('heading', {
+      name: textMock('app_content_library.landing_page.title'),
+    });
+    expect(landingPageTitle).toBeInTheDocument();
+    const landingPageDescription = screen.getByText(
+      textMock('app_content_library.landing_page.description'),
+    );
+    expect(landingPageDescription).toBeInTheDocument();
+  });
+
+  it('renders the code list menu element', () => {
+    renderOrgContentLibrary({ initialEntries: ['/some-org'] });
+    const codeListMenuElement = screen.getByRole('tab', {
+      name: textMock('app_content_library.code_lists.page_name'),
+    });
+    expect(codeListMenuElement).toBeInTheDocument();
+  });
+
+  it('calls onUpdateCodeList when onUpdateCodeList is triggered', async () => {
+    const user = userEvent.setup();
+    renderOrgContentLibraryWithCodeLists({ initialEntries: [mockOrgPath] });
+    await goToLibraryPage(user, 'code_lists');
+    const updateCodeListButton = screen.getByRole('button', { name: updateCodeListButtonTextMock });
+    await user.click(updateCodeListButton);
+    expect(queriesMock.updateCodeListForOrg).toHaveBeenCalledTimes(1);
+    expect(queriesMock.updateCodeListForOrg).toHaveBeenCalledWith(
+      org,
+      codeListNameMock,
+      codeListMock,
+    );
+  });
+
+  it('calls onUploadCodeList when onUploadCodeList is triggered', async () => {
+    const user = userEvent.setup();
+    renderOrgContentLibraryWithCodeLists({ initialEntries: [mockOrgPath] });
+    await goToLibraryPage(user, 'code_lists');
+    const uploadCodeListButton = screen.getByRole('button', { name: uploadCodeListButtonTextMock });
+    await user.click(uploadCodeListButton);
+    expect(queriesMock.uploadCodeListForOrg).toHaveBeenCalledTimes(1);
+    expect(queriesMock.uploadCodeListForOrg).toHaveBeenCalledWith(org, expect.any(FormData));
+  });
+
+  it('renders success toast when onUploadCodeList is called successfully', async () => {
+    const user = userEvent.setup();
+    renderOrgContentLibraryWithCodeLists({ initialEntries: [mockOrgPath] });
+    await goToLibraryPage(user, 'code_lists');
+    const uploadCodeListButton = screen.getByRole('button', { name: uploadCodeListButtonTextMock });
+    await user.click(uploadCodeListButton);
+    const successToastMessage = screen.getByText(
+      textMock('dashboard.org_library.code_list_upload_success'),
+    );
+    expect(successToastMessage).toBeInTheDocument();
+  });
+
+  it('renders error toast when onUploadCodeList is rejected with unknown error code', async () => {
+    const user = userEvent.setup();
+    const uploadCodeListForOrg = jest
+      .fn()
+      .mockImplementation(() => Promise.reject({ response: {} }));
+    renderOrgContentLibraryWithCodeLists({
+      initialEntries: [mockOrgPath],
+      queries: { uploadCodeListForOrg },
+    });
+    await goToLibraryPage(user, 'code_lists');
+    const uploadCodeListButton = screen.getByRole('button', { name: uploadCodeListButtonTextMock });
+    await user.click(uploadCodeListButton);
+    const errorToastMessage = screen.getByText(
+      textMock('dashboard.org_library.code_list_upload_generic_error'),
+    );
+    expect(errorToastMessage).toBeInTheDocument();
+  });
+
+  it('calls onUploadCodeList and hides default error when handleUpload is triggered', async () => {
+    const user = userEvent.setup();
+    renderOrgContentLibraryWithCodeLists({ initialEntries: [mockOrgPath] });
+    await goToLibraryPage(user, 'code_lists');
+    const uploadCodeListButton = screen.getByRole('button', { name: uploadCodeListButtonTextMock });
+    await user.click(uploadCodeListButton);
+    expect(queriesMock.uploadCodeListForOrg).toHaveBeenCalledTimes(1);
+    expect(queriesMock.uploadCodeListForOrg).toHaveBeenCalledWith(org, expect.any(FormData));
+    const hideDefaultError = screen.queryByText(textMock('dashboard.org_library.default_error'));
+    expect(hideDefaultError).not.toBeInTheDocument();
+  });
+
+  it('calls deleteCodeListForOrg when onDeleteCodeList is triggered', async () => {
+    const user = userEvent.setup();
+    renderOrgContentLibraryWithCodeLists({ initialEntries: ['/testOrg'] });
+    await goToLibraryPage(user, 'code_lists');
+    const deleteCodeListButton = screen.getByRole('button', { name: deleteCodeListButtonTextMock });
+    await user.click(deleteCodeListButton);
+    expect(queriesMock.deleteCodeListForOrg).toHaveBeenCalledTimes(1);
+    expect(queriesMock.deleteCodeListForOrg).toHaveBeenCalledWith(org, codeListsDataMock[0].title);
+  });
+});
+
+const getLibraryPageTile = (libraryPage: string) =>
+  screen.getByText(textMock(`app_content_library.${libraryPage}.page_name`));
+
+const goToLibraryPage = async (user: UserEvent, libraryPage: string) => {
+  const libraryPageNavTile = getLibraryPageTile(libraryPage);
+  await user.click(libraryPageNavTile);
+};
+
+function renderOrgContentLibrary(providerData: ProviderData): RenderResult {
+  return renderWithProviders(
+    <Routes>
+      <Route path=':selectedContext' element={<OrgContentLibrary />} />
+    </Routes>,
+    providerData,
+  );
+}
+
+function renderOrgContentLibraryWithCodeLists(providerData: ProviderData): void {
+  const queryClient = createQueryClientWithOptionsDataList(codeListsDataMock);
+  renderOrgContentLibrary({ ...providerData, queryClient });
+}
+
+function createQueryClientWithOptionsDataList(
+  codeListDataList: CodeListData[] | undefined,
+): QueryClient {
+  const queryClient = createQueryClientMock();
+  queryClient.setQueryData([QueryKey.OrgCodeLists, org], codeListDataList);
+  return queryClient;
+}
diff --git a/frontend/dashboard/pages/OrgContentLibrary/OrgContentLibrary.tsx b/frontend/dashboard/pages/OrgContentLibrary/OrgContentLibrary.tsx
new file mode 100644
index 00000000000..dc2f6fd39bb
--- /dev/null
+++ b/frontend/dashboard/pages/OrgContentLibrary/OrgContentLibrary.tsx
@@ -0,0 +1,120 @@
+import type { ReactElement } from 'react';
+import React, { useCallback } from 'react';
+import { ResourceContentLibraryImpl } from '@studio/content-library';
+import type { CodeListData, CodeListWithMetadata } from '@studio/content-library';
+import { useSelectedContext } from '../../hooks/useSelectedContext';
+import {
+  StudioAlert,
+  StudioCenter,
+  StudioParagraph,
+  StudioPageError,
+  StudioPageSpinner,
+} from '@studio/components';
+import { useUpdateOrgCodeListMutation } from 'app-shared/hooks/mutations/useUpdateOrgCodeListMutation';
+import { useTranslation } from 'react-i18next';
+import { isErrorUnknown } from 'app-shared/utils/ApiErrorUtils';
+import type { ApiError } from 'app-shared/types/api/ApiError';
+import { useUploadOrgCodeListMutation } from 'app-shared/hooks/mutations/useUploadOrgCodeListMutation';
+import { toast } from 'react-toastify';
+import type { AxiosError } from 'axios';
+import { useDeleteOrgCodeListMutation } from 'app-shared/hooks/mutations/useDeleteOrgCodeListMutation';
+import { isOrg } from './utils';
+import { useOrgCodeListsQuery } from 'app-shared/hooks/queries/useOrgCodeListsQuery';
+
+export function OrgContentLibrary(): ReactElement {
+  const selectedContext = useSelectedContext();
+
+  return isOrg(selectedContext) ? (
+    <OrgContentLibraryWithContext />
+  ) : (
+    <ContextWithoutLibraryAccess />
+  );
+}
+
+function OrgContentLibraryWithContext(): ReactElement {
+  const { t } = useTranslation();
+  const selectedContext = useSelectedContext();
+
+  const { data: codeListsResponse, status: codeListResponseStatus } =
+    useOrgCodeListsQuery(selectedContext);
+
+  switch (codeListResponseStatus) {
+    case 'pending':
+      return <StudioPageSpinner spinnerTitle={t('general.loading')} />;
+    case 'error':
+      return <StudioPageError message={t('dashboard.org_library.fetch_error')} />;
+    case 'success':
+      return <OrgContentLibraryWithContextAndData codeListsDataList={codeListsResponse} />;
+  }
+}
+
+type OrgContentLibraryWithContextAndDataProps = {
+  codeListsDataList: CodeListData[];
+};
+
+function OrgContentLibraryWithContextAndData({
+  codeListsDataList,
+}: OrgContentLibraryWithContextAndDataProps): ReactElement {
+  const selectedContext = useSelectedContext();
+
+  const { mutate: updateOptionList } = useUpdateOrgCodeListMutation(selectedContext);
+  const { mutate: deleteCodeList } = useDeleteOrgCodeListMutation(selectedContext);
+
+  const handleUpload = useUploadCodeList(selectedContext);
+
+  const handleUpdate = ({ title, codeList }: CodeListWithMetadata): void => {
+    updateOptionList({ title, data: codeList });
+  };
+
+  const { getContentResourceLibrary } = new ResourceContentLibraryImpl({
+    pages: {
+      codeList: {
+        props: {
+          codeListsData: codeListsDataList,
+          onDeleteCodeList: deleteCodeList,
+          onUpdateCodeListId: () => {},
+          onUpdateCodeList: handleUpdate,
+          onUploadCodeList: handleUpload,
+        },
+      },
+    },
+  });
+
+  return <div>{getContentResourceLibrary()}</div>;
+}
+
+function ContextWithoutLibraryAccess(): ReactElement {
+  const { t } = useTranslation();
+  return (
+    <StudioCenter>
+      <StudioAlert>
+        <StudioParagraph>{t('dashboard.org_library.alert_no_org_selected')}</StudioParagraph>
+        <StudioParagraph>
+          {t('dashboard.org_library.alert_no_org_selected_no_access')}
+        </StudioParagraph>
+      </StudioAlert>
+    </StudioCenter>
+  );
+}
+
+function useUploadCodeList(org: string): (file: File) => void {
+  const { mutate: uploadCodeList } = useUploadOrgCodeListMutation(org, {
+    hideDefaultError: (error: AxiosError<ApiError>) => isErrorUnknown(error),
+  });
+  const { t } = useTranslation();
+
+  return useCallback(
+    (file: File) =>
+      uploadCodeList(file, {
+        onSuccess: () => {
+          toast.success(t('dashboard.org_library.code_list_upload_success'));
+        },
+        onError: (error: AxiosError<ApiError>) => {
+          if (isErrorUnknown(error)) {
+            toast.error(t('dashboard.org_library.code_list_upload_generic_error'));
+          }
+        },
+      }),
+    [uploadCodeList, t],
+  );
+}
diff --git a/frontend/dashboard/pages/OrgContentLibrary/index.ts b/frontend/dashboard/pages/OrgContentLibrary/index.ts
new file mode 100644
index 00000000000..c3425656352
--- /dev/null
+++ b/frontend/dashboard/pages/OrgContentLibrary/index.ts
@@ -0,0 +1 @@
+export * from './OrgContentLibrary';
diff --git a/frontend/dashboard/pages/OrgContentLibrary/utils.test.ts b/frontend/dashboard/pages/OrgContentLibrary/utils.test.ts
new file mode 100644
index 00000000000..a2145dd9df2
--- /dev/null
+++ b/frontend/dashboard/pages/OrgContentLibrary/utils.test.ts
@@ -0,0 +1,17 @@
+import { isOrg } from './utils';
+import { SelectedContextType } from '../../enums/SelectedContextType';
+
+describe('utils', () => {
+  describe('isOrg', () => {
+    it('Returns true when the input is not a reserved keyword', () => {
+      expect(isOrg('organisation')).toBe(true);
+    });
+
+    it.each([SelectedContextType.Self, SelectedContextType.All, SelectedContextType.None])(
+      'Returns false when the input is %s',
+      (contextType) => {
+        expect(isOrg(contextType)).toBe(false);
+      },
+    );
+  });
+});
diff --git a/frontend/dashboard/pages/OrgContentLibrary/utils.ts b/frontend/dashboard/pages/OrgContentLibrary/utils.ts
new file mode 100644
index 00000000000..9863a9c633a
--- /dev/null
+++ b/frontend/dashboard/pages/OrgContentLibrary/utils.ts
@@ -0,0 +1,10 @@
+import { SelectedContextType } from '../../enums/SelectedContextType';
+
+export function isOrg(contextType: string): boolean {
+  const notOrgContexts: string[] = [
+    SelectedContextType.Self,
+    SelectedContextType.All,
+    SelectedContextType.None,
+  ];
+  return !notOrgContexts.includes(contextType);
+}
diff --git a/frontend/dashboard/pages/PageLayout/DashboardHeader/DashboardHeader.module.css b/frontend/dashboard/pages/PageLayout/DashboardHeader/DashboardHeader.module.css
new file mode 100644
index 00000000000..13dd0977628
--- /dev/null
+++ b/frontend/dashboard/pages/PageLayout/DashboardHeader/DashboardHeader.module.css
@@ -0,0 +1,3 @@
+.active {
+  border-bottom: 2px solid var(--fds-semantic-surface-neutral-default);
+}
diff --git a/frontend/dashboard/pages/PageLayout/DashboardHeader/DashboardHeader.test.tsx b/frontend/dashboard/pages/PageLayout/DashboardHeader/DashboardHeader.test.tsx
index e0ad60ee309..21c9d6c3a40 100644
--- a/frontend/dashboard/pages/PageLayout/DashboardHeader/DashboardHeader.test.tsx
+++ b/frontend/dashboard/pages/PageLayout/DashboardHeader/DashboardHeader.test.tsx
@@ -2,19 +2,23 @@ import React from 'react';
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { DashboardHeader } from './DashboardHeader';
-import { HeaderContext, SelectedContextType } from 'dashboard/context/HeaderContext';
+import { Subroute } from '../../../enums/Subroute';
+import { HeaderContext } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../../enums/SelectedContextType';
 import { useParams } from 'react-router-dom';
 import { textMock } from '@studio/testing/mocks/i18nMock';
 import { type User } from 'app-shared/types/Repository';
 import { type Organization } from 'app-shared/types/Organization';
 import { type HeaderContextType } from 'dashboard/context/HeaderContext';
 import { MockServicesContextWrapper } from 'dashboard/dashboardTestUtils';
+import { typedLocalStorage } from '@studio/pure-functions';
+import { FeatureFlag } from 'app-shared/utils/featureToggleUtils';
 
 const mockNavigate = jest.fn();
 jest.mock('react-router-dom', () => ({
   ...jest.requireActual('react-router-dom'),
   useNavigate: () => mockNavigate,
-  useParams: jest.fn(),
+  useParams: jest.fn().mockReturnValue({ subroute: 'app-dashboard', selectedContext: 'self' }),
 }));
 
 const userMock: User = {
@@ -41,9 +45,7 @@ const mockOrg2: Organization = {
 const mockOrganizations: Organization[] = [mockOrg1, mockOrg2];
 
 describe('DashboardHeader', () => {
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
+  afterEach(jest.clearAllMocks);
 
   it('should render the user name as the profile button when in self context', () => {
     (useParams as jest.Mock).mockReturnValue({
@@ -104,10 +106,67 @@ describe('DashboardHeader', () => {
     expect(logoutItem).toBeInTheDocument();
   });
 
+  it('should render correct menu elements in header', () => {
+    typedLocalStorage.setItem('featureFlags', [FeatureFlag.OrgLibrary]);
+    renderDashboardHeader();
+    const libraryMenuItem = screen.getByRole('link', {
+      name: textMock('dashboard.header_item_library'),
+    });
+    expect(libraryMenuItem).toBeInTheDocument();
+    const appsMenuItem = screen.getByRole('link', {
+      name: textMock('dashboard.header_item_dashboard'),
+    });
+    expect(appsMenuItem).toBeInTheDocument();
+    typedLocalStorage.removeItem('featureFlags');
+  });
+
+  it('should render library menu element with correct link', () => {
+    typedLocalStorage.setItem('featureFlags', FeatureFlag.OrgLibrary);
+    renderDashboardHeader();
+    const libraryMenuItem = screen.getByRole('link', {
+      name: textMock('dashboard.header_item_library'),
+    });
+    expect(libraryMenuItem).toHaveAttribute(
+      'href',
+      `${Subroute.OrgLibrary}/${SelectedContextType.Self}`,
+    );
+    typedLocalStorage.removeItem('featureFlags');
+  });
+
+  it('should not render library menu element when featureFlag is not turned on', () => {
+    renderDashboardHeader();
+    const libraryMenuItem = screen.queryByRole('link', {
+      name: textMock('dashboard.header_item_library'),
+    });
+    expect(libraryMenuItem).not.toBeInTheDocument();
+  });
+
+  it('should not render dashboard menu element when featureFlag is not turned on', () => {
+    renderDashboardHeader();
+    const dashboardMenuItem = screen.queryByRole('link', {
+      name: textMock('dashboard.header_item_dashboard'),
+    });
+    expect(dashboardMenuItem).not.toBeInTheDocument();
+  });
+
+  it('should render apps menu element with correct link', () => {
+    typedLocalStorage.setItem('featureFlags', FeatureFlag.OrgLibrary);
+    renderDashboardHeader();
+    const appsMenuItem = screen.getByRole('link', {
+      name: textMock('dashboard.header_item_dashboard'),
+    });
+    expect(appsMenuItem).toHaveAttribute(
+      'href',
+      `${Subroute.AppDashboard}/${SelectedContextType.Self}`,
+    );
+    typedLocalStorage.removeItem('featureFlags');
+  });
+
   it('should navigate to the correct organization context when an org is selected', async () => {
     const user = userEvent.setup();
     (useParams as jest.Mock).mockReturnValue({
       selectedContext: SelectedContextType.Self,
+      subroute: Subroute.AppDashboard,
     });
 
     renderDashboardHeader();
@@ -118,7 +177,7 @@ describe('DashboardHeader', () => {
     const org1Item = screen.getByRole('menuitemradio', { name: mockOrg1.full_name });
     await user.click(org1Item);
 
-    expect(mockNavigate).toHaveBeenCalledWith(`/${mockOrg1.username}`);
+    expect(mockNavigate).toHaveBeenCalledWith(`${Subroute.AppDashboard}/${mockOrg1.username}`);
     expect(mockNavigate).toHaveBeenCalledTimes(1);
   });
 
@@ -126,6 +185,7 @@ describe('DashboardHeader', () => {
     const user = userEvent.setup();
     (useParams as jest.Mock).mockReturnValue({
       selectedContext: SelectedContextType.Self,
+      subroute: Subroute.AppDashboard,
     });
 
     renderDashboardHeader();
@@ -136,7 +196,9 @@ describe('DashboardHeader', () => {
     const allItem = screen.getByRole('menuitemradio', { name: textMock('shared.header_all') });
     await user.click(allItem);
 
-    expect(mockNavigate).toHaveBeenCalledWith(`/${SelectedContextType.All}`);
+    expect(mockNavigate).toHaveBeenCalledWith(
+      `${Subroute.AppDashboard}/${SelectedContextType.All}`,
+    );
     expect(mockNavigate).toHaveBeenCalledTimes(1);
   });
 
@@ -144,6 +206,7 @@ describe('DashboardHeader', () => {
     const user = userEvent.setup();
     (useParams as jest.Mock).mockReturnValue({
       selectedContext: SelectedContextType.All,
+      subroute: Subroute.AppDashboard,
     });
 
     renderDashboardHeader();
@@ -154,7 +217,9 @@ describe('DashboardHeader', () => {
     const selfItem = screen.getByRole('menuitemradio', { name: userMock.full_name });
     await user.click(selfItem);
 
-    expect(mockNavigate).toHaveBeenCalledWith(`/${SelectedContextType.Self}`);
+    expect(mockNavigate).toHaveBeenCalledWith(
+      `${Subroute.AppDashboard}/${SelectedContextType.Self}`,
+    );
     expect(mockNavigate).toHaveBeenCalledTimes(1);
   });
 });
diff --git a/frontend/dashboard/pages/PageLayout/DashboardHeader/DashboardHeader.tsx b/frontend/dashboard/pages/PageLayout/DashboardHeader/DashboardHeader.tsx
index a879ec30db8..857334c72a1 100644
--- a/frontend/dashboard/pages/PageLayout/DashboardHeader/DashboardHeader.tsx
+++ b/frontend/dashboard/pages/PageLayout/DashboardHeader/DashboardHeader.tsx
@@ -1,5 +1,7 @@
 import React, { useContext } from 'react';
-import { useNavigate } from 'react-router-dom';
+import classes from './DashboardHeader.module.css';
+import cn from 'classnames';
+import { NavLink, useLocation, useNavigate } from 'react-router-dom';
 import { useTranslation } from 'react-i18next';
 import {
   StudioAvatar,
@@ -11,11 +13,17 @@ import {
 import { useSelectedContext } from 'dashboard/hooks/useSelectedContext';
 import { type Organization } from 'app-shared/types/Organization';
 import { MEDIA_QUERY_MAX_WIDTH } from 'app-shared/constants';
-import { HeaderContext, SelectedContextType } from 'dashboard/context/HeaderContext';
+import { HeaderContext } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../../enums/SelectedContextType';
 import { useLogoutMutation } from 'app-shared/hooks/mutations/useLogoutMutation';
 import { useProfileMenuTriggerButtonText } from 'dashboard/hooks/useProfileMenuTriggerButtonText';
 import { useRepoPath } from 'dashboard/hooks/useRepoPath';
 import { usePageHeaderTitle } from 'dashboard/hooks/usePageHeaderTitle';
+import { useSubroute } from '../../../hooks/useSubRoute';
+import type { HeaderMenuItem } from '../../../types/HeaderMenuItem';
+import { dashboardHeaderMenuItems } from '../../../utils/headerUtils';
+import { StringUtils } from '@studio/pure-functions';
+import { FeatureFlag, shouldDisplayFeature } from 'app-shared/utils/featureToggleUtils';
 
 export const DashboardHeader = () => {
   const pageHeaderTitle: string = usePageHeaderTitle();
@@ -24,6 +32,12 @@ export const DashboardHeader = () => {
     <StudioPageHeader>
       <StudioPageHeader.Main>
         <StudioPageHeader.Left title={pageHeaderTitle} showTitle />
+        <StudioPageHeader.Center>
+          {shouldDisplayFeature(FeatureFlag.OrgLibrary) &&
+            dashboardHeaderMenuItems.map((menuItem: HeaderMenuItem) => (
+              <TopNavigationMenuItem key={menuItem.name} menuItem={menuItem} />
+            ))}
+        </StudioPageHeader.Center>
         <StudioPageHeader.Right>
           <DashboardHeaderMenu />
         </StudioPageHeader.Right>
@@ -32,10 +46,46 @@ export const DashboardHeader = () => {
   );
 };
 
+type TopNavigationMenuProps = {
+  menuItem: HeaderMenuItem;
+};
+
+function TopNavigationMenuItem({ menuItem }: TopNavigationMenuProps): React.ReactElement {
+  const selectedContext: string = useSelectedContext();
+  const { t } = useTranslation();
+  const location = useLocation();
+  const path: string = `${menuItem.link}/${selectedContext}`;
+  const currentRoutePath: string = extractSecondLastRouterParam(location.pathname);
+
+  return (
+    <StudioPageHeader.HeaderLink
+      color='dark'
+      variant='regular'
+      renderLink={(props) => (
+        <NavLink to={path} {...props}>
+          <span
+            className={cn({
+              [classes.active]: StringUtils.removeLeadingSlash(menuItem.link) === currentRoutePath,
+            })}
+          >
+            {t(menuItem.name)}
+          </span>
+        </NavLink>
+      )}
+    />
+  );
+}
+
+function extractSecondLastRouterParam(pathname: string): string {
+  const pathnameArray = pathname.split('/');
+  return pathnameArray[pathnameArray.length - 2];
+}
+
 const DashboardHeaderMenu = () => {
   const { t } = useTranslation();
   const showButtonText = !useMediaQuery(MEDIA_QUERY_MAX_WIDTH);
   const selectedContext = useSelectedContext();
+  const subroute = useSubroute();
   const { mutate: logout } = useLogoutMutation();
   const { user, selectableOrgs } = useContext(HeaderContext);
   const navigate = useNavigate();
@@ -44,7 +94,7 @@ const DashboardHeaderMenu = () => {
   const repoPath = useRepoPath();
 
   const handleSetSelectedContext = (context: string | SelectedContextType) => {
-    navigate('/' + context + location.search);
+    navigate(`${subroute}/${context}${location.search}`);
   };
 
   const allMenuItem: StudioProfileMenuItem = {
@@ -83,7 +133,7 @@ const DashboardHeaderMenu = () => {
 
   return (
     <StudioPageHeader.ProfileMenu
-      triggerButtonText={showButtonText && triggerButtonText}
+      triggerButtonText={showButtonText ? triggerButtonText : undefined}
       ariaLabelTriggerButton={triggerButtonText}
       color='dark'
       variant='regular'
diff --git a/frontend/dashboard/pages/PageLayout/PageLayout.test.tsx b/frontend/dashboard/pages/PageLayout/PageLayout.test.tsx
index 763b0ea5d87..f6ab4c5cfd7 100644
--- a/frontend/dashboard/pages/PageLayout/PageLayout.test.tsx
+++ b/frontend/dashboard/pages/PageLayout/PageLayout.test.tsx
@@ -7,7 +7,9 @@ import { PageLayout } from './PageLayout';
 import { createQueryClientMock } from 'app-shared/mocks/queryClientMock';
 import { QueryKey } from 'app-shared/types/QueryKey';
 import { useParams } from 'react-router-dom';
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { Subroute } from '../../enums/Subroute';
+import { SelectedContextType } from '../../enums/SelectedContextType';
+import { StringUtils } from '@studio/pure-functions';
 
 const mockedNavigate = jest.fn();
 jest.mock('react-router-dom', () => ({
@@ -72,13 +74,19 @@ describe('PageLayout', () => {
     });
     renderWithMockServices();
     expect(mockedNavigate).toHaveBeenCalledTimes(1);
-    expect(mockedNavigate).toHaveBeenCalledWith(SelectedContextType.Self, expect.anything());
+    expect(mockedNavigate).toHaveBeenCalledWith(
+      `${StringUtils.removeLeadingSlash(Subroute.AppDashboard)}/${SelectedContextType.Self}`,
+      expect.anything(),
+    );
   });
 
   it('should redirect to self context if none is defined', async () => {
     renderWithMockServices();
     expect(mockedNavigate).toHaveBeenCalledTimes(1);
-    expect(mockedNavigate).toHaveBeenCalledWith(SelectedContextType.Self, expect.anything());
+    expect(mockedNavigate).toHaveBeenCalledWith(
+      `${StringUtils.removeLeadingSlash(Subroute.AppDashboard)}/${SelectedContextType.Self}`,
+      expect.anything(),
+    );
   });
 
   it.each([['self', 'all', 'ttd']])(
@@ -89,7 +97,10 @@ describe('PageLayout', () => {
       });
       sessionStorage.setItem('dashboard::selectedContext', `"${context}"`);
       renderWithMockServices();
-      expect(mockedNavigate).toHaveBeenCalledWith(context, expect.anything());
+      expect(mockedNavigate).toHaveBeenCalledWith(
+        `${StringUtils.removeLeadingSlash(Subroute.AppDashboard)}/${context}`,
+        expect.anything(),
+      );
     },
   );
 
@@ -98,6 +109,9 @@ describe('PageLayout', () => {
     sessionStorage.setItem('dashboard::selectedContext', '"testinvalidcontext"');
     renderWithMockServices();
     expect(mockedNavigate).toHaveBeenCalledTimes(1);
-    expect(mockedNavigate).toHaveBeenCalledWith(SelectedContextType.Self, expect.anything());
+    expect(mockedNavigate).toHaveBeenCalledWith(
+      `${StringUtils.removeLeadingSlash(Subroute.AppDashboard)}/${SelectedContextType.Self}`,
+      expect.anything(),
+    );
   });
 });
diff --git a/frontend/dashboard/testing/mocks.tsx b/frontend/dashboard/testing/mocks.tsx
index 0acf1ad9c5f..c77569cb027 100644
--- a/frontend/dashboard/testing/mocks.tsx
+++ b/frontend/dashboard/testing/mocks.tsx
@@ -3,6 +3,7 @@ import type { Queries, RenderHookOptions, RenderOptions } from '@testing-library
 import { render, renderHook } from '@testing-library/react';
 import React from 'react';
 import type { ReactNode } from 'react';
+import type { MemoryRouterProps } from 'react-router-dom';
 import { MemoryRouter } from 'react-router-dom';
 import {
   type ServicesContextProps,
@@ -14,34 +15,33 @@ import type { QueryClient } from '@tanstack/react-query';
 type WrapperArgs = {
   queries: Partial<ServicesContextProps>;
   queryClient: QueryClient;
-};
+} & Pick<MemoryRouterProps, 'initialEntries'>;
 
 const wrapper =
-  ({ queries = {}, queryClient = queryClientMock }: WrapperArgs) =>
+  ({ queries = {}, queryClient = queryClientMock, initialEntries }: WrapperArgs) =>
   // eslint-disable-next-line react/display-name
   (component: ReactNode) => (
-    <MemoryRouter>
+    <MemoryRouter initialEntries={initialEntries}>
       <ServicesContextProvider {...queriesMock} {...queries} client={queryClient}>
         {component}
       </ServicesContextProvider>
     </MemoryRouter>
   );
 
-export interface ProviderData {
-  queries?: Partial<ServicesContextProps>;
-  queryClient?: QueryClient;
+export interface ProviderData extends Partial<WrapperArgs> {
   externalWrapper?: (children: ReactNode) => ReactNode;
 }
 
 export function renderWithProviders(
   component: ReactNode,
-  { queries = {}, queryClient = queryClientMock }: ProviderData = {},
+  { queries = {}, queryClient = queryClientMock, initialEntries }: ProviderData = {},
 ) {
   const renderOptions: RenderOptions = {
     wrapper: ({ children }) =>
       wrapper({
         queries,
         queryClient,
+        initialEntries,
       })(children),
   };
   return render(component, renderOptions);
@@ -53,6 +53,7 @@ export function renderHookWithProviders<HookResult, Props>(
     queries = {},
     queryClient = queryClientMock,
     externalWrapper = (children) => children,
+    initialEntries,
   }: ProviderData = {},
 ) {
   const renderHookOptions: RenderHookOptions<Props, Queries> = {
@@ -61,6 +62,7 @@ export function renderHookWithProviders<HookResult, Props>(
         wrapper({
           queries,
           queryClient,
+          initialEntries,
         })(children),
       ),
   };
diff --git a/frontend/dashboard/types/HeaderMenuItem.ts b/frontend/dashboard/types/HeaderMenuItem.ts
new file mode 100644
index 00000000000..a7a5a9e9127
--- /dev/null
+++ b/frontend/dashboard/types/HeaderMenuItem.ts
@@ -0,0 +1,7 @@
+import type { HeaderMenuItemKey } from '../enums/HeaderMenuItemKey';
+
+export type HeaderMenuItem = {
+  key: HeaderMenuItemKey;
+  link: string;
+  name: string;
+};
diff --git a/frontend/dashboard/utils/filterUtils/filterUtils.test.ts b/frontend/dashboard/utils/filterUtils/filterUtils.test.ts
index bf51902f1fe..341dc5f090f 100644
--- a/frontend/dashboard/utils/filterUtils/filterUtils.test.ts
+++ b/frontend/dashboard/utils/filterUtils/filterUtils.test.ts
@@ -1,4 +1,4 @@
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import { getUidFilter } from './filterUtils';
 
 describe('getUidFilter', () => {
diff --git a/frontend/dashboard/utils/filterUtils/filterUtils.ts b/frontend/dashboard/utils/filterUtils/filterUtils.ts
index 45c450409b7..4d10b659ac9 100644
--- a/frontend/dashboard/utils/filterUtils/filterUtils.ts
+++ b/frontend/dashboard/utils/filterUtils/filterUtils.ts
@@ -1,4 +1,4 @@
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import type { Organization } from 'app-shared/types/Organization';
 
 type GetUidFilter = {
diff --git a/frontend/dashboard/utils/headerUtils/headerUtils.ts b/frontend/dashboard/utils/headerUtils/headerUtils.ts
new file mode 100644
index 00000000000..e5bb1a11844
--- /dev/null
+++ b/frontend/dashboard/utils/headerUtils/headerUtils.ts
@@ -0,0 +1,16 @@
+import type { HeaderMenuItem } from '../../types/HeaderMenuItem';
+import { Subroute } from '../../enums/Subroute';
+import { HeaderMenuItemKey } from '../../enums/HeaderMenuItemKey';
+
+export const dashboardHeaderMenuItems: HeaderMenuItem[] = [
+  {
+    key: HeaderMenuItemKey.OrgLibrary,
+    link: Subroute.OrgLibrary,
+    name: 'dashboard.header_item_library',
+  },
+  {
+    key: HeaderMenuItemKey.AppDashboard,
+    link: Subroute.AppDashboard,
+    name: 'dashboard.header_item_dashboard',
+  },
+];
diff --git a/frontend/dashboard/utils/headerUtils/index.ts b/frontend/dashboard/utils/headerUtils/index.ts
new file mode 100644
index 00000000000..df8a8b8be5d
--- /dev/null
+++ b/frontend/dashboard/utils/headerUtils/index.ts
@@ -0,0 +1 @@
+export { dashboardHeaderMenuItems } from './headerUtils';
diff --git a/frontend/dashboard/utils/repoUtils/repoUtils.test.ts b/frontend/dashboard/utils/repoUtils/repoUtils.test.ts
index 3aae54e5c72..f0cc2d89d3f 100644
--- a/frontend/dashboard/utils/repoUtils/repoUtils.test.ts
+++ b/frontend/dashboard/utils/repoUtils/repoUtils.test.ts
@@ -1,4 +1,4 @@
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import { getReposLabel, validateRepoName } from './repoUtils';
 import { textMock } from '@studio/testing/mocks/i18nMock';
 import type { Organization } from 'app-shared/types/Organization';
diff --git a/frontend/dashboard/utils/repoUtils/repoUtils.ts b/frontend/dashboard/utils/repoUtils/repoUtils.ts
index 11d5f848e03..21104e24e46 100644
--- a/frontend/dashboard/utils/repoUtils/repoUtils.ts
+++ b/frontend/dashboard/utils/repoUtils/repoUtils.ts
@@ -1,4 +1,4 @@
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import type { Repository } from 'app-shared/types/Repository';
 import type { Organization } from 'app-shared/types/Organization';
 import type i18next from 'i18next';
diff --git a/frontend/dashboard/utils/userUtils/userUtils.test.ts b/frontend/dashboard/utils/userUtils/userUtils.test.ts
index 17b11351898..083af243687 100644
--- a/frontend/dashboard/utils/userUtils/userUtils.test.ts
+++ b/frontend/dashboard/utils/userUtils/userUtils.test.ts
@@ -1,4 +1,4 @@
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import {
   getOrgNameByUsername,
   getOrgUsernameByUsername,
diff --git a/frontend/dashboard/utils/userUtils/userUtils.ts b/frontend/dashboard/utils/userUtils/userUtils.ts
index 4e5e8085f89..8a25189d79a 100644
--- a/frontend/dashboard/utils/userUtils/userUtils.ts
+++ b/frontend/dashboard/utils/userUtils/userUtils.ts
@@ -1,4 +1,4 @@
-import { SelectedContextType } from 'dashboard/context/HeaderContext';
+import { SelectedContextType } from '../../enums/SelectedContextType';
 import type { Organization } from 'app-shared/types/Organization';
 
 export const userHasAccessToSelectedContext = ({
diff --git a/frontend/language/src/nb.json b/frontend/language/src/nb.json
index f7fdad2be41..ae948dc6a32 100644
--- a/frontend/language/src/nb.json
+++ b/frontend/language/src/nb.json
@@ -226,6 +226,8 @@
   "dashboard.favourites": "Favoritter",
   "dashboard.field_cannot_be_empty": "Dette feltet kan ikke være tomt",
   "dashboard.go_to_resources": "Gå til ressurser-dashboard",
+  "dashboard.header_item_dashboard": "Dashbord",
+  "dashboard.header_item_library": "Bibliotek",
   "dashboard.last_modified": "Sist endret",
   "dashboard.loading": "Laster inn dashboardet",
   "dashboard.loading_resource_list": "Laster inn ressursliste",
@@ -241,6 +243,10 @@
   "dashboard.open_repository": "Åpne repository",
   "dashboard.org_apps": "{{orgName}}s apper",
   "dashboard.org_data_models": "{{orgName}}s datamodeller",
+  "dashboard.org_library.alert_no_org_selected": "For å vise biblioteket, må du velge en organisasjon i menyen øverst til høyre.",
+  "dashboard.org_library.alert_no_org_selected_no_access": "Hvis du ikke har tilgang til noen organisasjoner, må du be om tilgang fra en tjenesteeier.",
+  "dashboard.org_library.code_list_upload_success": "Filen ble lastet opp.",
+  "dashboard.org_library.fetch_error": "Det har oppstått et problem ved henting av data til biblioteket.",
   "dashboard.org_resources": "{{orgName}}s ressurser",
   "dashboard.resource_contact_description": "Se oversikt over hvordan du kommer i kontakt med oss i Altinn Studio.",
   "dashboard.resource_contact_label": "Kontakt oss",
diff --git a/frontend/libs/studio-content-library/src/ContentLibrary/LibraryBody/pages/CodeListPage/CodeListPage.tsx b/frontend/libs/studio-content-library/src/ContentLibrary/LibraryBody/pages/CodeListPage/CodeListPage.tsx
index c89dc35262b..ba3424c589c 100644
--- a/frontend/libs/studio-content-library/src/ContentLibrary/LibraryBody/pages/CodeListPage/CodeListPage.tsx
+++ b/frontend/libs/studio-content-library/src/ContentLibrary/LibraryBody/pages/CodeListPage/CodeListPage.tsx
@@ -34,7 +34,7 @@ export type CodeListPageProps = {
   onUpdateCodeList: (updatedCodeList: CodeListWithMetadata) => void;
   onUpdateTextResource?: (textResource: TextResourceWithLanguage) => void;
   onUploadCodeList: (uploadedCodeList: File) => void;
-  codeListsUsages: CodeListReference[];
+  codeListsUsages?: CodeListReference[];
   textResources?: TextResources;
 };
 
diff --git a/frontend/libs/studio-content-library/src/ContentLibrary/LibraryBody/pages/CodeListPage/utils/utils.test.ts b/frontend/libs/studio-content-library/src/ContentLibrary/LibraryBody/pages/CodeListPage/utils/utils.test.ts
index ef52cb45fa7..f1359bebd35 100644
--- a/frontend/libs/studio-content-library/src/ContentLibrary/LibraryBody/pages/CodeListPage/utils/utils.test.ts
+++ b/frontend/libs/studio-content-library/src/ContentLibrary/LibraryBody/pages/CodeListPage/utils/utils.test.ts
@@ -50,6 +50,11 @@ describe('utils', () => {
       const codeListSources = getCodeListSourcesById([], codeListId1);
       expect(codeListSources).toEqual([]);
     });
+
+    it('returns an empty array if codeListUsages and codeListTitle are undefined', () => {
+      const codeListSources = getCodeListSourcesById(undefined, undefined);
+      expect(codeListSources).toEqual([]);
+    });
   });
 
   describe('getCodeListUsageCount', () => {
diff --git a/frontend/libs/studio-content-library/src/ContentLibrary/LibraryBody/pages/CodeListPage/utils/utils.ts b/frontend/libs/studio-content-library/src/ContentLibrary/LibraryBody/pages/CodeListPage/utils/utils.ts
index c57a51aa619..51b18ae35fb 100644
--- a/frontend/libs/studio-content-library/src/ContentLibrary/LibraryBody/pages/CodeListPage/utils/utils.ts
+++ b/frontend/libs/studio-content-library/src/ContentLibrary/LibraryBody/pages/CodeListPage/utils/utils.ts
@@ -5,10 +5,10 @@ import type { TextResource } from '@studio/components';
 import type { TextResourceWithLanguage } from '../../../../../types/TextResourceWithLanguage';
 
 export const getCodeListSourcesById = (
-  codeListsUsages: CodeListReference[],
+  codeListsUsages: CodeListReference[] | undefined,
   codeListTitle: string,
 ): CodeListIdSource[] => {
-  const codeListUsages: CodeListReference | undefined = codeListsUsages.find(
+  const codeListUsages: CodeListReference | undefined = codeListsUsages?.find(
     (codeListUsage) => codeListUsage.codeListId === codeListTitle,
   );
   return codeListUsages?.codeListIdSources ?? [];
diff --git a/frontend/libs/studio-pure-functions/src/FileUtils/FileUtils.test.ts b/frontend/libs/studio-pure-functions/src/FileUtils/FileUtils.test.ts
new file mode 100644
index 00000000000..b421f4d8d39
--- /dev/null
+++ b/frontend/libs/studio-pure-functions/src/FileUtils/FileUtils.test.ts
@@ -0,0 +1,17 @@
+import { FileUtils } from './FileUtils';
+
+describe('FileUtils', () => {
+  describe('convertToFormData', () => {
+    it('should append the file to FormData under the key "file"', () => {
+      const fileContent = 'Test file contents';
+      const fileName = 'test.txt';
+      const fileType = 'text/plain';
+      const file = new File([fileContent], fileName, { type: fileType });
+
+      const formData = FileUtils.convertToFormData(file);
+
+      const retrievedFile = formData.get('file');
+      expect(retrievedFile).toBe(file);
+    });
+  });
+});
diff --git a/frontend/libs/studio-pure-functions/src/FileUtils/FileUtils.ts b/frontend/libs/studio-pure-functions/src/FileUtils/FileUtils.ts
new file mode 100644
index 00000000000..618bfbc780a
--- /dev/null
+++ b/frontend/libs/studio-pure-functions/src/FileUtils/FileUtils.ts
@@ -0,0 +1,7 @@
+export class FileUtils {
+  static convertToFormData = (file: File): FormData => {
+    const formData = new FormData();
+    formData.append('file', file);
+    return formData;
+  };
+}
diff --git a/frontend/libs/studio-pure-functions/src/FileUtils/index.ts b/frontend/libs/studio-pure-functions/src/FileUtils/index.ts
new file mode 100644
index 00000000000..eaec5c5c5a3
--- /dev/null
+++ b/frontend/libs/studio-pure-functions/src/FileUtils/index.ts
@@ -0,0 +1 @@
+export { FileUtils } from './FileUtils';
diff --git a/frontend/libs/studio-pure-functions/src/StringUtils/StringUtils.test.ts b/frontend/libs/studio-pure-functions/src/StringUtils/StringUtils.test.ts
index 3731f936869..5022e1962dd 100644
--- a/frontend/libs/studio-pure-functions/src/StringUtils/StringUtils.test.ts
+++ b/frontend/libs/studio-pure-functions/src/StringUtils/StringUtils.test.ts
@@ -137,4 +137,28 @@ describe('StringUtils', () => {
       expect(StringUtils.areCaseInsensitiveEqual('', 'abc')).toBe(false);
     });
   });
+
+  describe('removeLeadingSlash', () => {
+    it('Removes leading slash from string', () => {
+      expect(StringUtils.removeLeadingSlash('/abc')).toBe('abc');
+    });
+
+    it('Does not remove anything if there is no leading slash', () => {
+      expect(StringUtils.removeLeadingSlash('abc')).toBe('abc');
+    });
+
+    it('Does not remove anything when there are slashes in other places than the start', () => {
+      expect(StringUtils.removeLeadingSlash('a/b/c/')).toBe('a/b/c/');
+    });
+
+    it('Removes the first slash only when there are multiple', () => {
+      expect(StringUtils.removeLeadingSlash('//a/b/c/')).toBe('/a/b/c/');
+    });
+
+    it('Does not change the input string object', () => {
+      const input = '/abc';
+      StringUtils.removeLeadingSlash(input);
+      expect(input).toBe('/abc');
+    });
+  });
 });
diff --git a/frontend/libs/studio-pure-functions/src/StringUtils/StringUtils.ts b/frontend/libs/studio-pure-functions/src/StringUtils/StringUtils.ts
index d1ec0006dfb..a2b781e156b 100644
--- a/frontend/libs/studio-pure-functions/src/StringUtils/StringUtils.ts
+++ b/frontend/libs/studio-pure-functions/src/StringUtils/StringUtils.ts
@@ -85,4 +85,6 @@ export class StringUtils {
 
   static areCaseInsensitiveEqual = (string: string, stringToCompare: string): boolean =>
     string.localeCompare(stringToCompare, 'nb', { sensitivity: 'base' }) === 0;
+
+  static removeLeadingSlash = (str: string): string => str.replace(/^\//g, '');
 }
diff --git a/frontend/libs/studio-pure-functions/src/index.ts b/frontend/libs/studio-pure-functions/src/index.ts
index 566087a5f25..7fde05af356 100644
--- a/frontend/libs/studio-pure-functions/src/index.ts
+++ b/frontend/libs/studio-pure-functions/src/index.ts
@@ -2,6 +2,7 @@ export * from './ArrayUtils';
 export * from './BlobDownloader';
 export * from './DateUtils';
 export * from './FileNameUtils';
+export * from './FileUtils';
 export * from './NumberUtils';
 export * from './ObjectUtils';
 export * from './ScopedStorage';
diff --git a/frontend/packages/shared/src/api/mutations.ts b/frontend/packages/shared/src/api/mutations.ts
index acbeea332e9..098c0ce18ff 100644
--- a/frontend/packages/shared/src/api/mutations.ts
+++ b/frontend/packages/shared/src/api/mutations.ts
@@ -49,6 +49,8 @@ import {
   dataTypePath,
   optionListPath,
   undeployAppFromEnvPath,
+  orgCodeListPath,
+  orgCodeListUploadPath,
   layoutPagesPath,
 } from 'app-shared/api/paths';
 import type { AddLanguagePayload } from 'app-shared/types/api/AddLanguagePayload';
@@ -58,7 +60,7 @@ import type { CreateDeploymentPayload } from 'app-shared/types/api/CreateDeploym
 import type { CreateReleasePayload } from 'app-shared/types/api/CreateReleasePayload';
 import type { CreateRepoCommitPayload } from 'app-shared/types/api/CreateRepoCommitPayload';
 import type { LayoutSetPayload } from 'app-shared/types/api/LayoutSetPayload';
-import type { ILayoutSettings, ITextResourcesObjectFormat } from 'app-shared/types/global';
+import type { ILayoutSettings, ITextResource, ITextResourcesObjectFormat, ITextResourcesWithLanguage } from 'app-shared/types/global';
 import type { RuleConfig } from 'app-shared/types/RuleConfig';
 import type { UpdateTextIdPayload } from 'app-shared/types/api/UpdateTextIdPayload';
 import { buildQueryParams } from 'app-shared/utils/urlUtils';
@@ -76,6 +78,9 @@ import type { FormLayoutRequest } from 'app-shared/types/api/FormLayoutRequest';
 import type { Option } from 'app-shared/types/Option';
 import type { MaskinportenScopes } from 'app-shared/types/MaskinportenScope';
 import type { DataType } from '../types/DataType';
+import type { CodeList } from 'app-shared/types/CodeList';
+import type { CodeListsResponse } from 'app-shared/types/api/CodeListsResponse';
+import { textResourcesMock } from 'app-shared/mocks/textResourcesMock';
 import type { PageModel } from '../types/api/dto/PageModel';
 import type { PagesModel } from '../types/api/dto/PagesModel';
 
@@ -174,3 +179,14 @@ export const updateProcessDataTypes = (org: string, app: string, dataTypesChange
 
 // Maskinporten
 export const updateSelectedMaskinportenScopes = (org: string, app: string, appScopesUpsertRequest: MaskinportenScopes) => put(selectedMaskinportenScopesPath(org, app), appScopesUpsertRequest);
+
+// Organisation library code lists:
+export const createCodeListForOrg = async (org: string, codeListId: string, payload: CodeList): Promise<CodeListsResponse> => post(orgCodeListPath(org, codeListId), payload);
+export const updateCodeListForOrg = async (org: string, codeListId: string, payload: CodeList): Promise<CodeListsResponse> => put(orgCodeListPath(org, codeListId), payload);
+export const deleteCodeListForOrg = async (org: string, codeListId: string): Promise<CodeListsResponse> => del(orgCodeListPath(org, codeListId));
+export const uploadCodeListForOrg = async (org: string, payload: FormData): Promise<CodeListsResponse> => post(orgCodeListUploadPath(org), payload);
+
+// Organisation text resources:
+// Todo: Replace these with real API calls when endpoints are ready. https://github.com/Altinn/altinn-studio/issues/14503
+export const createTextResourcesForOrg = async (org: string, language: string): Promise<ITextResourcesWithLanguage[]> => Promise.resolve([textResourcesMock]); // Todo: Replace with real API call when endpoint is ready. https://github.com/Altinn/altinn-studio/issues/14503
+export const updateTextResourcesForOrg = async (org: string, language: string, payload: ITextResource[]): Promise<ITextResourcesWithLanguage[]> => Promise.resolve([textResourcesMock]); // Todo: Replace with real API call when endpoint is ready. https://github.com/Altinn/altinn-studio/issues/14503
diff --git a/frontend/packages/shared/src/api/paths.js b/frontend/packages/shared/src/api/paths.js
index c62f0c2eaeb..4062ddda2e8 100644
--- a/frontend/packages/shared/src/api/paths.js
+++ b/frontend/packages/shared/src/api/paths.js
@@ -87,6 +87,11 @@ export const imagePath = (org, app, imageFilePath) => `${basePath}/${org}/${app}
 export const validateImageFromExternalUrlPath = (org, app, url) => `${basePath}/${org}/${app}/images/validate?${s({ url })}`; // Get
 export const getImageFileNamesPath = (org, app) => `${basePath}/${org}/${app}/images/fileNames`; // Get
 
+// Library - org-level
+export const orgCodeListsPath = (org) => `${basePath}/${org}/code-lists`; // Get
+export const orgCodeListPath = (org, codeListId) => `${basePath}/${org}/code-lists/${codeListId}`; // Post, Put, Delete
+export const orgCodeListUploadPath = (org) => `${basePath}/${org}/code-lists/upload`; // Post
+
 // Organizations
 export const orgsListPath = () => `${basePath}/orgs`; // Get
 
diff --git a/frontend/packages/shared/src/api/queries.ts b/frontend/packages/shared/src/api/queries.ts
index 4020861147e..ec13eecaebd 100644
--- a/frontend/packages/shared/src/api/queries.ts
+++ b/frontend/packages/shared/src/api/queries.ts
@@ -62,6 +62,7 @@ import {
   optionListReferencesPath,
   userOrgPermissionsPath,
   dataTypePath,
+  orgCodeListsPath,
   layoutPagesPath,
 } from './paths';
 
@@ -100,6 +101,8 @@ import type { OptionListReferences } from 'app-shared/types/OptionListReferences
 import type { LayoutSetsModel } from '../types/api/dto/LayoutSetsModel';
 import type { AccessPackageResource, PolicyAccessPackageAreaGroup } from 'app-shared/types/PolicyAccessPackages';
 import type { DataType } from '../types/DataType';
+import type { CodeListsResponse } from '../types/api/CodeListsResponse';
+import { textResourcesMock } from '../mocks/textResourcesMock';
 import type { PagesModel } from '../types/api/dto/PagesModel';
 
 export const getIsLoggedInWithAnsattporten = () => get<{ isLoggedIn: boolean }>(authStatusAnsattporten());
@@ -181,3 +184,7 @@ export const getProcessTaskType = (org: string, app: string, taskId: string) =>
 
 // Contact Page
 export const fetchBelongsToGiteaOrg = () => get(belongsToOrg());
+
+// Organisation library
+export const getCodeListsForOrg = (org: string) => get<CodeListsResponse>(orgCodeListsPath(org));
+export const getTextResourcesForOrg = async (org: string, language: string): Promise<ITextResourcesWithLanguage> => Promise.resolve(textResourcesMock); // Todo: Replace with real API call when endpoint is ready. https://github.com/Altinn/altinn-studio/issues/14503
diff --git a/frontend/packages/shared/src/constants.js b/frontend/packages/shared/src/constants.js
index d7776d6dbfd..521891df7d5 100644
--- a/frontend/packages/shared/src/constants.js
+++ b/frontend/packages/shared/src/constants.js
@@ -1,9 +1,10 @@
 // TODO: Extract/Centralize react-router routes (https://github.com/Altinn/altinn-studio/issues/12624)
 export const APP_DEVELOPMENT_BASENAME = '/editor';
+export const APP_DASHBOARD_BASENAME = '/app-dashboard';
 export const DASHBOARD_BASENAME = '/dashboard';
 export const DASHBOARD_ROOT_ROUTE = '/';
 export const RESOURCEADM_BASENAME = '/resourceadm';
-export const STUDIO_LIBRARY_BASENAME = '/library';
+export const ORG_LIBRARY_BASENAME = '/org-library';
 export const PREVIEW_BASENAME = '/preview';
 export const STUDIO_ROOT_BASENAME = '/';
 export const DEFAULT_LANGUAGE = 'nb';
diff --git a/frontend/packages/shared/src/hooks/mutations/useAddOptionListMutation.test.ts b/frontend/packages/shared/src/hooks/mutations/useAddOptionListMutation.test.ts
index 201486e2cc3..34b126c01a2 100644
--- a/frontend/packages/shared/src/hooks/mutations/useAddOptionListMutation.test.ts
+++ b/frontend/packages/shared/src/hooks/mutations/useAddOptionListMutation.test.ts
@@ -2,11 +2,11 @@ import { queriesMock } from 'app-shared/mocks/queriesMock';
 import { app, org } from '@studio/testing/testids';
 import { useAddOptionListMutation } from './useAddOptionListMutation';
 import { renderHookWithProviders } from 'app-shared/mocks/renderHookWithProviders';
+import { FileUtils } from '@studio/pure-functions';
 
 // Test data:
 const file = new File(['hello'], 'hello.json', { type: 'text/json' });
-const formData = new FormData();
-formData.append('file', file);
+const formData = FileUtils.convertToFormData(file);
 
 describe('useAddOptionsMutation', () => {
   afterEach(jest.clearAllMocks);
diff --git a/frontend/packages/shared/src/hooks/mutations/useAddOptionListMutation.ts b/frontend/packages/shared/src/hooks/mutations/useAddOptionListMutation.ts
index 50ab147c1e5..fd77c4bb432 100644
--- a/frontend/packages/shared/src/hooks/mutations/useAddOptionListMutation.ts
+++ b/frontend/packages/shared/src/hooks/mutations/useAddOptionListMutation.ts
@@ -2,13 +2,14 @@ import type { MutationMeta } from '@tanstack/react-query';
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { useServicesContext } from 'app-shared/contexts/ServicesContext';
 import { QueryKey } from 'app-shared/types/QueryKey';
+import { FileUtils } from '@studio/pure-functions';
 
 export const useAddOptionListMutation = (org: string, app: string, meta?: MutationMeta) => {
   const queryClient = useQueryClient();
   const { uploadOptionList } = useServicesContext();
 
   const mutationFn = (file: File) => {
-    const formData = createFormDataWithFile(file);
+    const formData = FileUtils.convertToFormData(file);
     return uploadOptionList(org, app, formData);
   };
 
@@ -21,9 +22,3 @@ export const useAddOptionListMutation = (org: string, app: string, meta?: Mutati
     meta,
   });
 };
-
-const createFormDataWithFile = (file: File): FormData => {
-  const formData = new FormData();
-  formData.append('file', file);
-  return formData;
-};
diff --git a/frontend/packages/shared/src/hooks/mutations/useCreateOrgCodeListMutation.test.ts b/frontend/packages/shared/src/hooks/mutations/useCreateOrgCodeListMutation.test.ts
new file mode 100644
index 00000000000..42b40bdd9b4
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/mutations/useCreateOrgCodeListMutation.test.ts
@@ -0,0 +1,60 @@
+import { renderHookWithProviders } from '../../mocks/renderHookWithProviders';
+import { org } from '@studio/testing/testids';
+import { queriesMock } from '../../mocks/queriesMock';
+import { useCreateOrgCodeListMutation } from './useCreateOrgCodeListMutation';
+import type { CodeList } from '../../types/CodeList';
+import type { CodeListData } from '../../types/CodeListData';
+import { createQueryClientMock } from '../../mocks/queryClientMock';
+import { QueryKey } from '../../types/QueryKey';
+import type { CodeListsResponse } from '../../types/api/CodeListsResponse';
+
+// Test data:
+const codeList: CodeList = [
+  {
+    value: 'test-value',
+    label: 'test-label',
+  },
+];
+
+const newCodeList: CodeListData = {
+  title: 'new-title',
+  data: codeList,
+};
+
+const existingCodeList: CodeListData = {
+  title: 'existing-title',
+  data: codeList,
+};
+
+describe('useCreateOrgCodeListMutation', () => {
+  beforeEach(jest.clearAllMocks);
+
+  it('Calls createCodeListForOrg with correct parameters', async () => {
+    const { result } = renderHookWithProviders(() => useCreateOrgCodeListMutation(org));
+
+    await result.current.mutateAsync(newCodeList);
+
+    expect(queriesMock.createCodeListForOrg).toHaveBeenCalledTimes(1);
+    expect(queriesMock.createCodeListForOrg).toHaveBeenCalledWith(
+      org,
+      newCodeList.title,
+      newCodeList.data,
+    );
+  });
+
+  it('Replaces cache with api response', async () => {
+    const queryClient = createQueryClientMock();
+    queryClient.setQueryData([QueryKey.OrgCodeLists, org], [existingCodeList]);
+    const createCodeListForOrg = jest.fn(() => Promise.resolve([existingCodeList, newCodeList]));
+    const { result } = renderHookWithProviders(() => useCreateOrgCodeListMutation(org), {
+      queryClient,
+      queries: { createCodeListForOrg },
+    });
+
+    await result.current.mutateAsync(newCodeList);
+
+    const expectedUpdatedData: CodeListsResponse = [existingCodeList, newCodeList];
+    const updatedData = queryClient.getQueryData([QueryKey.OrgCodeLists, org]);
+    expect(updatedData).toEqual(expectedUpdatedData);
+  });
+});
diff --git a/frontend/packages/shared/src/hooks/mutations/useCreateOrgCodeListMutation.ts b/frontend/packages/shared/src/hooks/mutations/useCreateOrgCodeListMutation.ts
new file mode 100644
index 00000000000..58753abcbb5
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/mutations/useCreateOrgCodeListMutation.ts
@@ -0,0 +1,22 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useServicesContext } from '../../contexts/ServicesContext';
+import { QueryKey } from '../../types/QueryKey';
+import type { CodeListsResponse } from '../../types/api/CodeListsResponse';
+import type { CodeListData } from '../../types/CodeListData';
+
+type CreateOrgCodeListMutationArgs = Pick<CodeListData, 'title' | 'data'>;
+
+export const useCreateOrgCodeListMutation = (org: string) => {
+  const queryClient = useQueryClient();
+  const { createCodeListForOrg } = useServicesContext();
+
+  const mutationFn = ({ title, data }: CreateOrgCodeListMutationArgs) =>
+    createCodeListForOrg(org, title, data);
+
+  return useMutation({
+    mutationFn,
+    onSuccess: (newData: CodeListsResponse) => {
+      queryClient.setQueryData([QueryKey.OrgCodeLists, org], newData);
+    },
+  });
+};
diff --git a/frontend/packages/shared/src/hooks/mutations/useCreateTextResourcesForOrgMutation.test.ts b/frontend/packages/shared/src/hooks/mutations/useCreateTextResourcesForOrgMutation.test.ts
new file mode 100644
index 00000000000..06b084a5c47
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/mutations/useCreateTextResourcesForOrgMutation.test.ts
@@ -0,0 +1,23 @@
+import { queriesMock } from '../../mocks/queriesMock';
+import { renderHookWithProviders } from '../../mocks/renderHookWithProviders';
+import { useCreateTextResourcesForOrgMutation } from './useCreateTextResourcesForOrgMutation';
+import { waitFor } from '@testing-library/react';
+import { org } from '@studio/testing/testids';
+
+const languageMock: string = 'nb';
+
+describe('useCreateTextResourcesForOrgMutation', () => {
+  beforeEach(jest.clearAllMocks);
+
+  it('Calls createTextResourcesForOrg with correct arguments and payload', async () => {
+    const { result } = renderHookWithProviders(() =>
+      useCreateTextResourcesForOrgMutation(org, languageMock),
+    );
+
+    result.current.mutate();
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(queriesMock.createTextResourcesForOrg).toHaveBeenCalledTimes(1);
+    expect(queriesMock.createTextResourcesForOrg).toHaveBeenCalledWith(org, languageMock);
+  });
+});
diff --git a/frontend/packages/shared/src/hooks/mutations/useCreateTextResourcesForOrgMutation.ts b/frontend/packages/shared/src/hooks/mutations/useCreateTextResourcesForOrgMutation.ts
new file mode 100644
index 00000000000..5ea73f058f8
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/mutations/useCreateTextResourcesForOrgMutation.ts
@@ -0,0 +1,19 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useServicesContext } from '../../contexts/ServicesContext';
+import { QueryKey } from '../../types/QueryKey';
+import { type ITextResourcesWithLanguage } from '../../types/global';
+
+export const useCreateTextResourcesForOrgMutation = (org: string, language: string) => {
+  const q = useQueryClient();
+  const { createTextResourcesForOrg } = useServicesContext();
+  return useMutation({
+    mutationFn: async () => {
+      const textResourcesWithLanguage: ITextResourcesWithLanguage[] =
+        await createTextResourcesForOrg(org, language);
+
+      return textResourcesWithLanguage;
+    },
+    onSuccess: (textResourcesWithLanguage) =>
+      q.setQueryData([QueryKey.TextResourcesForOrg, org], textResourcesWithLanguage),
+  });
+};
diff --git a/frontend/packages/shared/src/hooks/mutations/useDeleteOrgCodeListMutation.test.ts b/frontend/packages/shared/src/hooks/mutations/useDeleteOrgCodeListMutation.test.ts
new file mode 100644
index 00000000000..2d3e05a11b4
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/mutations/useDeleteOrgCodeListMutation.test.ts
@@ -0,0 +1,56 @@
+import { renderHookWithProviders } from '../../mocks/renderHookWithProviders';
+import { org } from '@studio/testing/testids';
+import { queriesMock } from '../../mocks/queriesMock';
+import { useDeleteOrgCodeListMutation } from '../../hooks/mutations/useDeleteOrgCodeListMutation';
+import { createQueryClientMock } from '../../mocks/queryClientMock';
+import { QueryKey } from '../../types/QueryKey';
+import type { CodeListsResponse } from '../../types/api/CodeListsResponse';
+import type { CodeListData } from '../../types/CodeListData';
+import type { CodeList } from '../../types/CodeList';
+
+// Test data:
+const title = 'testId';
+
+const codeList: CodeList = [
+  {
+    value: 'test-value',
+    label: 'test-label',
+  },
+];
+
+const codeListToDelete: CodeListData = {
+  title: 'deleted-title',
+  data: codeList,
+};
+
+const otherCodeList: CodeListData = {
+  title: 'other-title',
+  data: codeList,
+};
+
+describe('useDeleteOrgCodeListMutation', () => {
+  beforeEach(jest.clearAllMocks);
+
+  it('Calls deleteCodeListForOrg with correct parameters', async () => {
+    const { result } = renderHookWithProviders(() => useDeleteOrgCodeListMutation(org));
+    await result.current.mutateAsync(title);
+    expect(queriesMock.deleteCodeListForOrg).toHaveBeenCalledTimes(1);
+    expect(queriesMock.deleteCodeListForOrg).toHaveBeenCalledWith(org, title);
+  });
+
+  it('Replaces cache with api response', async () => {
+    const queryClient = createQueryClientMock();
+    queryClient.setQueryData([QueryKey.OrgCodeLists, org], [codeListToDelete, otherCodeList]);
+    const deleteCodeListForOrg = jest.fn(() => Promise.resolve([otherCodeList]));
+    const { result } = renderHookWithProviders(() => useDeleteOrgCodeListMutation(org), {
+      queryClient,
+      queries: { deleteCodeListForOrg },
+    });
+
+    await result.current.mutateAsync({ title: codeListToDelete.title });
+
+    const expectedUpdatedData: CodeListsResponse = [otherCodeList];
+    const updatedData = queryClient.getQueryData([QueryKey.OrgCodeLists, org]);
+    expect(updatedData).toEqual(expectedUpdatedData);
+  });
+});
diff --git a/frontend/packages/shared/src/hooks/mutations/useDeleteOrgCodeListMutation.ts b/frontend/packages/shared/src/hooks/mutations/useDeleteOrgCodeListMutation.ts
new file mode 100644
index 00000000000..003a0b146f7
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/mutations/useDeleteOrgCodeListMutation.ts
@@ -0,0 +1,18 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useServicesContext } from '../../contexts/ServicesContext';
+import { QueryKey } from '../../types/QueryKey';
+import type { CodeListsResponse } from '../../types/api/CodeListsResponse';
+
+export const useDeleteOrgCodeListMutation = (org: string) => {
+  const queryClient = useQueryClient();
+  const { deleteCodeListForOrg } = useServicesContext();
+
+  const mutationFn = (title: string) => deleteCodeListForOrg(org, title);
+
+  return useMutation({
+    mutationFn,
+    onSuccess: (newData: CodeListsResponse) => {
+      queryClient.setQueryData([QueryKey.OrgCodeLists, org], newData);
+    },
+  });
+};
diff --git a/frontend/packages/shared/src/hooks/mutations/useUpdateOrgCodeListMutation.test.ts b/frontend/packages/shared/src/hooks/mutations/useUpdateOrgCodeListMutation.test.ts
new file mode 100644
index 00000000000..9e89cd5d4d4
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/mutations/useUpdateOrgCodeListMutation.test.ts
@@ -0,0 +1,58 @@
+import { renderHookWithProviders } from '../../mocks/renderHookWithProviders';
+import { org } from '@studio/testing/testids';
+import { queriesMock } from '../../mocks/queriesMock';
+import type { CodeList } from '../../types/CodeList';
+import { useUpdateOrgCodeListMutation } from './useUpdateOrgCodeListMutation';
+import { createQueryClientMock } from '../../mocks/queryClientMock';
+import { QueryKey } from '../../types/QueryKey';
+import type { CodeListsResponse } from '../../types/api/CodeListsResponse';
+import type { CodeListData } from '../../types/CodeListData';
+
+// Test data:
+const codeList: CodeList = [
+  {
+    value: 'test-value',
+    label: 'test-label',
+  },
+];
+
+const oldCodeList: CodeListData = {
+  title: 'old-title',
+  data: codeList,
+};
+
+const updatedCodeList: CodeListData = {
+  title: 'updated-title',
+  data: codeList,
+};
+
+describe('useUpdateOrgCodeListMutation', () => {
+  beforeEach(jest.clearAllMocks);
+
+  it('Calls updateCodeListForOrg with correct parameters', async () => {
+    const { result } = renderHookWithProviders(() => useUpdateOrgCodeListMutation(org));
+    await result.current.mutateAsync(updatedCodeList);
+    expect(queriesMock.updateCodeListForOrg).toHaveBeenCalledTimes(1);
+    expect(queriesMock.updateCodeListForOrg).toHaveBeenCalledWith(
+      org,
+      updatedCodeList.title,
+      updatedCodeList.data,
+    );
+  });
+
+  it('Replaces cache with api response', async () => {
+    const queryClient = createQueryClientMock();
+    queryClient.setQueryData([QueryKey.OrgCodeLists, org], [oldCodeList]);
+    const updateCodeListForOrg = jest.fn(() => Promise.resolve([updatedCodeList]));
+    const { result } = renderHookWithProviders(() => useUpdateOrgCodeListMutation(org), {
+      queryClient,
+      queries: { updateCodeListForOrg },
+    });
+
+    await result.current.mutateAsync(updatedCodeList);
+
+    const expectedUpdatedData: CodeListsResponse = [updatedCodeList];
+    const updatedData = queryClient.getQueryData([QueryKey.OrgCodeLists, org]);
+    expect(updatedData).toEqual(expectedUpdatedData);
+  });
+});
diff --git a/frontend/packages/shared/src/hooks/mutations/useUpdateOrgCodeListMutation.ts b/frontend/packages/shared/src/hooks/mutations/useUpdateOrgCodeListMutation.ts
new file mode 100644
index 00000000000..5c397a0b356
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/mutations/useUpdateOrgCodeListMutation.ts
@@ -0,0 +1,22 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useServicesContext } from '../../contexts/ServicesContext';
+import { QueryKey } from '../../types/QueryKey';
+import type { CodeListData } from '../../types/CodeListData';
+import type { CodeListsResponse } from '../../types/api/CodeListsResponse';
+
+type UpdateOrgCodeListMutationArgs = Pick<CodeListData, 'title' | 'data'>;
+
+export const useUpdateOrgCodeListMutation = (org: string) => {
+  const queryClient = useQueryClient();
+  const { updateCodeListForOrg } = useServicesContext();
+
+  const mutationFn = ({ title, data }: UpdateOrgCodeListMutationArgs) =>
+    updateCodeListForOrg(org, title, data);
+
+  return useMutation({
+    mutationFn,
+    onSuccess: (newData: CodeListsResponse) => {
+      queryClient.setQueryData([QueryKey.OrgCodeLists, org], newData);
+    },
+  });
+};
diff --git a/frontend/packages/shared/src/hooks/mutations/useUpdateTextResourcesForOrgMutation.test.ts b/frontend/packages/shared/src/hooks/mutations/useUpdateTextResourcesForOrgMutation.test.ts
new file mode 100644
index 00000000000..b3c60792e6d
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/mutations/useUpdateTextResourcesForOrgMutation.test.ts
@@ -0,0 +1,28 @@
+import { queriesMock } from '../../mocks/queriesMock';
+import { renderHookWithProviders } from '../../mocks/renderHookWithProviders';
+import { useUpdateTextResourcesForOrgMutation } from './useUpdateTextResourcesForOrgMutation';
+import { waitFor } from '@testing-library/react';
+import { org } from '@studio/testing/testids';
+import { type ITextResource } from '../../types/global';
+import { label1TextResource, label2TextResource } from '../../mocks/textResourcesMock';
+
+const languageMock: string = 'nb';
+const textResourcesMock: ITextResource[] = [label1TextResource, label2TextResource];
+
+describe('useUpdateTextResourcesForOrgMutation', () => {
+  it('Calls updateTextResourcesForOrg with correct arguments and payload', async () => {
+    const { result } = renderHookWithProviders(() =>
+      useUpdateTextResourcesForOrgMutation(org, languageMock),
+    );
+
+    result.current.mutate(textResourcesMock);
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(queriesMock.updateTextResourcesForOrg).toHaveBeenCalledTimes(1);
+    expect(queriesMock.updateTextResourcesForOrg).toHaveBeenCalledWith(
+      org,
+      languageMock,
+      textResourcesMock,
+    );
+  });
+});
diff --git a/frontend/packages/shared/src/hooks/mutations/useUpdateTextResourcesForOrgMutation.ts b/frontend/packages/shared/src/hooks/mutations/useUpdateTextResourcesForOrgMutation.ts
new file mode 100644
index 00000000000..255cdf41a3b
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/mutations/useUpdateTextResourcesForOrgMutation.ts
@@ -0,0 +1,19 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useServicesContext } from '../../contexts/ServicesContext';
+import { type ITextResourcesWithLanguage, type ITextResource } from '../../types/global';
+import { QueryKey } from '../../types/QueryKey';
+
+export const useUpdateTextResourcesForOrgMutation = (org: string, language: string) => {
+  const q = useQueryClient();
+  const { updateTextResourcesForOrg } = useServicesContext();
+  return useMutation({
+    mutationFn: async (payload: ITextResource[]) => {
+      const textResourcesWithLanguage: ITextResourcesWithLanguage[] =
+        await updateTextResourcesForOrg(org, language, payload);
+
+      return textResourcesWithLanguage;
+    },
+    onSuccess: (textResourcesWithLanguage) =>
+      q.setQueryData([QueryKey.TextResourcesForOrg, org], textResourcesWithLanguage),
+  });
+};
diff --git a/frontend/packages/shared/src/hooks/mutations/useUploadOrgCodeListMutation.test.ts b/frontend/packages/shared/src/hooks/mutations/useUploadOrgCodeListMutation.test.ts
new file mode 100644
index 00000000000..03badabc8d5
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/mutations/useUploadOrgCodeListMutation.test.ts
@@ -0,0 +1,55 @@
+import { renderHookWithProviders } from '../../mocks/renderHookWithProviders';
+import { org } from '@studio/testing/testids';
+import { queriesMock } from '../../mocks/queriesMock';
+import { useUploadOrgCodeListMutation } from './useUploadOrgCodeListMutation';
+import { createQueryClientMock } from '../../mocks/queryClientMock';
+import { QueryKey } from '../../types/QueryKey';
+import type { CodeListsResponse } from '../../types/api/CodeListsResponse';
+import type { CodeList } from '../../types/CodeList';
+import { FileUtils } from '@studio/pure-functions';
+
+// Test data:
+const fileName = 'fileName';
+const fileData: CodeList = [
+  {
+    value: 'test-value',
+    label: 'test-label',
+  },
+];
+
+const jsonData = JSON.stringify(fileData);
+const file = new File([jsonData], `${fileName}.json`, { type: 'text/json' });
+const formData = FileUtils.convertToFormData(file);
+
+const codeListResponse: CodeListsResponse = [
+  {
+    title: fileName,
+    data: fileData,
+  },
+];
+
+describe('useUploadOrgCodeListMutation', () => {
+  beforeEach(jest.clearAllMocks);
+
+  it('Calls uploadCodeListForOrg with correct parameters', async () => {
+    const { result } = renderHookWithProviders(() => useUploadOrgCodeListMutation(org));
+    await result.current.mutateAsync(file);
+    expect(queriesMock.uploadCodeListForOrg).toHaveBeenCalledTimes(1);
+    expect(queriesMock.uploadCodeListForOrg).toHaveBeenCalledWith(org, formData);
+  });
+
+  it('Replaces cache with api response', async () => {
+    const queryClient = createQueryClientMock();
+    const uploadCodeListForOrg = jest.fn(() => Promise.resolve(codeListResponse));
+    const { result } = renderHookWithProviders(() => useUploadOrgCodeListMutation(org), {
+      queryClient,
+      queries: { uploadCodeListForOrg },
+    });
+
+    await result.current.mutateAsync(file);
+
+    const expectedUpdatedData: CodeListsResponse = codeListResponse;
+    const updatedData = queryClient.getQueryData([QueryKey.OrgCodeLists, org]);
+    expect(updatedData).toEqual(expectedUpdatedData);
+  });
+});
diff --git a/frontend/packages/shared/src/hooks/mutations/useUploadOrgCodeListMutation.ts b/frontend/packages/shared/src/hooks/mutations/useUploadOrgCodeListMutation.ts
new file mode 100644
index 00000000000..13197f015cb
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/mutations/useUploadOrgCodeListMutation.ts
@@ -0,0 +1,24 @@
+import type { MutationMeta } from '@tanstack/react-query';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useServicesContext } from '../../contexts/ServicesContext';
+import { QueryKey } from '../../types/QueryKey';
+import type { CodeListsResponse } from '../../types/api/CodeListsResponse';
+import { FileUtils } from '@studio/pure-functions';
+
+export const useUploadOrgCodeListMutation = (org: string, meta?: MutationMeta) => {
+  const queryClient = useQueryClient();
+  const { uploadCodeListForOrg } = useServicesContext();
+
+  const mutationFn = (file: File) => {
+    const formData = FileUtils.convertToFormData(file);
+    return uploadCodeListForOrg(org, formData);
+  };
+
+  return useMutation({
+    mutationFn,
+    onSuccess: (newData: CodeListsResponse) => {
+      queryClient.setQueryData([QueryKey.OrgCodeLists, org], newData);
+    },
+    meta,
+  });
+};
diff --git a/frontend/packages/shared/src/hooks/queries/useOrgCodeListsQuery.test.ts b/frontend/packages/shared/src/hooks/queries/useOrgCodeListsQuery.test.ts
new file mode 100644
index 00000000000..5e1324de43f
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/queries/useOrgCodeListsQuery.test.ts
@@ -0,0 +1,18 @@
+import { waitFor } from '@testing-library/react';
+import { queriesMock } from '../../mocks/queriesMock';
+import { renderHookWithProviders } from '../../mocks/renderHookWithProviders';
+import { org } from '@studio/testing/testids';
+import { useOrgCodeListsQuery } from '../../hooks/queries/useOrgCodeListsQuery';
+
+describe('useOrgCodeListsQuery', () => {
+  it('calls getCodeListsForOrg with the correct parameters', () => {
+    render();
+    expect(queriesMock.getCodeListsForOrg).toHaveBeenCalledWith(org);
+  });
+});
+
+const render = async () => {
+  const { result } = renderHookWithProviders(() => useOrgCodeListsQuery(org));
+  await waitFor(() => expect(result.current.isSuccess).toBe(true));
+  return result;
+};
diff --git a/frontend/packages/shared/src/hooks/queries/useOrgCodeListsQuery.ts b/frontend/packages/shared/src/hooks/queries/useOrgCodeListsQuery.ts
new file mode 100644
index 00000000000..0a180a244ef
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/queries/useOrgCodeListsQuery.ts
@@ -0,0 +1,13 @@
+import { useServicesContext } from 'app-shared/contexts/ServicesContext';
+import { QueryKey } from '../../types/QueryKey';
+import type { UseQueryResult } from '@tanstack/react-query';
+import { useQuery } from '@tanstack/react-query';
+import type { CodeListsResponse } from '../../types/api/CodeListsResponse';
+
+export const useOrgCodeListsQuery = (org: string): UseQueryResult<CodeListsResponse> => {
+  const { getCodeListsForOrg } = useServicesContext();
+  return useQuery<CodeListsResponse>({
+    queryKey: [QueryKey.OrgCodeLists, org],
+    queryFn: () => getCodeListsForOrg(org),
+  });
+};
diff --git a/frontend/packages/shared/src/hooks/queries/useTextResourcesForOrgQuery.test.ts b/frontend/packages/shared/src/hooks/queries/useTextResourcesForOrgQuery.test.ts
new file mode 100644
index 00000000000..db8e32d6324
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/queries/useTextResourcesForOrgQuery.test.ts
@@ -0,0 +1,22 @@
+import { queriesMock } from 'app-shared/mocks/queriesMock';
+import { renderHookWithProviders } from 'app-shared/mocks/renderHookWithProviders';
+import { waitFor } from '@testing-library/react';
+import { org } from '@studio/testing/testids';
+import { useTextResourcesForOrgQuery } from './useTextResourcesForOrgQuery';
+
+const languageMock: string = 'nb';
+
+describe('useTextResourcesForOrgQuery', () => {
+  beforeEach(jest.clearAllMocks);
+
+  it('calls getTextResourcesForOrg with the correct parameters', () => {
+    renderAndWaitForResult();
+    expect(queriesMock.getTextResourcesForOrg).toHaveBeenCalledWith(org, languageMock);
+    expect(queriesMock.getTextResourcesForOrg).toHaveBeenCalledTimes(1);
+  });
+});
+
+const renderAndWaitForResult = async (): Promise<void> => {
+  const { result } = renderHookWithProviders(() => useTextResourcesForOrgQuery(org, languageMock));
+  await waitFor(() => expect(result.current.isSuccess).toBe(true));
+};
diff --git a/frontend/packages/shared/src/hooks/queries/useTextResourcesForOrgQuery.ts b/frontend/packages/shared/src/hooks/queries/useTextResourcesForOrgQuery.ts
new file mode 100644
index 00000000000..8cf4e283aca
--- /dev/null
+++ b/frontend/packages/shared/src/hooks/queries/useTextResourcesForOrgQuery.ts
@@ -0,0 +1,15 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { QueryKey } from '../../types/QueryKey';
+import { useServicesContext } from '../../contexts/ServicesContext';
+import { type ITextResourcesWithLanguage } from '../../types/global';
+
+export const useTextResourcesForOrgQuery = (
+  org: string,
+  language: string,
+): UseQueryResult<ITextResourcesWithLanguage> => {
+  const { getTextResourcesForOrg } = useServicesContext();
+  return useQuery<ITextResourcesWithLanguage>({
+    queryKey: [QueryKey.TextResourcesForOrg],
+    queryFn: () => getTextResourcesForOrg(org, language),
+  });
+};
diff --git a/frontend/packages/shared/src/mocks/codeListsResponse.ts b/frontend/packages/shared/src/mocks/codeListsResponse.ts
new file mode 100644
index 00000000000..63a9a94ef81
--- /dev/null
+++ b/frontend/packages/shared/src/mocks/codeListsResponse.ts
@@ -0,0 +1,47 @@
+import type { CodeListsResponse } from '../types/api/CodeListsResponse';
+import type { CodeListData } from '@studio/content-library';
+import {
+  description1TextResource,
+  description2TextResource,
+  helpText1TextResource,
+  helpText2TextResource,
+  label1TextResource,
+  label2TextResource,
+  label3TextResource,
+  label4TextResource,
+  label5TextResource,
+} from 'app-shared/mocks/textResourcesMock';
+
+const codeList1: CodeListData = {
+  title: 'codeList1',
+  data: [
+    {
+      description: description1TextResource.id,
+      helpText: helpText1TextResource.id,
+      label: label1TextResource.id,
+      value: 'item1',
+    },
+    {
+      description: description2TextResource.id,
+      helpText: helpText2TextResource.id,
+      label: label2TextResource.id,
+      value: 'item2',
+    },
+  ],
+};
+
+const codeList2: CodeListData = {
+  title: 'codeList2',
+  data: [
+    { label: label3TextResource.id, value: 'a' },
+    { label: label4TextResource.id, value: 'b' },
+    { label: label5TextResource.id, value: 'c' },
+  ],
+};
+
+const codeListWithError: CodeListData = {
+  title: 'codeListWithError',
+  hasError: true,
+};
+
+export const codeListsResponse: CodeListsResponse = [codeList1, codeList2, codeListWithError];
diff --git a/frontend/packages/shared/src/mocks/queriesMock.ts b/frontend/packages/shared/src/mocks/queriesMock.ts
index f230ea80b12..7bd42b3daa4 100644
--- a/frontend/packages/shared/src/mocks/queriesMock.ts
+++ b/frontend/packages/shared/src/mocks/queriesMock.ts
@@ -74,6 +74,7 @@ import type { OptionListReferences } from 'app-shared/types/OptionListReferences
 import type { LayoutSetsModel } from '../types/api/dto/LayoutSetsModel';
 import { layoutSetsExtendedMock } from '@altinn/ux-editor/testing/layoutSetsMock';
 import type { OptionListsResponse } from 'app-shared/types/api/OptionListsResponse';
+import type { CodeListsResponse } from 'app-shared/types/api/CodeListsResponse';
 
 export const queriesMock: ServicesContextProps = {
   // Queries
@@ -83,6 +84,7 @@ export const queriesMock: ServicesContextProps = {
     .mockImplementation(() => Promise.resolve<AppReleasesResponse>(appReleasesResponse)),
   getAppVersion: jest.fn().mockImplementation(() => Promise.resolve<AppVersion>(appVersion)),
   getBranchStatus: jest.fn().mockImplementation(() => Promise.resolve<BranchStatus>(branchStatus)),
+  getCodeListsForOrg: jest.fn().mockImplementation(() => Promise.resolve<CodeListsResponse>([])),
   getDataModel: jest.fn().mockImplementation(() => Promise.resolve<JsonSchema>({})),
   getDataModelMetadata: jest
     .fn()
@@ -196,6 +198,11 @@ export const queriesMock: ServicesContextProps = {
   getSelectedMaskinportenScopes: jest
     .fn()
     .mockImplementation(() => Promise.resolve<MaskinportenScope[]>([])),
+  getTextResourcesForOrg: jest
+    .fn()
+    .mockImplementation(() =>
+      Promise.resolve<ITextResourcesWithLanguage>(textResourcesWithLanguage),
+    ),
   updateSelectedMaskinportenScopes: jest.fn().mockImplementation(() => Promise.resolve()),
 
   // Queries - Contact
@@ -215,6 +222,7 @@ export const queriesMock: ServicesContextProps = {
     .fn()
     .mockImplementation(() => Promise.resolve<CreateRepoCommitPayload>(createRepoCommitPayload)),
   copyApp: jest.fn().mockImplementation(() => Promise.resolve()),
+  createCodeListForOrg: jest.fn().mockImplementation(() => Promise.resolve()),
   createDataModel: jest.fn().mockImplementation(() => Promise.resolve<JsonSchema>({})),
   updateDataType: jest.fn().mockImplementation(() => Promise.resolve<JsonSchema>({})),
   createDeployment: jest.fn().mockImplementation(() => Promise.resolve()),
@@ -222,7 +230,9 @@ export const queriesMock: ServicesContextProps = {
   createRepoCommit: jest
     .fn()
     .mockImplementation(() => Promise.resolve<CreateRepoCommitPayload>(createRepoCommitPayload)),
+  createTextResourcesForOrg: jest.fn().mockImplementation(() => Promise.resolve()),
   deleteAppAttachmentMetadata: jest.fn().mockImplementation(() => Promise.resolve()),
+  deleteCodeListForOrg: jest.fn().mockImplementation(() => Promise.resolve()),
   deleteDataModel: jest.fn().mockImplementation(() => Promise.resolve()),
   deleteDataTypeFromAppMetadata: jest.fn().mockImplementation(() => Promise.resolve()),
   deleteFormLayout: jest.fn().mockImplementation(() => Promise.resolve()),
@@ -249,8 +259,11 @@ export const queriesMock: ServicesContextProps = {
   updateAppPolicy: jest.fn().mockImplementation(() => Promise.resolve()),
   updateAppMetadata: jest.fn().mockImplementation(() => Promise.resolve()),
   updateAppConfig: jest.fn().mockImplementation(() => Promise.resolve()),
+  updateCodeListForOrg: jest.fn().mockImplementation(() => Promise.resolve()),
   updateOptionList: jest.fn().mockImplementation(() => Promise.resolve()),
   updateOptionListId: jest.fn().mockImplementation(() => Promise.resolve()),
+  updateTextResourcesForOrg: jest.fn().mockImplementation(() => Promise.resolve()),
+  uploadCodeListForOrg: jest.fn().mockImplementation(() => Promise.resolve()),
   uploadDataModel: jest.fn().mockImplementation(() => Promise.resolve<JsonSchema>({})),
   uploadOptionList: jest.fn().mockImplementation(() => Promise.resolve()),
   upsertTextResources: jest
diff --git a/frontend/packages/shared/src/mocks/textResourcesMock.ts b/frontend/packages/shared/src/mocks/textResourcesMock.ts
new file mode 100644
index 00000000000..422d756b113
--- /dev/null
+++ b/frontend/packages/shared/src/mocks/textResourcesMock.ts
@@ -0,0 +1,87 @@
+import type { ITextResource, ITextResourcesWithLanguage } from 'app-shared/types/global';
+
+export const label1TextResource: ITextResource = {
+  id: 'label1',
+  value: 'Ledetekst 1',
+};
+export const label2TextResource: ITextResource = {
+  id: 'label2',
+  value: 'Ledetekst 2',
+};
+export const label3TextResource: ITextResource = {
+  id: 'label3',
+  value: 'Ledetekst 3',
+};
+export const label4TextResource: ITextResource = {
+  id: 'label4',
+  value: 'Ledetekst 4',
+};
+export const label5TextResource: ITextResource = {
+  id: 'label5',
+  value: 'Ledetekst 5',
+};
+
+export const description1TextResource: ITextResource = {
+  id: 'description1',
+  value: 'Beskrivelse 1',
+};
+export const description2TextResource: ITextResource = {
+  id: 'description2',
+  value: 'Beskrivelse 2',
+};
+export const description3TextResource: ITextResource = {
+  id: 'description3',
+  value: 'Beskrivelse 3',
+};
+export const description4TextResource: ITextResource = {
+  id: 'description4',
+  value: 'Beskrivelse 4',
+};
+export const description5TextResource: ITextResource = {
+  id: 'description5',
+  value: 'Beskrivelse 5',
+};
+
+export const helpText1TextResource: ITextResource = {
+  id: 'helpText1',
+  value: 'Hjelpetekst 1',
+};
+export const helpText2TextResource: ITextResource = {
+  id: 'helpText2',
+  value: 'Hjelpetekst 2',
+};
+export const helpText3TextResource: ITextResource = {
+  id: 'helpText3',
+  value: 'Hjelpetekst 3',
+};
+export const helpText4TextResource: ITextResource = {
+  id: 'helpText4',
+  value: 'Hjelpetekst 4',
+};
+export const helpText5TextResource: ITextResource = {
+  id: 'helpText5',
+  value: 'Hjelpetekst 5',
+};
+
+const textResources: ITextResource[] = [
+  label1TextResource,
+  label2TextResource,
+  label3TextResource,
+  label4TextResource,
+  label5TextResource,
+  description1TextResource,
+  description2TextResource,
+  description3TextResource,
+  description4TextResource,
+  description5TextResource,
+  helpText1TextResource,
+  helpText2TextResource,
+  helpText3TextResource,
+  helpText4TextResource,
+  helpText5TextResource,
+];
+
+export const textResourcesMock: ITextResourcesWithLanguage = {
+  language: 'nb',
+  resources: textResources,
+};
diff --git a/frontend/packages/shared/src/types/CodeList.ts b/frontend/packages/shared/src/types/CodeList.ts
new file mode 100644
index 00000000000..bd336bfa537
--- /dev/null
+++ b/frontend/packages/shared/src/types/CodeList.ts
@@ -0,0 +1 @@
+export type { CodeList } from '@studio/components';
diff --git a/frontend/packages/shared/src/types/CodeListData.ts b/frontend/packages/shared/src/types/CodeListData.ts
new file mode 100644
index 00000000000..d09e909f0c4
--- /dev/null
+++ b/frontend/packages/shared/src/types/CodeListData.ts
@@ -0,0 +1,7 @@
+import type { CodeListItem } from '@studio/components';
+
+export type CodeListData = {
+  title: string;
+  data?: CodeListItem[];
+  hasError?: boolean;
+};
diff --git a/frontend/packages/shared/src/types/QueryKey.ts b/frontend/packages/shared/src/types/QueryKey.ts
index 42563eec16c..3e9c6e04687 100644
--- a/frontend/packages/shared/src/types/QueryKey.ts
+++ b/frontend/packages/shared/src/types/QueryKey.ts
@@ -30,6 +30,7 @@ export enum QueryKey {
   OptionListsUsage = 'OptionListsUsage',
   OptionLists = 'OptionLists',
   OptionListIds = 'OptionListIds',
+  OrgCodeLists = 'OrgCodeLists',
   OrgList = 'OrgList',
   Organizations = 'Organizations',
   ProcessTaskDataType = 'ProcessTaskDataType',
@@ -50,6 +51,7 @@ export enum QueryKey {
   SelectedAppScopes = 'SelectedAppScopes',
   UserOrgPermissions = 'UserOrgPermissions',
   DataType = 'DataType',
+  TextResourcesForOrg = 'TextResourcesForOrg',
   Pages = 'Pages',
 
   // Resourceadm
diff --git a/frontend/packages/shared/src/types/api/CodeListsResponse.ts b/frontend/packages/shared/src/types/api/CodeListsResponse.ts
new file mode 100644
index 00000000000..875fa3b26dd
--- /dev/null
+++ b/frontend/packages/shared/src/types/api/CodeListsResponse.ts
@@ -0,0 +1,3 @@
+import type { CodeListData } from '../CodeListData';
+
+export type CodeListsResponse = CodeListData[];
diff --git a/frontend/packages/shared/src/utils/featureToggleUtils.ts b/frontend/packages/shared/src/utils/featureToggleUtils.ts
index defafe43ee5..98a84eb2581 100644
--- a/frontend/packages/shared/src/utils/featureToggleUtils.ts
+++ b/frontend/packages/shared/src/utils/featureToggleUtils.ts
@@ -10,6 +10,7 @@ export enum FeatureFlag {
   Maskinporten = 'maskinporten',
   MainConfig = 'mainConfig',
   OptionListEditor = 'optionListEditor',
+  OrgLibrary = 'orgLibrary',
   ShouldOverrideAppLibCheck = 'shouldOverrideAppLibCheck',
   TaskNavigation = 'taskNavigation',
 }
diff --git a/frontend/testing/playwright/components/DashboardHeader.ts b/frontend/testing/playwright/components/DashboardHeader.ts
new file mode 100644
index 00000000000..4249c6a54be
--- /dev/null
+++ b/frontend/testing/playwright/components/DashboardHeader.ts
@@ -0,0 +1,17 @@
+import { BasePage } from '../helpers/BasePage';
+import type { Environment } from '../helpers/StudioEnvironment';
+import type { Page } from '@playwright/test';
+
+type TopMenuName = 'dashboard' | 'library';
+
+export class DashboardHeader extends BasePage {
+  constructor(page: Page, environment?: Environment) {
+    super(page, environment);
+  }
+
+  public async clickOnNavigateToPageInTopMenuHeader(menuName: TopMenuName): Promise<void> {
+    await this.page
+      .getByRole('link', { name: this.textMock(`dashboard.header_item_${menuName}`) })
+      .click();
+  }
+}
diff --git a/frontend/testing/playwright/enum/AppNames.ts b/frontend/testing/playwright/enum/AppNames.ts
index 2e289eed1ac..23085cdd5aa 100644
--- a/frontend/testing/playwright/enum/AppNames.ts
+++ b/frontend/testing/playwright/enum/AppNames.ts
@@ -8,4 +8,5 @@ export enum AppNames {
   UI_EDITOR_APP = 'ui-editor-app-test',
   TEXT_EDITOR_APP = 'text-editor-app-test',
   PROCESS_EDITOR_APP = 'process-editor-app-test',
+  ORG_LIBRARY = 'org-library-app-test',
 }
diff --git a/frontend/testing/playwright/enum/TestNames.ts b/frontend/testing/playwright/enum/TestNames.ts
index 29518cdb97d..fcd051b0653 100644
--- a/frontend/testing/playwright/enum/TestNames.ts
+++ b/frontend/testing/playwright/enum/TestNames.ts
@@ -11,4 +11,5 @@ export enum TestNames {
   SETTINGS_MODAL = 'settings-modal',
   TEXT_EDITOR = 'text-editor',
   PROCESS_EDITOR = 'process-editor',
+  ORG_LIBRARY = 'org-library',
 }
diff --git a/frontend/testing/playwright/helpers/RouterRoute.ts b/frontend/testing/playwright/helpers/RouterRoute.ts
index 04a354ca238..8c29511d37b 100644
--- a/frontend/testing/playwright/helpers/RouterRoute.ts
+++ b/frontend/testing/playwright/helpers/RouterRoute.ts
@@ -5,6 +5,8 @@ type SupportedRoutes =
   | 'altinnLoginPage'
   | 'dashboard'
   | 'dashboardCreateApp'
+  | 'dashboardAsOrg'
+  | 'orgLibrary'
   | 'deploy'
   | 'editorOverview'
   | 'editorDataModel'
@@ -18,8 +20,10 @@ type RouterRoutes = Record<SupportedRoutes, string>;
 
 const routerRoutes: RouterRoutes = {
   altinnLoginPage: '/',
-  dashboard: '/dashboard/self',
-  dashboardCreateApp: '/dashboard/self/new',
+  dashboard: '/dashboard/app-dashboard/self',
+  dashboardCreateApp: '/dashboard/app-dashboard/self/new',
+  dashboardAsOrg: '/dashboard/app-dashboard/{{org}}',
+  orgLibrary: '/dashboard/org-library/{{org}}',
   deploy: '/editor/{{org}}/{{app}}/deploy',
   editorOverview: '/editor/{{org}}/{{app}}/overview',
   editorDataModel: '/editor/{{org}}/{{app}}/data-model',
diff --git a/frontend/testing/playwright/pages/DashboardPage.ts b/frontend/testing/playwright/pages/DashboardPage.ts
index b28f3417140..65e04f27cfe 100644
--- a/frontend/testing/playwright/pages/DashboardPage.ts
+++ b/frontend/testing/playwright/pages/DashboardPage.ts
@@ -11,10 +11,20 @@ export class DashboardPage extends BasePage {
     await this.page.goto(this.getRoute('dashboard'));
   }
 
+  public async loadDashboardPageAsOrg(featureFlag?: string): Promise<void> {
+    const featureFlagParam: string = featureFlag ?? '';
+    await this.page.goto(this.getRoute('dashboardAsOrg') + featureFlagParam);
+  }
+
   public async verifyDashboardPage(): Promise<void> {
     await this.page.waitForURL(this.getRoute('dashboard'));
   }
 
+  public async verifyDashboardPageAsOrg(featureFlag?: string): Promise<void> {
+    const featureFlagParam: string = featureFlag ?? '';
+    await this.page.waitForURL(this.getRoute('dashboardAsOrg') + featureFlagParam);
+  }
+
   public async clickOnCreateAppLink(): Promise<void> {
     await this.page.getByRole('link', { name: this.textMock('dashboard.new_service') }).click();
   }
diff --git a/frontend/testing/playwright/pages/OrgLibraryPage/CodeLists.ts b/frontend/testing/playwright/pages/OrgLibraryPage/CodeLists.ts
new file mode 100644
index 00000000000..130f8ba625b
--- /dev/null
+++ b/frontend/testing/playwright/pages/OrgLibraryPage/CodeLists.ts
@@ -0,0 +1,212 @@
+import { BasePage } from '../../helpers/BasePage';
+import { expect, type Page } from '@playwright/test';
+import path from 'path';
+
+export class CodeLists extends BasePage {
+  constructor(public page: Page) {
+    super(page);
+  }
+
+  public async waitForCodeListPageToLoad(): Promise<void> {
+    const heading = this.page.getByRole('heading', {
+      name: this.textMock('app_content_library.code_lists.page_name'),
+      level: 1,
+      exact: true,
+    });
+
+    await expect(heading).toBeVisible();
+  }
+
+  public async clickOnCreateNewCodelistButton(): Promise<void> {
+    await this.page
+      .getByRole('button', {
+        name: this.textMock('app_content_library.code_lists.create_new_code_list'),
+      })
+      .click();
+  }
+
+  public async verifyNewCodelistModalIsOpen(): Promise<void> {
+    const modalTitle = this.page.getByRole('heading', {
+      name: this.textMock('app_content_library.code_lists.create_new_code_list_modal_title'),
+      level: 2,
+    });
+
+    await expect(modalTitle).toBeVisible({ timeout: 8000 });
+  }
+
+  public async writeCodelistTitle(title: string): Promise<void> {
+    await this.page
+      .getByRole('textbox', {
+        name: this.textMock('app_content_library.code_lists.create_new_code_list_name'),
+      })
+      .fill(title);
+  }
+
+  public async clickOnAddAlternativeButton(): Promise<void> {
+    await this.page
+      .getByRole('button', {
+        name: this.textMock('code_list_editor.add_option'),
+      })
+      .click();
+  }
+
+  public async verifyNewItemValueFieldIsVisible(itemNumber: number): Promise<void> {
+    const newItemValueField = this.page.getByRole('textbox', {
+      name: this.textMock('code_list_editor.value_item', { number: itemNumber.toString() }),
+      exact: true,
+    });
+
+    await expect(newItemValueField).toBeVisible();
+  }
+
+  public async writeCodelistValue(itemNumber: number, value: string): Promise<void> {
+    await this.page
+      .getByRole('textbox', {
+        name: this.textMock('code_list_editor.value_item', { number: itemNumber.toString() }),
+        exact: true,
+      })
+      .fill(value);
+  }
+
+  public async writeCodelistLabel(itemNumber: number, label: string): Promise<void> {
+    await this.page
+      .getByRole('textbox', {
+        name: this.textMock('code_list_editor.label_item', { number: itemNumber.toString() }),
+      })
+      .fill(label);
+  }
+
+  public async clickOnSaveCodelistButton(): Promise<void> {
+    await this.page
+      .getByRole('button', {
+        name: this.textMock('app_content_library.code_lists.save_new_code_list'),
+      })
+      .click();
+  }
+
+  public async verifyThatCodeListIsVisible(title: string): Promise<void> {
+    const codeList = this.page.getByTitle(
+      this.textMock('app_content_library.code_lists.code_list_accordion_title', {
+        codeListTitle: title,
+      }),
+    );
+
+    await expect(codeList).toBeVisible();
+  }
+
+  public async clickOnAddItemButton(): Promise<void> {
+    await this.page
+      .getByRole('button', {
+        name: this.textMock('code_list_editor.add_option'),
+      })
+      .click();
+  }
+
+  public async clickOnCodeListAccordion(codeListTitle: string): Promise<void> {
+    await this.page.getByRole('heading', { name: codeListTitle }).click();
+  }
+
+  public async typeInSearchBox(searchTerm: string): Promise<void> {
+    await this.page
+      .getByRole('searchbox', {
+        name: this.textMock('app_content_library.code_lists.search_label'),
+      })
+      .fill(searchTerm);
+  }
+
+  public async clickOnDeleteCodelistButton(): Promise<void> {
+    await this.page
+      .getByRole('button', {
+        name: this.textMock('app_content_library.code_lists.code_list_delete'),
+      })
+      .click();
+  }
+
+  public async verifyEmptyValueTextfield(itemNumber: number): Promise<void> {
+    await this.verifyValueTextfield(itemNumber, '');
+  }
+
+  public async verifyEmptyLabelTextfield(itemNumber: number): Promise<void> {
+    await this.verifyLabelTextfield(itemNumber, '');
+  }
+
+  public async verifyValueTextfield(itemNumber: number, value: string): Promise<void> {
+    const textfield = this.page.getByRole('textbox', {
+      name: this.textMock(`code_list_editor.value_item`, { number: itemNumber.toString() }),
+      exact: true,
+    });
+
+    await expect(textfield).toHaveValue(value);
+  }
+
+  public async verifyLabelTextfield(itemNumber: number, value: string): Promise<void> {
+    const textfield = this.page.getByRole('textbox', {
+      name: this.textMock(`code_list_editor.label_item`, { number: itemNumber.toString() }),
+      exact: true,
+    });
+
+    await expect(textfield).toHaveValue(value);
+  }
+
+  public async clickOnUploadButtonAndSelectFileToUpload(fileName: string): Promise<void> {
+    const fileChooserPromise = this.page.waitForEvent('filechooser');
+
+    await this.clickOnUploadCodelistButton();
+
+    const fileChooser = await fileChooserPromise;
+    await fileChooser.setFiles(path.join(__dirname, fileName));
+  }
+
+  public async listenToAndWaitForConfirmDeleteCodeList(codeListTitle: string): Promise<void> {
+    this.page.once('dialog', async (dialog) => {
+      expect(dialog.type()).toBe('confirm');
+      expect(dialog.message()).toContain(
+        this.textMock('app_content_library.code_lists.code_list_delete_confirm', { codeListTitle }),
+      );
+      await dialog.accept();
+    });
+  }
+
+  public async verifyThatCodeListIsNotVisible(title: string): Promise<void> {
+    const codeList = this.page.getByTitle(
+      this.textMock('app_content_library.code_lists.code_list_accordion_title', {
+        codeListTitle: title,
+      }),
+    );
+
+    await expect(codeList).toBeHidden();
+  }
+
+  public async verifyNumberOfItemsInTheCodelist(
+    numberOfItems: number,
+    codeListTitle: string,
+  ): Promise<void> {
+    const accordionTitle = this.page.getByRole('heading', { name: codeListTitle });
+    const accordion = accordionTitle.locator('xpath=..');
+    const table = accordion.getByRole('table');
+    const rows = table.getByRole('row');
+
+    const headerRow: number = 1;
+    const totalNumberOfRows: number = numberOfItems + headerRow;
+
+    await expect(rows).toHaveCount(totalNumberOfRows);
+  }
+
+  public async clickOnDeleteItemButton(itemNumber: number): Promise<void> {
+    await this.page
+      .getByRole('button', {
+        name: this.textMock('code_list_editor.delete_code_list_item', {
+          number: itemNumber.toString(),
+        }),
+      })
+      .click();
+  }
+
+  private async clickOnUploadCodelistButton(): Promise<void> {
+    await this.page
+      .getByRole('button', {
+        name: this.textMock('app_content_library.code_lists.upload_code_list'),
+      })
+      .click();
+  }
+}
diff --git a/frontend/testing/playwright/pages/OrgLibraryPage/OrgLibraryPage.ts b/frontend/testing/playwright/pages/OrgLibraryPage/OrgLibraryPage.ts
new file mode 100644
index 00000000000..f4b5d41ce93
--- /dev/null
+++ b/frontend/testing/playwright/pages/OrgLibraryPage/OrgLibraryPage.ts
@@ -0,0 +1,38 @@
+import { expect } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import { BasePage } from '../../helpers/BasePage';
+import type { Environment } from '../../helpers/StudioEnvironment';
+import { CodeLists } from './CodeLists';
+
+export class OrgLibraryPage extends BasePage {
+  public readonly codeLists: CodeLists;
+
+  constructor(page: Page, environment?: Environment) {
+    super(page, environment);
+    this.codeLists = new CodeLists(page);
+  }
+
+  public async loadOrgLibraryPage(): Promise<void> {
+    await this.page.goto(this.getRoute('orgLibrary'));
+  }
+
+  public async verifyOrgLibraryPage(): Promise<void> {
+    await this.page.waitForURL(this.getRoute('orgLibrary'));
+  }
+
+  public async waitForPageHeaderToBeVisible(): Promise<void> {
+    const heading = this.page.getByRole('heading', {
+      name: this.textMock('app_content_library.library_heading'),
+      level: 1,
+      exact: true,
+    });
+
+    await expect(heading).toBeVisible();
+  }
+
+  public async clickOnNavigateToCodeListPage(): Promise<void> {
+    await this.page
+      .getByRole('tab', { name: this.textMock('app_content_library.code_lists.page_name') })
+      .click();
+  }
+}
diff --git a/frontend/testing/playwright/pages/OrgLibraryPage/index.ts b/frontend/testing/playwright/pages/OrgLibraryPage/index.ts
new file mode 100644
index 00000000000..9422c4b787b
--- /dev/null
+++ b/frontend/testing/playwright/pages/OrgLibraryPage/index.ts
@@ -0,0 +1 @@
+export { OrgLibraryPage } from './OrgLibraryPage';
diff --git a/frontend/testing/playwright/pages/OrgLibraryPage/testCodelist.json b/frontend/testing/playwright/pages/OrgLibraryPage/testCodelist.json
new file mode 100644
index 00000000000..4663f2cd33c
--- /dev/null
+++ b/frontend/testing/playwright/pages/OrgLibraryPage/testCodelist.json
@@ -0,0 +1,5 @@
+[
+  { "value": "test1", "label": "test1" },
+  { "value": "test2", "label": "test2" },
+  { "value": "test3", "label": "test3" }
+]
diff --git a/frontend/testing/playwright/playwright.config.ts b/frontend/testing/playwright/playwright.config.ts
index 35416cdfb59..e28105184ab 100644
--- a/frontend/testing/playwright/playwright.config.ts
+++ b/frontend/testing/playwright/playwright.config.ts
@@ -132,6 +132,19 @@ export default defineConfig<ExtendedTestOptions>({
         headless: true,
       },
     },
+    {
+      name: TestNames.ORG_LIBRARY,
+      dependencies: [TestNames.SETUP],
+      testDir: './tests/org-library/',
+      testMatch: '*.spec.ts',
+      timeout: 60000,
+      use: {
+        ...devices['Desktop Chrome'],
+        storageState: '.playwright/auth/user.json',
+        testAppName: AppNames.ORG_LIBRARY,
+        headless: true,
+      },
+    },
     {
       name: TestNames.LOGOUT,
       dependencies: [
@@ -145,6 +158,7 @@ export default defineConfig<ExtendedTestOptions>({
         TestNames.SETTINGS_MODAL,
         TestNames.TEXT_EDITOR,
         TestNames.PROCESS_EDITOR,
+        TestNames.ORG_LIBRARY,
       ],
       testDir: './tests/logout/',
       testMatch: '*.spec.ts',
diff --git a/frontend/testing/playwright/tests/dashboard/dashboard-navigation.spec.ts b/frontend/testing/playwright/tests/dashboard/dashboard-navigation.spec.ts
new file mode 100644
index 00000000000..95f5bbc3362
--- /dev/null
+++ b/frontend/testing/playwright/tests/dashboard/dashboard-navigation.spec.ts
@@ -0,0 +1,48 @@
+import { expect } from '@playwright/test';
+import { test } from '../../extenders/testExtend';
+import { DesignerApi } from '../../helpers/DesignerApi';
+import type { StorageState } from '../../types/StorageState';
+import { Gitea } from '../../helpers/Gitea';
+import { OrgLibraryPage } from '../../pages/OrgLibraryPage';
+import { DashboardPage } from '../../pages/DashboardPage';
+import { DashboardHeader } from '../../components/DashboardHeader';
+
+const TEST_ORG: string = 'ttd';
+const ORG_LIBRARY_FEATURE_FLAG: string = '?featureFlags=orgLibrary&persistFeatureFlag=true';
+
+test.describe.configure({ mode: 'serial' });
+
+test.beforeAll(async ({ testAppName, request, storageState }) => {
+  const designerApi = new DesignerApi({ app: testAppName, org: TEST_ORG });
+  const response = await designerApi.createApp(request, storageState as StorageState);
+  expect(response.ok()).toBeTruthy();
+});
+
+test.afterAll(async ({ request, testAppName }) => {
+  const gitea = new Gitea();
+  const response = await request.delete(
+    gitea.getDeleteAppEndpoint({ app: testAppName, org: TEST_ORG }),
+  );
+  expect(response.ok()).toBeTruthy();
+});
+
+test('that it is possible to navigate from dashboard page to library page and back again', async ({
+  page,
+  testAppName,
+}) => {
+  const dashboardPage = new DashboardPage(page, { app: testAppName, org: TEST_ORG });
+  const dashboardHeader: DashboardHeader = new DashboardHeader(page, {
+    app: testAppName,
+    org: TEST_ORG,
+  });
+  const orgLibraryPage = new OrgLibraryPage(page, { app: testAppName, org: TEST_ORG });
+
+  await dashboardPage.loadDashboardPageAsOrg(ORG_LIBRARY_FEATURE_FLAG);
+  await dashboardPage.verifyDashboardPageAsOrg(ORG_LIBRARY_FEATURE_FLAG);
+  await dashboardHeader.clickOnNavigateToPageInTopMenuHeader('library');
+  await orgLibraryPage.verifyOrgLibraryPage();
+  await orgLibraryPage.waitForPageHeaderToBeVisible();
+
+  await dashboardHeader.clickOnNavigateToPageInTopMenuHeader('dashboard');
+  await dashboardPage.verifyDashboardPageAsOrg();
+});
diff --git a/frontend/testing/playwright/tests/org-library/codelists.spec.ts b/frontend/testing/playwright/tests/org-library/codelists.spec.ts
new file mode 100644
index 00000000000..5cc1403baa7
--- /dev/null
+++ b/frontend/testing/playwright/tests/org-library/codelists.spec.ts
@@ -0,0 +1,190 @@
+import { expect } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import { test } from '../../extenders/testExtend';
+import { DesignerApi } from '../../helpers/DesignerApi';
+import type { StorageState } from '../../types/StorageState';
+import { Gitea } from '../../helpers/Gitea';
+import { OrgLibraryPage } from '../../pages/OrgLibraryPage';
+
+const TEST_ORG: string = 'ttd';
+const CODELIST_TITLE_MANUALLY: string = 'Test_codelist';
+const CODELIST_TITLE_UPLOADED: string = 'testCodelist';
+
+const EXPECTED_NUMBER_OF_ITEMS_IN_MANUALLY_CREATED_CODELIST: number = 1;
+const EXPECTED_NUMBER_OF_ROWS_IN_MANUALLY_CREATED_CODELIST_AFTER_ADDING_ROW: number =
+  EXPECTED_NUMBER_OF_ITEMS_IN_MANUALLY_CREATED_CODELIST + 1;
+const EXPECTED_NUMBER_OF_ROWS_IN_UPLOADED_CODELIST: number = 3;
+const EXPECTED_NUMBER_OF_ROWS_IN_UPLOADED_CODELIST_AFTER_DELETE: number =
+  EXPECTED_NUMBER_OF_ROWS_IN_UPLOADED_CODELIST - 1;
+
+test.describe.configure({ mode: 'serial' });
+
+test.beforeAll(async ({ testAppName, request, storageState }) => {
+  const designerApi = new DesignerApi({ app: testAppName, org: TEST_ORG });
+  const response = await designerApi.createApp(request, storageState as StorageState);
+  expect(response.ok()).toBeTruthy();
+});
+
+test.afterAll(async ({ request, testAppName }) => {
+  const gitea = new Gitea();
+  const response = await request.delete(
+    gitea.getDeleteAppEndpoint({ app: testAppName, org: TEST_ORG }),
+  );
+  expect(response.ok()).toBeTruthy();
+});
+
+const setupAndVerifyCodeListPage = async (
+  page: Page,
+  testAppName: string,
+): Promise<OrgLibraryPage> => {
+  const orgLibraryPage = new OrgLibraryPage(page, { app: testAppName, org: TEST_ORG });
+  await orgLibraryPage.loadOrgLibraryPage();
+  await orgLibraryPage.verifyOrgLibraryPage();
+  await orgLibraryPage.waitForPageHeaderToBeVisible();
+  await orgLibraryPage.clickOnNavigateToCodeListPage();
+  await orgLibraryPage.codeLists.waitForCodeListPageToLoad();
+
+  return orgLibraryPage;
+};
+
+test('that it is possible to create a new codelist', async ({ page, testAppName }) => {
+  const orgLibraryPage: OrgLibraryPage = await setupAndVerifyCodeListPage(page, testAppName);
+
+  await orgLibraryPage.codeLists.clickOnCreateNewCodelistButton();
+  await orgLibraryPage.codeLists.verifyNewCodelistModalIsOpen();
+  await orgLibraryPage.codeLists.writeCodelistTitle(CODELIST_TITLE_MANUALLY);
+  await orgLibraryPage.codeLists.clickOnAddAlternativeButton();
+
+  await orgLibraryPage.codeLists.verifyNewItemValueFieldIsVisible(
+    EXPECTED_NUMBER_OF_ITEMS_IN_MANUALLY_CREATED_CODELIST,
+  );
+  const firstRowValue: string = 'First value';
+  await orgLibraryPage.codeLists.writeCodelistValue(
+    EXPECTED_NUMBER_OF_ITEMS_IN_MANUALLY_CREATED_CODELIST,
+    firstRowValue,
+  );
+  const firstRowLabel: string = 'First label';
+  await orgLibraryPage.codeLists.writeCodelistLabel(
+    EXPECTED_NUMBER_OF_ITEMS_IN_MANUALLY_CREATED_CODELIST,
+    firstRowLabel,
+  );
+
+  await orgLibraryPage.codeLists.clickOnSaveCodelistButton();
+  await orgLibraryPage.codeLists.verifyThatCodeListIsVisible(CODELIST_TITLE_MANUALLY);
+});
+
+test('that it is possible to add a new row to an existing codelist and modify the fields in the row', async ({
+  page,
+  testAppName,
+}) => {
+  const orgLibraryPage: OrgLibraryPage = await setupAndVerifyCodeListPage(page, testAppName);
+
+  await orgLibraryPage.codeLists.verifyThatCodeListIsVisible(CODELIST_TITLE_MANUALLY);
+  await orgLibraryPage.codeLists.clickOnCodeListAccordion(CODELIST_TITLE_MANUALLY);
+
+  await orgLibraryPage.codeLists.verifyNumberOfItemsInTheCodelist(
+    EXPECTED_NUMBER_OF_ITEMS_IN_MANUALLY_CREATED_CODELIST,
+    CODELIST_TITLE_MANUALLY,
+  );
+
+  await orgLibraryPage.codeLists.clickOnAddItemButton();
+  await orgLibraryPage.codeLists.verifyNumberOfItemsInTheCodelist(
+    EXPECTED_NUMBER_OF_ROWS_IN_MANUALLY_CREATED_CODELIST_AFTER_ADDING_ROW,
+    CODELIST_TITLE_MANUALLY,
+  );
+
+  const lastlyAddedItemNumber: number =
+    EXPECTED_NUMBER_OF_ROWS_IN_MANUALLY_CREATED_CODELIST_AFTER_ADDING_ROW;
+  await orgLibraryPage.codeLists.verifyEmptyValueTextfield(lastlyAddedItemNumber);
+  await orgLibraryPage.codeLists.verifyEmptyLabelTextfield(lastlyAddedItemNumber);
+
+  const value: string = 'value';
+  await orgLibraryPage.codeLists.writeCodelistValue(lastlyAddedItemNumber, value);
+  await orgLibraryPage.codeLists.verifyValueTextfield(lastlyAddedItemNumber, value);
+
+  const label: string = 'label';
+  await orgLibraryPage.codeLists.writeCodelistLabel(lastlyAddedItemNumber, label);
+  await orgLibraryPage.codeLists.verifyLabelTextfield(lastlyAddedItemNumber, label);
+});
+
+test('that it is possible to upload a new codelist', async ({ page, testAppName }) => {
+  const orgLibraryPage: OrgLibraryPage = await setupAndVerifyCodeListPage(page, testAppName);
+
+  const codelistFileName: string = `${CODELIST_TITLE_UPLOADED}.json`;
+  await orgLibraryPage.codeLists.clickOnUploadButtonAndSelectFileToUpload(codelistFileName);
+  await orgLibraryPage.codeLists.verifyThatCodeListIsVisible(CODELIST_TITLE_UPLOADED);
+  await orgLibraryPage.codeLists.verifyNumberOfItemsInTheCodelist(
+    EXPECTED_NUMBER_OF_ROWS_IN_UPLOADED_CODELIST,
+    CODELIST_TITLE_UPLOADED,
+  );
+});
+
+test('that it is possible to delete a row in an uploaded codelist', async ({
+  page,
+  testAppName,
+}) => {
+  const orgLibraryPage: OrgLibraryPage = await setupAndVerifyCodeListPage(page, testAppName);
+
+  await orgLibraryPage.codeLists.clickOnCodeListAccordion(CODELIST_TITLE_UPLOADED);
+  await orgLibraryPage.codeLists.verifyThatCodeListIsVisible(CODELIST_TITLE_UPLOADED);
+  await orgLibraryPage.codeLists.verifyNumberOfItemsInTheCodelist(
+    EXPECTED_NUMBER_OF_ROWS_IN_UPLOADED_CODELIST,
+    CODELIST_TITLE_UPLOADED,
+  );
+
+  const itemNumberOne: number = 1;
+  const firstItemValue: string = 'test1';
+  const secondItemValue: string = 'test2';
+  await orgLibraryPage.codeLists.verifyValueTextfield(itemNumberOne, firstItemValue);
+  await orgLibraryPage.codeLists.clickOnDeleteItemButton(itemNumberOne);
+
+  await orgLibraryPage.codeLists.verifyNumberOfItemsInTheCodelist(
+    EXPECTED_NUMBER_OF_ROWS_IN_UPLOADED_CODELIST_AFTER_DELETE,
+    CODELIST_TITLE_UPLOADED,
+  );
+  await orgLibraryPage.codeLists.verifyValueTextfield(itemNumberOne, secondItemValue);
+});
+
+test('that it is possible to search for and delete the new codelists', async ({
+  page,
+  testAppName,
+}) => {
+  const orgLibraryPage: OrgLibraryPage = await setupAndVerifyCodeListPage(page, testAppName);
+
+  await searchForAndOpenCodeList(orgLibraryPage, CODELIST_TITLE_MANUALLY);
+  await deleteAndVerifyDeletionOfCodeList(
+    orgLibraryPage,
+    CODELIST_TITLE_MANUALLY,
+    EXPECTED_NUMBER_OF_ROWS_IN_MANUALLY_CREATED_CODELIST_AFTER_ADDING_ROW,
+  );
+
+  await searchForAndOpenCodeList(orgLibraryPage, CODELIST_TITLE_UPLOADED);
+  await deleteAndVerifyDeletionOfCodeList(
+    orgLibraryPage,
+    CODELIST_TITLE_UPLOADED,
+    EXPECTED_NUMBER_OF_ROWS_IN_UPLOADED_CODELIST_AFTER_DELETE,
+  );
+});
+
+const searchForAndOpenCodeList = async (
+  orgLibraryPage: OrgLibraryPage,
+  codelistTitle: string,
+): Promise<void> => {
+  await orgLibraryPage.codeLists.typeInSearchBox(codelistTitle);
+  await orgLibraryPage.codeLists.verifyThatCodeListIsVisible(codelistTitle);
+  await orgLibraryPage.codeLists.clickOnCodeListAccordion(codelistTitle);
+};
+
+const deleteAndVerifyDeletionOfCodeList = async (
+  orgLibraryPage: OrgLibraryPage,
+  codelistTitle: string,
+  expectedNumberOfRowsInCodeList: number,
+): Promise<void> => {
+  await orgLibraryPage.codeLists.verifyNumberOfItemsInTheCodelist(
+    expectedNumberOfRowsInCodeList,
+    codelistTitle,
+  );
+  await orgLibraryPage.codeLists.listenToAndWaitForConfirmDeleteCodeList(codelistTitle);
+  await orgLibraryPage.codeLists.clickOnDeleteCodelistButton();
+  await orgLibraryPage.codeLists.verifyThatCodeListIsNotVisible(codelistTitle);
+};
diff --git a/frontend/testing/playwright/tests/org-library/org-library.spec.ts b/frontend/testing/playwright/tests/org-library/org-library.spec.ts
new file mode 100644
index 00000000000..381290beb29
--- /dev/null
+++ b/frontend/testing/playwright/tests/org-library/org-library.spec.ts
@@ -0,0 +1,46 @@
+import { expect } from '@playwright/test';
+import type { Page } from '@playwright/test';
+import { test } from '../../extenders/testExtend';
+import { DesignerApi } from '../../helpers/DesignerApi';
+import type { StorageState } from '../../types/StorageState';
+import { Gitea } from '../../helpers/Gitea';
+import { OrgLibraryPage } from '../../pages/OrgLibraryPage';
+
+const TEST_ORG: string = 'ttd';
+
+test.describe.configure({ mode: 'serial' });
+
+test.beforeAll(async ({ testAppName, request, storageState }) => {
+  const designerApi = new DesignerApi({ app: testAppName, org: TEST_ORG });
+  const response = await designerApi.createApp(request, storageState as StorageState);
+  expect(response.ok()).toBeTruthy();
+});
+
+test.afterAll(async ({ request, testAppName }) => {
+  const gitea = new Gitea();
+  const response = await request.delete(
+    gitea.getDeleteAppEndpoint({ app: testAppName, org: TEST_ORG }),
+  );
+  expect(response.ok()).toBeTruthy();
+});
+
+const setupAndVerifyOrgLibraryPage = async (
+  page: Page,
+  testAppName: string,
+): Promise<OrgLibraryPage> => {
+  const orgLibraryPage = new OrgLibraryPage(page, { app: testAppName, org: TEST_ORG });
+  await orgLibraryPage.loadOrgLibraryPage();
+  await orgLibraryPage.verifyOrgLibraryPage();
+  await orgLibraryPage.waitForPageHeaderToBeVisible();
+  return orgLibraryPage;
+};
+
+test('that it is possible to navigate to code list page and that the page is empty', async ({
+  page,
+  testAppName,
+}) => {
+  const orgLibraryPage: OrgLibraryPage = await setupAndVerifyOrgLibraryPage(page, testAppName);
+
+  await orgLibraryPage.clickOnNavigateToCodeListPage();
+  await orgLibraryPage.codeLists.waitForCodeListPageToLoad();
+});