chore: add coverage directory to .gitignore

refactor: remove unused using directive for Going.Plaid.Transactions in PlaidTransactionProcessorTests
tests(infra.tests): enhance AccountBuilder with metadata handling and expand PlaidTransactionSyncerTests
2026-03-08 16:22:39 -05:00 · 2026-03-08 16:16:07 -05:00 · 2026-03-08 16:14:51 -05:00 · 2026-03-08 09:15:45 -05:00 · 2026-03-08 07:18:27 -05:00 · 2026-03-06 07:14:57 -06:00
193 changed files with 66239 additions and 325 deletions
@@ -0,0 +1,3 @@
+{
+  "appHostPath": "../src/FiscalOS.AppHost/FiscalOS.AppHost.csproj"
+}
@@ -94,7 +94,7 @@ csharp_style_var_when_type_is_apparent = true:suggestion
 csharp_style_expression_bodied_accessors = true:silent
 csharp_style_expression_bodied_constructors = false:silent
 csharp_style_expression_bodied_indexers = true:silent
-csharp_style_expression_bodied_lambdas = true:suggestion
+csharp_style_expression_bodied_lambdas = when_on_single_line:suggestion
 csharp_style_expression_bodied_local_functions = false:silent
 csharp_style_expression_bodied_methods = false:silent
 csharp_style_expression_bodied_operators = false:silent
@@ -3,6 +3,9 @@
 ##
 ## Get latest from `dotnet new gitignore`

+# coverage
+coverage/
+
 # appsettings
 appsettings*.json
 !appsettings.Example.json
