diff --git a/.github/workflows/fw-lite.yaml b/.github/workflows/fw-lite.yaml
index 9c060178b6..71ac864746 100644
--- a/.github/workflows/fw-lite.yaml
+++ b/.github/workflows/fw-lite.yaml
@@ -22,6 +22,9 @@ on:
       - develop
       - main
       - shadcn-ui-main #just for now ensure PRs to this branch have checks run
+
+permissions:
+  contents: read
 env:
   VIEWER_BUILD_OUTPUT_DIR: backend/FwLite/FwLiteShared/wwwroot/viewer
 jobs:
@@ -112,7 +115,8 @@ jobs:
         run: pnpm exec playwright install --with-deps
       - name: Run snapshot tests
         working-directory: frontend/viewer
-        run: task playwright-test-standalone
+        run: task test:snapshot-standalone
+
       - name: Build viewer
         working-directory: frontend/viewer
         run: pnpm run build
@@ -125,6 +129,9 @@ jobs:
           path: ${{ env.VIEWER_BUILD_OUTPUT_DIR }}
 
   frontend-component-unit-tests:
+    permissions:
+      contents: read
+      checks: write
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -366,6 +373,8 @@ jobs:
           path: backend/FwLite/artifacts/sign/*.msixbundle
 
   create-release:
+    permissions:
+      contents: write
     if: ${{ github.ref_name == 'main' }}
     environment:
       name: production
@@ -420,3 +429,79 @@ jobs:
           sleep 10
           curl -X POST https://lexbox.org/api/fwlite-release/new-release
 
+
+  e2e-test:
+    name: E2E Tests
+    needs: [publish-linux]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - uses: actions/download-artifact@v4
+        id: download-artifact
+        with:
+          name: fw-lite-web-linux
+          path: fw-lite-web-linux
+
+      - name: Debug downloaded artifact contents
+        shell: bash
+        run: |
+          set -e
+          echo "download-path=${{ steps.download-artifact.outputs.download-path }}"
+          ls -la "${{ steps.download-artifact.outputs.download-path }}"
+          ls -Rla "${{ steps.download-artifact.outputs.download-path }}"
+
+      - name: set execute permissions
+        shell: bash
+        run: |
+          set -e
+          find "${{ steps.download-artifact.outputs.download-path }}" -type f -name FwLiteWeb -exec chmod +x {} +
+      - name: Install Task
+        uses: arduino/setup-task@b91d5d2c96a56797b48ac1e0e89220bf64044611 #v2
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: pnpm/action-setup@fe02b34f77f8bc703788d5817da081398fad5dd2 # v4.0.0
+        with:
+          package_json_file: 'frontend/package.json'
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: './frontend/package.json'
+          cache: 'pnpm'
+          cache-dependency-path: './frontend/pnpm-lock.yaml'
+      - name: Prepare frontend
+        working-directory: frontend
+        run: |
+          pnpm install
+      - name: Test fw lite launcher
+        working-directory: frontend/viewer
+        env:
+          FW_LITE_BINARY_PATH: ${{ steps.download-artifact.outputs.download-path }}/release_linux-x64/FwLiteWeb
+        run: task e2e-test-helper-unit-tests
+
+      - uses: ./.github/actions/setup-k8s
+        with:
+          lexbox-api-tag: develop
+          ingress-controller-port: '6579' # todo, figure out if we can use https as it's required for the tests
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up Playwright dependencies
+        working-directory: frontend/viewer
+        run: pnpm exec playwright install --with-deps
+
+      - name: Run E2E tests
+        working-directory: frontend/viewer
+        env:
+          FW_LITE_BINARY_PATH: ${{ steps.download-artifact.outputs.download-path }}/release_linux-x64/FwLiteWeb
+          TEST_SERVER_PORT: 6579
+        run: task test:e2e
+
+      - name: Upload Playwright test results and traces (on failure)
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: fw-lite-e2e-test-results
+          if-no-files-found: ignore
+          path: |
+            frontend/viewer/tests/e2e/test-results/
diff --git a/.gitignore b/.gitignore
index ed18941d1b..0d7741e559 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,6 +26,12 @@ artifacts/
 project-cache.json
 localResourcesCache/
 
+# Kiro AI-generated specs (not part of repo source)
+.kiro/
+
+# Kiro-generated specs
+.kiro/
+
 #Verify
 *.received.*
 backend/FwLite/FwLiteShared/wwwroot/viewer
diff --git a/backend/FwLite/FwLiteWeb/FwLiteWebServer.cs b/backend/FwLite/FwLiteWeb/FwLiteWebServer.cs
index f8caa4738f..8bcb3234fb 100644
--- a/backend/FwLite/FwLiteWeb/FwLiteWebServer.cs
+++ b/backend/FwLite/FwLiteWeb/FwLiteWebServer.cs
@@ -69,6 +69,7 @@ public static WebApplication SetupAppServer(WebApplicationOptions options, Actio
             options.AddFilter(new LockedProjectFilter());
             options.EnableDetailedErrors = true;
         }).AddJsonProtocol();
+        builder.Services.AddHealthChecks();
 
         configure?.Invoke(builder);
         var app = builder.Build();
@@ -123,6 +124,7 @@ public static WebApplication SetupAppServer(WebApplicationOptions options, Actio
         app.MapImport();
         app.MapAuthRoutes();
         app.MapMiniLcmRoutes("/api/mini-lcm");
+        app.MapHealthChecks("/health");
 
         app.MapStaticAssets();
         app.MapRazorComponents<App>()
diff --git a/backend/FwLite/FwLiteWeb/Program.cs b/backend/FwLite/FwLiteWeb/Program.cs
index 62388267fc..d6ad0eb155 100644
--- a/backend/FwLite/FwLiteWeb/Program.cs
+++ b/backend/FwLite/FwLiteWeb/Program.cs
@@ -29,5 +29,13 @@
              await app.StopAsync();
          });
 
+    _ = Task.Run(async () =>
+    {
+        // Wait for the "shutdown" command from stdin
+        while (await Console.In.ReadLineAsync() is not "shutdown") { }
+
+        await app.StopAsync();
+    });
+
     await app.WaitForShutdownAsync();
 }
diff --git a/backend/FwLite/FwLiteWeb/Routes/AuthRoutes.cs b/backend/FwLite/FwLiteWeb/Routes/AuthRoutes.cs
index 55bc0711c4..a1cc1fad68 100644
--- a/backend/FwLite/FwLiteWeb/Routes/AuthRoutes.cs
+++ b/backend/FwLite/FwLiteWeb/Routes/AuthRoutes.cs
@@ -18,6 +18,9 @@ public static IEndpointConventionBuilder MapAuthRoutes(this WebApplication app)
             async (AuthService authService, string authority, IOptions<AuthConfig> options, [FromHeader] string referer) =>
             {
                 var returnUrl = new Uri(referer).PathAndQuery;
+                if (returnUrl.StartsWith("/api/auth/login")) {
+                    returnUrl = "/";
+                }
                 if (options.Value.SystemWebViewLogin)
                 {
                     throw new NotSupportedException("System web view login is not supported for this endpoint");
diff --git a/backend/FwLite/FwLiteWeb/Routes/ProjectRoutes.cs b/backend/FwLite/FwLiteWeb/Routes/ProjectRoutes.cs
index 0795351782..87967906f8 100644
--- a/backend/FwLite/FwLiteWeb/Routes/ProjectRoutes.cs
+++ b/backend/FwLite/FwLiteWeb/Routes/ProjectRoutes.cs
@@ -70,6 +70,12 @@ [FromQuery] UserProjectRole? role
                     _ => Results.InternalServerError("DownloadProjectByCodeResult enum value not handled, please inform FW Lite devs")
                 };
             });
+        group.MapDelete("/crdt/{code}",
+            async (CrdtProjectsService projectService, string code) =>
+            {
+                await projectService.DeleteProject(code);
+                return TypedResults.Ok();
+            });
         return group;
     }
 }
diff --git a/frontend/viewer/.gitignore b/frontend/viewer/.gitignore
index 7e0b04f8df..782c55ec55 100644
--- a/frontend/viewer/.gitignore
+++ b/frontend/viewer/.gitignore
@@ -26,4 +26,5 @@ html-test-results
 
 *storybook.log
 storybook-static
-"screenshots/" 
+screenshots/*
+**/*-html-report
diff --git a/frontend/viewer/Taskfile.yml b/frontend/viewer/Taskfile.yml
index af04e77550..350cddd802 100644
--- a/frontend/viewer/Taskfile.yml
+++ b/frontend/viewer/Taskfile.yml
@@ -42,19 +42,27 @@ tasks:
   test-unit:
     cmd: pnpm test --project unit
 
-  playwright-test:
-    desc: 'runs playwright tests against already running server'
-    cmd: pnpm run test:playwright {{.CLI_ARGS}}
-  playwright-test-standalone:
-    desc: 'runs playwright tests and runs dev automatically, run ui mode by calling with -- --ui or use --update-snapshots'
+  test:snapshot:
+    desc: 'runs snapshot tests against already running server'
+    cmd: pnpm run test:snapshots {{.CLI_ARGS}}
+  test:snapshot-standalone:
+    desc: 'runs snapshot tests and runs dev automatically, run ui mode by calling with -- --ui or use --update-snapshots'
     env:
       AUTO_START_SERVER: true
-    cmd: pnpm run test:playwright {{.CLI_ARGS}}
+    cmd: pnpm run test:snapshots {{.CLI_ARGS}}
   generate-marketing-screenshots:
     desc: 'they should be in the screenshots folder'
     env:
       AUTO_START_SERVER: true
       MARKETING_SCREENSHOTS: true
-    cmd: pnpm run test:playwright {{.CLI_ARGS}}
-  playwright-test-report:
-    cmd: pnpm run test:playwright-report
+    cmd: pnpm run test:snapshots {{.CLI_ARGS}}
+
+  test:e2e-setup:
+    deps: [build]
+    cmds:
+      - dotnet publish ../../backend/FwLite/FwLiteWeb/FwLiteWeb.csproj --configuration Release --self-contained --output ./dist/fw-lite-server
+  test:e2e:
+    cmd: pnpm run test:e2e {{.CLI_ARGS}}
+  e2e-test-helper-unit-tests:
+    desc: 'tests the fw lite launcher, run `setup-e2e-test` first'
+    cmd: pnpm test:unit --run fw-lite-launcher
diff --git a/frontend/viewer/package.json b/frontend/viewer/package.json
index 591a6349ee..a17c2d0b0a 100644
--- a/frontend/viewer/package.json
+++ b/frontend/viewer/package.json
@@ -13,16 +13,15 @@
     "build": "vite build",
     "build-ffmpeg-worker": "vite build --config vite.config.ffmpeg-worker.ts",
     "preview": "vite preview",
-    "pretest:playwright": "playwright install",
-    "test:playwright": "playwright test",
-    "test:playwright-report": "playwright show-report html-test-results",
-    "test:playwright-record": "playwright codegen",
+    "pretest:snapshots": "playwright install chromium",
+    "pretest:e2e": "playwright install chromium",
+    "test:snapshots": "playwright test -c ./tests/snapshots/playwright.config.ts",
+    "test:e2e": "playwright test -c ./tests/e2e/playwright.config.ts",
     "test": "vitest run",
     "test:ui": "vitest --ui",
     "test:watch": "vitest",
     "test:storybook": "vitest --project=storybook",
     "test:unit": "vitest --project=unit",
-    "test:browser": "vitest --project=browser",
     "check": "svelte-check",
     "lint": "eslint",
     "lint:report": "eslint-output",
diff --git a/frontend/viewer/src/fw-lite-launcher.test.ts b/frontend/viewer/src/fw-lite-launcher.test.ts
new file mode 100644
index 0000000000..603a6f3406
--- /dev/null
+++ b/frontend/viewer/src/fw-lite-launcher.test.ts
@@ -0,0 +1,215 @@
+/**
+ * Integration tests for FW Lite Application Launcher
+ *
+ * These tests run against the real implementation without mocking
+ * to ensure the launcher works correctly in practice.
+ */
+
+import {describe, it, expect, assert, beforeEach, afterEach} from 'vitest';
+import {FwLiteLauncher} from '../tests/e2e/helpers/fw-lite-launcher';
+import type {LaunchConfig} from '../tests/e2e/types';
+import {getTestConfig} from '../tests/e2e/config';
+
+describe('FwLiteLauncher', () => {
+  let launcher: FwLiteLauncher;
+
+  beforeEach(() => {
+    launcher = new FwLiteLauncher();
+  });
+
+  afterEach(async () => {
+    // Ensure cleanup after each test
+    if (launcher.isRunning()) {
+      await launcher.shutdown();
+    }
+  });
+
+  describe('basic functionality', () => {
+    it('should return false when not launched', () => {
+      expect(launcher.isRunning()).toBe(false);
+    });
+
+    it('should throw error when getting base URL while not running', () => {
+      expect(() => launcher.getBaseUrl()).toThrow('FW Lite is not running');
+    });
+
+    it('should handle shutdown when not running', async () => {
+      await expect(launcher.shutdown()).resolves.not.toThrow();
+      expect(launcher.isRunning()).toBe(false);
+    });
+
+    it('should throw error if binary does not exist', async () => {
+      const config: LaunchConfig = {
+        binaryPath: '/nonexistent/path/to/fw-lite',
+        serverUrl: 'http://localhost:5137',
+        port: 5000,
+        timeout: 1000,
+      };
+
+      await expect(launcher.launch(config)).rejects.toThrow(
+        'FW Lite binary not found or not executable'
+      );
+    });
+
+    it('should throw error if already running', async () => {
+      // Create a fake binary file for testing
+      const testBinaryPath = './test-fake-binary.js';
+
+      const fs = await import('node:fs/promises');
+      await fs.writeFile(testBinaryPath, '#!/usr/bin/env node\nconsole.log("fake binary");', {mode: 0o755});
+
+      const config: LaunchConfig = {
+        binaryPath: testBinaryPath,
+        serverUrl: 'http://localhost:5137',
+        port: 5000,
+        timeout: 1000,
+      };
+
+      // First launch should fail because it's not a real FW Lite binary
+      await expect(launcher.launch(config)).rejects.toThrow();
+
+      // Clean up
+      await fs.unlink(testBinaryPath).catch(() => { });
+    }, 10000);
+  });
+
+  describe('port finding functionality', () => {
+    it('should be able to find available ports', async () => {
+      const net = await import('node:net');
+
+      // Test the port finding logic by creating a server on a port
+      const server = net.createServer();
+
+      return new Promise<void>((resolve, reject) => {
+        server.listen(0, () => {
+          const address = server.address();
+          const port = typeof address === 'object' && address ? address.port : 0;
+
+          expect(port).toBeGreaterThan(0);
+
+          server.close(() => {
+            resolve();
+          });
+        });
+
+        server.on('error', reject);
+      });
+    });
+  });
+
+  describe('configuration validation', () => {
+    it('should validate launch configuration parameters', () => {
+      const validConfig: LaunchConfig = {
+        binaryPath: '/path/to/fw-lite',
+        serverUrl: 'http://localhost:5137',
+        port: 5000,
+        timeout: 10000,
+      };
+
+      // Test that config properties are accessible
+      expect(validConfig.binaryPath).toBe('/path/to/fw-lite');
+      expect(validConfig.serverUrl).toBe('http://localhost:5137');
+      expect(validConfig.port).toBe(5000);
+      expect(validConfig.timeout).toBe(10000);
+    });
+
+    it('should handle optional configuration parameters', () => {
+      const minimalConfig: LaunchConfig = {
+        binaryPath: '/path/to/fw-lite',
+        serverUrl: 'http://localhost:5137',
+      };
+
+      // Test that optional parameters can be undefined
+      expect(minimalConfig.port).toBeUndefined();
+      expect(minimalConfig.timeout).toBeUndefined();
+    });
+  });
+
+  describe('launcher state management', () => {
+    it('should maintain proper state transitions', () => {
+      // Initial state
+      expect(launcher.isRunning()).toBe(false);
+
+      // State should remain consistent
+      expect(launcher.isRunning()).toBe(false);
+      expect(launcher.isRunning()).toBe(false);
+    });
+  });
+
+  describe('real FW Lite server integration', () => {
+    async function getFwLiteBinaryPath() {
+      const binaryPath = getTestConfig().fwLite.binaryPath;
+      const fs = await import('node:fs/promises');
+      try {
+        await fs.access(binaryPath);
+      } catch {
+        assert.fail(`FW Lite binary not found at ${binaryPath}, skipping integration test. Run "pnpm build:fw-lite" first.`);
+      }
+      return binaryPath;
+    }
+
+
+
+    it('should successfully launch and shutdown real FW Lite server', async () => {
+      // Check if the FW Lite binary exists
+      const binaryPath = await getFwLiteBinaryPath();
+
+
+      const config: LaunchConfig = {
+        binaryPath,
+        serverUrl: 'http://localhost:5137',
+        port: 5555, // Use a specific port for testing
+        timeout: 30000, // 30 seconds timeout
+      };
+
+      // Launch the server
+      await launcher.launch(config);
+
+      // Verify it's running
+      expect(launcher.isRunning()).toBe(true);
+      expect(launcher.getBaseUrl()).toBe('http://localhost:5555');
+
+      // Test that we can make a request to the server
+      try {
+        const response = await fetch(`${launcher.getBaseUrl()}/health`);
+        // Accept any response that indicates the server is running
+        expect(response.status).toBeLessThan(500);
+      } catch {
+        // If /health doesn't exist, try the root endpoint
+        const response = await fetch(launcher.getBaseUrl());
+        expect(response.status).toBeLessThan(500);
+      }
+
+      // Shutdown the server
+      await launcher.shutdown();
+
+      // Verify it's stopped
+      expect(launcher.isRunning()).toBe(false);
+    }, 60000); // 60 second timeout for this test
+
+    it('should handle multiple launch attempts gracefully', async () => {
+      // Check if the FW Lite binary exists
+      const binaryPath = await getFwLiteBinaryPath();
+
+      const config: LaunchConfig = {
+        binaryPath,
+        serverUrl: 'http://localhost:5137',
+        port: 5556, // Use a different port
+        timeout: 30000,
+      };
+
+      // First launch should succeed
+      await launcher.launch(config);
+      expect(launcher.isRunning()).toBe(true);
+
+      // Second launch should fail
+      await expect(launcher.launch(config)).rejects.toThrow(
+        'FW Lite is already running. Call shutdown() first.'
+      );
+
+      // Cleanup
+      await launcher.shutdown();
+      expect(launcher.isRunning()).toBe(false);
+    }, 60000);
+  });
+});
diff --git a/frontend/viewer/src/home/HomeView.svelte b/frontend/viewer/src/home/HomeView.svelte
index 54ce53c754..c817938b0d 100644
--- a/frontend/viewer/src/home/HomeView.svelte
+++ b/frontend/viewer/src/home/HomeView.svelte
@@ -189,7 +189,7 @@
       <p>{$t`loading...`}</p>
     {:then projects}
       <div class="space-y-4 md:space-y-8">