@@ -0,0 +1,11 @@
+{
+  "recommendations": [
+    "Vue.volar",
+    "vitest.explorer",
+    "ms-playwright.playwright",
+    "dbaeumer.vscode-eslint",
+    "EditorConfig.EditorConfig",
+    "oxc.oxc-vscode",
+    "esbenp.prettier-vscode"
+  ]
+}
@@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "aspire",
+      "request": "launch",
+      "name": "Aspire: Launch default apphost",
+      "program": "${workspaceFolder}"
+    }
+  ]
+}
@@ -0,0 +1,19 @@
+{
+  "dotnet.defaultSolution": "FiscalOS.slnx",
+  "explorer.fileNesting.enabled": true,
+  "explorer.fileNesting.patterns": {
+    "tsconfig.json": "tsconfig.*.json, env.d.ts, typed-router.d.ts",
+    "vite.config.*": "jsconfig*, vitest.config.*, cypress.config.*, playwright.config.*",
+    "package.json": "package-lock.json, pnpm*, .yarnrc*, yarn*, .eslint*, eslint*, .oxlint*, oxlint*, .oxfmt*, .prettier*, prettier*, .editorconfig"
+  },
+  "editor.codeActionsOnSave": {
+    "source.fixAll": "explicit"
+  },
+  "editor.formatOnSave": true,
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "cSpell.words": ["Encryptor"],
+  "python-envs.defaultEnvManager": "ms-python.python:system",
+  "search.exclude": {
+    "**/Migrations": true
+  }
+}
@@ -1,131 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.0.31903.59
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{0AB3BF05-4346-4AA6-1389-037BE0695223}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FiscalOS.API.Tests", "tests\FiscalOS.API.Tests\FiscalOS.API.Tests.csproj", "{1869E249-07F6-41CD-B143-AF86F022E4A6}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{827E0CD3-B72D-47B6-A68D-7590B98EB39B}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FiscalOS.API", "src\FiscalOS.API\FiscalOS.API.csproj", "{85E0C8F3-AE69-4012-836C-759E9D297762}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FiscalOS.AdminCLI", "src\FiscalOS.AdminCLI\FiscalOS.AdminCLI.csproj", "{C46818A0-1A92-4E4F-8390-48CBA9971745}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FiscalOS.Core", "src\FiscalOS.Core\FiscalOS.Core.csproj", "{612496CD-1F25-4804-8C52-49E62D01FFDC}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FiscalOS.Infra", "src\FiscalOS.Infra\FiscalOS.Infra.csproj", "{DAB42870-02A2-4ECB-B07F-6815C52D2435}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FiscalOS.Infra.Tests", "tests\FiscalOS.Infra.Tests\FiscalOS.Infra.Tests.csproj", "{48E0737E-0200-468E-ADA7-75893935DBC0}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FiscalOS.Core.Tests", "tests\FiscalOS.Core.Tests\FiscalOS.Core.Tests.csproj", "{2D9C02A9-C704-4275-88E9-1BBD3AC12700}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Debug|x64 = Debug|x64
-		Debug|x86 = Debug|x86
-		Release|Any CPU = Release|Any CPU
-		Release|x64 = Release|x64
-		Release|x86 = Release|x86
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{1869E249-07F6-41CD-B143-AF86F022E4A6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{1869E249-07F6-41CD-B143-AF86F022E4A6}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{1869E249-07F6-41CD-B143-AF86F022E4A6}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{1869E249-07F6-41CD-B143-AF86F022E4A6}.Debug|x64.Build.0 = Debug|Any CPU
-		{1869E249-07F6-41CD-B143-AF86F022E4A6}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{1869E249-07F6-41CD-B143-AF86F022E4A6}.Debug|x86.Build.0 = Debug|Any CPU
-		{1869E249-07F6-41CD-B143-AF86F022E4A6}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{1869E249-07F6-41CD-B143-AF86F022E4A6}.Release|Any CPU.Build.0 = Release|Any CPU
-		{1869E249-07F6-41CD-B143-AF86F022E4A6}.Release|x64.ActiveCfg = Release|Any CPU
-		{1869E249-07F6-41CD-B143-AF86F022E4A6}.Release|x64.Build.0 = Release|Any CPU
-		{1869E249-07F6-41CD-B143-AF86F022E4A6}.Release|x86.ActiveCfg = Release|Any CPU
-		{1869E249-07F6-41CD-B143-AF86F022E4A6}.Release|x86.Build.0 = Release|Any CPU
-		{85E0C8F3-AE69-4012-836C-759E9D297762}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{85E0C8F3-AE69-4012-836C-759E9D297762}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{85E0C8F3-AE69-4012-836C-759E9D297762}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{85E0C8F3-AE69-4012-836C-759E9D297762}.Debug|x64.Build.0 = Debug|Any CPU
-		{85E0C8F3-AE69-4012-836C-759E9D297762}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{85E0C8F3-AE69-4012-836C-759E9D297762}.Debug|x86.Build.0 = Debug|Any CPU
-		{85E0C8F3-AE69-4012-836C-759E9D297762}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{85E0C8F3-AE69-4012-836C-759E9D297762}.Release|Any CPU.Build.0 = Release|Any CPU
-		{85E0C8F3-AE69-4012-836C-759E9D297762}.Release|x64.ActiveCfg = Release|Any CPU
-		{85E0C8F3-AE69-4012-836C-759E9D297762}.Release|x64.Build.0 = Release|Any CPU
-		{85E0C8F3-AE69-4012-836C-759E9D297762}.Release|x86.ActiveCfg = Release|Any CPU
-		{85E0C8F3-AE69-4012-836C-759E9D297762}.Release|x86.Build.0 = Release|Any CPU
-		{C46818A0-1A92-4E4F-8390-48CBA9971745}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{C46818A0-1A92-4E4F-8390-48CBA9971745}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{C46818A0-1A92-4E4F-8390-48CBA9971745}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{C46818A0-1A92-4E4F-8390-48CBA9971745}.Debug|x64.Build.0 = Debug|Any CPU
-		{C46818A0-1A92-4E4F-8390-48CBA9971745}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{C46818A0-1A92-4E4F-8390-48CBA9971745}.Debug|x86.Build.0 = Debug|Any CPU
-		{C46818A0-1A92-4E4F-8390-48CBA9971745}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{C46818A0-1A92-4E4F-8390-48CBA9971745}.Release|Any CPU.Build.0 = Release|Any CPU
-		{C46818A0-1A92-4E4F-8390-48CBA9971745}.Release|x64.ActiveCfg = Release|Any CPU
-		{C46818A0-1A92-4E4F-8390-48CBA9971745}.Release|x64.Build.0 = Release|Any CPU
-		{C46818A0-1A92-4E4F-8390-48CBA9971745}.Release|x86.ActiveCfg = Release|Any CPU
-		{C46818A0-1A92-4E4F-8390-48CBA9971745}.Release|x86.Build.0 = Release|Any CPU
-		{612496CD-1F25-4804-8C52-49E62D01FFDC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{612496CD-1F25-4804-8C52-49E62D01FFDC}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{612496CD-1F25-4804-8C52-49E62D01FFDC}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{612496CD-1F25-4804-8C52-49E62D01FFDC}.Debug|x64.Build.0 = Debug|Any CPU
-		{612496CD-1F25-4804-8C52-49E62D01FFDC}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{612496CD-1F25-4804-8C52-49E62D01FFDC}.Debug|x86.Build.0 = Debug|Any CPU
-		{612496CD-1F25-4804-8C52-49E62D01FFDC}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{612496CD-1F25-4804-8C52-49E62D01FFDC}.Release|Any CPU.Build.0 = Release|Any CPU
-		{612496CD-1F25-4804-8C52-49E62D01FFDC}.Release|x64.ActiveCfg = Release|Any CPU
-		{612496CD-1F25-4804-8C52-49E62D01FFDC}.Release|x64.Build.0 = Release|Any CPU
-		{612496CD-1F25-4804-8C52-49E62D01FFDC}.Release|x86.ActiveCfg = Release|Any CPU
-		{612496CD-1F25-4804-8C52-49E62D01FFDC}.Release|x86.Build.0 = Release|Any CPU
-		{DAB42870-02A2-4ECB-B07F-6815C52D2435}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{DAB42870-02A2-4ECB-B07F-6815C52D2435}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{DAB42870-02A2-4ECB-B07F-6815C52D2435}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{DAB42870-02A2-4ECB-B07F-6815C52D2435}.Debug|x64.Build.0 = Debug|Any CPU
-		{DAB42870-02A2-4ECB-B07F-6815C52D2435}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{DAB42870-02A2-4ECB-B07F-6815C52D2435}.Debug|x86.Build.0 = Debug|Any CPU
-		{DAB42870-02A2-4ECB-B07F-6815C52D2435}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{DAB42870-02A2-4ECB-B07F-6815C52D2435}.Release|Any CPU.Build.0 = Release|Any CPU
-		{DAB42870-02A2-4ECB-B07F-6815C52D2435}.Release|x64.ActiveCfg = Release|Any CPU
-		{DAB42870-02A2-4ECB-B07F-6815C52D2435}.Release|x64.Build.0 = Release|Any CPU
-		{DAB42870-02A2-4ECB-B07F-6815C52D2435}.Release|x86.ActiveCfg = Release|Any CPU
-		{DAB42870-02A2-4ECB-B07F-6815C52D2435}.Release|x86.Build.0 = Release|Any CPU
-		{48E0737E-0200-468E-ADA7-75893935DBC0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{48E0737E-0200-468E-ADA7-75893935DBC0}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{48E0737E-0200-468E-ADA7-75893935DBC0}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{48E0737E-0200-468E-ADA7-75893935DBC0}.Debug|x64.Build.0 = Debug|Any CPU
-		{48E0737E-0200-468E-ADA7-75893935DBC0}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{48E0737E-0200-468E-ADA7-75893935DBC0}.Debug|x86.Build.0 = Debug|Any CPU
-		{48E0737E-0200-468E-ADA7-75893935DBC0}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{48E0737E-0200-468E-ADA7-75893935DBC0}.Release|Any CPU.Build.0 = Release|Any CPU
-		{48E0737E-0200-468E-ADA7-75893935DBC0}.Release|x64.ActiveCfg = Release|Any CPU
-		{48E0737E-0200-468E-ADA7-75893935DBC0}.Release|x64.Build.0 = Release|Any CPU
-		{48E0737E-0200-468E-ADA7-75893935DBC0}.Release|x86.ActiveCfg = Release|Any CPU
-		{48E0737E-0200-468E-ADA7-75893935DBC0}.Release|x86.Build.0 = Release|Any CPU
-		{2D9C02A9-C704-4275-88E9-1BBD3AC12700}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{2D9C02A9-C704-4275-88E9-1BBD3AC12700}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{2D9C02A9-C704-4275-88E9-1BBD3AC12700}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{2D9C02A9-C704-4275-88E9-1BBD3AC12700}.Debug|x64.Build.0 = Debug|Any CPU
-		{2D9C02A9-C704-4275-88E9-1BBD3AC12700}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{2D9C02A9-C704-4275-88E9-1BBD3AC12700}.Debug|x86.Build.0 = Debug|Any CPU
-		{2D9C02A9-C704-4275-88E9-1BBD3AC12700}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{2D9C02A9-C704-4275-88E9-1BBD3AC12700}.Release|Any CPU.Build.0 = Release|Any CPU
-		{2D9C02A9-C704-4275-88E9-1BBD3AC12700}.Release|x64.ActiveCfg = Release|Any CPU
-		{2D9C02A9-C704-4275-88E9-1BBD3AC12700}.Release|x64.Build.0 = Release|Any CPU
-		{2D9C02A9-C704-4275-88E9-1BBD3AC12700}.Release|x86.ActiveCfg = Release|Any CPU
-		{2D9C02A9-C704-4275-88E9-1BBD3AC12700}.Release|x86.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(NestedProjects) = preSolution
-		{1869E249-07F6-41CD-B143-AF86F022E4A6} = {0AB3BF05-4346-4AA6-1389-037BE0695223}
-		{85E0C8F3-AE69-4012-836C-759E9D297762} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
-		{C46818A0-1A92-4E4F-8390-48CBA9971745} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
-		{612496CD-1F25-4804-8C52-49E62D01FFDC} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
-		{DAB42870-02A2-4ECB-B07F-6815C52D2435} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
-		{48E0737E-0200-468E-ADA7-75893935DBC0} = {0AB3BF05-4346-4AA6-1389-037BE0695223}
-		{2D9C02A9-C704-4275-88E9-1BBD3AC12700} = {0AB3BF05-4346-4AA6-1389-037BE0695223}
-	EndGlobalSection
-EndGlobal
@@ -0,0 +1,21 @@
+<Solution>
+  <Configurations>
+    <Platform Name="Any CPU" />
+    <Platform Name="x64" />
+    <Platform Name="x86" />
+  </Configurations>
+  <Folder Name="/src/">
+    <Project Path="src/FiscalOS.AdminCLI/FiscalOS.AdminCLI.csproj" />
+    <Project Path="src/FiscalOS.API/FiscalOS.API.csproj" />
+    <Project Path="src/FiscalOS.Core/FiscalOS.Core.csproj" />
+    <Project Path="src/FiscalOS.Infra/FiscalOS.Infra.csproj" />
+  </Folder>
+  <Folder Name="/tests/">
+    <Project Path="tests/FiscalOS.API.Tests/FiscalOS.API.Tests.csproj" />
+    <Project Path="tests/FiscalOS.AppHost.Tests/FiscalOS.AppHost.Tests.csproj" />
+    <Project Path="tests/FiscalOS.Core.Tests/FiscalOS.Core.Tests.csproj" />
+    <Project Path="tests/FiscalOS.Infra.Tests/FiscalOS.Infra.Tests.csproj" />
+  </Folder>
+  <Project Path="src/FiscalOS.AppHost/FiscalOS.AppHost.csproj" />
+  <Project Path="src/FiscalOS.ServiceDefaults/FiscalOS.ServiceDefaults.csproj" />
+</Solution>
@@ -0,0 +1,4 @@
+[*.cs]
+
+dotnet_code_quality.ca1711.allowed_suffixes = Queue
+dotnet_diagnostic.CA1031.severity = none
@@ -3,6 +3,8 @@
    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
  </PropertyGroup>
  <ItemGroup>
+    <PackageVersion Include="Aspire.Hosting.JavaScript" Version="13.1.2" />
+    <PackageVersion Include="Going.Plaid" Version="6.56.0" />
    <PackageVersion Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.2" />
    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.2">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
@@ -12,5 +14,12 @@
    <PackageVersion Include="Microsoft.Extensions.Hosting" Version="10.0.2" />
    <PackageVersion Include="Spectre.Console" Version="0.54.0" />
    <PackageVersion Include="TestableIO.System.IO.Abstractions.Wrappers" Version="22.1.0" />
+    <PackageVersion Include="Microsoft.Extensions.Http.Resilience" Version="10.1.0" />
+    <PackageVersion Include="Microsoft.Extensions.ServiceDiscovery" Version="10.1.0" />
+    <PackageVersion Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.14.0" />
+    <PackageVersion Include="OpenTelemetry.Extensions.Hosting" Version="1.14.0" />
+    <PackageVersion Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.14.0" />
+    <PackageVersion Include="OpenTelemetry.Instrumentation.Http" Version="1.14.0" />
+    <PackageVersion Include="OpenTelemetry.Instrumentation.Runtime" Version="1.14.0" />
  </ItemGroup>
-</Project>
+</Project>
@@ -0,0 +1,16 @@
+namespace FiscalOS.API.Accounts;
+
+internal static class AccountsExtensions
+{
+  private const string RouteGroupPrefix = "/accounts";
+
+  public static RouteGroupBuilder MapAccountsEndpoints(this WebApplication app)
+  {
+    var accountsGroup = app.MapGroup(RouteGroupPrefix)
+      .RequireAuthorization();
+
+    accountsGroup.MapAddEndpoint();
+
+    return accountsGroup;
+  }
+}
@@ -0,0 +1,73 @@
+using Account = FiscalOS.Core.Accounts.Account;
+
+namespace FiscalOS.API.Accounts.Add;
+
+internal static class Endpoint
+{
+  private const string Route = "/";
+
+  public static RouteHandlerBuilder MapAddEndpoint(this RouteGroupBuilder groupBuilder)
+  {
+    return groupBuilder.MapPost(Route, HandleAsync);
+  }
+
+  private static async Task<IResult> HandleAsync(
+    HttpContext httpContext,
+    [FromBody] Request request,
+    [FromServices] AppDbContext appDbContext,
+    [FromServices] IEncryptor encryptor,
+    [FromServices] IPlaidAccountService plaidAccountService,
+    [FromServices] IAsyncQueue<SyncUpdatesQueueItem> queue,
+    CancellationToken ct
+  )
+  {
+    var userId = httpContext.GetUserId();
+
+    var user = await appDbContext.Users
+      .Include(u => u.Institutions.Where(i => i.Metadata is PlaidInstitutionMetadata && ((PlaidInstitutionMetadata)i.Metadata).PlaidId == request.PlaidInstitutionId))
+      .ThenInclude(i => i.Metadata)
+      .Include(u => u.Accounts.Where(a => a.Metadata is PlaidAccountMetadata && ((PlaidAccountMetadata)a.Metadata).PlaidId == request.PlaidAccountId))
+      .ThenInclude(a => a.Metadata)
+      .AsSplitQuery()
+      .SingleOrDefaultAsync(u => u.Id == userId, ct);
+
+    if (user is null)
+    {
+      return Results.Unauthorized();
+    }
+
+    if (user.Institutions.Any() is false)
+    {
+      return Results.ValidationProblem(new Dictionary<string, string[]>
+      {
+        ["PlaidInstitutionId"] = ["The PlaidInstitutionId field is invalid. No institution connected with the given PlaidInstitutionId was found for the user."],
+      });
+    }
+
+    var plaidInstitutionMetadata = (PlaidInstitutionMetadata?)user.Institutions.First().Metadata;
+
+    if (plaidInstitutionMetadata is null)
+    {
+      return Results.ValidationProblem(new Dictionary<string, string[]>
+      {
+        ["PlaidInstitutionId"] = ["The PlaidInstitutionId field is invalid. The connected institution has no plaid metadata"],
+      });
+    }
+
+    if (user.Accounts.Any())
+    {
+      return Results.Conflict();
+    }
+
+    var decryptedAccessToken = await encryptor.DecryptAsyncFor(user, plaidInstitutionMetadata.EncryptedAccessToken, ct);
+    var accountMetadata = PlaidAccountMetadata.From(request.PlaidAccountId, request.PlaidAccountName);
+    var account = Account.From(request.PlaidAccountName, accountMetadata);
+    user.AddAccount(account);
+    user.Institutions.First().AddAccount(account);
+
+    await appDbContext.SaveChangesAsync(ct);
+    await queue.EnqueueAsync(new(plaidInstitutionMetadata.ItemId), ct);
+
+    return Results.Ok();
+  }
+}
@@ -0,0 +1,29 @@
+namespace FiscalOS.API.Accounts.Add;
+
+public record Request : IValidatableObject
+{
+  public string PlaidInstitutionId { get; init; } = string.Empty;
+  public string PlaidAccountId { get; init; } = string.Empty;
+  public string PlaidAccountName { get; init; } = string.Empty;
+
+  public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+  {
+    if (string.IsNullOrWhiteSpace(PlaidInstitutionId))
+    {
+      var fieldName = nameof(PlaidInstitutionId);
+      yield return new($"The {fieldName} field is required.", [fieldName]);
+    }
+
+    if (string.IsNullOrWhiteSpace(PlaidAccountId))
+    {
+      var fieldName = nameof(PlaidAccountId);
+      yield return new($"The {fieldName} field is required.", [fieldName]);
+    }
+
+    if (string.IsNullOrWhiteSpace(PlaidAccountName))
+    {
+      var fieldName = nameof(PlaidAccountName);
+      yield return new($"The {fieldName} field is required.", [fieldName]);
+    }
+  }
+}
@@ -0,0 +1,18 @@
+namespace FiscalOS.API.Auth;
+
+internal static class AuthExtensions
+{
+  private const string RouteGroupPrefix = "/auth";
+
+  public static RouteGroupBuilder MapAuthEndpoints(this WebApplication app)
+  {
+    var authGroup = app.MapGroup(RouteGroupPrefix);
+
+    authGroup.MapLoginEndpoint();
+
+    authGroup.MapRefreshEndpoint()
+      .RequireAuthorization(Schemes.AllowExpiredTokens);
+
+    return authGroup;
+  }
+}
@@ -1,17 +1,17 @@
-namespace FiscalOS.API.Login;
+namespace FiscalOS.API.Auth.Login;

 internal static class Endpoint
 {
  private const string Route = "/login";

-  public static RouteHandlerBuilder MapLoginEndpoint(this WebApplication app)
+  public static RouteHandlerBuilder MapLoginEndpoint(this RouteGroupBuilder groupBuilder)
  {
-    return app.MapPost(Route, HandleAsync);
+    return groupBuilder.MapPost(Route, HandleAsync);
  }

  private static async Task<IResult> HandleAsync(
    HttpContext httpContext,
-    [FromBody] LoginRequest loginRequest,
+    [FromBody] Request loginRequest,
    [FromServices] AppDbContext appDbContext,
    [FromServices] IPasswordHasher passwordHasher,
    [FromServices] ITokenGenerator tokenService
@@ -1,7 +1,6 @@
+namespace FiscalOS.API.Auth.Login;

-namespace FiscalOS.API.Login;
-
-public record LoginRequest : IValidatableObject
+public record Request : IValidatableObject
 {
  public string Username { get; init; } = string.Empty;
  public string Password { get; init; } = string.Empty;
@@ -10,12 +9,14 @@ public record LoginRequest : IValidatableObject
  {
    if (string.IsNullOrWhiteSpace(Username))
    {
-      yield return new("The Username field is required.", [nameof(Username)]);
+      var fieldName = nameof(Username);
+      yield return new($"The {fieldName} field is required.", [fieldName]);
    }

    if (string.IsNullOrWhiteSpace(Password))
    {
-      yield return new("The Password field is required.", [nameof(Password)]);
+      var fieldName = nameof(Password);
+      yield return new($"The {fieldName} field is required.", [fieldName]);
    }
  }
 }
@@ -1,4 +1,4 @@
-namespace FiscalOS.API.Refresh;
+namespace FiscalOS.API.Auth.Login;

 internal sealed record Response
 {
@@ -1,12 +1,12 @@
-namespace FiscalOS.API.Refresh;
+namespace FiscalOS.API.Auth.Refresh;

 internal static class Endpoint
 {
  private const string Route = "/refresh";

-  public static RouteHandlerBuilder MapRefreshEndpoint(this WebApplication app)
+  public static RouteHandlerBuilder MapRefreshEndpoint(this RouteGroupBuilder groupBuilder)
  {
-    return app.MapPost(Route, HandleAsync);
+    return groupBuilder.MapPost(Route, HandleAsync);
  }

  private static async Task<IResult> HandleAsync(
@@ -1,4 +1,4 @@
-namespace FiscalOS.API.Login;
+namespace FiscalOS.API.Auth.Refresh;

 internal sealed record Response
 {
@@ -10,6 +10,7 @@
  <ItemGroup>
    <ProjectReference Include="..\FiscalOS.Core\FiscalOS.Core.csproj" />
    <ProjectReference Include="..\FiscalOS.Infra\FiscalOS.Infra.csproj" />
+    <ProjectReference Include="..\FiscalOS.ServiceDefaults\FiscalOS.ServiceDefaults.csproj" />
  </ItemGroup>

 </Project>
@@ -1,5 +1,3 @@
-using FiscalOS.Core.Identity;
-
 namespace FiscalOS.API.Http;

 internal static class HttpContextExtensions
@@ -0,0 +1,58 @@
+using Institution = FiscalOS.Core.Accounts.Institution;
+
+namespace FiscalOS.API.Institutions.Connect;
+
+internal static class Endpoint
+{
+  private const string Route = "/connect";
+
+  public static RouteHandlerBuilder MapConnectEndpoint(this RouteGroupBuilder groupBuilder)
+  {
+    return groupBuilder.MapPost(Route, HandleAsync);
+  }
+
+  private static async Task<IResult> HandleAsync(
+    HttpContext httpContext,
+    [FromBody] Request request,
+    [FromServices] AppDbContext appDbContext,
+    [FromServices] IPlaidAccountService plaidAccountService,
+    [FromServices] IEncryptor encryptor,
+    CancellationToken ct
+  )
+  {
+    var userId = httpContext.GetUserId();
+
+    var user = await appDbContext.Users
+      .Include(u => u.Institutions
+        .Where(
+          i => i.Metadata is PlaidInstitutionMetadata &&
+            ((PlaidInstitutionMetadata)i.Metadata).PlaidId == request.PlaidInstitutionId
+        )
+      )
+      .ThenInclude(i => i.Metadata)
+      .SingleOrDefaultAsync(u => u.Id == userId, ct);
+
+    if (user is null)
+    {
+      return Results.Unauthorized();
+    }
+
+    if (user.Institutions.Any())
+    {
+      return Results.Conflict();
+    }
+
+    var (itemId, accessToken) = await plaidAccountService.ExchangeTokenAsync(request.PublicToken);
+    var item = await plaidAccountService.GetItemAsync(accessToken);
+    var encryptedAccessToken = await encryptor.EncryptAsyncFor(user, accessToken, ct);
+
+    var plaidMetadata = PlaidInstitutionMetadata.From(item.InstitutionId, item.InstitutionName, encryptedAccessToken, itemId);
+    var institution = Institution.From(item.InstitutionName, plaidMetadata);
+
+    user.AddInstitution(institution);
+
+    await appDbContext.SaveChangesAsync(ct);
+
+    return Results.Ok();
+  }
+}
@@ -0,0 +1,22 @@
+namespace FiscalOS.API.Institutions.Connect;
+
+public record Request : IValidatableObject
+{
+  public string PublicToken { get; init; } = string.Empty;
+  public string PlaidInstitutionId { get; init; } = string.Empty;
+
+  public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+  {
+    if (string.IsNullOrWhiteSpace(PublicToken))
+    {
+      var fieldName = nameof(PublicToken);
+      yield return new($"The {fieldName} field is required.", [fieldName]);
+    }
+
+    if (string.IsNullOrWhiteSpace(PlaidInstitutionId))
+    {
+      var fieldName = nameof(PlaidInstitutionId);
+      yield return new($"The {fieldName} field is required.", [fieldName]);
+    }
+  }
+}
@@ -0,0 +1,35 @@
+namespace FiscalOS.API.Institutions.Get;
+
+internal static class Endpoint
+{
+  private const string Route = "/";
+
+  public static RouteHandlerBuilder MapGetEndpoint(this RouteGroupBuilder groupBuilder)
+  {
+    return groupBuilder.MapGet(Route, HandleAsync);
+  }
+
+  private static async Task<IResult> HandleAsync(
+    HttpContext httpContext,
+    [FromServices] AppDbContext appDbContext
+  )
+  {
+    var userId = httpContext.GetUserId();
+
+    var user = await appDbContext.Users
+      .Include(u => u.Institutions)
+      .ThenInclude(i => i.Accounts)
+      .FirstOrDefaultAsync(u => u.Id == userId);
+
+    if (user is null)
+    {
+      return Results.Unauthorized();
+    }
+
+    var institutionDtos = user.Institutions
+      .Select(InstitutionDto.From)
+      .OrderBy(dto => dto.Name);
+
+    return Results.Ok(Response.From(institutionDtos));
+  }
+}
@@ -0,0 +1,64 @@
+using Account = FiscalOS.Core.Accounts.Account;
+using Institution = FiscalOS.Core.Accounts.Institution;
+
+namespace FiscalOS.API.Institutions.Get;
+
+internal sealed record Response
+{
+  public IEnumerable<InstitutionDto> Institutions { get; init; } = [];
+
+  [JsonConstructor]
+  private Response()
+  {
+  }
+
+  public static Response From(IEnumerable<InstitutionDto> institutions)
+  {
+    return new Response
+    {
+      Institutions = institutions,
+    };
+  }
+}
+
+internal sealed record AccountDto
+{
+  public string Id { get; init; } = string.Empty;
+  public string Name { get; init; } = string.Empty;
+
+  [JsonConstructor]
+  private AccountDto()
+  {
+  }
+
+  public static AccountDto From(Account account)
+  {
+    return new()
+    {
+      Id = account.Id.ToString(),
+      Name = account.Name,
+    };
+  }
+}
+
+internal sealed record InstitutionDto
+{
+  public string Id { get; init; } = string.Empty;
+  public string Name { get; init; } = string.Empty;
+  public IEnumerable<AccountDto> Accounts { get; init; } = [];
+
+  [JsonConstructor]
+  private InstitutionDto()
+  {
+  }
+
+  public static InstitutionDto From(Institution institution)
+  {
+    return new()
+    {
+      Id = institution.Id.ToString(),
+      Name = institution.Name,
+      Accounts = institution.Accounts.Select(AccountDto.From),
+    };
+  }
+}
@@ -0,0 +1,51 @@
+namespace FiscalOS.API.Institutions.GetAvailable;
+
+internal static class Endpoint
+{
+  private const string Route = "/{id}/available";
+
+  public static RouteHandlerBuilder MapGetAvailableEndpoint(this RouteGroupBuilder groupBuilder)
+  {
+    return groupBuilder.MapGet(Route, HandleAsync);
+  }
+
+  private static async Task<IResult> HandleAsync(
+    HttpContext httpContext,
+    [FromRoute] Guid id,
+    [FromServices] AppDbContext appDbContext,
+    [FromServices] IPlaidAccountService plaidAccountService,
+    [FromServices] IEncryptor encryptor,
+    CancellationToken ct
+  )
+  {
+    var userId = httpContext.GetUserId();
+
+    var user = await appDbContext.Users
+      .Include(u => u.Institutions.Where(i => i.Id == id))
+      .ThenInclude(i => i.Metadata)
+      .SingleOrDefaultAsync(u => u.Id == userId, ct);
+
+    if (user is null)
+    {
+      return Results.Unauthorized();
+    }
+
+    if (user.Institutions.Any() is false)
+    {
+      return Results.NotFound();
+    }
+
+    var institution = user.Institutions.First();
+
+    if (institution.Metadata is not PlaidInstitutionMetadata plaidMetadata)
+    {
+      return Results.BadRequest();
+    }
+
+    var accessToken = await encryptor.DecryptAsyncFor(user, plaidMetadata.EncryptedAccessToken, ct);
+    var accounts = await plaidAccountService.GetAccountsAsync(accessToken);
+    var accountsDtos = accounts.Select(a => AvailableAccountDto.From(plaidMetadata, a));
+
+    return Results.Ok(Response.From(accountsDtos));
+  }
+}
@@ -0,0 +1,50 @@
+namespace FiscalOS.API.Institutions.GetAvailable;
+
+internal sealed record Response
+{
+  public IEnumerable<AvailableAccountDto> Accounts { get; init; } = [];
+
+  [JsonConstructor]
+  private Response()
+  {
+  }
+
+  public static Response From(IEnumerable<AvailableAccountDto> accounts)
+  {
+    return new Response
+    {
+      Accounts = accounts
+    };
+  }
+}
+
+internal sealed record AvailableAccountDto
+{
+  public string ProviderInstitutionId { get; init; } = string.Empty;
+  public string ProviderId { get; init; } = string.Empty;
+  public string ProviderName { get; init; } = string.Empty;
+  public decimal CurrentBalance { get; init; }
+  public decimal AvailableBalance { get; init; }
+  public string CurrencyCode { get; init; } = string.Empty;
+
+  [JsonConstructor]
+  private AvailableAccountDto()
+  {
+  }
+
+  public static AvailableAccountDto From(
+    PlaidInstitutionMetadata plaidMetadata,
+    Going.Plaid.Entity.Account plaidAccount
+  )
+  {
+    return new AvailableAccountDto
+    {
+      ProviderInstitutionId = plaidMetadata.PlaidId,
+      ProviderId = plaidAccount.AccountId,
+      ProviderName = plaidAccount.Name,
+      AvailableBalance = plaidAccount.Available,
+      CurrentBalance = plaidAccount.Current,
+      CurrencyCode = plaidAccount.CurrencyCode,
+    };
+  }
+}
@@ -0,0 +1,19 @@
+namespace FiscalOS.API.Institutions;
+
+internal static class InstitutionsExtensions
+{
+  private const string RouteGroupPrefix = "/institutions";
+
+  public static RouteGroupBuilder MapInstitutionsEndpoints(this WebApplication app)
+  {
+    var institutionsGroup = app.MapGroup(RouteGroupPrefix)
+      .RequireAuthorization();
+
+    institutionsGroup.MapConnectEndpoint();
+    institutionsGroup.MapGetAvailableEndpoint();
+    institutionsGroup.MapLinkEndpoint();
+    institutionsGroup.MapGetEndpoint();
+
+    return institutionsGroup;
+  }
+}
@@ -0,0 +1,31 @@
+namespace FiscalOS.API.Institutions.Link;
+
+internal static class Endpoint
+{
+  private const string Route = "/link";
+
+  public static RouteHandlerBuilder MapLinkEndpoint(this RouteGroupBuilder groupBuilder)
+  {
+    return groupBuilder.MapPost(Route, HandleAsync);
+  }
+
+  private static async Task<IResult> HandleAsync(
+    HttpContext httpContext,
+    [FromServices] AppDbContext appDbContext,
+    [FromServices] IPlaidAccountService plaidAccountService
+  )
+  {
+    var userId = httpContext.GetUserId();
+
+    var user = await appDbContext.Users.SingleOrDefaultAsync(u => u.Id == userId);
+
+    if (user is null)
+    {
+      return Results.Unauthorized();
+    }
+
+    var linkToken = await plaidAccountService.CreateLinkTokenAsync(user.Id.ToString());
+
+    return Results.Ok(Response.From(linkToken));
+  }
+}
@@ -0,0 +1,19 @@
+namespace FiscalOS.API.Institutions.Link;
+
+public sealed record Response
+{
+  public string LinkToken { get; init; } = string.Empty;
+
+  [JsonConstructor]
+  private Response()
+  {
+  }
+
+  public static Response From(string linkToken)
+  {
+    return new()
+    {
+      LinkToken = linkToken,
+    };
+  }
+}
@@ -1,8 +1,16 @@
 var builder = WebApplication.CreateBuilder(args);

+builder.AddServiceDefaults();
+
 builder.Services.AddValidation();
 builder.Services.AddProblemDetails();

+builder.Services.ConfigureHttpJsonOptions(static options =>
+{
+  options.SerializerOptions.Converters.Add(new EnumConverterFactory());
+  options.SerializerOptions.Converters.Add(new WebhookBaseConverter());
+});
+
 builder.Services.AddInfrastructure();

 builder.Services.AddAuthentication(static o =>
@@ -32,9 +40,11 @@ app.UseAuthentication();
 app.UseAuthorization();
 app.UseStatusCodePages();

-app.MapLoginEndpoint();
+app.MapDefaultEndpoints();

-app.MapRefreshEndpoint()
-  .RequireAuthorization(Schemes.AllowExpiredTokens);
+app.MapAuthEndpoints();
+app.MapAccountsEndpoints();
+app.MapInstitutionsEndpoints();
+app.MapTransactionsGroup();

 app.Run();
@@ -18,6 +18,6 @@
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
-    },
+    }
  }
 }
@@ -0,0 +1,62 @@
+namespace FiscalOS.API.Transactions.FireWebhook;
+
+internal static class Endpoint
+{
+  private const string Route = "/fire-webhook";
+
+  public static RouteHandlerBuilder MapFireWebhookEndpoint(this RouteGroupBuilder groupBuilder)
+  {
+    return groupBuilder.MapPost(Route, HandleAsync);
+  }
+
+  private static async Task<IResult> HandleAsync(
+    HttpContext httpContext,
+    [FromBody] Request request,
+    [FromServices] AppDbContext appDbContext,
+    [FromServices] IEncryptor encryptor,
+    [FromServices] PlaidClient plaidClient,
+    CancellationToken ct
+  )
+  {
+    var userId = httpContext.GetUserId();
+
+    var user = await appDbContext.Users
+      .Include(u => u.Accounts.Where(a => a.Id.ToString() == request.AccountId))
+      .ThenInclude(static a => a.Institution!)
+      .ThenInclude(static i => i.Metadata)
+      .FirstOrDefaultAsync(u => u.Id == userId, ct);
+
+    if (user is null)
+    {
+      return Results.Unauthorized();
+    }
+
+    if (user.Accounts.Any() is false)
+    {
+      return Results.NotFound();
+    }
+
+    var plaidMetadata = (PlaidInstitutionMetadata?)user.Accounts.First().Institution?.Metadata;
+
+    if (plaidMetadata is null)
+    {
+      return Results.InternalServerError("No metadata associated with account");
+    }
+
+    var accessToken = await encryptor.DecryptAsyncFor(user, plaidMetadata.EncryptedAccessToken, ct);
+
+    var fireEventResponse = await plaidClient.SandboxItemFireWebhookAsync(new()
+    {
+      AccessToken = accessToken,
+      WebhookType = SandboxItemFireWebhookRequestWebhookTypeEnum.Transactions,
+      WebhookCode = SandboxItemFireWebhookRequestWebhookCodeEnum.SyncUpdatesAvailable,
+    });
+
+    if (fireEventResponse.IsSuccessStatusCode is false)
+    {
+      return Results.InternalServerError(fireEventResponse.Error?.ErrorMessage);
+    }
+
+    return Results.Ok(new { fireEventResponse.RequestId, fireEventResponse.WebhookFired });
+  }
+}
@@ -0,0 +1,7 @@
+namespace FiscalOS.API.Transactions.FireWebhook;
+
+public sealed record Request(
+  string AccountId,
+  string WebhookType,
+  string WebhookCode
+);
@@ -0,0 +1,21 @@
+namespace FiscalOS.API.Transactions;
+
+internal static class TransactionsExtensions
+{
+  private const string RouteGroupPrefix = "/transactions";
+
+  public static RouteGroupBuilder MapTransactionsGroup(this WebApplication app)
+  {
+    var transactionsGroup = app.MapGroup(RouteGroupPrefix)
+      .RequireAuthorization();
+
+    if (app.Environment.IsProduction() is false)
+    {
+      transactionsGroup.MapFireWebhookEndpoint();
+    }
+
+    transactionsGroup.MapWebhookEndpoint().AllowAnonymous();
+
+    return transactionsGroup;
+  }
+}
@@ -0,0 +1,41 @@
+namespace FiscalOS.API.Transactions.Webhook;
+
+internal static class Endpoint
+{
+  private const string Route = "/webhook";
+
+  public static RouteHandlerBuilder MapWebhookEndpoint(this RouteGroupBuilder groupBuilder)
+  {
+    return groupBuilder.MapPost(Route, HandleAsync);
+  }
+
+  private static async Task<IResult> HandleAsync(
+    [FromBody] WebhookBase request,
+    [FromServices] ILogger<Program> logger,
+    [FromServices] IAsyncQueue<SyncUpdatesQueueItem> queue,
+    CancellationToken ct
+  )
+  {
+    logger.LogInformation(
+      "Received {WebhookType} webhook with {WebhookCode} payload",
+      request.WebhookType,
+      request.WebhookCode
+    );
+
+    switch (request)
+    {
+      case SyncUpdatesAvailableWebhook webhook:
+        await queue.EnqueueAsync(new(webhook.ItemId), ct);
+        logger.LogInformation(
+          "Enqueued {WebhookType} webhook with {WebhookCode} payload",
+          request.WebhookType,
+          request.WebhookCode
+        );
+        break;
+      default:
+        break;
+    }
+
+    return Results.Ok();
+  }
+}
@@ -2,13 +2,35 @@ global using System.ComponentModel.DataAnnotations;
 global using System.Security.Claims;
 global using System.Text.Json.Serialization;

+global using FiscalOS.API.Accounts;
+global using FiscalOS.API.Accounts.Add;
+global using FiscalOS.API.Auth;
+global using FiscalOS.API.Auth.Login;
+global using FiscalOS.API.Auth.Refresh;
 global using FiscalOS.API.Http;
-global using FiscalOS.API.Login;
-global using FiscalOS.API.Refresh;
+global using FiscalOS.API.Institutions;
+global using FiscalOS.API.Institutions.Connect;
+global using FiscalOS.API.Institutions.Get;
+global using FiscalOS.API.Institutions.GetAvailable;
+global using FiscalOS.API.Institutions.Link;
+global using FiscalOS.API.Transactions;
+global using FiscalOS.API.Transactions.FireWebhook;
+global using FiscalOS.API.Transactions.Webhook;
 global using FiscalOS.Core.Authentication;
+global using FiscalOS.Core.Identity;
+global using FiscalOS.Core.Queuing;
+global using FiscalOS.Core.Security;
+global using FiscalOS.Infra.Accounts.Plaid;
 global using FiscalOS.Infra.Authentication;
 global using FiscalOS.Infra.Data;
 global using FiscalOS.Infra.DependencyInjection;
+global using FiscalOS.Infra.Transactions.Plaid;
+global using FiscalOS.ServiceDefaults;
+
+global using Going.Plaid;
+global using Going.Plaid.Converters;
+global using Going.Plaid.Entity;
+global using Going.Plaid.Webhook;

 global using Microsoft.AspNetCore.Mvc;
 global using Microsoft.EntityFrameworkCore;
@@ -19,8 +19,9 @@
    "KeysDirectoryPath": "KeysDirectoryPath",
    "PrimaryKeyId": "PrimaryKeyId"
  },
-  "PlaidOptions": {
+  "PlaidClientOptions": {
    "ClientId": "ClientId",
-    "Secret": "Secret"
+    "Secret": "Secret",
+    "Webhook": "Webhook"
  }
 }
@@ -47,6 +47,52 @@ internal sealed class App(
        var keyRingEntry = await keyRing.SaveKeyAsync(key);
        _console.MarkupLine($"Key generated with id [green]{keyRingEntry.KeyId}[/] generated successfully.");
        break;
+      case Commands.RemoveInstitution:
+        var institutionId = await _console.AskAsync<string>("Enter the [green]institution id[/] of the item you want to remove:", cancellationToken);
+
+        var institution = await appDbContext.Institutions
+          .Include(i => i.User)
+          .Include(i => i.Metadata)
+          .FirstOrDefaultAsync(cancellationToken);
+
+        if (institution is null)
+        {
+          _console.MarkupLine($"Institution with id [green]{institutionId}[/] not found.");
+          break;
+        }
+
+        if (institution.User is null)
+        {
+          _console.MarkupLine($"Institution with id [green]{institutionId}[/] has no user.");
+          break;
+        }
+
+        if (institution.Metadata is not PlaidInstitutionMetadata plaidInstitutionMetadata)
+        {
+          _console.MarkupLine($"Institution with id [green]{institutionId}[/] has no plaid metadata.");
+          break;
+        }
+
+        var accessToken = await encryptor.DecryptAsyncFor(institution.User, plaidInstitutionMetadata.EncryptedAccessToken, cancellationToken);
+
+        var plaidClient = scope.ServiceProvider.GetRequiredService<PlaidClient>();
+
+        var removeItemResponse = await plaidClient.ItemRemoveAsync(new()
+        {
+          AccessToken = accessToken,
+        });
+
+        if (removeItemResponse.IsSuccessStatusCode is false)
+        {
+          _console.MarkupLine($"Failed to remove item for institution id [green]{institutionId}[/]. Plaid error: {removeItemResponse.Error?.ErrorMessage}");
+          break;
+        }
+
+        appDbContext.Institutions.Remove(institution);
+        await appDbContext.SaveChangesAsync(cancellationToken);
+
+        _console.MarkupLine($"Institution with id [green]{institutionId}[/] removed successfully.");
+        break;
      case Commands.Exit:
      default:
        break;
@@ -4,11 +4,13 @@ internal static class Commands
 {
  public const string CreateUser = "Create User";
  public const string GenerateKey = "Generate Key";
+  public const string RemoveInstitution = "Remove Institution";
  public const string Exit = "Exit";

  public static readonly string[] All = [
    CreateUser,
    GenerateKey,
+    RemoveInstitution,
    Exit
  ];
 }
@@ -2,9 +2,13 @@ global using FiscalOS.AdminCLI;
 global using FiscalOS.Core.Authentication;
 global using FiscalOS.Core.Identity;
 global using FiscalOS.Core.Security;
+global using FiscalOS.Infra.Accounts.Plaid;
 global using FiscalOS.Infra.Data;
 global using FiscalOS.Infra.DependencyInjection;

+global using Going.Plaid;
+
+global using Microsoft.EntityFrameworkCore;
 global using Microsoft.Extensions.Configuration;
 global using Microsoft.Extensions.DependencyInjection;
 global using Microsoft.Extensions.Hosting;
@@ -0,0 +1,12 @@
+using FiscalOS.AppHost;
+
+var builder = DistributedApplication.CreateBuilder(args);
+
+var api = builder.AddProject<Projects.FiscalOS_API>(ProjectNames.API)
+  .WithHttpHealthCheck("/health");
+
+builder.AddViteApp(ProjectNames.Web, "../FiscalOS.Web")
+  .WithReference(api)
+  .WithHttpsEndpoint(port: 7061, env: "PORT");
+
+builder.Build().Run();
@@ -0,0 +1,19 @@
+<Project Sdk="Aspire.AppHost.Sdk/13.1.2">
+
+  <ItemGroup>
+    <ProjectReference Include="..\FiscalOS.API\FiscalOS.API.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Aspire.Hosting.JavaScript" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <UserSecretsId>80a27726-36cc-4a4d-a55d-11af527158bc</UserSecretsId>
+  </PropertyGroup>
+
+</Project>
@@ -0,0 +1,7 @@
+namespace FiscalOS.AppHost;
+
+public static class ProjectNames
+{
+  public const string API = "api";
+  public const string Web = "web";
+}
@@ -0,0 +1,31 @@
+{
+  "$schema": "https://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "https://localhost:17104;http://localhost:15068",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "DOTNET_ENVIRONMENT": "Development",
+        "ASPIRE_DASHBOARD_OTLP_ENDPOINT_URL": "https://localhost:21226",
+        "ASPIRE_DASHBOARD_MCP_ENDPOINT_URL": "https://localhost:23228",
+        "ASPIRE_RESOURCE_SERVICE_ENDPOINT_URL": "https://localhost:22081"
+      }
+    },
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "applicationUrl": "http://localhost:15068",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "DOTNET_ENVIRONMENT": "Development",
+        "ASPIRE_DASHBOARD_OTLP_ENDPOINT_URL": "http://localhost:19221",
+        "ASPIRE_DASHBOARD_MCP_ENDPOINT_URL": "http://localhost:18206",
+        "ASPIRE_RESOURCE_SERVICE_ENDPOINT_URL": "http://localhost:20097"
+      }
+    }
+  }
+}
@@ -0,0 +1,46 @@
+namespace FiscalOS.Core.Accounts;
+
+public sealed class Account : Entity
+{
+  public Guid UserId { get; init; }
+  public Guid InstitutionId { get; init; }
+  public Institution? Institution { get; init; }
+  public string Name { get; init; } = string.Empty;
+  public AccountMetadata? Metadata { get; init; }
+
+  private readonly List<Balance> _balances = [];
+  public IEnumerable<Balance> Balances => _balances;
+
+  private readonly List<Transaction> _transactions = [];
+  public IEnumerable<Transaction> Transactions => _transactions;
+
+  private Account()
+  {
+  }
+
+  public static Account From(
+    string name,
+    AccountMetadata accountMetadata
+  )
+  {
+    return new()
+    {
+      Name = name,
+      Metadata = accountMetadata,
+    };
+  }
+
+  public void AddBalance(Balance balance)
+  {
+    ArgumentNullException.ThrowIfNull(balance, nameof(balance));
+
+    _balances.Add(balance);
+  }
+
+  public void AddTransaction(Transaction transaction)
+  {
+    ArgumentNullException.ThrowIfNull(transaction, nameof(transaction));
+
+    _transactions.Add(transaction);
+  }
+}
@@ -0,0 +1,15 @@
+namespace FiscalOS.Core.Accounts;
+
+public abstract class AccountMetadata : Entity
+{
+  private readonly string _type;
+
+  public string Type => _type;
+
+  public Guid AccountId { get; init; }
+
+  protected AccountMetadata(string type)
+  {
+    _type = type;
+  }
+}
@@ -0,0 +1,29 @@
+namespace FiscalOS.Core.Accounts;
+
+public sealed class Balance : Entity
+{
+  public Guid AccountId { get; init; }
+  public decimal Current { get; init; }
+  public decimal Available { get; init; }
+  public string CurrencyCode { get; init; } = string.Empty;
+
+  private Balance()
+  {
+  }
+
+  public static Balance From(
+    decimal current,
+    decimal available,
+    string currencyCode
+  )
+  {
+    ArgumentNullException.ThrowIfNull(currencyCode, nameof(currencyCode));
+
+    return new()
+    {
+      Current = current,
+      Available = available,
+      CurrencyCode = currencyCode,
+    };
+  }
+}
@@ -0,0 +1,35 @@
+namespace FiscalOS.Core.Accounts;
+
+public sealed class Institution : Entity
+{
+  public Guid UserId { get; init; }
+  public User? User { get; init; }
+  public string Name { get; init; } = string.Empty;
+  public InstitutionMetadata? Metadata { get; init; }
+
+  private readonly List<Account> _accounts = [];
+  public IEnumerable<Account> Accounts => _accounts;
+
+  private Institution()
+  {
+  }
+
+  public static Institution From(string? name, InstitutionMetadata metadata)
+  {
+    ArgumentNullException.ThrowIfNull(name, nameof(name));
+    ArgumentNullException.ThrowIfNull(metadata, nameof(metadata));
+
+    return new Institution()
+    {
+      Name = name,
+      Metadata = metadata
+    };
+  }
+
+  public void AddAccount(Account account)
+  {
+    ArgumentNullException.ThrowIfNull(account, nameof(account));
+
+    _accounts.Add(account);
+  }
+}
@@ -0,0 +1,15 @@
+namespace FiscalOS.Core.Accounts;
+
+public abstract class InstitutionMetadata : Entity
+{
+  private readonly string _type;
+
+  public string Type => _type;
+
+  public Guid InstitutionId { get; init; }
+
+  protected InstitutionMetadata(string type)
+  {
+    _type = type;
+  }
+}
@@ -24,7 +24,7 @@ public sealed class RefreshToken : Entity

  public static RefreshToken From(User user, string token, DateTimeOffset expiresAt)
  {
-    ArgumentNullException.ThrowIfNull(user);
+    ArgumentNullException.ThrowIfNull(user, nameof(user));

    return new()
    {
@@ -2,15 +2,23 @@ namespace FiscalOS.Core.Identity;

 public sealed class User : Entity
 {
-  private readonly List<RefreshToken> _refreshTokens = [];
-
  public string Username { get; init; } = string.Empty;
  public string HashedPassword { get; init; } = string.Empty;
  public string EncryptionKeyId { get; init; } = string.Empty;
  public string EncryptedDataKey { get; init; } = string.Empty;

+  private readonly List<RefreshToken> _refreshTokens = [];
  public IEnumerable<RefreshToken> RefreshTokens => _refreshTokens;

+  private readonly List<Institution> _institutions = [];
+  public IEnumerable<Institution> Institutions => _institutions;
+
+  private readonly List<Account> _accounts = [];
+  public IEnumerable<Account> Accounts => _accounts;
+
+  private readonly List<Transaction> _transactions = [];
+  public IEnumerable<Transaction> Transactions => _transactions;
+
  private User()
  {
  }
@@ -22,9 +30,9 @@ public sealed class User : Entity

  public static User From(string username, string hashedPassword, EncryptedDataKey encryptedDataKey)
  {
-    ArgumentNullException.ThrowIfNull(username);
-    ArgumentNullException.ThrowIfNull(hashedPassword);
-    ArgumentNullException.ThrowIfNull(encryptedDataKey);
+    ArgumentNullException.ThrowIfNull(username, nameof(username));
+    ArgumentNullException.ThrowIfNull(hashedPassword, nameof(hashedPassword));
+    ArgumentNullException.ThrowIfNull(encryptedDataKey, nameof(encryptedDataKey));

    return new()
    {
@@ -37,8 +45,29 @@ public sealed class User : Entity

  public void AddRefreshToken(RefreshToken refreshToken)
  {
-    ArgumentNullException.ThrowIfNull(refreshToken);
+    ArgumentNullException.ThrowIfNull(refreshToken, nameof(refreshToken));

    _refreshTokens.Add(refreshToken);
  }
+
+  public void AddInstitution(Institution institution)
+  {
+    ArgumentNullException.ThrowIfNull(institution, nameof(institution));
+
+    _institutions.Add(institution);
+  }
+
+  public void AddAccount(Account account)
+  {
+    ArgumentNullException.ThrowIfNull(account, nameof(account));
+
+    _accounts.Add(account);
+  }
+
+  public void AddTransaction(Transaction transaction)
+  {
+    ArgumentNullException.ThrowIfNull(transaction, nameof(transaction));
+
+    _transactions.Add(transaction);
+  }
 }
@@ -0,0 +1,8 @@
+namespace FiscalOS.Core.Queuing;
+
+public interface IAsyncQueue<T>
+{
+  Task EnqueueAsync(T item, CancellationToken cancellationToken = default);
+  Task<T> DequeueAsync(CancellationToken cancellationToken = default);
+  ValueTask DisposeAsync();
+}
@@ -0,0 +1,6 @@
+namespace FiscalOS.Core.Queuing;
+
+public interface IAsyncQueueProcessor<T>
+{
+  Task ProcessAsync(T item, CancellationToken cancellationToken = default);
+}
@@ -13,8 +13,8 @@ public sealed record EncryptedDataKey

  public static EncryptedDataKey From(string keyIdUsed, string encryptedKey)
  {
-    ArgumentNullException.ThrowIfNull(keyIdUsed);
-    ArgumentNullException.ThrowIfNull(encryptedKey);
+    ArgumentNullException.ThrowIfNull(keyIdUsed, nameof(keyIdUsed));
+    ArgumentNullException.ThrowIfNull(encryptedKey, nameof(encryptedKey));

    return new(keyIdUsed, encryptedKey);
  }
@@ -13,8 +13,8 @@ public sealed record KeyRingEntry

  public static KeyRingEntry From(string keyId, string key)
  {
-    ArgumentNullException.ThrowIfNull(keyId);
-    ArgumentNullException.ThrowIfNull(key);
+    ArgumentNullException.ThrowIfNull(keyId, nameof(keyId));
+    ArgumentNullException.ThrowIfNull(key, nameof(key));

    return new(keyId, key);
  }
@@ -0,0 +1,82 @@
+namespace FiscalOS.Core.Transactions;
+
+public sealed class Transaction : Entity
+{
+  public Guid UserId { get; private set; }
+  public User? User { get; init; }
+
+  public Guid AccountId { get; init; }
+  public Account? Account { get; init; }
+
+  public string MerchantName { get; private set; } = string.Empty;
+  public string Description { get; init; } = string.Empty;
+  public decimal Amount { get; init; }
+  public DateTimeOffset Date { get; init; }
+
+  public TransactionMetadata? Metadata { get; init; }
+
+  private Transaction()
+  {
+  }
+
+  public static Transaction From(
+    string merchantName,
+    string description,
+    decimal? amount,
+    DateTimeOffset? date,
+    TransactionMetadata metadata
+  )
+  {
+    return From(Guid.Empty, Guid.Empty, Guid.Empty, merchantName, description, amount, date, metadata);
+  }
+
+  public static Transaction From(
+    Guid userId,
+    Guid accountId,
+    string merchantName,
+    string description,
+    decimal? amount,
+    DateTimeOffset? date,
+    TransactionMetadata metadata
+  )
+  {
+    return From(Guid.Empty, userId, accountId, merchantName, description, amount, date, metadata);
+  }
+
+  public static Transaction From(
+    Guid id,
+    Guid userId,
+    Guid accountId,
+    string merchantName,
+    string description,
+    decimal? amount,
+    DateTimeOffset? date,
+    TransactionMetadata metadata
+  )
+  {
+    ArgumentNullException.ThrowIfNull(merchantName, nameof(merchantName));
+    ArgumentNullException.ThrowIfNull(description, nameof(description));
+
+    if (amount.HasValue is false)
+    {
+      throw new ArgumentNullException(nameof(amount));
+    }
+
+    if (date.HasValue is false)
+    {
+      throw new ArgumentNullException(nameof(date));
+    }
+
+    return new()
+    {
+      Id = id,
+      UserId = userId,
+      AccountId = accountId,
+      MerchantName = merchantName,
+      Description = description,
+      Amount = amount.Value,
+      Date = date.Value,
+      Metadata = metadata,
+    };
+  }
+}
@@ -0,0 +1,15 @@
+namespace FiscalOS.Core.Transactions;
+
+public abstract class TransactionMetadata : Entity
+{
+  private readonly string _type;
+
+  public string Type => _type;
+
+  public Guid TransactionId { get; init; }
+
+  protected TransactionMetadata(string type)
+  {
+    _type = type;
+  }
+}
@@ -1,3 +1,5 @@
+global using FiscalOS.Core.Accounts;
 global using FiscalOS.Core.Data;
 global using FiscalOS.Core.Identity;
-global using FiscalOS.Core.Security;
+global using FiscalOS.Core.Security;
+global using FiscalOS.Core.Transactions;
@@ -1,4 +1,4 @@
 [*.cs]

 dotnet_diagnostic.CA1062.severity = none
-dotnet_diagnostic.CA5404.severity = none
+dotnet_diagnostic.CA5404.severity = none
@@ -0,0 +1,32 @@
+namespace FiscalOS.Infra.Accounts.Plaid;
+
+public sealed class PlaidAccountMetadata : AccountMetadata
+{
+  public const string TypeValue = Providers.Plaid;
+  public string PlaidId { get; init; } = string.Empty;
+  public string PlaidName { get; init; } = string.Empty;
+  public string? Cursor { get; private set; }
+
+  private PlaidAccountMetadata() : base(TypeValue)
+  {
+  }
+
+  public static PlaidAccountMetadata From(
+    string plaidId,
+    string plaidName
+  )
+  {
+    return new()
+    {
+      PlaidId = plaidId,
+      PlaidName = plaidName,
+    };
+  }
+
+  public void SetCursor(string cursor)
+  {
+    ArgumentException.ThrowIfNullOrWhiteSpace(cursor, nameof(cursor));
+
+    Cursor = cursor;
+  }
+}
@@ -0,0 +1,99 @@
+namespace FiscalOS.Infra.Accounts.Plaid;
+
+public interface IPlaidAccountService
+{
+  Task<string> CreateLinkTokenAsync(string id);
+  Task<(string ItemId, string AccessToken)> ExchangeTokenAsync(string publicToken);
+  Task<List<Going.Plaid.Entity.Account>> GetAccountsAsync(string accessToken);
+  Task<ItemWithConsentFields> GetItemAsync(string accessToken);
+}
+
+internal sealed class PlaidAccountService : IPlaidAccountService
+{
+  private readonly IOptions<PlaidClientOptions> _options;
+  private readonly PlaidClient _client;
+
+  private PlaidAccountService(PlaidClient client, IOptions<PlaidClientOptions> options)
+  {
+    _client = client;
+    _options = options;
+  }
+
+  public static PlaidAccountService From(IServiceProvider sp)
+  {
+    var client = sp.GetRequiredService<PlaidClient>();
+    var options = sp.GetRequiredService<IOptions<PlaidClientOptions>>();
+    return new(client, options);
+  }
+
+  public async Task<string> CreateLinkTokenAsync(string id)
+  {
+    var assemblyName = Assembly.GetExecutingAssembly().GetName().FullName;
+    var environmentName = System.Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
+
+    var ltr = await _client.LinkTokenCreateAsync(new()
+    {
+      ClientName = $"{assemblyName}_{environmentName}",
+      Products = [Products.Transactions],
+      CountryCodes = [CountryCode.Us],
+      Language = Language.English,
+      User = new()
+      {
+        ClientUserId = id,
+      },
+      Webhook = _options.Value.Webhook,
+    }).ConfigureAwait(false);
+
+    if (ltr.IsSuccessStatusCode is false)
+    {
+      throw new PlaidException("Unable to create link token");
+    }
+
+    return ltr.LinkToken;
+  }
+
+  public async Task<(string ItemId, string AccessToken)> ExchangeTokenAsync(string publicToken)
+  {
+    var ptr = await _client.ItemPublicTokenExchangeAsync(new()
+    {
+      PublicToken = publicToken,
+    }).ConfigureAwait(false);
+
+    if (ptr.IsSuccessStatusCode is false)
+    {
+      throw new PlaidException("Unable to exchange public token for access token");
+    }
+
+    return (ptr.ItemId, ptr.AccessToken);
+  }
+
+  public async Task<List<Going.Plaid.Entity.Account>> GetAccountsAsync(string accessToken)
+  {
+    var ar = await _client.AccountsGetAsync(new()
+    {
+      AccessToken = accessToken,
+    }).ConfigureAwait(false);
+
+    if (ar.IsSuccessStatusCode is false)
+    {
+      throw new PlaidException("Unable to retrieve accounts");
+    }
+
+    return [.. ar.Accounts];
+  }
+
+  public async Task<ItemWithConsentFields> GetItemAsync(string accessToken)
+  {
+    var ar = await _client.ItemGetAsync(new()
+    {
+      AccessToken = accessToken,
+    }).ConfigureAwait(false);
+
+    if (ar.IsSuccessStatusCode is false)
+    {
+      throw new PlaidException("Unable to retrieve item");
+    }
+
+    return ar.Item;
+  }
+}
@@ -0,0 +1,33 @@
+namespace FiscalOS.Infra.Accounts.Plaid;
+
+public sealed record PlaidClientOptions
+{
+  public string ClientId { get; init; } = string.Empty;
+  public string Secret { get; init; } = string.Empty;
+  public string Webhook { get; init; } = string.Empty;
+
+  public IOptions<PlaidOptions> ToPlaidOptions()
+  {
+    return Options.Create<PlaidOptions>(new()
+    {
+      ClientId = ClientId,
+      Secret = Secret
+    });
+  }
+}
+
+public sealed record PlaidClientOptionsSetup : IConfigureOptions<PlaidClientOptions>
+{
+  private const string SectionName = nameof(PlaidClientOptions);
+  private readonly IConfiguration _configuration;
+
+  public PlaidClientOptionsSetup(IConfiguration configuration)
+  {
+    _configuration = configuration;
+  }
+
+  public void Configure(PlaidClientOptions options)
+  {
+    _configuration.GetSection(SectionName).Bind(options);
+  }
+}
@@ -0,0 +1,15 @@
+namespace FiscalOS.Infra.Accounts.Plaid;
+
+public static class PlaidExtensions
+{
+#pragma warning disable CA1034
+  extension(Going.Plaid.Entity.Account act)
+  {
+    public string CurrencyCode => act.Balances.IsoCurrencyCode
+      ?? act.Balances.UnofficialCurrencyCode
+      ?? "Unknown";
+
+    public decimal Available => act.Balances.Available.GetValueOrDefault();
+    public decimal Current => act.Balances.Current.GetValueOrDefault();
+  }
+}
@@ -0,0 +1,35 @@
+namespace FiscalOS.Infra.Accounts.Plaid;
+
+public sealed class PlaidInstitutionMetadata : InstitutionMetadata
+{
+  public const string TypeValue = Providers.Plaid;
+  public string PlaidId { get; init; } = string.Empty;
+  public string PlaidName { get; init; } = string.Empty;
+  public string EncryptedAccessToken { get; init; } = string.Empty;
+  public string ItemId { get; init; } = string.Empty;
+
+  private PlaidInstitutionMetadata() : base(TypeValue)
+  {
+  }
+
+  public static PlaidInstitutionMetadata From(
+    string? plaidId,
+    string? plaidName,
+    string encryptedAccessToken,
+    string itemId
+  )
+  {
+    ArgumentNullException.ThrowIfNull(plaidId, nameof(plaidId));
+    ArgumentNullException.ThrowIfNull(plaidName, nameof(plaidName));
+    ArgumentNullException.ThrowIfNull(encryptedAccessToken, nameof(encryptedAccessToken));
+    ArgumentNullException.ThrowIfNull(itemId, nameof(itemId));
+
+    return new()
+    {
+      PlaidId = plaidId,
+      PlaidName = plaidName,
+      EncryptedAccessToken = encryptedAccessToken,
+      ItemId = itemId,
+    };
+  }
+}
@@ -0,0 +1,16 @@
+namespace FiscalOS.Infra.Common;
+
+public class PlaidException : Exception
+{
+  public PlaidException()
+  {
+  }
+
+  public PlaidException(string message) : base(message)
+  {
+  }
+
+  public PlaidException(string message, Exception innerException) : base(message, innerException)
+  {
+  }
+}
@@ -0,0 +1,6 @@
+namespace FiscalOS.Infra.Common;
+
+public static class Providers
+{
+  public const string Plaid = nameof(Plaid);
+}
@@ -1,3 +1,7 @@
+using Account = FiscalOS.Core.Accounts.Account;
+using Institution = FiscalOS.Core.Accounts.Institution;
+using Transaction = FiscalOS.Core.Transactions.Transaction;
+
 namespace FiscalOS.Infra.Data;

 public sealed class AppDbContext(
@@ -11,6 +15,8 @@ public sealed class AppDbContext(

  public DbSet<User> Users => Set<User>();
  public DbSet<RefreshToken> RefreshTokens => Set<RefreshToken>();
+  public DbSet<Institution> Institutions => Set<Institution>();
+  public DbSet<Transaction> Transactions => Set<Transaction>();

  protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
  {
@@ -49,15 +55,25 @@ public sealed class AppDbContext(

    modelBuilder.Entity<User>(static eb =>
    {
+      eb.Property(static u => u.Username);
+      eb.HasIndex(static u => u.Username).IsUnique();
+
+      eb.Property(static u => u.HashedPassword);
+
      eb.HasMany(static u => u.RefreshTokens)
        .WithOne(static t => t.User)
        .HasForeignKey(static t => t.UserId)
        .OnDelete(DeleteBehavior.Cascade);

-      eb.Property(static u => u.Username);
-      eb.HasIndex(static u => u.Username).IsUnique();
+      eb.HasMany(static u => u.Institutions)
+        .WithOne(static i => i.User)
+        .HasForeignKey(static i => i.UserId)
+        .OnDelete(DeleteBehavior.Cascade);

-      eb.Property(static u => u.HashedPassword);
+      eb.HasMany(static u => u.Accounts)
+        .WithOne()
+        .HasForeignKey(static a => a.UserId)
+        .OnDelete(DeleteBehavior.Cascade);
    });

    modelBuilder.Entity<RefreshToken>(static eb =>
@@ -69,5 +85,115 @@ public sealed class AppDbContext(
      eb.Property(static t => t.Token);
      eb.HasIndex(static t => t.Token).IsUnique();
    });
+
+    modelBuilder.Entity<Institution>(static eb =>
+    {
+      eb.Property(static i => i.Name);
+
+      eb.HasOne(static i => i.Metadata)
+        .WithOne()
+        .HasForeignKey<InstitutionMetadata>(static m => m.InstitutionId)
+        .OnDelete(DeleteBehavior.Cascade);
+    });
+
+    modelBuilder.Entity<InstitutionMetadata>(static eb =>
+    {
+      eb.HasDiscriminator(static m => m.Type)
+        .HasValue<PlaidInstitutionMetadata>(PlaidInstitutionMetadata.TypeValue);
+
+      eb.Property(static m => m.InstitutionId);
+      eb.Property(static m => m.Type);
+    });
+
+    modelBuilder.Entity<PlaidInstitutionMetadata>(static eb =>
+    {
+      eb.HasBaseType<InstitutionMetadata>();
+
+      eb.Property(static m => m.PlaidId);
+      eb.Property(static m => m.PlaidName);
+      eb.Property(static m => m.EncryptedAccessToken);
+      eb.Property(static m => m.ItemId);
+    });
+
+    modelBuilder.Entity<Account>(static eb =>
+    {
+      eb.Property(static a => a.Name);
+
+      eb.HasOne(static a => a.Institution)
+        .WithMany(static i => i.Accounts)
+        .HasForeignKey(static a => a.InstitutionId)
+        .OnDelete(DeleteBehavior.Cascade);
+
+      eb.HasOne(static a => a.Metadata)
+        .WithOne()
+        .HasForeignKey<AccountMetadata>(static m => m.AccountId)
+        .OnDelete(DeleteBehavior.Cascade);
+
+      eb.HasMany(static a => a.Balances)
+        .WithOne()
+        .HasForeignKey(static b => b.AccountId)
+        .OnDelete(DeleteBehavior.Cascade);
+    });
+
+    modelBuilder.Entity<AccountMetadata>(static eb =>
+    {
+      eb.HasDiscriminator(static m => m.Type)
+        .HasValue<PlaidAccountMetadata>(PlaidAccountMetadata.TypeValue);
+
+      eb.Property(static m => m.AccountId);
+      eb.Property(static m => m.Type);
+    });
+
+    modelBuilder.Entity<PlaidAccountMetadata>(static eb =>
+    {
+      eb.HasBaseType<AccountMetadata>();
+
+      eb.Property(static m => m.PlaidId);
+      eb.Property(static m => m.PlaidName);
+      eb.Property(static m => m.Cursor);
+    });
+
+    modelBuilder.Entity<Balance>(static eb =>
+    {
+      eb.Property(static b => b.AccountId);
+      eb.Property(static b => b.Current);
+      eb.Property(static b => b.Available);
+      eb.Property(static b => b.CurrencyCode);
+    });
+
+    modelBuilder.Entity<Transaction>(static eb =>
+    {
+      eb.HasOne(static t => t.User)
+        .WithMany(static u => u.Transactions)
+        .HasForeignKey(static t => t.UserId)
+        .OnDelete(DeleteBehavior.Cascade);
+
+      eb.HasOne(static t => t.Account)
+        .WithMany(static a => a.Transactions)
+        .HasForeignKey(static t => t.AccountId)
+        .OnDelete(DeleteBehavior.Cascade);
+
+      eb.Property(static t => t.MerchantName);
+      eb.Property(static t => t.Description);
+      eb.Property(static t => t.Amount);
+      eb.Property(static t => t.Date);
+    });
+
+    modelBuilder.Entity<TransactionMetadata>(static eb =>
+    {
+      eb.HasDiscriminator(static m => m.Type)
+        .HasValue(PlaidTransactionMetadata.TypeValue);
+
+      eb.Property(static m => m.TransactionId);
+      eb.Property(static m => m.Type);
+    });
+
+    modelBuilder.Entity<PlaidTransactionMetadata>(static eb =>
+    {
+      eb.HasDiscriminator(static m => m.Type)
+        .HasValue(PlaidTransactionMetadata.TypeValue);
+
+      eb.Property(static m => m.PlaidId);
+    });
  }
 }
@@ -6,6 +6,7 @@ public static class ServiceCollectionExtensions
  {
    services.AddSingleton<IAuthorizationMiddlewareResultHandler, ProblemDetailsAuthResultHandler>();

+    services.AddHttpClient();
    services.AddSingleton(TimeProvider.System);
    services.AddSingleton<IFileSystem, FileSystem>();

@@ -23,6 +24,28 @@ public static class ServiceCollectionExtensions
    services.AddDbContext<AppDbContext>();
    services.AddHostedService<MigrationService>();

+    services.ConfigureOptions<PlaidClientOptionsSetup>();
+    services.AddSingleton(static sp =>
+    {
+      var factory = sp.GetRequiredService<IHttpClientFactory>();
+      var logger = sp.GetRequiredService<ILogger<PlaidClient>>();
+      var clientOptions = sp.GetRequiredService<IOptions<PlaidClientOptions>>();
+      var options = clientOptions.Value.ToPlaidOptions();
+      return new PlaidClient(options, factory, logger);
+    });
+    services.AddSingleton<IPlaidAccountService>(PlaidAccountService.From);
+    services.AddSingleton<IPlaidTransactionService>(PlaidTransactionService.From);
+
+    services.AddScoped<IPlaidAddedTransactionHandler>(PlaidAddedTransactionHandler.From);
+    services.AddScoped<IPlaidModifiedTransactionHandler>(PlaidModifiedTransactionHandler.From);
+    services.AddScoped<IPlaidRemovedTransactionHandler>(PlaidRemovedTransactionHandler.From);
+    services.AddScoped<IPlaidTransactionProcessor>(PlaidTransactionProcessor.From);
+    services.AddScoped<IPlaidTransactionSyncer>(PlaidTransactionSyncer.From);
+
+    services.AddSingleton<IAsyncQueue<SyncUpdatesQueueItem>>(ChannelAsyncQueue<SyncUpdatesQueueItem>.From);
+    services.AddScoped<IAsyncQueueProcessor<SyncUpdatesQueueItem>>(SyncUpdatesProcessor.From);
+    services.AddHostedService(AsyncQueueHostedService<SyncUpdatesQueueItem>.From);
+
    return services;
  }
 }
@@ -1,6 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">

  <ItemGroup>
+    <PackageReference Include="Going.Plaid" />
    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" />
    <PackageReference Include="Microsoft.Extensions.Hosting" />
@@ -0,0 +1,215 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260212215015_InstitutionAndMetadata")]
+    partial class InstitutionAndMetadata
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Revoked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedDataKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptionKeyId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Metadata")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("Institutions");
+
+                    b.Navigation("RefreshTokens");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,80 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+  /// <inheritdoc />
+  public partial class InstitutionAndMetadata : Migration
+  {
+    /// <inheritdoc />
+    protected override void Up(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.CreateTable(
+          name: "Institution",
+          columns: table => new
+          {
+            Id = table.Column<Guid>(type: "TEXT", nullable: false),
+            UserId = table.Column<Guid>(type: "TEXT", nullable: false),
+            Name = table.Column<string>(type: "TEXT", nullable: false),
+            CreatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false),
+            UpdatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false)
+          },
+          constraints: table =>
+          {
+            table.PrimaryKey("PK_Institution", x => x.Id);
+            table.ForeignKey(
+                      name: "FK_Institution_Users_UserId",
+                      column: x => x.UserId,
+                      principalTable: "Users",
+                      principalColumn: "Id",
+                      onDelete: ReferentialAction.Cascade);
+          });
+
+      migrationBuilder.CreateTable(
+          name: "InstitutionMetadata",
+          columns: table => new
+          {
+            Id = table.Column<Guid>(type: "TEXT", nullable: false),
+            Type = table.Column<string>(type: "TEXT", maxLength: 21, nullable: false),
+            InstitutionId = table.Column<Guid>(type: "TEXT", nullable: false),
+            PlaidId = table.Column<string>(type: "TEXT", nullable: true),
+            PlaidName = table.Column<string>(type: "TEXT", nullable: true),
+            EncryptedAccessToken = table.Column<string>(type: "TEXT", nullable: true),
+            CreatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false),
+            UpdatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false)
+          },
+          constraints: table =>
+          {
+            table.PrimaryKey("PK_InstitutionMetadata", x => x.Id);
+            table.ForeignKey(
+                      name: "FK_InstitutionMetadata_Institution_InstitutionId",
+                      column: x => x.InstitutionId,
+                      principalTable: "Institution",
+                      principalColumn: "Id",
+                      onDelete: ReferentialAction.Cascade);
+          });
+
+      migrationBuilder.CreateIndex(
+          name: "IX_Institution_UserId",
+          table: "Institution",
+          column: "UserId");
+
+      migrationBuilder.CreateIndex(
+          name: "IX_InstitutionMetadata_InstitutionId",
+          table: "InstitutionMetadata",
+          column: "InstitutionId",
+          unique: true);
+    }
+
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.DropTable(
+          name: "InstitutionMetadata");
+
+      migrationBuilder.DropTable(
+          name: "Institution");
+    }
+  }
+}
@@ -0,0 +1,327 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260213130218_AccountAndMetadata")]
+    partial class AccountAndMetadata
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstituionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstituionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Account");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId")
+                        .IsUnique();
+
+                    b.ToTable("AccountMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("AccountMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Revoked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedDataKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptionKeyId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidAccountMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.AccountMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", "Institution")
+                        .WithMany()
+                        .HasForeignKey("InstituionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.AccountMetadata", "AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Navigation("Metadata")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Metadata")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Institutions");
+
+                    b.Navigation("RefreshTokens");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,91 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+  /// <inheritdoc />
+  public partial class AccountAndMetadata : Migration
+  {
+    /// <inheritdoc />
+    protected override void Up(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.CreateTable(
+          name: "Account",
+          columns: table => new
+          {
+            Id = table.Column<Guid>(type: "TEXT", nullable: false),
+            UserId = table.Column<Guid>(type: "TEXT", nullable: false),
+            InstituionId = table.Column<Guid>(type: "TEXT", nullable: false),
+            Name = table.Column<string>(type: "TEXT", nullable: false),
+            CreatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false),
+            UpdatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false)
+          },
+          constraints: table =>
+          {
+            table.PrimaryKey("PK_Account", x => x.Id);
+            table.ForeignKey(
+                      name: "FK_Account_Institution_InstituionId",
+                      column: x => x.InstituionId,
+                      principalTable: "Institution",
+                      principalColumn: "Id",
+                      onDelete: ReferentialAction.Cascade);
+            table.ForeignKey(
+                      name: "FK_Account_Users_UserId",
+                      column: x => x.UserId,
+                      principalTable: "Users",
+                      principalColumn: "Id",
+                      onDelete: ReferentialAction.Cascade);
+          });
+
+      migrationBuilder.CreateTable(
+          name: "AccountMetadata",
+          columns: table => new
+          {
+            Id = table.Column<Guid>(type: "TEXT", nullable: false),
+            Type = table.Column<string>(type: "TEXT", maxLength: 21, nullable: false),
+            AccountId = table.Column<Guid>(type: "TEXT", nullable: false),
+            PlaidId = table.Column<string>(type: "TEXT", nullable: true),
+            PlaidName = table.Column<string>(type: "TEXT", nullable: true),
+            CreatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false),
+            UpdatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false)
+          },
+          constraints: table =>
+          {
+            table.PrimaryKey("PK_AccountMetadata", x => x.Id);
+            table.ForeignKey(
+                      name: "FK_AccountMetadata_Account_AccountId",
+                      column: x => x.AccountId,
+                      principalTable: "Account",
+                      principalColumn: "Id",
+                      onDelete: ReferentialAction.Cascade);
+          });
+
+      migrationBuilder.CreateIndex(
+          name: "IX_Account_InstituionId",
+          table: "Account",
+          column: "InstituionId");
+
+      migrationBuilder.CreateIndex(
+          name: "IX_Account_UserId",
+          table: "Account",
+          column: "UserId");
+
+      migrationBuilder.CreateIndex(
+          name: "IX_AccountMetadata_AccountId",
+          table: "AccountMetadata",
+          column: "AccountId",
+          unique: true);
+    }
+
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.DropTable(
+          name: "AccountMetadata");
+
+      migrationBuilder.DropTable(
+          name: "Account");
+    }
+  }
+}
@@ -0,0 +1,327 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260213180002_FixAccountInstitutionColumnName")]
+    partial class FixAccountInstitutionColumnName
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Account");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId")
+                        .IsUnique();
+
+                    b.ToTable("AccountMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("AccountMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Revoked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedDataKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptionKeyId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidAccountMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.AccountMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", "Institution")
+                        .WithMany()
+                        .HasForeignKey("InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.AccountMetadata", "AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Navigation("Metadata")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Metadata")
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Institutions");
+
+                    b.Navigation("RefreshTokens");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,62 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+  /// <inheritdoc />
+  public partial class FixAccountInstitutionColumnName : Migration
+  {
+    /// <inheritdoc />
+    protected override void Up(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.DropForeignKey(
+          name: "FK_Account_Institution_InstituionId",
+          table: "Account");
+
+      migrationBuilder.RenameColumn(
+          name: "InstituionId",
+          table: "Account",
+          newName: "InstitutionId");
+
+      migrationBuilder.RenameIndex(
+          name: "IX_Account_InstituionId",
+          table: "Account",
+          newName: "IX_Account_InstitutionId");
+
+      migrationBuilder.AddForeignKey(
+          name: "FK_Account_Institution_InstitutionId",
+          table: "Account",
+          column: "InstitutionId",
+          principalTable: "Institution",
+          principalColumn: "Id",
+          onDelete: ReferentialAction.Cascade);
+    }
+
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.DropForeignKey(
+          name: "FK_Account_Institution_InstitutionId",
+          table: "Account");
+
+      migrationBuilder.RenameColumn(
+          name: "InstitutionId",
+          table: "Account",
+          newName: "InstituionId");
+
+      migrationBuilder.RenameIndex(
+          name: "IX_Account_InstitutionId",
+          table: "Account",
+          newName: "IX_Account_InstituionId");
+
+      migrationBuilder.AddForeignKey(
+          name: "FK_Account_Institution_InstituionId",
+          table: "Account",
+          column: "InstituionId",
+          principalTable: "Institution",
+          principalColumn: "Id",
+          onDelete: ReferentialAction.Cascade);
+    }
+  }
+}
@@ -0,0 +1,364 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260214112234_AddBalancesWithConnectionToAccounts")]
+    partial class AddBalancesWithConnectionToAccounts
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Account");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId")
+                        .IsUnique();
+
+                    b.ToTable("AccountMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("AccountMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Available")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Current")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("Balance");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Revoked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedDataKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptionKeyId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidAccountMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.AccountMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", "Institution")
+                        .WithMany()
+                        .HasForeignKey("InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.AccountMetadata", "AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Balances")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Navigation("Balances");
+
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Institutions");
+
+                    b.Navigation("RefreshTokens");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,48 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+  /// <inheritdoc />
+  public partial class AddBalancesWithConnectionToAccounts : Migration
+  {
+    /// <inheritdoc />
+    protected override void Up(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.CreateTable(
+          name: "Balance",
+          columns: table => new
+          {
+            Id = table.Column<Guid>(type: "TEXT", nullable: false),
+            AccountId = table.Column<Guid>(type: "TEXT", nullable: false),
+            Current = table.Column<decimal>(type: "TEXT", nullable: false),
+            Available = table.Column<decimal>(type: "TEXT", nullable: false),
+            CreatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false),
+            UpdatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false)
+          },
+          constraints: table =>
+          {
+            table.PrimaryKey("PK_Balance", x => x.Id);
+            table.ForeignKey(
+                      name: "FK_Balance_Account_AccountId",
+                      column: x => x.AccountId,
+                      principalTable: "Account",
+                      principalColumn: "Id",
+                      onDelete: ReferentialAction.Cascade);
+          });
+
+      migrationBuilder.CreateIndex(
+          name: "IX_Balance_AccountId",
+          table: "Balance",
+          column: "AccountId");
+    }
+
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.DropTable(
+          name: "Balance");
+    }
+  }
+}
@@ -0,0 +1,368 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260214122622_AddCurrencyCodeToBalanceModel")]
+    partial class AddCurrencyCodeToBalanceModel
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Account");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId")
+                        .IsUnique();
+
+                    b.ToTable("AccountMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("AccountMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Available")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CurrencyCode")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Current")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("Balance");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Revoked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedDataKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptionKeyId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidAccountMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.AccountMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", "Institution")
+                        .WithMany()
+                        .HasForeignKey("InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.AccountMetadata", "AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Balances")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Navigation("Balances");
+
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Institutions");
+
+                    b.Navigation("RefreshTokens");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+  /// <inheritdoc />
+  public partial class AddCurrencyCodeToBalanceModel : Migration
+  {
+    /// <inheritdoc />
+    protected override void Up(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.AddColumn<string>(
+          name: "CurrencyCode",
+          table: "Balance",
+          type: "TEXT",
+          nullable: false,
+          defaultValue: "");
+    }
+
+    /// <inheritdoc />
+    protected override void Down(MigrationBuilder migrationBuilder)
+    {
+      migrationBuilder.DropColumn(
+          name: "CurrencyCode",
+          table: "Balance");
+    }
+  }
+}
@@ -0,0 +1,374 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260226123411_AddItemIdToPlaidMetadata")]
+    partial class AddItemIdToPlaidMetadata
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Account");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId")
+                        .IsUnique();
+
+                    b.ToTable("AccountMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("AccountMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Available")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CurrencyCode")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Current")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("Balance");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Revoked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedDataKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptionKeyId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidAccountMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.AccountMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", "Institution")
+                        .WithMany("Accounts")
+                        .HasForeignKey("InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.AccountMetadata", "AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Balances")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Navigation("Balances");
+
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Institutions");
+
+                    b.Navigation("RefreshTokens");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,28 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddItemIdToPlaidMetadata : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "ItemId",
+                table: "InstitutionMetadata",
+                type: "TEXT",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "ItemId",
+                table: "InstitutionMetadata");
+        }
+    }
+}
@@ -0,0 +1,376 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260226131150_AddNavigationPropertyToInstitutionForUser")]
+    partial class AddNavigationPropertyToInstitutionForUser
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Account");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId")
+                        .IsUnique();
+
+                    b.ToTable("AccountMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("AccountMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Available")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CurrencyCode")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Current")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("Balance");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institutions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Revoked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedDataKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptionKeyId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidAccountMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.AccountMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", "Institution")
+                        .WithMany("Accounts")
+                        .HasForeignKey("InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.AccountMetadata", "AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Balances")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Navigation("Balances");
+
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Institutions");
+
+                    b.Navigation("RefreshTokens");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,126 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddNavigationPropertyToInstitutionForUser : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Account_Institution_InstitutionId",
+                table: "Account");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Institution_Users_UserId",
+                table: "Institution");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_InstitutionMetadata_Institution_InstitutionId",
+                table: "InstitutionMetadata");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_Institution",
+                table: "Institution");
+
+            migrationBuilder.RenameTable(
+                name: "Institution",
+                newName: "Institutions");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Institution_UserId",
+                table: "Institutions",
+                newName: "IX_Institutions_UserId");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_Institutions",
+                table: "Institutions",
+                column: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Account_Institutions_InstitutionId",
+                table: "Account",
+                column: "InstitutionId",
+                principalTable: "Institutions",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_InstitutionMetadata_Institutions_InstitutionId",
+                table: "InstitutionMetadata",
+                column: "InstitutionId",
+                principalTable: "Institutions",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Institutions_Users_UserId",
+                table: "Institutions",
+                column: "UserId",
+                principalTable: "Users",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Account_Institutions_InstitutionId",
+                table: "Account");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_InstitutionMetadata_Institutions_InstitutionId",
+                table: "InstitutionMetadata");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Institutions_Users_UserId",
+                table: "Institutions");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_Institutions",
+                table: "Institutions");
+
+            migrationBuilder.RenameTable(
+                name: "Institutions",
+                newName: "Institution");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Institutions_UserId",
+                table: "Institution",
+                newName: "IX_Institution_UserId");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_Institution",
+                table: "Institution",
+                column: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Account_Institution_InstitutionId",
+                table: "Account",
+                column: "InstitutionId",
+                principalTable: "Institution",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Institution_Users_UserId",
+                table: "Institution",
+                column: "UserId",
+                principalTable: "Users",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_InstitutionMetadata_Institution_InstitutionId",
+                table: "InstitutionMetadata",
+                column: "InstitutionId",
+                principalTable: "Institution",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}
@@ -0,0 +1,376 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260226224648_RenamePlaidMetadataEntity")]
+    partial class RenamePlaidMetadataEntity
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Account");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId")
+                        .IsUnique();
+
+                    b.ToTable("AccountMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("AccountMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Available")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CurrencyCode")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Current")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("Balance");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institutions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Revoked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedDataKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptionKeyId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidAccountMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.AccountMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidInstitutionMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", "Institution")
+                        .WithMany("Accounts")
+                        .HasForeignKey("InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.AccountMetadata", "AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Balances")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Navigation("Balances");
+
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Institutions");
+
+                    b.Navigation("RefreshTokens");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,22 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    /// <inheritdoc />
+    public partial class RenamePlaidMetadataEntity : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}
@@ -0,0 +1,504 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260228123108_AddTransactionAndTransactionMetadataModels")]
+    partial class AddTransactionAndTransactionMetadataModels
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Account");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId")
+                        .IsUnique();
+
+                    b.ToTable("AccountMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("AccountMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Available")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CurrencyCode")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Current")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("Balance");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institutions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Revoked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedDataKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptionKeyId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("AccountId1")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Amount")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("MerchantName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("AccountId1");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Transaction");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.TransactionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TransactionId")
+                        .IsUnique();
+
+                    b.ToTable("TransactionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("Plaid");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidAccountMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.AccountMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidInstitutionMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Transactions.Plaid.PlaidTransactionMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Transactions.TransactionMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", "Institution")
+                        .WithMany("Accounts")
+                        .HasForeignKey("InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.AccountMetadata", "AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Balances")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Transactions")
+                        .HasForeignKey("AccountId1");
+
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.TransactionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Transactions.Transaction", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Transactions.TransactionMetadata", "TransactionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Navigation("Balances");
+
+                    b.Navigation("Metadata");
+
+                    b.Navigation("Transactions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Institutions");
+
+                    b.Navigation("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,104 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddTransactionAndTransactionMetadataModels : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Transaction",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "TEXT", nullable: false),
+                    UserId = table.Column<Guid>(type: "TEXT", nullable: false),
+                    AccountId = table.Column<Guid>(type: "TEXT", nullable: false),
+                    MerchantName = table.Column<string>(type: "TEXT", nullable: false),
+                    Description = table.Column<string>(type: "TEXT", nullable: false),
+                    Amount = table.Column<decimal>(type: "TEXT", nullable: false),
+                    Date = table.Column<DateTimeOffset>(type: "TEXT", nullable: false),
+                    AccountId1 = table.Column<Guid>(type: "TEXT", nullable: true),
+                    CreatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false),
+                    UpdatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Transaction", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Transaction_Account_AccountId",
+                        column: x => x.AccountId,
+                        principalTable: "Account",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Transaction_Account_AccountId1",
+                        column: x => x.AccountId1,
+                        principalTable: "Account",
+                        principalColumn: "Id");
+                    table.ForeignKey(
+                        name: "FK_Transaction_Users_UserId",
+                        column: x => x.UserId,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "TransactionMetadata",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "TEXT", nullable: false),
+                    Type = table.Column<string>(type: "TEXT", maxLength: 5, nullable: false),
+                    TransactionId = table.Column<Guid>(type: "TEXT", nullable: false),
+                    PlaidId = table.Column<string>(type: "TEXT", nullable: true),
+                    CreatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false),
+                    UpdatedAt = table.Column<DateTimeOffset>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_TransactionMetadata", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_TransactionMetadata_Transaction_TransactionId",
+                        column: x => x.TransactionId,
+                        principalTable: "Transaction",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Transaction_AccountId",
+                table: "Transaction",
+                column: "AccountId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Transaction_AccountId1",
+                table: "Transaction",
+                column: "AccountId1");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Transaction_UserId",
+                table: "Transaction",
+                column: "UserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_TransactionMetadata_TransactionId",
+                table: "TransactionMetadata",
+                column: "TransactionId",
+                unique: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "TransactionMetadata");
+
+            migrationBuilder.DropTable(
+                name: "Transaction");
+        }
+    }
+}
@@ -0,0 +1,508 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260301104650_AddCursorToAccountModel")]
+    partial class AddCursorToAccountModel
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Account");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId")
+                        .IsUnique();
+
+                    b.ToTable("AccountMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("AccountMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Available")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CurrencyCode")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Current")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("Balance");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institutions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Revoked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedDataKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptionKeyId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("AccountId1")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Amount")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("MerchantName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("AccountId1");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Transaction");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.TransactionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TransactionId")
+                        .IsUnique();
+
+                    b.ToTable("TransactionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("Plaid");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidAccountMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.AccountMetadata");
+
+                    b.Property<string>("Cursor")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidInstitutionMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Transactions.Plaid.PlaidTransactionMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Transactions.TransactionMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", "Institution")
+                        .WithMany("Accounts")
+                        .HasForeignKey("InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.AccountMetadata", "AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Balances")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Transactions")
+                        .HasForeignKey("AccountId1");
+
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.TransactionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Transactions.Transaction", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Transactions.TransactionMetadata", "TransactionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Navigation("Balances");
+
+                    b.Navigation("Metadata");
+
+                    b.Navigation("Transactions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Institutions");
+
+                    b.Navigation("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,28 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddCursorToAccountModel : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "Cursor",
+                table: "AccountMetadata",
+                type: "TEXT",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Cursor",
+                table: "AccountMetadata");
+        }
+    }
+}
@@ -0,0 +1,507 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260302015827_AddInstitutionsDbSet")]
+    partial class AddInstitutionsDbSet
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Account");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId")
+                        .IsUnique();
+
+                    b.ToTable("AccountMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("AccountMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Available")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CurrencyCode")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Current")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("Balance");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institutions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Revoked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedDataKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptionKeyId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("AccountId1")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Amount")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("MerchantName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("AccountId1");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Transactions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.TransactionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TransactionId")
+                        .IsUnique();
+
+                    b.ToTable("TransactionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("Plaid");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidAccountMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.AccountMetadata");
+
+                    b.Property<string>("Cursor")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidInstitutionMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Transactions.Plaid.PlaidTransactionMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Transactions.TransactionMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", "Institution")
+                        .WithMany("Accounts")
+                        .HasForeignKey("InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.AccountMetadata", "AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Balances")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Transactions")
+                        .HasForeignKey("AccountId1");
+
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.TransactionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Transactions.Transaction", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Transactions.TransactionMetadata", "TransactionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Navigation("Balances");
+
+                    b.Navigation("Metadata");
+
+                    b.Navigation("Transactions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Institutions");
+
+                    b.Navigation("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,168 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddInstitutionsDbSet : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Transaction_Account_AccountId",
+                table: "Transaction");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Transaction_Account_AccountId1",
+                table: "Transaction");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Transaction_Users_UserId",
+                table: "Transaction");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_TransactionMetadata_Transaction_TransactionId",
+                table: "TransactionMetadata");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_Transaction",
+                table: "Transaction");
+
+            migrationBuilder.RenameTable(
+                name: "Transaction",
+                newName: "Transactions");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Transaction_UserId",
+                table: "Transactions",
+                newName: "IX_Transactions_UserId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Transaction_AccountId1",
+                table: "Transactions",
+                newName: "IX_Transactions_AccountId1");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Transaction_AccountId",
+                table: "Transactions",
+                newName: "IX_Transactions_AccountId");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_Transactions",
+                table: "Transactions",
+                column: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_TransactionMetadata_Transactions_TransactionId",
+                table: "TransactionMetadata",
+                column: "TransactionId",
+                principalTable: "Transactions",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Transactions_Account_AccountId",
+                table: "Transactions",
+                column: "AccountId",
+                principalTable: "Account",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Transactions_Account_AccountId1",
+                table: "Transactions",
+                column: "AccountId1",
+                principalTable: "Account",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Transactions_Users_UserId",
+                table: "Transactions",
+                column: "UserId",
+                principalTable: "Users",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_TransactionMetadata_Transactions_TransactionId",
+                table: "TransactionMetadata");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Transactions_Account_AccountId",
+                table: "Transactions");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Transactions_Account_AccountId1",
+                table: "Transactions");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Transactions_Users_UserId",
+                table: "Transactions");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_Transactions",
+                table: "Transactions");
+
+            migrationBuilder.RenameTable(
+                name: "Transactions",
+                newName: "Transaction");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Transactions_UserId",
+                table: "Transaction",
+                newName: "IX_Transaction_UserId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Transactions_AccountId1",
+                table: "Transaction",
+                newName: "IX_Transaction_AccountId1");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_Transactions_AccountId",
+                table: "Transaction",
+                newName: "IX_Transaction_AccountId");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_Transaction",
+                table: "Transaction",
+                column: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Transaction_Account_AccountId",
+                table: "Transaction",
+                column: "AccountId",
+                principalTable: "Account",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Transaction_Account_AccountId1",
+                table: "Transaction",
+                column: "AccountId1",
+                principalTable: "Account",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Transaction_Users_UserId",
+                table: "Transaction",
+                column: "UserId",
+                principalTable: "Users",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_TransactionMetadata_Transaction_TransactionId",
+                table: "TransactionMetadata",
+                column: "TransactionId",
+                principalTable: "Transaction",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}
@@ -0,0 +1,518 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260303124406_AddTransactionsNavigationPropertyToUser")]
+    partial class AddTransactionsNavigationPropertyToUser
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Account");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId")
+                        .IsUnique();
+
+                    b.ToTable("AccountMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("AccountMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Available")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CurrencyCode")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Current")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("Balance");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institutions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Revoked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedDataKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptionKeyId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("AccountId1")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Amount")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("MerchantName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("UserId1")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("AccountId1");
+
+                    b.HasIndex("UserId");
+
+                    b.HasIndex("UserId1");
+
+                    b.ToTable("Transactions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.TransactionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TransactionId")
+                        .IsUnique();
+
+                    b.ToTable("TransactionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("Plaid");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidAccountMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.AccountMetadata");
+
+                    b.Property<string>("Cursor")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidInstitutionMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Transactions.Plaid.PlaidTransactionMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Transactions.TransactionMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", "Institution")
+                        .WithMany("Accounts")
+                        .HasForeignKey("InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.AccountMetadata", "AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Balances")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Transactions")
+                        .HasForeignKey("AccountId1");
+
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Transactions")
+                        .HasForeignKey("UserId1");
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.TransactionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Transactions.Transaction", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Transactions.TransactionMetadata", "TransactionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Navigation("Balances");
+
+                    b.Navigation("Metadata");
+
+                    b.Navigation("Transactions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Institutions");
+
+                    b.Navigation("RefreshTokens");
+
+                    b.Navigation("Transactions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,48 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddTransactionsNavigationPropertyToUser : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<Guid>(
+                name: "UserId1",
+                table: "Transactions",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Transactions_UserId1",
+                table: "Transactions",
+                column: "UserId1");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Transactions_Users_UserId1",
+                table: "Transactions",
+                column: "UserId1",
+                principalTable: "Users",
+                principalColumn: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Transactions_Users_UserId1",
+                table: "Transactions");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Transactions_UserId1",
+                table: "Transactions");
+
+            migrationBuilder.DropColumn(
+                name: "UserId1",
+                table: "Transactions");
+        }
+    }
+}
@@ -0,0 +1,500 @@
+// <auto-generated />
+using System;
+using FiscalOS.Infra.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20260303130637_UpdateAppDbContextToIncludeTransactionNavigationProperties")]
+    partial class UpdateAppDbContextToIncludeTransactionNavigationProperties
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Account");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId")
+                        .IsUnique();
+
+                    b.ToTable("AccountMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("AccountMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Available")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CurrencyCode")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Current")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("Balance");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institutions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("ExpiresAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Revoked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Token")
+                        .IsUnique();
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RefreshTokens");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptedDataKey")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EncryptionKeyId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("HashedPassword")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Amount")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("MerchantName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Transactions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.TransactionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TransactionId")
+                        .IsUnique();
+
+                    b.ToTable("TransactionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("Plaid");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidAccountMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.AccountMetadata");
+
+                    b.Property<string>("Cursor")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidInstitutionMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Transactions.Plaid.PlaidTransactionMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Transactions.TransactionMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", "Institution")
+                        .WithMany("Accounts")
+                        .HasForeignKey("InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.AccountMetadata", "AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Balances")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("RefreshTokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", "Account")
+                        .WithMany("Transactions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("Transactions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.TransactionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Transactions.Transaction", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Transactions.TransactionMetadata", "TransactionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Navigation("Balances");
+
+                    b.Navigation("Metadata");
+
+                    b.Navigation("Transactions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Metadata");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Institutions");
+
+                    b.Navigation("RefreshTokens");
+
+                    b.Navigation("Transactions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.Navigation("Metadata");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
@@ -0,0 +1,78 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace FiscalOS.Infra.Migrations
+{
+    /// <inheritdoc />
+    public partial class UpdateAppDbContextToIncludeTransactionNavigationProperties : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Transactions_Account_AccountId1",
+                table: "Transactions");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_Transactions_Users_UserId1",
+                table: "Transactions");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Transactions_AccountId1",
+                table: "Transactions");
+
+            migrationBuilder.DropIndex(
+                name: "IX_Transactions_UserId1",
+                table: "Transactions");
+
+            migrationBuilder.DropColumn(
+                name: "AccountId1",
+                table: "Transactions");
+
+            migrationBuilder.DropColumn(
+                name: "UserId1",
+                table: "Transactions");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<Guid>(
+                name: "AccountId1",
+                table: "Transactions",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.AddColumn<Guid>(
+                name: "UserId1",
+                table: "Transactions",
+                type: "TEXT",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Transactions_AccountId1",
+                table: "Transactions",
+                column: "AccountId1");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Transactions_UserId1",
+                table: "Transactions",
+                column: "UserId1");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Transactions_Account_AccountId1",
+                table: "Transactions",
+                column: "AccountId1",
+                principalTable: "Account",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Transactions_Users_UserId1",
+                table: "Transactions",
+                column: "UserId1",
+                principalTable: "Users",
+                principalColumn: "Id");
+        }
+    }
+}
@@ -17,6 +17,159 @@ namespace FiscalOS.Infra.Migrations
 #pragma warning disable 612, 618
            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");

+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Account");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId")
+                        .IsUnique();
+
+                    b.ToTable("AccountMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("AccountMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Available")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CurrencyCode")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Current")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.ToTable("Balance");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Institutions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("InstitutionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(21)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstitutionId")
+                        .IsUnique();
+
+                    b.ToTable("InstitutionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("InstitutionMetadata");
+
+                    b.UseTphMappingStrategy();
+                });
+
            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
                {
                    b.Property<Guid>("Id")
@@ -88,6 +241,186 @@ namespace FiscalOS.Infra.Migrations
                    b.ToTable("Users");
                });

+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("AccountId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<decimal>("Amount")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("Date")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("MerchantName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Transactions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.TransactionMetadata", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("TransactionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(5)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("UpdatedAt")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TransactionId")
+                        .IsUnique();
+
+                    b.ToTable("TransactionMetadata");
+
+                    b.HasDiscriminator<string>("Type").HasValue("Plaid");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidAccountMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.AccountMetadata");
+
+                    b.Property<string>("Cursor")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Accounts.Plaid.PlaidInstitutionMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Accounts.InstitutionMetadata");
+
+                    b.Property<string>("EncryptedAccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlaidName")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Infra.Transactions.Plaid.PlaidTransactionMetadata", b =>
+                {
+                    b.HasBaseType("FiscalOS.Core.Transactions.TransactionMetadata");
+
+                    b.Property<string>("PlaidId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasDiscriminator().HasValue("Plaid");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", "Institution")
+                        .WithMany("Accounts")
+                        .HasForeignKey("InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", null)
+                        .WithMany("Accounts")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Institution");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.AccountMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.AccountMetadata", "AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Balance", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", null)
+                        .WithMany("Balances")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("Institutions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.InstitutionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Institution", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Accounts.InstitutionMetadata", "InstitutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
            modelBuilder.Entity("FiscalOS.Core.Identity.RefreshToken", b =>
                {
                    b.HasOne("FiscalOS.Core.Identity.User", "User")
@@ -99,9 +432,64 @@ namespace FiscalOS.Infra.Migrations
                    b.Navigation("User");
                });

+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Accounts.Account", "Account")
+                        .WithMany("Transactions")
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("FiscalOS.Core.Identity.User", "User")
+                        .WithMany("Transactions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Account");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.TransactionMetadata", b =>
+                {
+                    b.HasOne("FiscalOS.Core.Transactions.Transaction", null)
+                        .WithOne("Metadata")
+                        .HasForeignKey("FiscalOS.Core.Transactions.TransactionMetadata", "TransactionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Account", b =>
+                {
+                    b.Navigation("Balances");
+
+                    b.Navigation("Metadata");
+
+                    b.Navigation("Transactions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Accounts.Institution", b =>
+                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Metadata");
+                });
+
            modelBuilder.Entity("FiscalOS.Core.Identity.User", b =>
                {
+                    b.Navigation("Accounts");
+
+                    b.Navigation("Institutions");
+
                    b.Navigation("RefreshTokens");
+
+                    b.Navigation("Transactions");
+                });
+
+            modelBuilder.Entity("FiscalOS.Core.Transactions.Transaction", b =>
+                {
+                    b.Navigation("Metadata");
                });
 #pragma warning restore 612, 618
        }
@@ -0,0 +1,55 @@
+namespace FiscalOS.Infra.Queuing;
+
+internal class AsyncQueueHostedService<T> : BackgroundService where T : notnull
+{
+  private readonly IAsyncQueue<T> _queue;
+  private readonly IServiceProvider _serviceProvider;
+  private readonly ILogger<AsyncQueueHostedService<T>> _logger;
+
+  private AsyncQueueHostedService(
+    IAsyncQueue<T> queue,
+    IServiceProvider serviceProvider,
+    ILogger<AsyncQueueHostedService<T>> logger
+  )
+  {
+    _queue = queue;
+    _serviceProvider = serviceProvider;
+    _logger = logger;
+  }
+
+  public static AsyncQueueHostedService<T> From(IServiceProvider serviceProvider)
+  {
+    var queue = serviceProvider.GetRequiredService<IAsyncQueue<T>>();
+    var logger = serviceProvider.GetRequiredService<ILogger<AsyncQueueHostedService<T>>>();
+    return new(queue, serviceProvider, logger);
+  }
+
+  protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+  {
+    _logger.LogInformation("Queue hosted service for {ItemType} starting", typeof(T).Name);
+
+    try
+    {
+      while (!stoppingToken.IsCancellationRequested)
+      {
+        var item = await _queue.DequeueAsync(stoppingToken).ConfigureAwait(false);
+
+        using var scope = _serviceProvider.CreateScope();
+        var processor = scope.ServiceProvider.GetRequiredService<IAsyncQueueProcessor<T>>();
+
+        try
+        {
+          await processor.ProcessAsync(item, stoppingToken).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+          _logger.LogError(ex, "Error processing queue item of type {ItemType}", typeof(T).Name);
+        }
+      }
+    }
+    catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
+    {
+      _logger.LogInformation("Queue hosted service for {ItemType} stopped", typeof(T).Name);
+    }
+  }
+}
@@ -0,0 +1,31 @@
+namespace FiscalOS.Infra.Queuing;
+
+internal class ChannelAsyncQueue<T> : IAsyncQueue<T>
+{
+  private readonly Channel<T> _channel = Channel.CreateUnbounded<T>();
+
+  private ChannelAsyncQueue()
+  {
+  }
+
+  public static ChannelAsyncQueue<T> From(IServiceProvider serviceProvider)
+  {
+    return new();
+  }
+
+  public async Task EnqueueAsync(T item, CancellationToken cancellationToken = default)
+  {
+    await _channel.Writer.WriteAsync(item, cancellationToken).ConfigureAwait(false);
+  }
+
+  public async Task<T> DequeueAsync(CancellationToken cancellationToken = default)
+  {
+    return await _channel.Reader.ReadAsync(cancellationToken).ConfigureAwait(false);
+  }
+
+  public async ValueTask DisposeAsync()
+  {
+    _channel.Writer.Complete();
+    await _channel.Reader.Completion.ConfigureAwait(false);
+  }
+}
@@ -0,0 +1,114 @@
+using Account = FiscalOS.Core.Accounts.Account;
+using Transaction = FiscalOS.Core.Transactions.Transaction;
+
+namespace FiscalOS.Infra.Transactions.Plaid;
+
+internal interface IPlaidAddedTransactionHandler
+{
+  Task<int> HandleAsync(
+    Account account,
+    IEnumerable<Going.Plaid.Entity.Transaction> added,
+    CancellationToken ct
+  );
+}
+
+internal sealed class PlaidAddedTransactionHandler : IPlaidAddedTransactionHandler
+{
+  private readonly ILogger<PlaidAddedTransactionHandler> _logger;
+  private readonly AppDbContext _appDbContext;
+
+  private PlaidAddedTransactionHandler(
+    ILogger<PlaidAddedTransactionHandler> logger,
+    AppDbContext appDbContext
+  )
+  {
+    _logger = logger;
+    _appDbContext = appDbContext;
+  }
+
+  public static PlaidAddedTransactionHandler From(
+    ILogger<PlaidAddedTransactionHandler> logger,
+    AppDbContext appDbContext
+  )
+  {
+    return new(logger, appDbContext);
+  }
+
+  public static PlaidAddedTransactionHandler From(IServiceProvider serviceProvider)
+  {
+    return new(
+      serviceProvider.GetRequiredService<ILogger<PlaidAddedTransactionHandler>>(),
+      serviceProvider.GetRequiredService<AppDbContext>()
+    );
+  }
+
+  public async Task<int> HandleAsync(Account account, IEnumerable<Going.Plaid.Entity.Transaction> added, CancellationToken ct)
+  {
+    var existingTransactionIds = added.Select(t => t.TransactionId);
+    var existingTransactions = await _appDbContext.Transactions
+      .Where(t => t.Metadata is PlaidTransactionMetadata && existingTransactionIds.Contains(((PlaidTransactionMetadata)t.Metadata).PlaidId))
+      .ToListAsync(ct)
+      .ConfigureAwait(false);
+
+    var addedCount = 0;
+
+    foreach (var addedTransaction in added)
+    {
+      try
+      {
+        if (addedTransaction.Pending.GetValueOrDefault())
+        {
+          _logger.LogInformation(
+            "Skipping pending transaction {TransactionId} for account {AccountId} as it has not been posted yet",
+            addedTransaction.TransactionId,
+            account.Id
+          );
+          addedCount++;
+          continue;
+        }
+
+        var existingTransaction = existingTransactions.FirstOrDefault(
+          t => t.Metadata is PlaidTransactionMetadata metadata && metadata.PlaidId == addedTransaction.TransactionId
+        );
+
+        if (existingTransaction is not null)
+        {
+          _logger.LogInformation(
+            "Skipping added transaction {PlaidTransactionId} for account {AccountId} as it has already been added as transaction {TransactionId}",
+            addedTransaction.TransactionId,
+            account.Id,
+            existingTransaction.Id
+          );
+          addedCount++;
+          continue;
+        }
+
+        var transactionMetadata = PlaidTransactionMetadata.From(addedTransaction.TransactionId);
+        var transaction = Transaction.From(
+          account.UserId,
+          account.Id,
+          addedTransaction.Merchant,
+          addedTransaction.Description,
+          addedTransaction.Amount,
+          addedTransaction.PostedDate,
+          transactionMetadata
+        );
+        account.AddTransaction(transaction);
+        addedCount++;
+      }
+      catch (Exception ex)
+      {
+        _logger.LogError(
+          ex,
+          "Failed to added transaction {PlaidTransactionId} to account {AccountId}",
+          account.Id,
+          addedTransaction.TransactionId
+        );
+      }
+    }
+
+    _logger.LogInformation("Added {AddedCount} transactions to account {AccountId}", addedCount, account.Id);
+
+    return addedCount;
+  }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Stevan Freeborn	4b030651b3	chore: add coverage directory to .gitignore	2026-03-08 16:22:39 -05:00
Stevan Freeborn	d293c0d75a	refactor: remove unused using directive for Going.Plaid.Transactions in PlaidTransactionProcessorTests	2026-03-08 16:16:07 -05:00
Stevan Freeborn	1c0fdc205e	tests(infra.tests): enhance AccountBuilder with metadata handling and expand PlaidTransactionSyncerTests	2026-03-08 16:14:51 -05:00
Stevan Freeborn	1a4f7fac8d	tests(infra,api): refactor to allow further config of TestApi	2026-03-08 09:15:45 -05:00
Stevan Freeborn	870baf7b6c	tests(infra.tests): added builder classes for creating test entities	2026-03-08 07:18:27 -05:00
Stevan Freeborn	27d2ccbd45	tests(infra.tests): wip on builder apis for test data	2026-03-06 07:14:57 -06:00
Stevan Freeborn	66f4046d2e	feat: implement transaction handling and add integration tests for Plaid transaction handlers	2026-03-05 13:58:00 -06:00
Stevan Freeborn	0f0ed561c3	feat: update account handling in add endpoint and tests	2026-03-03 07:40:19 -06:00
Stevan Freeborn	74793b5800	feat: continued wip on supporting transactions	2026-03-03 07:36:09 -06:00
Stevan Freeborn	562a708c74	fix(infra): don't advance account cursor unless all transactions proceed successfully	2026-03-03 05:09:03 -06:00
Stevan Freeborn	19a4520a7b	refactor(core): make parameters non-nullable	2026-03-03 05:08:35 -06:00
Stevan Freeborn	33f74ee018	tests(api.tests): fix methods broken in refactor	2026-03-03 05:08:12 -06:00
Stevan Freeborn	2bc9cab43d	feat: rename transaction table to transactions and update related references	2026-03-01 20:35:33 -06:00
Stevan Freeborn	b9d0869ae3	feat: add Plaid transaction handling and async queue processing - introduced new migration to add Cursor column to AccountMetadata. - updated AppDbContext model snapshot to reflect changes in the database schema. - implemented async queue processing with ChannelAsyncQueue and AsyncQueueHostedService. - created Plaid transaction handlers for added, modified, and removed transactions. - developed PlaidTransactionService and PlaidTransactionSyncer for syncing transactions. - added SyncUpdatesProcessor to handle sync updates from Plaid. - updated tests to accommodate changes in institution and account metadata handling.	2026-03-01 19:56:29 -06:00
Stevan Freeborn	48e95e5242	refactor(api.tests): updated model names	2026-02-24 06:55:37 -06:00
Stevan Freeborn	d0b0097032	feat(web): handle adding accounts to institution	2026-02-24 06:55:37 -06:00
Stevan Freeborn	81c45350e8	feat(api): include accounts in institution dto	2026-02-24 06:55:37 -06:00
Stevan Freeborn	2fa34fe5ab	feat(infra): updated modeling to reflect new navigation property	2026-02-24 06:55:37 -06:00
Stevan Freeborn	0815620028	feat(core): added navigation property to institution for accounts	2026-02-24 06:55:37 -06:00
Stevan Freeborn	d5b6fb3a38	tests(apphost.tests): added support for end to end testing using playwright	2026-02-23 05:56:34 -06:00
Stevan Freeborn	fd2cd68d73	feat(web,api): added ability to add and then display list of institutions	2026-02-22 06:53:13 -06:00
Stevan Freeborn	b4fbf16869	feat(web): finish implementing login	2026-02-21 07:32:28 -06:00
Stevan Freeborn	d9130e75a4	feat(web): make things work - setup basic login form - setup basic add institution functionality	2026-02-21 07:32:28 -06:00
Stevan Freeborn	e2537d77c4	feat(web): working on login style	2026-02-21 07:32:28 -06:00
Stevan Freeborn	fcbc9e78c2	style(web): add fonts	2026-02-21 07:32:28 -06:00
Stevan Freeborn	9042cd4ead	feat(web): use user store and auth service to handle logging in and persistenting user state	2026-02-21 07:32:28 -06:00
Stevan Freeborn	1c3de212ff	chore(web): configure prettier to my preferences	2026-02-21 07:32:28 -06:00
Stevan Freeborn	72a534a8e0	feat(web): add composable for creating auth service	2026-02-21 07:32:28 -06:00
Stevan Freeborn	74e55b2f48	feat(web): implement user store	2026-02-21 07:32:28 -06:00
Stevan Freeborn	a3dc58d19b	feat(web): implement auth service	2026-02-21 07:32:28 -06:00
Stevan Freeborn	5a878bf4b3	feat(web): add small http client implementation around fetch	2026-02-21 07:32:28 -06:00
Stevan Freeborn	dee331fb0d	feat(web): implement initial logic to handle protected vs public routing	2026-02-21 07:32:28 -06:00
Stevan Freeborn	df859b91b0	feat: add frontend with aspire integration	2026-02-17 06:19:05 -06:00
Stevan Freeborn	d77e5d45f6	feat: aspirify the solution	2026-02-15 08:16:47 -06:00
Stevan Freeborn	2cca5c15a0	chore: run dotnet format	2026-02-15 08:16:47 -06:00
Stevan Freeborn	ab88656c1e	feat(api): implement endpoint for creating link tokens	2026-02-15 07:02:01 -06:00
Stevan Freeborn	6b2b19cb5b	feat(infra): add create link token to plaid service	2026-02-15 07:02:01 -06:00
Stevan Freeborn	9c0f642f90	feat(api): support passing and persistenting currency code for balances	2026-02-14 06:46:05 -06:00
Stevan Freeborn	701b89d704	feat(infra): added modeling and migrations for currency code prop	2026-02-14 06:46:05 -06:00
Stevan Freeborn	49e4288eba	feat(core): extend balance model to store currency code	2026-02-14 06:46:05 -06:00
Stevan Freeborn	497dedf6ac	feat(api): return balance info to frontend	2026-02-14 06:46:05 -06:00
Stevan Freeborn	29d8758ede	feat(infra): add extensions members for plaid accounts	2026-02-14 06:46:05 -06:00
Stevan Freeborn	6190470fe2	feat(api): initialize account with starting balance	2026-02-14 06:46:05 -06:00
Stevan Freeborn	ed7e25961c	feat(infra): add modeling to dbcontext for balance model with migrations	2026-02-14 06:46:05 -06:00
Stevan Freeborn	e331030bb0	feat(core): add balance model	2026-02-14 06:46:05 -06:00
Stevan Freeborn	3b7830b1bc	refactor(api): introduce DTOs for institutional account discovery - Replace raw Plaid entity response with a dedicated Response wrapper - Map Plaid accounts to AccountDto to decouple API from external SDK models - Update integration tests to assert against the new response structure - Add JsonConstructors to DTO records for reliable deserialization	2026-02-14 06:46:05 -06:00
Stevan Freeborn	dad2ceb450	feat(api,core,infra): refactor endpoint routing and add institution account discovery - Move login and refresh endpoints under a unified /auth route group - Relocate institution connection logic from /accounts to /institutions - Implement GET /institutions/{id}/available to fetch real-time Plaid accounts - Introduce HttpRequestBuilder utility to streamline integration testing - Enhance PlaidService with GetAccountsAsync to support account fetching - Clean up global usings and project structure for better domain isolation	2026-02-14 06:46:05 -06:00
Stevan Freeborn	32cf48bf36	refactor(infra,api.tests): fix my null lies	2026-02-13 12:38:18 -06:00
Stevan Freeborn	502f6f61c1	feat(api): validate account institution is connected and allow adding new account	2026-02-13 12:38:18 -06:00
Stevan Freeborn	6ca90ed25a	refactor(api.tests): rename variable	2026-02-13 12:38:18 -06:00
Stevan Freeborn	5192c06627	refactor(api): use convenience methods	2026-02-13 12:38:18 -06:00
Stevan Freeborn	2fd55a55cd	fix(infra): update db model to address property name correction	2026-02-13 12:38:18 -06:00
Stevan Freeborn	a2e9fc3f30	fix(core): fix incorrectly named property	2026-02-13 12:38:18 -06:00
Stevan Freeborn	a83dbbcc54	feat(api): add validation to prevent duplicate accounts from being added	2026-02-13 12:38:18 -06:00
Stevan Freeborn	a07fd24ee9	feat(infra): added plaid specific metadata and updated context to model account	2026-02-13 12:38:18 -06:00
Stevan Freeborn	2fdb849142	feat(core): add models for account	2026-02-13 12:38:18 -06:00
Stevan Freeborn	1a41c3c0b6	feat(api): implement storing connected insitution in db	2026-02-13 04:37:47 -06:00
Stevan Freeborn	c4a8aada6b	feat(infra): implement plaid service	2026-02-13 04:37:47 -06:00
Stevan Freeborn	dd08eee5a3	refactor(infra): remove unneeded qualifiers	2026-02-13 04:37:47 -06:00
Stevan Freeborn	7cdf87b860	tests(api.tests): pass cancellation token through delegate	2026-02-13 04:37:47 -06:00
Stevan Freeborn	8663daabae	chore(api.tests): add example test settings file	2026-02-13 04:37:47 -06:00
Stevan Freeborn	0b7c33a024	fix(core): pass name of null param	2026-02-13 04:37:47 -06:00
Stevan Freeborn	823ba4dc5a	chore: update example appsettings file	2026-02-13 04:37:47 -06:00
Stevan Freeborn	1d661ac409	feat(api): prevent user from connecting to same institution twice	2026-02-13 04:37:47 -06:00
Stevan Freeborn	069d019d80	feat(infra): update db context with modeling for institution and relationships	2026-02-13 04:37:47 -06:00
Stevan Freeborn	3f62a246ee	feat(core): add models for institution	2026-02-13 04:37:47 -06:00
Stevan Freeborn	5da1f1decf	refactor(api.tests): check for correct status code first in assertion	2026-02-13 04:37:47 -06:00
Stevan Freeborn	1f5e4a319a	fix(api.tests): use a serializable dictionary for xunit test case data	2026-02-13 04:37:47 -06:00
Stevan Freeborn	683ca3fac4	feat(api): add validation for connect account request	2026-02-13 04:37:47 -06:00
Stevan Freeborn	e88adfd2a7	refactor(api): derive field name from property being validated	2026-02-13 04:37:47 -06:00
Stevan Freeborn	6fc8bd0366	refactor(api): rename type	2026-02-13 04:37:47 -06:00
Stevan Freeborn	ab23593359	refactor(api): remove whitespace	2026-02-13 04:37:47 -06:00
Stevan Freeborn	87a68669cf	feat(api): add protected connect account endpoint	2026-02-13 04:37:47 -06:00
Stevan Freeborn	b4744076b7	tests: update test ring implementation	2026-02-06 06:53:20 -06:00
Stevan Freeborn	5b1a5f003e	tests: add mucho tests	2026-02-06 06:53:20 -06:00
Stevan Freeborn	b2086d8185	feat(admincli): add generate key command	2026-02-06 06:53:20 -06:00
Stevan Freeborn	9b4f0c6b9e	refactor(api): clean up usings	2026-02-06 06:53:20 -06:00
Stevan Freeborn	259daf1e5b	chore: update example settings file	2026-02-06 06:53:20 -06:00
Stevan Freeborn	e02a18df00	chore: added filesystem abstraction package	2026-02-06 06:53:20 -06:00
Stevan Freeborn	c1932246f3	feat(infra): create initial encryption implementations	2026-02-06 06:53:20 -06:00
Stevan Freeborn	4eb833d2c8	chore: add services registrations	2026-02-06 06:53:20 -06:00
Stevan Freeborn	af29df5d19	refactor(infra): move database path logic into app context	2026-02-06 06:53:20 -06:00
Stevan Freeborn	04e0a31b27	chore: remove unnecessary using	2026-02-06 06:53:20 -06:00
Stevan Freeborn	97c7847a89	chore: removed unnecessary usings	2026-02-06 06:53:20 -06:00
Stevan Freeborn	f34fb5ce41	feat(core): define primary models and services for encryption	2026-02-06 06:53:20 -06:00
Stevan Freeborn	38c311bdd1	feat(core): extend user model with encryption related properties	2026-02-06 06:53:20 -06:00
Stevan Freeborn	e9b1bd11bb	feat(infra): added migrations for adding properties to user model	2026-02-06 06:53:20 -06:00