-        <div>
+        <div id="local-projects">
           <div class="flex flex-row items-end">
             <p class="sub-title">{$t`Local`}</p>
             <div class="flex-grow"></div>
diff --git a/frontend/viewer/src/home/Server.svelte b/frontend/viewer/src/home/Server.svelte
index 0022a49b05..893da9ce2c 100644
--- a/frontend/viewer/src/home/Server.svelte
+++ b/frontend/viewer/src/home/Server.svelte
@@ -114,7 +114,7 @@
   onDownloadProject={downloadCrdtProjectByCode}
   validateCode={validateCodeForDownload}
   />
-<div>
+<div id={server?.id}>
   <div class="flex flex-row mb-2 items-end mr-2 md:mr-0">
     <div class="sub-title !my-0">
       {#if server}
diff --git a/frontend/viewer/tests/e2e/config.ts b/frontend/viewer/tests/e2e/config.ts
new file mode 100644
index 0000000000..136d04654f
--- /dev/null
+++ b/frontend/viewer/tests/e2e/config.ts
@@ -0,0 +1,108 @@
+/**
+ * E2E Test Configuration and Constants
+ */
+
+import type { E2ETestConfig, TestProject } from './types';
+
+/**
+ * Default test configuration
+ */
+export const DEFAULT_E2E_CONFIG: E2ETestConfig = {
+  lexboxServer: {
+    hostname: process.env.TEST_SERVER_HOSTNAME || 'localhost',
+    protocol: 'https',
+    port: process.env.TEST_SERVER_PORT ? parseInt(process.env.TEST_SERVER_PORT) : 6579,
+  },
+  fwLite: {
+    binaryPath: process.env.FW_LITE_BINARY_PATH || './dist/fw-lite-server/FwLiteWeb.exe',
+    launchTimeout: 30000, // 30 seconds
+    shutdownTimeout: 10000, // 10 seconds
+  },
+  testData: {
+    projectCode: process.env.TEST_PROJECT_CODE || 'sena-3',
+    testUser: process.env.TEST_USER || 'manager',
+    testPassword: process.env.TEST_DEFAULT_PASSWORD || 'pass',
+  },
+  timeouts: {
+    projectDownload: 60000, // 60 seconds
+    entryCreation: 30000, // 30 seconds
+    dataSync: 45000, // 45 seconds
+  },
+};
+
+/**
+ * Test project configurations
+ */
+export const TEST_PROJECTS: Record<string, TestProject> = {
+  'sena-3': {
+    code: 'sena-3',
+    name: 'Sena 3',
+    expectedEntries: 0, // Will be updated based on actual project state
+    testUser: 'admin',
+  },
+};
+
+/**
+ * Test data constants
+ */
+export const TEST_CONSTANTS = {
+  // Unique identifier prefix for test entries to avoid conflicts
+  TEST_ENTRY_PREFIX: 'e2e-test',
+
+  // Default test entry data
+  DEFAULT_TEST_ENTRY: {
+    lexeme: 'test-word',
+    definition: 'A word created during E2E testing',
+    partOfSpeech: 'noun',
+  },
+
+  // Retry configuration for flaky operations
+  RETRY_CONFIG: {
+    projectDownload: { attempts: 3, delay: 5000 },
+    entryCreation: { attempts: 2, delay: 2000 },
+    dataSync: { attempts: 3, delay: 3000 },
+  },
+
+  // UI selectors (to be updated based on actual FW Lite UI)
+  SELECTORS: {
+    projectList: '[data-testid="project-list"]',
+    downloadButton: '[data-testid="download-project"]',
+    newEntryButton: '[data-testid="new-entry"]',
+    entryForm: '[data-testid="entry-form"]',
+    saveButton: '[data-testid="save-entry"]',
+    searchInput: '[data-testid="search-entries"]',
+    deleteProjectButton: '[data-testid="delete-project"]',
+  },
+} as const;
+
+/**
+ * Generate unique test identifier
+ */
+export function generateTestId(): string {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${TEST_CONSTANTS.TEST_ENTRY_PREFIX}-${timestamp}-${random}`;
+}
+
+/**
+ * Get test configuration with environment variable overrides
+ */
+export function getTestConfig(): E2ETestConfig {
+  return {
+    ...DEFAULT_E2E_CONFIG,
+    lexboxServer: {
+      ...DEFAULT_E2E_CONFIG.lexboxServer,
+      hostname: process.env.TEST_SERVER_HOSTNAME || DEFAULT_E2E_CONFIG.lexboxServer.hostname,
+    },
+    fwLite: {
+      ...DEFAULT_E2E_CONFIG.fwLite,
+      binaryPath: process.env.FW_LITE_BINARY_PATH || DEFAULT_E2E_CONFIG.fwLite.binaryPath,
+    },
+    testData: {
+      ...DEFAULT_E2E_CONFIG.testData,
+      projectCode: process.env.TEST_PROJECT_CODE || DEFAULT_E2E_CONFIG.testData.projectCode,
+      testUser: process.env.TEST_USER || DEFAULT_E2E_CONFIG.testData.testUser,
+      testPassword: process.env.TEST_DEFAULT_PASSWORD || DEFAULT_E2E_CONFIG.testData.testPassword,
+    },
+  };
+}
diff --git a/frontend/viewer/tests/e2e/fixtures/test-projects.json b/frontend/viewer/tests/e2e/fixtures/test-projects.json
new file mode 100644
index 0000000000..07f261e103
--- /dev/null
+++ b/frontend/viewer/tests/e2e/fixtures/test-projects.json
@@ -0,0 +1,39 @@
+{
+  "projects": {
+    "sena-3": {
+      "code": "sena-3",
+      "name": "Sena 3",
+      "description": "Test project for E2E testing",
+      "expectedEntries": 0,
+      "testUser": "admin",
+      "permissions": ["read", "write", "delete"],
+      "mediaFiles": [],
+      "expectedStructure": {
+        "hasLexicon": true,
+        "hasGrammar": false,
+        "hasTexts": false
+      }
+    }
+  },
+  "testUsers": {
+    "admin": {
+      "username": "admin",
+      "role": "admin",
+      "permissions": ["read", "write", "delete", "admin"],
+      "projects": ["sena-3"]
+    }
+  },
+  "testEntries": {
+    "sample": {
+      "lexeme": "sample-word",
+      "definition": "A sample word for testing",
+      "partOfSpeech": "noun",
+      "examples": [
+        {
+          "sentence": "This is a sample sentence.",
+          "translation": "This is a sample translation."
+        }
+      ]
+    }
+  }
+}
diff --git a/frontend/viewer/tests/e2e/fw-lite-integration.test.ts b/frontend/viewer/tests/e2e/fw-lite-integration.test.ts
new file mode 100644
index 0000000000..15f3aec39f
--- /dev/null
+++ b/frontend/viewer/tests/e2e/fw-lite-integration.test.ts
@@ -0,0 +1,147 @@
+/**
+ * FW Lite Integration E2E Tests
+ *
+ * This test suite implements the core integration scenarios for FW Lite and LexBox.
+ * It tests the complete workflow: download project, create entry, delete local copy,
+ * re-download, and verify entry persistence.
+ */
+
+import {expect, test} from '@playwright/test';
+import {FwLiteLauncher} from './helpers/fw-lite-launcher';
+import {
+  deleteProject,
+  logoutFromServer,
+} from './helpers/project-operations';
+import {
+  cleanupTestData,
+  generateTestEntry,
+  generateUniqueIdentifier,
+  getTestProject,
+  validateTestDataConfiguration
+} from './helpers/test-data';
+import {getTestConfig} from './config';
+import type {TestEntry, TestProject} from './types';
+import {HomePage} from './helpers/home-page';
+import { ProjectPage } from './helpers/project-page';
+
+// Test configuration
+const config = getTestConfig();
+let fwLiteLauncher: FwLiteLauncher;
+let testProject: TestProject;
+let testEntry: TestEntry;
+let testId: string;
+
+/**
+ * Test suite setup and teardown
+ */
+test.describe('FW Lite Integration Tests', () => {
+  test.beforeAll(async () => {
+    console.log('Setting up FW Lite Integration Test Suite');
+
+    // Validate test configuration
+    validateTestDataConfiguration(config.testData.projectCode);
+
+    // Get test project configuration
+    testProject = getTestProject(config.testData.projectCode);
+
+    // Generate unique test identifier
+    testId = generateUniqueIdentifier('integration');
+
+    // Generate test entry data
+    testEntry = generateTestEntry(testId, 'basic');
+
+    console.log('Test configuration:', {
+      project: testProject.code,
+      testId,
+      entry: testEntry.lexeme
+    });
+  });
+
+  test.beforeEach(async ({ page }, testInfo) => {
+    console.log('Setting up individual test');
+
+    // Initialize FW Lite launcher
+    fwLiteLauncher = new FwLiteLauncher();
+
+    // Launch FW Lite application
+    await fwLiteLauncher.launch({
+      binaryPath: config.fwLite.binaryPath,
+      serverUrl: `${config.lexboxServer.protocol}://${config.lexboxServer.hostname}`,
+      timeout: config.fwLite.launchTimeout,
+      logFile: testInfo.outputPath('fw-lite-server.log'),
+    });
+
+    console.log(`FW Lite launched at: ${fwLiteLauncher.getBaseUrl()}`);
+
+    await page.goto(fwLiteLauncher.getBaseUrl());
+    await page.waitForLoadState('networkidle');
+
+    console.log('FW Lite application is ready for testing');
+  });
+
+  test.afterEach(async ({ page }) => {
+    console.log('Cleaning up individual test');
+
+    try {
+
+      // Logout from server
+      await logoutFromServer(page, config.lexboxServer);
+    } catch (error) {
+      console.warn('Cleanup warning:', error);
+    }
+
+    await deleteProject(page, 'sena-3');
+
+    // Shutdown FW Lite application
+    if (fwLiteLauncher) {
+      await fwLiteLauncher.shutdown();
+      console.log('FW Lite application shut down');
+    }
+  });
+
+  test.afterAll(async () => {
+    console.log('Cleaning up test suite');
+
+    // Clean up test data
+    try {
+      cleanupTestData(testProject.code, [testId]);
+      console.log('Test data cleanup completed');
+    } catch (error) {
+      console.warn('Test data cleanup warning:', error);
+    }
+  });
+  /**
+   * Smoke test: Basic application launch and connectivity
+   */
+  test('Smoke test: Application launch and server connectivity', async ({ page }) => {
+    const homePage = new HomePage(page);
+    await test.step('Verify application is accessible', async () => {
+      await homePage.waitFor();
+    });
+
+    await test.step('Verify server connectivity', async () => {
+      // Attempt login to verify server connection
+      await homePage.ensureLoggedIn(config.lexboxServer, config.testData.testUser, config.testData.testPassword);
+
+      expect(await homePage.serverProjects(config.lexboxServer).count()).toBeGreaterThan(0);
+    });
+  });
+
+  /**
+   * Project download test: Isolated project download verification
+   */
+  test('Project download: Download and verify project structure', async ({ page }) => {
+    test.setTimeout(1 * 60 * 1000);
+    const homePage = new HomePage(page);
+
+    await homePage.waitFor();
+    await homePage.ensureLoggedIn(config.lexboxServer, config.testData.testUser, config.testData.testPassword);
+
+    await homePage.downloadProject(config.lexboxServer, 'sena-3');
+
+    await homePage.openLocalProject('sena-3');
+
+    const projectPage = new ProjectPage(page, 'sena-3');
+    await projectPage.waitFor();
+  });
+});
diff --git a/frontend/viewer/tests/e2e/global-setup.ts b/frontend/viewer/tests/e2e/global-setup.ts
new file mode 100644
index 0000000000..090aae4f97
--- /dev/null
+++ b/frontend/viewer/tests/e2e/global-setup.ts
@@ -0,0 +1,59 @@
+/**
+ * Global Setup for FW Lite E2E Tests
+ *
+ * This file handles global test setup operations that need to run once
+ * before all tests in the suite.
+ */
+
+import { getTestConfig } from './config';
+import { validateTestDataConfiguration } from './helpers/test-data';
+
+async function globalSetup() {
+  console.log('🚀 Starting FW Lite E2E Test Suite Global Setup');
+
+  const config = getTestConfig();
+
+  try {
+    // Validate test configuration
+    console.log('📋 Validating test configuration...');
+    console.log('Test Config:', {
+      server: config.lexboxServer.hostname,
+      project: config.testData.projectCode,
+      user: config.testData.testUser,
+      binaryPath: config.fwLite.binaryPath
+    });
+
+    // Validate test data configuration
+    console.log('🔍 Validating test data configuration...');
+    validateTestDataConfiguration(config.testData.projectCode);
+
+    // Check if FW Lite binary exists
+    console.log('🔧 Checking FW Lite binary availability...');
+    const fs = await import('node:fs/promises');
+    try {
+      await fs.access(config.fwLite.binaryPath);
+      console.log('✅ FW Lite binary found at:', config.fwLite.binaryPath);
+    } catch (error) {
+      console.warn('⚠️  FW Lite binary not found at:', config.fwLite.binaryPath);
+      console.warn('   Tests will fail if binary is not available during execution');
+      console.warn('   Error:', error);
+      throw error;
+    }
+
+    // Log test environment information
+    console.log('🌍 Test Environment Information:');
+    console.log('   - Lexbox Server:', `${config.lexboxServer.protocol}://${config.lexboxServer.hostname}`);
+    console.log('   - Project:', config.testData.projectCode);
+    console.log('   - Test User:', config.testData.testUser);
+    console.log('   - Binary Path:', config.fwLite.binaryPath);
+    console.log('   - CI Mode:', !!process.env.CI);
+
+    console.log('✅ Global setup completed successfully');
+
+  } catch (error) {
+    console.error('❌ Global setup failed:', error);
+    throw error;
+  }
+}
+
+export default globalSetup;
diff --git a/frontend/viewer/tests/e2e/global-teardown.ts b/frontend/viewer/tests/e2e/global-teardown.ts
new file mode 100644
index 0000000000..b05381291e
--- /dev/null
+++ b/frontend/viewer/tests/e2e/global-teardown.ts
@@ -0,0 +1,44 @@
+/**
+ * Global Teardown for FW Lite E2E Tests
+ *
+ * This file handles global test teardown operations that need to run once
+ * after all tests in the suite have completed.
+ */
+
+import { getTestConfig } from './config';
+import { cleanupAllTestData, getActiveTestIds } from './helpers/test-data';
+
+async function globalTeardown() {
+  console.log('🧹 Starting FW Lite E2E Test Suite Global Teardown');
+
+  const config = getTestConfig();
+
+  try {
+    // Clean up any remaining test data
+    console.log('🗑️  Cleaning up test data...');
+    const activeIds = getActiveTestIds();
+
+    if (activeIds.length > 0) {
+      console.log(`   Found ${activeIds.length} active test entries to clean up`);
+      await cleanupAllTestData(config.testData.projectCode);
+      console.log('✅ Test data cleanup completed');
+    } else {
+      console.log('   No active test data found to clean up');
+    }
+
+    // Log test completion summary
+    console.log('📊 Test Suite Summary:');
+    console.log('   - Project:', config.testData.projectCode);
+    console.log('   - Cleaned up entries:', activeIds.length);
+    console.log('   - CI Mode:', !!process.env.CI);
+
+    console.log('✅ Global teardown completed successfully');
+
+  } catch (error) {
+    console.error('❌ Global teardown failed:', error);
+    // Don't throw error in teardown to avoid masking test failures
+    console.warn('   Continuing despite teardown errors...');
+  }
+}
+
+export default globalTeardown;
diff --git a/frontend/viewer/tests/e2e/helpers/fw-lite-launcher.ts b/frontend/viewer/tests/e2e/helpers/fw-lite-launcher.ts
new file mode 100644
index 0000000000..d4fd05530b
--- /dev/null
+++ b/frontend/viewer/tests/e2e/helpers/fw-lite-launcher.ts
@@ -0,0 +1,254 @@
+/**
+ * FW Lite Application Launcher
+ *
+ * Manages the FW Lite application lifecycle during tests.
+ * Handles launching, health checking, and shutting down the FW Lite application.
+ */
+
+import { spawn, type ChildProcess } from 'node:child_process';
+import { access, constants } from 'node:fs/promises';
+import { platform } from 'node:os';
+import type { FwLiteManager, LaunchConfig } from '../types';
+
+export class FwLiteLauncher implements FwLiteManager {
+  private process: ChildProcess | null = null;
+  private baseUrl = '';
+  private port = 0;
+  private isHealthy = false;
+
+  /**
+   * Launch the FW Lite application
+   */
+  async launch(config: LaunchConfig): Promise<void> {
+    if (this.process) {
+      throw new Error('FW Lite is already running. Call shutdown() first.');
+    }
+
+    // Validate binary exists and is executable
+    await this.validateBinary(config.binaryPath);
+
+    // Find available port
+    this.port = config.port || await this.findAvailablePort(5000);
+    this.baseUrl = `http://localhost:${this.port}`;
+
+    // Launch the application
+    await this.launchProcess(config);
+
+    // Wait for application to be ready
+    await this.waitForHealthy(config.timeout || 30000);
+  }
+
+  /**
+   * Shutdown the FW Lite application
+   */
+  async shutdown(): Promise<void> {
+    if (!this.process) {
+      return;
+    }
+
+    this.isHealthy = false;
+
+    // Try graceful shutdown first
+    if (platform() === 'win32') {
+      //windows sucks https://stackoverflow.com/a/41976985/1620542
+      this.process.stdin?.write('shutdown\n');
+      this.process.stdin?.end();
+    } else {
+      this.process.kill('SIGTERM');
+    }
+
+    // Wait for graceful shutdown
+    const shutdownPromise = new Promise<void>((resolve) => {
+      if (!this.process) {
+        resolve();
+        return;
+      }
+
+      this.process.on('exit', () => {
+        resolve();
+      });
+    });
+
+    // Force kill after timeout
+    const timeoutPromise = new Promise<void>((resolve) => {
+      setTimeout(() => {
+        if (this.process && !this.process.killed) {
+          this.process.kill('SIGKILL');
+        }
+        resolve();
+      }, 10000); // 10 second timeout
+    });
+
+    await Promise.race([shutdownPromise, timeoutPromise]);
+
+    this.process = null;
+    this.baseUrl = '';
+    this.port = 0;
+  }
+
+  /**
+   * Check if the application is running
+   */
+  isRunning(): boolean {
+    return this.process !== null && !this.process.killed && this.isHealthy;
+  }
+
+  /**
+   * Get the base URL of the running application
+   */
+  getBaseUrl(): string {
+    if (!this.isRunning()) {
+      throw new Error('FW Lite is not running');
+    }
+    return this.baseUrl;
+  }
+
+  /**
+   * Validate that the binary exists and is executable
+   */
+  private async validateBinary(binaryPath: string): Promise<void> {
+    try {
+      await access(binaryPath, constants.F_OK | constants.X_OK);
+    } catch (error) {
+      throw new Error(`FW Lite binary not found or not executable: ${binaryPath}. Error: ${error}`);
+    }
+  }
+
+  /**
+   * Find an available port starting from the given port
+   */
+  private async findAvailablePort(startPort: number): Promise<number> {
+    const net = await import('node:net');
+
+    return new Promise((resolve, reject) => {
+      const server = net.createServer();
+
+      server.listen(startPort, () => {
+        const port = (server.address() as any)?.port;
+        server.close(() => {
+          resolve(port);
+        });
+      });
+
+      server.on('error', (err: any) => {
+        if (err.code === 'EADDRINUSE') {
+          // Port is in use, try next one
+          this.findAvailablePort(startPort + 1).then(resolve).catch(reject);
+        } else {
+          reject(err);
+        }
+      });
+    });
+  }
+
+  /**
+   * Launch the FW Lite process
+   */
+  private async launchProcess(config: LaunchConfig): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const args = [
+        '--urls', this.baseUrl,
+        '--Auth:LexboxServers:0:Authority', config.serverUrl,
+        '--Auth:LexboxServers:0:DisplayName', 'e2e test server',
+        '--FwLiteWeb:OpenBrowser', 'false',
+        '--environment', 'Development',//required to allow oauth to accept self signed certs
+        '--FwLite:UseDevAssets', 'false',//in dev env we'd use dev assets normally
+      ];
+      if (config.logFile) {
+        args.push('--FwLiteWeb:LogFileName', config.logFile);
+      }
+
+      this.process = spawn(config.binaryPath, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        detached: false,
+      });
+
+      // Handle process events
+      this.process.on('error', (error) => {
+        reject(new Error(`Failed to start FW Lite: ${error.message}`));
+      });
+
+      this.process.on('exit', (code, signal) => {
+        if (code !== 0 && code !== null) {
+          reject(new Error(`FW Lite exited with code ${code}`));
+        } else if (signal) {
+          reject(new Error(`FW Lite was killed with signal ${signal}`));
+        }
+      });
+
+      // Capture stdout/stderr for debugging
+      if (this.process.stdout) {
+        this.process.stdout.on('data', (data) => {
+          const output = data.toString();
+          // Look for startup indicators
+          if (output.includes('Now listening on:') || output.includes('Application started')) {
+            resolve();
+          }
+        });
+      }
+
+      if (this.process.stderr) {
+        this.process.stderr.on('data', (data) => {
+          console.error('FW Lite stderr:', data.toString());
+        });
+      }
+
+      // Fallback timeout for process startup
+      setTimeout(() => {
+        resolve();
+      }, 5000);
+    });
+  }
+
+  /**
+   * Wait for the application to be healthy and responsive
+   */
+  private async waitForHealthy(timeout: number): Promise<void> {
+    const startTime = Date.now();
+    const checkInterval = 1000; // Check every second
+
+    while (Date.now() - startTime < timeout) {
+      try {
+        const isHealthy = await this.performHealthCheck();
+        if (isHealthy) {
+          this.isHealthy = true;
+          return;
+        }
+      } catch (error) {
+        // Health check failed, continue waiting
+      }
+
+      await new Promise(resolve => setTimeout(resolve, checkInterval));
+    }
+
+    throw new Error(`FW Lite failed to become healthy within ${timeout}ms`);
+  }
+
+  /**
+   * Perform a health check on the running application
+   */
+  private async performHealthCheck(): Promise<boolean> {
+    try {
+      // Try to fetch a basic endpoint to verify the app is responding
+      const response = await fetch(`${this.baseUrl}/health`, {
+        method: 'GET',
+        signal: AbortSignal.timeout(5000), // 5 second timeout
+      });
+
+      return response.ok;
+    } catch (error) {
+      // If /health doesn't exist, try the root endpoint
+      try {
+        const response = await fetch(this.baseUrl, {
+          method: 'GET',
+          signal: AbortSignal.timeout(5000),
+        });
+
+        // Accept any response that isn't a connection error
+        return response.status < 500;
+      } catch (rootError) {
+        return false;
+      }
+    }
+  }
+}
diff --git a/frontend/viewer/tests/e2e/helpers/home-page.ts b/frontend/viewer/tests/e2e/helpers/home-page.ts
new file mode 100644
index 0000000000..c36f996af4
--- /dev/null
+++ b/frontend/viewer/tests/e2e/helpers/home-page.ts
@@ -0,0 +1,103 @@
+import {expect, type Page} from '@playwright/test';
+import type {E2ETestConfig} from '../types';
+import {LoginPage} from '../../../../tests/pages/loginPage';
+
+type Server = E2ETestConfig['lexboxServer'];
+
+export class HomePage {
+
+
+  constructor(private page: Page) {
+  }
+
+  public async waitFor() {
+    await this.page.waitForLoadState('load');
+    await expect(this.page.getByRole('heading', {name: 'Dictionaries'})).toBeVisible();
+  }
+
+  public serverSection(server: Server) {
+    return this.page.locator(`#${server.hostname}`);
+  }
+
+  public userIndicator(server: Server) {
+    return this.serverSection(server).locator(`.i-mdi-account-circle`);
+  }
+
+  public loginButton(server: Server) {
+    return this.serverSection(server).locator(`a:has-text("Login")`);
+  }
+
+  public serverProjects(server: Server) {
+    return this.serverSection(server).getByRole('row');
+  }
+
+  public localProjects() {
+    return this.page.locator('#local-projects');
+  }
+
+  public async ensureLoggedIn(server: Server, username: string, password: string) {
+    await this.serverSection(server).waitFor({state: 'visible'});
+    const isLoggedIn = await this.userIndicator(server).isVisible();
+
+    if (isLoggedIn) {
+      console.log('User already logged in, skipping login process');
+      return;
+    }    // Look for login button or link
+    const loginButton = this.loginButton(server);
+
+    await loginButton.waitFor({state: 'visible'});
+    await loginButton.click();
+
+    await expect(this.page).toHaveURL(url => url.href.startsWith(`${server.protocol}://${server.hostname}/login`));
+
+    const loginPage = new LoginPage(this.page);
+    await loginPage.waitFor();
+    await loginPage.fillForm(username, password);
+    await loginPage.submit();
+
+    await this.userIndicator(server).waitFor({state: 'visible'});
+  }
+
+  public async ensureLoggedOut(server: Server) {
+    await this.serverSection(server).waitFor({state: 'visible'});
+    const isLoggedIn = await this.userIndicator(server).isVisible();
+
+    if (!isLoggedIn) {
+      console.log('User already logged out, skipping logout process');
+      return;
+    }
+
+    await this.userIndicator(server).click();
+
+    const logoutButton = this.page.getByRole('menuitem', {name: 'Logout'});
+    await logoutButton.click();
+
+    await this.loginButton(server).waitFor({state: 'visible'});
+  }
+
+  async downloadProject(server: Server, projectCode: string) {
+    await this.serverProjects(server)
+      .locator(`:has-text("${projectCode}")`)
+      .first()
+      .click();
+    await this.page.locator('.i-mdi-loading').waitFor({
+      state: 'visible'
+    });
+
+
+    const progressIndicator = this.page.locator('.i-mdi-loading');
+    await expect(progressIndicator).toBeVisible();
+    await progressIndicator.waitFor({
+      state: 'detached',
+      timeout: 60_000
+    });
+
+    // Look for synced
+    const projectElement = this.localProjects().getByText(`${projectCode}`);
+    await expect(projectElement).toBeVisible();
+  }
+
+  async openLocalProject(projectCode: string) {
+    await this.localProjects().getByText(`${projectCode}`).click();
+  }
+}
diff --git a/frontend/viewer/tests/e2e/helpers/project-operations.ts b/frontend/viewer/tests/e2e/helpers/project-operations.ts
new file mode 100644
index 0000000000..43b5cb4ee9
--- /dev/null
+++ b/frontend/viewer/tests/e2e/helpers/project-operations.ts
@@ -0,0 +1,52 @@
+/**
+ * Project Operations Helper
+ *
+ * This module provides functions for project download automation and management.
+ * It handles UI interactions for downloading projects, creating entries, and verifying data.
+ */
+
+import {type Page} from '@playwright/test';
+import type {E2ETestConfig} from '../types';
+import {HomePage} from './home-page';
+
+
+/**
+ * Login to the LexBox server
+ * Handles authentication before accessing server resources
+ *
+ * @param page - Playwright page object
+ * @param username - Username for authentication
+ * @param password - Password for authentication
+ * @throws Error if login fails
+ */
+export async function loginToServer(page: Page, username: string, password: string, server: E2ETestConfig['lexboxServer']): Promise<void> {
+  console.log(`Attempting to login as user: ${username}`);
+  const homePage = new HomePage(page);
+  await homePage.ensureLoggedIn(server, username, password);
+}
+
+/**
+ * Logout from the LexBox server
+ * Clears authentication state
+ *
+ * @param page - Playwright page object
+ */
+export async function logoutFromServer(page: Page, server: E2ETestConfig['lexboxServer']): Promise<void> {
+  console.log('Attempting to logout');
+
+  const homePage = new HomePage(page);
+  await homePage.ensureLoggedOut(server);
+}
+
+/**
+ * Delete a local project copy
+ *
+ * @param page - Playwright page object
+ * @param projectCode - Code of the project to delete
+ * @throws Error if deletion fails
+ */
+export async function deleteProject(page: Page, projectCode: string): Promise<void> {
+  const origin = new URL(page.url()).origin;
+  await page.request.delete(`${origin}/api/crdt/${projectCode}`).catch(() => {
+  });
+}
diff --git a/frontend/viewer/tests/e2e/helpers/project-page.ts b/frontend/viewer/tests/e2e/helpers/project-page.ts
new file mode 100644
index 0000000000..13664a9e6e
--- /dev/null
+++ b/frontend/viewer/tests/e2e/helpers/project-page.ts
@@ -0,0 +1,21 @@
+import {expect, type Page} from '@playwright/test';
+
+export class ProjectPage {
+  constructor(private page: Page, private projectCode: string) {
+
+  }
+
+  public async waitFor() {
+    await this.page.waitForLoadState('load');
+    await this.page.locator('.i-mdi-loading').waitFor({state: 'detached'});
+    await expect(this.page.locator('.animate-pulse')).toHaveCount(0);
+    await expect(this.page.getByRole('textbox', {name: 'Filter'})).toBeVisible();
+    await expect(this.page.getByRole('button', {name: 'Headword'})).toBeVisible();
+    const count = await this.entryRows().count();
+    expect(count).toBeGreaterThan(5);
+  }
+
+  public entryRows() {
+    return this.page.getByRole('table').getByRole('row');
+  }
+}
diff --git a/frontend/viewer/tests/e2e/helpers/test-data.ts b/frontend/viewer/tests/e2e/helpers/test-data.ts
new file mode 100644
index 0000000000..7ca6e86ca6
--- /dev/null
+++ b/frontend/viewer/tests/e2e/helpers/test-data.ts
@@ -0,0 +1,246 @@
+/**
+ * Test Data Management
+ *
+ * This module provides test data configurations and utilities for E2E tests.
+ * It manages test projects, entries, and cleanup operations to ensure test isolation.
+ */
+
+import type {TestProject, TestEntry} from '../types';
+import testProjectsData from '../fixtures/test-projects.json' assert {type: 'json'};
+
+// Test session identifier for unique test data
+const TEST_SESSION_ID = `test-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+
+/**
+ * Available test projects with their configurations
+ */
+export const TEST_PROJECTS: Record<string, TestProject> = {
+  'sena-3': {
+    code: 'sena-3',
+    name: 'Sena 3',
+    expectedEntries: 0,
+    testUser: 'admin'
+  }
+};
+
+/**
+ * Test entry templates for different types of entries
+ */
+export const TEST_ENTRY_TEMPLATES = {
+  basic: {
+    lexeme: 'test-word',
+    definition: 'A test word created during E2E testing',
+    partOfSpeech: 'noun'
+  },
+  verb: {
+    lexeme: 'test-action',
+    definition: 'A test action verb created during E2E testing',
+    partOfSpeech: 'verb'
+  },
+  adjective: {
+    lexeme: 'test-quality',
+    definition: 'A test adjective created during E2E testing',
+    partOfSpeech: 'adjective'
+  }
+};
+
+/**
+ * Active test identifiers for cleanup tracking
+ */
+const activeTestIds = new Set<string>();
+
+/**
+ * Get test project configuration by project code
+ * @param projectCode - The project code to retrieve
+ * @returns TestProject configuration
+ * @throws Error if project code is not found
+ */
+export function getTestProject(projectCode: string): TestProject {
+  const project = TEST_PROJECTS[projectCode];
+  if (!project) {
+    throw new Error(`Test project '${projectCode}' not found. Available projects: ${Object.keys(TEST_PROJECTS).join(', ')}`);
+  }
+  return project;
+}
+
+/**
+ * Generate a test entry with unique identifier
+ * @param uniqueId - Unique identifier for the entry
+ * @param template - Template type to use ('basic', 'verb', 'adjective')
+ * @returns TestEntry with unique data
+ */
+export function generateTestEntry(uniqueId: string, template: keyof typeof TEST_ENTRY_TEMPLATES = 'basic'): TestEntry {
+  const baseTemplate = TEST_ENTRY_TEMPLATES[template];
+  if (!baseTemplate) {
+    throw new Error(`Test entry template '${template}' not found. Available templates: ${Object.keys(TEST_ENTRY_TEMPLATES).join(', ')}`);
+  }
+
+  const entry: TestEntry = {
+    lexeme: `${baseTemplate.lexeme}-${uniqueId}`,
+    definition: `${baseTemplate.definition} (ID: ${uniqueId})`,
+    partOfSpeech: baseTemplate.partOfSpeech,
+    uniqueIdentifier: uniqueId
+  };
+
+  // Track this test ID for cleanup
+  activeTestIds.add(uniqueId);
+
+  return entry;
+}
+
+/**
+ * Generate a unique identifier for test data
+ * Uses session ID and timestamp to ensure uniqueness across test runs
+ * @param prefix - Optional prefix for the identifier
+ * @returns Unique identifier string
+ */
+export function generateUniqueIdentifier(prefix = 'e2e'): string {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 8);
+  const uniqueId = `${prefix}-${TEST_SESSION_ID}-${timestamp}-${random}`;
+
+  // Track this ID for cleanup
+  activeTestIds.add(uniqueId);
+
+  return uniqueId;
+}
+
+/**
+ * Generate multiple unique identifiers
+ * @param count - Number of identifiers to generate
+ * @param prefix - Optional prefix for the identifiers
+ * @returns Array of unique identifier strings
+ */
+export function generateUniqueIdentifiers(count: number, prefix = 'e2e'): string[] {
+  return Array.from({length: count}, () => generateUniqueIdentifier(prefix));
+}
+
+/**
+ * Get all test projects from fixtures
+ * @returns Record of all available test projects
+ */
+export function getAllTestProjects(): Record<string, TestProject> {
+  return TEST_PROJECTS;
+}
+
+/**
+ * Get test user configuration for a project
+ * @param projectCode - Project code to get user for
+ * @returns Test user information
+ */
+export function getTestUser(projectCode: string): {username: string; role: string} {
+  const project = getTestProject(projectCode);
+  const userData = testProjectsData.testUsers[project.testUser as keyof typeof testProjectsData.testUsers];
+
+  if (!userData) {
+    throw new Error(`Test user '${project.testUser}' not found for project '${projectCode}'`);
+  }
+
+  return {
+    username: userData.username,
+    role: userData.role
+  };
+}
+
+/**
+ * Get expected project structure for validation
+ * @param projectCode - Project code to get structure for
+ * @returns Expected project structure
+ */
+export function getExpectedProjectStructure(projectCode: string): {
+  hasLexicon: boolean;
+  hasGrammar: boolean;
+  hasTexts: boolean;
+} {
+  const projectData = testProjectsData.projects[projectCode as keyof typeof testProjectsData.projects];
+
+  if (!projectData) {
+    throw new Error(`Project structure data not found for '${projectCode}'`);
+  }
+
+  return projectData.expectedStructure;
+}
+
+/**
+ * Clean up test data created during test execution
+ * This function should be called after each test to remove temporary test entries
+ * @param projectCode - Project code to clean up data from
+ * @param testIds - Array of test identifiers to clean up
+ * @returns Promise that resolves when cleanup is complete
+ */
+export function cleanupTestData(projectCode: string, testIds: string[]): void {
+  console.log(`Cleaning up test data for project '${projectCode}' with IDs:`, testIds);
+
+
+  // In a real implementation, this would make API calls to delete test entries
+  // For now, we'll simulate the cleanup process
+  try {
+    // Simulate API cleanup calls
+    for (const testId of testIds) {
+      console.log(`Cleaning up test entry with ID: ${testId}`);
+      // TODO: Implement actual API calls to delete entries when API is available
+      // await deleteTestEntry(projectCode, testId);
+      activeTestIds.delete(testId);
+    }
+
+    console.log(`Successfully cleaned up ${testIds.length} test entries from project '${projectCode}'`);
+  } catch (error) {
+    console.error(`Failed to clean up test data for project '${projectCode}':`, error);
+    throw new Error(`Test data cleanup failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  }
+}
+
+/**
+ * Clean up all active test data for the current session
+ * Should be called at the end of test suite execution
+ * @param projectCode - Project code to clean up data from
+ * @returns Promise that resolves when cleanup is complete
+ */
+export async function cleanupAllTestData(projectCode: string): Promise<void> {
+  const allActiveIds = Array.from(activeTestIds);
+  if (allActiveIds.length > 0) {
+    console.log(`Cleaning up all active test data (${allActiveIds.length} entries) for session: ${TEST_SESSION_ID}`);
+    await cleanupTestData(projectCode, allActiveIds);
+  } else {
+    console.log('No active test data to clean up');
+  }
+}
+
+/**
+ * Get the current test session ID
+ * @returns Current test session identifier
+ */
+export function getTestSessionId(): string {
+  return TEST_SESSION_ID;
+}
+
+/**
+ * Get all active test IDs for the current session
+ * @returns Array of active test identifiers
+ */
+export function getActiveTestIds(): string[] {
+  return Array.from(activeTestIds);
+}
+
+/**
+ * Validate test data configuration
+ * Ensures all required test data is available before running tests
+ * @param projectCode - Project code to validate
+ * @throws Error if validation fails
+ */
+export function validateTestDataConfiguration(projectCode: string): void {
+  // Check if project exists
+  const project = getTestProject(projectCode);
+
+  // Check if test user exists
+  const user = getTestUser(projectCode);
+
+  // Check if project structure data exists
+  const structure = getExpectedProjectStructure(projectCode);
+
+  console.log(`Test data validation passed for project '${projectCode}':`, {
+    project: project.name,
+    user: user.username,
+    structure: structure
+  });
+}
diff --git a/frontend/viewer/tests/e2e/playwright.config.ts b/frontend/viewer/tests/e2e/playwright.config.ts
new file mode 100644
index 0000000000..faa82a8c13
--- /dev/null
+++ b/frontend/viewer/tests/e2e/playwright.config.ts
@@ -0,0 +1,89 @@
+/**
+ * Playwright Configuration for FW Lite E2E Tests
+ *
+ * This configuration is specifically for E2E integration tests that require
+ * FW Lite application management and extended timeouts.
+ */
+
+import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: '.',
+  testMatch: '**/*.test.ts',
+
+  // E2E tests need more time due to application startup and complex workflows
+  timeout: 300000, // 5 minutes per test
+
+  expect: {
+    timeout: 30000, // 30 seconds for assertions
+  },
+
+  // Sequential execution to avoid resource conflicts
+  fullyParallel: false,
+  workers: 1,
+
+  // Retry failed tests once in CI
+  retries: process.env.CI ? 1 : 0,
+
+  // Fail fast on CI if test.only is left in code
+  forbidOnly: !!process.env.CI,
+
+  // Output configuration
+  outputDir: 'test-results',
+
+  // Reporter configuration
+  reporter: process.env.CI
+    ? [
+        ['github'],
+        ['list'],
+        ['junit', { outputFile: 'test-results/e2e-results.xml' }],
+        ['html', { outputFolder: 'test-results/e2e-html-report', open: 'never' }]
+      ]
+    : [
+        ['list'],
+        ['html', { outputFolder: 'e2e-html-report', open: 'never' }]
+      ],
+
+  use: {
+    // No base URL since we'll be connecting to dynamically launched FW Lite
+    baseURL: undefined,
+
+    // Extended timeouts for E2E operations
+    actionTimeout: 30000, // 30 seconds for actions
+    navigationTimeout: 60000, // 60 seconds for navigation
+
+    // Always capture traces and screenshots for debugging
+    trace: 'on',
+    screenshot: 'on',
+    video: 'retain-on-failure',
+
+    // Browser context settings
+    viewport: { width: 1280, height: 720 },
+    ignoreHTTPSErrors: true, // For self-signed certificates in test environments
+
+    // Storage state for test isolation
+    storageState: {
+      cookies: [],
+      origins: []
+    }
+  },
+
+  // Browser projects
+  projects: [
+    {
+      name: 'chromium',
+      use: {
+        ...devices['Desktop Chrome'],
+        // Use a specific user agent to identify E2E tests
+        userAgent: 'Playwright E2E Tests - Chrome'
+      },
+    },
+
+    // Only run on Chrome for E2E tests to reduce complexity and execution time
+    // Additional browsers can be added later if needed
+  ],
+
+  // Global setup and teardown
+  globalSetup: './global-setup',
+  globalTeardown: './global-teardown',
+});
diff --git a/frontend/viewer/tests/e2e/types.ts b/frontend/viewer/tests/e2e/types.ts
new file mode 100644
index 0000000000..b47832a83c
--- /dev/null
+++ b/frontend/viewer/tests/e2e/types.ts
@@ -0,0 +1,64 @@
+/**
+ * TypeScript type definitions for E2E tests
+ */
+
+export interface E2ETestConfig {
+  lexboxServer: {
+    hostname: string;
+    protocol: 'http' | 'https';
+    port?: number;
+  };
+  fwLite: {
+    binaryPath: string;
+    launchTimeout: number;
+    shutdownTimeout: number;
+  };
+  testData: {
+    projectCode: string;
+    testUser: string;
+    testPassword: string;
+  };
+  timeouts: {
+    projectDownload: number;
+    entryCreation: number;
+    dataSync: number;
+  };
+}
+
+export interface TestProject {
+  code: string;
+  name: string;
+  expectedEntries: number;
+  testUser: string;
+}
+
+export interface TestEntry {
+  lexeme: string;
+  definition: string;
+  partOfSpeech: string;
+  uniqueIdentifier: string;
+}
+
+export interface LaunchConfig {
+  binaryPath: string;
+  serverUrl: string;
+  port?: number;
+  timeout?: number;
+  logFile?: string;
+}
+
+export interface TestResult {
+  testName: string;
+  status: 'passed' | 'failed' | 'skipped';
+  duration: number;
+  error?: string;
+  screenshots: string[];
+  logs: string[];
+}
+
+export interface FwLiteManager {
+  launch(config: LaunchConfig): Promise<void>;
+  shutdown(): Promise<void>;
+  isRunning(): boolean;
+  getBaseUrl(): string;
+}
diff --git a/frontend/viewer/playwright.config.ts b/frontend/viewer/tests/snapshots/playwright.config.ts
similarity index 93%
rename from frontend/viewer/playwright.config.ts
rename to frontend/viewer/tests/snapshots/playwright.config.ts
index 094f0c9d5e..e6db6841ab 100644
--- a/frontend/viewer/playwright.config.ts
+++ b/frontend/viewer/tests/snapshots/playwright.config.ts
@@ -1,5 +1,5 @@
-import { defineConfig, devices, type ReporterDescription } from '@playwright/test';
-import * as testEnv from '../tests/envVars';
+import {defineConfig, devices, type ReporterDescription} from '@playwright/test';
+import * as testEnv from '../../../tests/envVars';
 const vitePort = '5173';
 const dotnetPort = '5137';
 const autoStartServer = process.env.AUTO_START_SERVER ? Boolean(process.env.AUTO_START_SERVER) : false;
@@ -18,7 +18,7 @@ const ciReporters: ReporterDescription[] = [['github'], ['junit', {outputFile: '
   }
 ]];
 export default defineConfig({
-  testDir: './tests',
+  testDir: '.',
   fullyParallel: true,
   /* Fail the build on CI if you accidentally left test.only in the source code. */
   forbidOnly: !!process.env.CI,
@@ -41,6 +41,7 @@ export default defineConfig({
 
   use: {
     baseURL: 'http://localhost:' + serverPort,
+    ignoreHTTPSErrors: true,
     /* Local storage to be populated for every test */
     storageState: {
       cookies: [],
diff --git a/frontend/viewer/tests/project-view-snapshots.test.ts b/frontend/viewer/tests/snapshots/project-view-snapshots.test.ts
similarity index 100%
rename from frontend/viewer/tests/project-view-snapshots.test.ts
rename to frontend/viewer/tests/snapshots/project-view-snapshots.test.ts
diff --git a/frontend/viewer/tests/snapshot.ts b/frontend/viewer/tests/snapshots/snapshot.ts
similarity index 100%
rename from frontend/viewer/tests/snapshot.ts
rename to frontend/viewer/tests/snapshots/snapshot.ts
diff --git a/frontend/viewer/tsconfig.node.json b/frontend/viewer/tsconfig.node.json
index 494bfe0835..ae3723ec14 100644
--- a/frontend/viewer/tsconfig.node.json
+++ b/frontend/viewer/tsconfig.node.json
@@ -3,7 +3,8 @@
     "composite": true,
     "skipLibCheck": true,
     "module": "ESNext",
-    "moduleResolution": "bundler"
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
   },
   "include": ["vite.config.ts"]
 }
diff --git a/frontend/viewer/vitest.config.ts b/frontend/viewer/vitest.config.ts
index 78476abbcd..446fa63649 100644
--- a/frontend/viewer/vitest.config.ts
+++ b/frontend/viewer/vitest.config.ts
@@ -1,4 +1,5 @@
-import {defineConfig} from 'vitest/config';
+import {configDefaults, defineConfig} from 'vitest/config';
+
 import {fileURLToPath} from 'node:url';
 import path from 'node:path';
 import {playwright} from '@vitest/browser-playwright';
@@ -8,9 +9,8 @@ import {svelte} from '@sveltejs/vite-plugin-svelte';
 const dirname =
   typeof __dirname !== 'undefined' ? __dirname : path.dirname(fileURLToPath(import.meta.url));
 
-const browserTestPattern = '**/*.browser.{test,spec}.?(c|m)[jt]s?(x)';
-const e2eTestPattern = './tests/**';
-const defaultExcludeList = ['**/node_modules/**', '**/dist/**', '**/cypress/**', '**/.{idea,git,cache,output,temp}/**', '**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*'];
+const browserTestPattern = './tests/integration/*.{test,spec}.?(c|m)[jt]s?(x)';
+const e2eTestPatterns = ['./tests/**'];
 
 export default defineConfig({
   test: {
@@ -24,32 +24,12 @@ export default defineConfig({
           // $effect.root requires a dom.
           // We can add a node environment test project later if needed.
           environment:'jsdom',
-          exclude: [browserTestPattern, e2eTestPattern, ...defaultExcludeList],
-        },
-        resolve: {
-          alias: [
-            {find: '$lib', replacement: '/src/lib'},
-            {find: '$project', replacement: '/src/project'},
+          exclude: [
+            browserTestPattern,
+            ...e2eTestPatterns,
+            ...configDefaults.exclude
           ]
         },
-      },
-      {
-        plugins: [
-          svelte(),
-        ],
-        test: {
-          name: 'browser',
-          browser: {
-            enabled: true,
-            headless: true,
-            provider: playwright(),
-            instances: [
-              {browser: 'chromium'},
-              {browser: 'firefox'},
-            ],
-          },
-          include: [browserTestPattern],
-        },
         resolve: {
           alias: [
             {find: '$lib', replacement: '/src/lib'},