diff --git a/.vscode/launch.json b/.vscode/launch.json
index cdfed78..40bd929 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -18,6 +18,24 @@
         "${workspaceFolder}/apps/api/dist/**/*.(m|c|)js",
         "!**/node_modules/**"
       ]
+    },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Debug worker with Nx",
+      "runtimeExecutable": "npx",
+      "runtimeArgs": ["nx", "serve", "worker"],
+      "env": {
+        "NODE_OPTIONS": "--inspect=9230"
+      },
+      "console": "integratedTerminal",
+      "internalConsoleOptions": "neverOpen",
+      "skipFiles": ["<node_internals>/**"],
+      "sourceMaps": true,
+      "outFiles": [
+        "${workspaceFolder}/apps/worker/dist/**/*.(m|c|)js",
+        "!**/node_modules/**"
+      ]
     }
   ]
 }
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index a668fe5..0e91783 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -23,6 +23,27 @@
       },
       "problemMatcher": []
     },
+    {
+      "label": "💻 Worker",
+      "type": "shell",
+      "command": "npx",
+      "args": ["nx", "serve", "worker", "--no-tui"],
+      "group": "build",
+      "presentation": {
+        "echo": true,
+        "reveal": "always",
+        "focus": false,
+        "panel": "dedicated",
+        "showReuseMessage": true,
+        "clear": false
+      },
+      "options": {
+        "env": {
+          "NODE_ENV": "development"
+        }
+      },
+      "problemMatcher": []
+    },
     {
       "label": "🛑 Stop Nx Daemon",
       "type": "shell",
diff --git a/apps/api/src/app/app.module.ts b/apps/api/src/app/app.module.ts
index d42bc2c..f528583 100644
--- a/apps/api/src/app/app.module.ts
+++ b/apps/api/src/app/app.module.ts
@@ -4,6 +4,7 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import configuration from '../config/configuration';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
+import { QueueModule } from './queue/queue.module';
 import { StorageModule } from './storage/storage.module';
 import { VideosModule } from './videos/videos.module';
 
@@ -31,6 +32,7 @@ import { VideosModule } from './videos/videos.module';
     }),
     VideosModule,
     StorageModule,
+    QueueModule,
   ],
   controllers: [AppController],
   providers: [AppService],
diff --git a/apps/api/src/app/queue/queue.module.ts b/apps/api/src/app/queue/queue.module.ts
new file mode 100644
index 0000000..bff277e
--- /dev/null
+++ b/apps/api/src/app/queue/queue.module.ts
@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { QueueService } from './queue.service';
+
+@Module({
+  imports: [ConfigModule],
+  providers: [QueueService],
+  exports: [QueueService],
+})
+export class QueueModule {}
+
diff --git a/apps/api/src/app/queue/queue.service.ts b/apps/api/src/app/queue/queue.service.ts
new file mode 100644
index 0000000..5ce8574
--- /dev/null
+++ b/apps/api/src/app/queue/queue.service.ts
@@ -0,0 +1,192 @@
+import { Injectable, Logger, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import * as amqp from 'amqplib';
+
+@Injectable()
+export class QueueService implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(QueueService.name);
+
+  private connection: amqp.ChannelModel | null = null;
+
+  private channel: amqp.Channel | null = null;
+
+  constructor(private readonly configService: ConfigService) {}
+
+  async onModuleInit(): Promise<void> {
+    this.logger.log('Initializing QueueService and establishing RabbitMQ connection...');
+
+    try {
+      await this.initializeConnection();
+      await this.declareQueue();
+      this.logger.log('QueueService initialized successfully. RabbitMQ connection and queue are ready.');
+    } catch (error) {
+      this.logger.error('Failed to initialize QueueService (RabbitMQ connection/queue).', error as Error);
+      throw error;
+    }
+  }
+
+  async onModuleDestroy(): Promise<void> {
+    this.logger.log('Shutting down QueueService and closing RabbitMQ connection...');
+
+    try {
+      await this.closeConnection();
+      this.logger.log('QueueService shut down cleanly. RabbitMQ connection closed.');
+    } catch (error) {
+      this.logger.error('Error while closing RabbitMQ connection in QueueService.', error as Error);
+    }
+  }
+
+  /**
+   * Initialize RabbitMQ connection and channel.
+   * Idempotent: if connection & channel already exist, it returns early.
+   */
+  private async initializeConnection(): Promise<void> {
+    if (this.connection && this.channel) {
+      // Already initialized
+      return;
+    }
+
+    const host = this.configService.get<string>('rabbitmq.host');
+    const port = this.configService.get<number>('rabbitmq.port');
+    const user = this.configService.get<string>('rabbitmq.user');
+    const password = this.configService.get<string>('rabbitmq.password');
+
+    const connectionUrl = `amqp://${user}:${password}@${host}:${port}`;
+
+    try {
+      this.logger.log(`Connecting to RabbitMQ at ${connectionUrl}...`);
+      this.connection = await amqp.connect(connectionUrl);
+      this.channel = await this.connection.createChannel();
+      this.logger.log('RabbitMQ connection and channel established.');
+    } catch (error) {
+      this.logger.error('Failed to establish RabbitMQ connection/channel.', error as Error);
+      // Clean up partial state
+      this.connection = null;
+      this.channel = null;
+      throw error;
+    }
+  }
+
+  /**
+   * Declare the durable transcode queue.
+   * Safe to call multiple times (RabbitMQ assertQueue is idempotent).
+   */
+  private async declareQueue(): Promise<void> {
+    if (!this.channel) {
+      // Ensure we have a channel first
+      await this.initializeConnection();
+    }
+
+    const queueName = this.configService.get<string>('rabbitmq.queueName');
+
+    try {
+      this.logger.log(`Declaring RabbitMQ queue '${queueName}' (durable)...`);
+      await this.channel.assertQueue(queueName, {
+        durable: true,
+      });
+      this.logger.log(`RabbitMQ queue '${queueName}' declared (durable).`);
+    } catch (error) {
+      this.logger.error(`Failed to declare RabbitMQ queue '${queueName}'.`, error as Error);
+      throw error;
+    }
+  }
+
+  /**
+   * Close RabbitMQ channel and connection gracefully.
+   */
+  private async closeConnection(): Promise<void> {
+    try {
+      if (this.channel) {
+        await this.channel.close();
+        this.logger.log('RabbitMQ channel closed.');
+      }
+    } catch (error) {
+      this.logger.error('Error while closing RabbitMQ channel.', error as Error);
+    } finally {
+      this.channel = null;
+    }
+
+    try {
+      if (this.connection) {
+        await this.connection.close();
+        this.logger.log('RabbitMQ connection closed.');
+      }
+    } catch (error) {
+      this.logger.error('Error while closing RabbitMQ connection.', error as Error);
+    } finally {
+      this.connection = null;
+    }
+  }
+
+  /**
+   * Publish a transcode job message to the configured RabbitMQ queue.
+   */
+  async publishTranscodeJob(
+    videoId: string,
+    s3Key: string,
+    resolutions: string[],
+  ): Promise<void> {
+    // Basic input validation
+    if (!videoId || typeof videoId !== 'string') {
+      this.logger.warn('publishTranscodeJob called with invalid videoId.');
+      throw new Error('Invalid videoId for publishTranscodeJob.');
+    }
+
+    if (!s3Key || typeof s3Key !== 'string') {
+      this.logger.warn('publishTranscodeJob called with invalid s3Key.');
+      throw new Error('Invalid s3Key for publishTranscodeJob.');
+    }
+
+    if (!Array.isArray(resolutions)) {
+      this.logger.warn('publishTranscodeJob called with invalid resolutions (must be an array).');
+      throw new Error('Invalid resolutions for publishTranscodeJob. Expected an array of strings.');
+    }
+
+    const queueName = this.configService.get<string>('rabbitmq.queueName');
+
+    const jobPayload = {
+      videoId,
+      s3Key,
+      resolutions,
+    };
+
+    const message = JSON.stringify(jobPayload);
+
+    try {
+      // Ensure connection/channel are ready
+      await this.initializeConnection();
+
+      if (!this.channel) {
+        this.logger.error('RabbitMQ channel is not available in publishTranscodeJob.');
+        throw new Error('RabbitMQ channel is not available.');
+      }
+
+      const sent = this.channel.sendToQueue(
+        queueName,
+        Buffer.from(message),
+        {
+          persistent: true,
+          contentType: 'application/json',
+        },
+      );
+
+      if (!sent) {
+        this.logger.error(
+          `Failed to publish transcode job to queue '${queueName}' (sendToQueue returned false). videoId=${videoId}`,
+        );
+        throw new Error(`Failed to publish transcode job for videoId=${videoId}.`);
+      }
+
+      this.logger.log(
+        `Published transcode job to queue '${queueName}': videoId=${videoId}`,
+      );
+    } catch (error) {
+      this.logger.error(
+        `Error while publishing transcode job to queue '${queueName}' for videoId=${videoId}.`,
+        error as Error,
+      );
+      throw error;
+    }
+  }
+}
+
diff --git a/apps/api/src/app/videos/videos.module.ts b/apps/api/src/app/videos/videos.module.ts
index dedcef5..f87e9c4 100644
--- a/apps/api/src/app/videos/videos.module.ts
+++ b/apps/api/src/app/videos/videos.module.ts
@@ -1,5 +1,6 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
+import { QueueModule } from '../queue/queue.module';
 import { StorageModule } from '../storage/storage.module';
 import { Video } from './entities/video.entity';
 import { VideosService } from './videos.service';
@@ -8,6 +9,7 @@ import { VideosService } from './videos.service';
   imports: [
     TypeOrmModule.forFeature([Video]),
     StorageModule, // Import StorageModule to use StorageService
+    QueueModule, // Import QueueModule to use QueueService
   ],
   providers: [VideosService],
   exports: [VideosService],
diff --git a/apps/api/src/app/videos/videos.service.ts b/apps/api/src/app/videos/videos.service.ts
index ac1306c..48370f5 100644
--- a/apps/api/src/app/videos/videos.service.ts
+++ b/apps/api/src/app/videos/videos.service.ts
@@ -3,6 +3,7 @@ import { InjectRepository } from '@nestjs/typeorm';
 import { Readable } from 'stream';
 import { Repository } from 'typeorm';
 import { v4 as uuidv4 } from 'uuid';
+import { QueueService } from '../queue/queue.service';
 import { StorageService } from '../storage/storage.service';
 import { Video, VideoStatus } from './entities/video.entity';
 
@@ -14,6 +15,7 @@ export class VideosService {
     @InjectRepository(Video)
     private videoRepository: Repository<Video>,
     private storageService: StorageService,
+    private queueService: QueueService,
   ) {}
 
   /**
@@ -55,7 +57,7 @@ export class VideosService {
       await this.storageService.uploadStream(uploadData, s3Key, metadata, fileSize);
       this.logger.log(`File uploaded successfully to MinIO: s3Key=${s3Key}`);
 
-      // Create video record in database
+      // Create video record in database with status UPLOADED
       const video = await this.create(
         originalFilename,
         s3Key,
@@ -63,10 +65,42 @@ export class VideosService {
         VideoStatus.UPLOADED,
       );
 
-      this.logger.log(
-        `Video upload and record creation completed: id=${video.id}, s3Key=${video.s3Key}`,
-      );
-      return video;
+      // After successful upload and DB record creation, publish transcode job
+      try {
+        const defaultResolutions = ['360p', '720p', '1080p'];
+
+        this.logger.log(
+          `Publishing transcode job for video: id=${video.id}, s3Key=${video.s3Key}, resolutions=${defaultResolutions.join(
+            ',',
+          )}`,
+        );
+
+        await this.queueService.publishTranscodeJob(
+          video.id,
+          s3Key,
+          defaultResolutions,
+        );
+
+        // Update status to QUEUED after successful publish
+        const queuedVideo = await this.updateStatus(
+          video.id,
+          VideoStatus.QUEUED,
+        );
+
+        this.logger.log(
+          `Video upload, record creation, and queue publish completed: id=${queuedVideo.id}, status=${queuedVideo.status}`,
+        );        return queuedVideo;
+      } catch (error) {
+        // If queue publishing fails, log error but do not fail the upload
+        this.logger.error(
+          `Failed to publish transcode job for video id=${video.id}, s3Key=${s3Key}. Keeping status as UPLOADED. Error: ${error.message}`,
+          error.stack,
+        );
+
+        this.logger.log(
+          `Video upload and record creation completed (without queue publish): id=${video.id}, s3Key=${video.s3Key}, status=${video.status}`,
+        );        return video;
+      }
     } catch (error) {
       this.logger.error(
         `Failed to upload video file: ${error.message}`,
diff --git a/apps/worker-e2e/eslint.config.mjs b/apps/worker-e2e/eslint.config.mjs
new file mode 100644
index 0000000..b7f6277
--- /dev/null
+++ b/apps/worker-e2e/eslint.config.mjs
@@ -0,0 +1,3 @@
+import baseConfig from '../../eslint.config.mjs';
+
+export default [...baseConfig];
diff --git a/apps/worker-e2e/jest.config.cts b/apps/worker-e2e/jest.config.cts
new file mode 100644
index 0000000..af2a0ed
--- /dev/null
+++ b/apps/worker-e2e/jest.config.cts
@@ -0,0 +1,18 @@
+export default {
+  displayName: 'worker-e2e',
+  preset: '../../jest.preset.js',
+  globalSetup: '<rootDir>/src/support/global-setup.ts',
+  globalTeardown: '<rootDir>/src/support/global-teardown.ts',
+  setupFiles: ['<rootDir>/src/support/test-setup.ts'],
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': [
+      'ts-jest',
+      {
+        tsconfig: '<rootDir>/tsconfig.spec.json',
+      },
+    ],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/worker-e2e',
+};
diff --git a/apps/worker-e2e/project.json b/apps/worker-e2e/project.json
new file mode 100644
index 0000000..a4e9de7
--- /dev/null
+++ b/apps/worker-e2e/project.json
@@ -0,0 +1,17 @@
+{
+  "name": "worker-e2e",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "projectType": "application",
+  "implicitDependencies": ["worker"],
+  "targets": {
+    "e2e": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{e2eProjectRoot}"],
+      "options": {
+        "jestConfig": "apps/worker-e2e/jest.config.cts",
+        "passWithNoTests": true
+      },
+      "dependsOn": ["worker:build", "worker:serve"]
+    }
+  }
+}
diff --git a/apps/worker-e2e/src/support/global-setup.ts b/apps/worker-e2e/src/support/global-setup.ts
new file mode 100644
index 0000000..76a5879
--- /dev/null
+++ b/apps/worker-e2e/src/support/global-setup.ts
@@ -0,0 +1,16 @@
+import { waitForPortOpen } from '@nx/node/utils';
+
+/* eslint-disable */
+var __TEARDOWN_MESSAGE__: string;
+
+module.exports = async function () {
+  // Start services that that the app needs to run (e.g. database, docker-compose, etc.).
+  console.log('\nSetting up...\n');
+
+  const host = process.env.HOST ?? 'localhost';
+  const port = process.env.PORT ? Number(process.env.PORT) : 3000;
+  await waitForPortOpen(port, { host });
+
+  // Hint: Use `globalThis` to pass variables to global teardown.
+  globalThis.__TEARDOWN_MESSAGE__ = '\nTearing down...\n';
+};
diff --git a/apps/worker-e2e/src/support/global-teardown.ts b/apps/worker-e2e/src/support/global-teardown.ts
new file mode 100644
index 0000000..a28dd11
--- /dev/null
+++ b/apps/worker-e2e/src/support/global-teardown.ts
@@ -0,0 +1,10 @@
+import { killPort } from '@nx/node/utils';
+/* eslint-disable */
+
+module.exports = async function () {
+  // Put clean up logic here (e.g. stopping services, docker-compose, etc.).
+  // Hint: `globalThis` is shared between setup and teardown.
+  const port = process.env.PORT ? Number(process.env.PORT) : 3000;
+  await killPort(port);
+  console.log(globalThis.__TEARDOWN_MESSAGE__);
+};
diff --git a/apps/worker-e2e/src/support/test-setup.ts b/apps/worker-e2e/src/support/test-setup.ts
new file mode 100644
index 0000000..c185541
--- /dev/null
+++ b/apps/worker-e2e/src/support/test-setup.ts
@@ -0,0 +1,9 @@
+/* eslint-disable */
+import axios from 'axios';
+
+module.exports = async function () {
+  // Configure axios for tests to use.
+  const host = process.env.HOST ?? 'localhost';
+  const port = process.env.PORT ?? '3000';
+  axios.defaults.baseURL = `http://${host}:${port}`;
+};
diff --git a/apps/worker-e2e/src/worker/worker.spec.ts b/apps/worker-e2e/src/worker/worker.spec.ts
new file mode 100644
index 0000000..e8ac2a6
--- /dev/null
+++ b/apps/worker-e2e/src/worker/worker.spec.ts
@@ -0,0 +1,10 @@
+import axios from 'axios';
+
+describe('GET /api', () => {
+  it('should return a message', async () => {
+    const res = await axios.get(`/api`);
+
+    expect(res.status).toBe(200);
+    expect(res.data).toEqual({ message: 'Hello API' });
+  });
+});
diff --git a/apps/worker-e2e/tsconfig.json b/apps/worker-e2e/tsconfig.json
new file mode 100644
index 0000000..ed633e1
--- /dev/null
+++ b/apps/worker-e2e/tsconfig.json
@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ],
+  "compilerOptions": {
+    "esModuleInterop": true
+  }
+}
diff --git a/apps/worker-e2e/tsconfig.spec.json b/apps/worker-e2e/tsconfig.spec.json
new file mode 100644
index 0000000..d7f9cf2
--- /dev/null
+++ b/apps/worker-e2e/tsconfig.spec.json
@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"]
+  },
+  "include": ["jest.config.ts", "src/**/*.ts"]
+}
diff --git a/apps/worker/eslint.config.mjs b/apps/worker/eslint.config.mjs
new file mode 100644
index 0000000..b7f6277
--- /dev/null
+++ b/apps/worker/eslint.config.mjs
@@ -0,0 +1,3 @@
+import baseConfig from '../../eslint.config.mjs';
+
+export default [...baseConfig];
diff --git a/apps/worker/jest.config.cts b/apps/worker/jest.config.cts
new file mode 100644
index 0000000..4750861
--- /dev/null
+++ b/apps/worker/jest.config.cts
@@ -0,0 +1,10 @@
+module.exports = {
+  displayName: 'worker',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/apps/worker',
+};
diff --git a/apps/worker/project.json b/apps/worker/project.json
new file mode 100644
index 0000000..ed1a8b6
--- /dev/null
+++ b/apps/worker/project.json
@@ -0,0 +1,72 @@
+{
+  "name": "worker",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "apps/worker/src",
+  "projectType": "application",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "webpack-cli build",
+        "args": ["--node-env=production"],
+        "cwd": "apps/worker"
+      },
+      "configurations": {
+        "development": {
+          "args": ["--node-env=development"]
+        }
+      }
+    },
+    "prune-lockfile": {
+      "dependsOn": ["build"],
+      "cache": true,
+      "executor": "@nx/js:prune-lockfile",
+      "outputs": [
+        "{workspaceRoot}/dist/apps/worker/package.json",
+        "{workspaceRoot}/dist/apps/worker/package-lock.json"
+      ],
+      "options": {
+        "buildTarget": "build"
+      }
+    },
+    "copy-workspace-modules": {
+      "dependsOn": ["build"],
+      "cache": true,
+      "outputs": ["{workspaceRoot}/dist/apps/worker/workspace_modules"],
+      "executor": "@nx/js:copy-workspace-modules",
+      "options": {
+        "buildTarget": "build"
+      }
+    },
+    "prune": {
+      "dependsOn": ["prune-lockfile", "copy-workspace-modules"],
+      "executor": "nx:noop"
+    },
+    "serve": {
+      "continuous": true,
+      "executor": "@nx/js:node",
+      "defaultConfiguration": "development",
+      "dependsOn": ["build"],
+      "options": {
+        "buildTarget": "worker:build",
+        "runBuildTargetDependencies": false
+      },
+      "configurations": {
+        "development": {
+          "buildTarget": "worker:build:development",
+          "inspect": "inspect",
+          "port": 9232
+        },
+        "production": {
+          "buildTarget": "worker:build:production"
+        }
+      }
+    },
+    "test": {
+      "options": {
+        "passWithNoTests": true
+      }
+    }
+  }
+}
diff --git a/apps/worker/src/app/app.controller.spec.ts b/apps/worker/src/app/app.controller.spec.ts
new file mode 100644
index 0000000..f27e3af
--- /dev/null
+++ b/apps/worker/src/app/app.controller.spec.ts
@@ -0,0 +1,21 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+describe('AppController', () => {
+  let app: TestingModule;
+
+  beforeAll(async () => {
+    app = await Test.createTestingModule({
+      controllers: [AppController],
+      providers: [AppService],
+    }).compile();
+  });
+
+  describe('getData', () => {
+    it('should return "Hello API"', () => {
+      const appController = app.get<AppController>(AppController);
+      expect(appController.getData()).toEqual({ message: 'Hello API' });
+    });
+  });
+});
diff --git a/apps/worker/src/app/app.controller.ts b/apps/worker/src/app/app.controller.ts
new file mode 100644
index 0000000..aa4a3dd
--- /dev/null
+++ b/apps/worker/src/app/app.controller.ts
@@ -0,0 +1,12 @@
+import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getData() {
+    return this.appService.getData();
+  }
+}
diff --git a/apps/worker/src/app/app.module.ts b/apps/worker/src/app/app.module.ts
new file mode 100644
index 0000000..8662803
--- /dev/null
+++ b/apps/worker/src/app/app.module.ts
@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+@Module({
+  imports: [],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
diff --git a/apps/worker/src/app/app.service.spec.ts b/apps/worker/src/app/app.service.spec.ts
new file mode 100644
index 0000000..99d5d8c
--- /dev/null
+++ b/apps/worker/src/app/app.service.spec.ts
@@ -0,0 +1,20 @@
+import { Test } from '@nestjs/testing';
+import { AppService } from './app.service';
+
+describe('AppService', () => {
+  let service: AppService;
+
+  beforeAll(async () => {
+    const app = await Test.createTestingModule({
+      providers: [AppService],
+    }).compile();
+
+    service = app.get<AppService>(AppService);
+  });
+
+  describe('getData', () => {
+    it('should return "Hello API"', () => {
+      expect(service.getData()).toEqual({ message: 'Hello API' });
+    });
+  });
+});
diff --git a/apps/worker/src/app/app.service.ts b/apps/worker/src/app/app.service.ts
new file mode 100644
index 0000000..cd8cede
--- /dev/null
+++ b/apps/worker/src/app/app.service.ts
@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getData(): { message: string } {
+    return { message: 'Hello API' };
+  }
+}
diff --git a/apps/worker/src/assets/.gitkeep b/apps/worker/src/assets/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/apps/worker/src/main.ts b/apps/worker/src/main.ts
new file mode 100644
index 0000000..db23f4f
--- /dev/null
+++ b/apps/worker/src/main.ts
@@ -0,0 +1,95 @@
+import * as amqp from 'amqplib';
+
+async function bootstrap() {
+  const host = process.env.RABBITMQ_HOST || 'localhost';
+  const port = parseInt(process.env.RABBITMQ_PORT || '5672', 10);
+  const user = process.env.RABBITMQ_USER || 'admin';
+  const password = process.env.RABBITMQ_PASSWORD || 'admin';
+  const queueName = process.env.RABBITMQ_QUEUE_NAME || 'transcode_queue';
+
+  const connectionUrl = `amqp://${user}:${password}@${host}:${port}`;
+
+  // Simple console-based logger for the worker
+  const log = (...args: unknown[]) => console.log('[Worker]', ...args);
+  const errorLog = (...args: unknown[]) => console.error('[Worker]', ...args);
+
+  let connection: amqp.ChannelModel | null = null;
+  let channel: amqp.Channel | null = null;
+
+  try {
+    log(`Connecting to RabbitMQ at ${connectionUrl}...`);
+    connection = await amqp.connect(connectionUrl);
+    channel = await connection.createChannel();
+
+    await channel.assertQueue(queueName, { durable: true });
+    await channel.prefetch(1);
+
+    log(`Connected. Waiting for messages on queue '${queueName}'...`);
+
+    await channel.consume(
+      queueName,
+      (msg) => {
+        if (!msg) {
+          return;
+        }
+
+        try {
+          const payloadText = msg.content.toString();
+          const job = JSON.parse(payloadText) as {
+            videoId?: string;
+            s3Key?: string;
+            resolutions?: string[];
+          };
+
+          log(
+            `Received transcode job: videoId=${job.videoId}, s3Key=${job.s3Key}, resolutions=${JSON.stringify(
+              job.resolutions,
+            )}`,
+          );
+
+          channel.ack(msg);
+        } catch (err) {
+          errorLog('Failed to process job message.', err);
+          // Reject and do not requeue malformed messages
+          channel.nack(msg, false, false);
+        }
+      },
+      { noAck: false },
+    );
+  } catch (err) {
+    errorLog('Worker failed to connect or start consuming from RabbitMQ.', err);
+    process.exit(1);
+  }
+
+  const shutdown = async () => {
+    log('Shutting down worker...');
+    try {
+      if (channel) {
+        await channel.close();
+        log('Channel closed.');
+      }
+    } catch (err) {
+      errorLog('Error closing channel.', err);
+    }
+
+    try {
+      if (connection) {
+        await connection.close();
+        log('Connection closed.');
+      }
+    } catch (err) {
+      errorLog('Error closing connection.', err);
+    }
+
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+bootstrap().catch((err) => {
+  // Last-resort error handler
+  console.error('[Worker] Unhandled error in bootstrap.', err);
+  process.exit(1);
+});
diff --git a/apps/worker/tsconfig.app.json b/apps/worker/tsconfig.app.json
new file mode 100644
index 0000000..759ab58
--- /dev/null
+++ b/apps/worker/tsconfig.app.json
@@ -0,0 +1,19 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["node"],
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "target": "es2021",
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": [
+    "jest.config.ts",
+    "jest.config.cts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.ts"
+  ]
+}
diff --git a/apps/worker/tsconfig.json b/apps/worker/tsconfig.json
new file mode 100644
index 0000000..c1e2dd4
--- /dev/null
+++ b/apps/worker/tsconfig.json
@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.app.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ],
+  "compilerOptions": {
+    "esModuleInterop": true
+  }
+}
diff --git a/apps/worker/tsconfig.spec.json b/apps/worker/tsconfig.spec.json
new file mode 100644
index 0000000..01c59b6
--- /dev/null
+++ b/apps/worker/tsconfig.spec.json
@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "moduleResolution": "node10",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "jest.config.ts",
+    "jest.config.cts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.d.ts"
+  ]
+}
diff --git a/apps/worker/webpack.config.js b/apps/worker/webpack.config.js
new file mode 100644
index 0000000..ba04548
--- /dev/null
+++ b/apps/worker/webpack.config.js
@@ -0,0 +1,25 @@
+const { NxAppWebpackPlugin } = require('@nx/webpack/app-plugin');
+const { join } = require('path');
+
+module.exports = {
+  output: {
+    path: join(__dirname, '../../dist/apps/worker'),
+    clean: true,
+    ...(process.env.NODE_ENV !== 'production' && {
+      devtoolModuleFilenameTemplate: '[absolute-resource-path]',
+    }),
+  },
+  plugins: [
+    new NxAppWebpackPlugin({
+      target: 'node',
+      compiler: 'tsc',
+      main: './src/main.ts',
+      tsConfig: './tsconfig.app.json',
+      assets: ['./src/assets'],
+      optimization: false,
+      outputHashing: 'none',
+      generatePackageJson: true,
+      sourceMaps: true,
+    }),
+  ],
+};
diff --git a/docs/active/.gitkeep b/docs/active/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/docs/PRD/DAY3-4-IMPLEMENTATION-GUIDE.md b/docs/done/DAY3-4-IMPLEMENTATION-GUIDE.md
similarity index 100%
rename from docs/PRD/DAY3-4-IMPLEMENTATION-GUIDE.md
rename to docs/done/DAY3-4-IMPLEMENTATION-GUIDE.md
diff --git a/docs/done/DAY8-9-PRD-RABBITMQ-INTEGRATION-IMPLEMENTATION-REPORT.md b/docs/done/DAY8-9-PRD-RABBITMQ-INTEGRATION-IMPLEMENTATION-REPORT.md
new file mode 100644
index 0000000..33b6c2d
--- /dev/null
+++ b/docs/done/DAY8-9-PRD-RABBITMQ-INTEGRATION-IMPLEMENTATION-REPORT.md
@@ -0,0 +1,71 @@
+# RabbitMQ Integration – Implementation Status (API + Worker)
+
+This report summarizes how the current implementation compares to `PRD-RABBITMQ-INTEGRATION.md`, focusing only on what is implemented vs. missing.
+
+## Implemented
+
+- **Queue module & service (FR1–FR4, FR8 partially)**
+  - `queue.module.ts` exists, exports `QueueService`.
+  - `QueueService` uses `ConfigService` and `amqplib` to:
+    - Establish a single RabbitMQ connection/channel on module init.
+    - Declare a durable `transcode_queue` (idempotent).
+    - Close channel/connection on module destroy.
+  - Logging is in place for connect/declare/close and failure paths.
+
+- **Job publishing (FR3)**
+  - `publishTranscodeJob(videoId, s3Key, resolutions)` implemented with:
+    - Basic parameter validation.
+    - JSON serialization of a `{ videoId, s3Key, resolutions }` payload.
+    - `sendToQueue` with `persistent: true` and `contentType: 'application/json'`.
+    - Error logging and rethrow so callers can decide how to handle failures.
+
+- **Integration with `VideosService` (FR7)**
+  - `VideosService.uploadAndCreate`:
+    - Uploads to MinIO and creates a `Video` with status `UPLOADED`.
+    - Calls `queueService.publishTranscodeJob(video.id, s3Key, ['360p','720p','1080p'])`.
+    - On success, updates status to `QUEUED` and persists it.
+    - On publish failure, logs the error and returns the video with status left as `UPLOADED` (upload does not fail).
+  - `VideoStatus` enum already includes `UPLOADING`, `UPLOADED`, `QUEUED`, `PROCESSING`, `COMPLETED`, `FAILED`.
+
+- **Worker application & consumer (FR5–FR6)**
+  - `apps/worker` Nest app generated and wired via Nx (`project.json` with `build`/`serve`).
+  - `apps/worker/src/main.ts` replaced with a RabbitMQ worker that:
+    - Reads `RABBITMQ_*` env vars with the same defaults as the API.
+    - Connects to RabbitMQ and asserts durable `transcode_queue`.
+    - Sets `prefetch(1)` and `noAck: false`.
+    - Consumes jobs, parses JSON, logs `[Worker]` messages including `videoId`, `s3Key`, `resolutions`, and `ack`s on success.
+    - `nack`s malformed messages without requeue and logs errors.
+    - Handles `SIGINT`/`SIGTERM` with graceful channel/connection close.
+
+## Gaps / Missing vs. PRD
+
+- **Custom error types (FR8 detail)**
+  - The PRD mentions `QueueConnectionError`, `QueuePublishError`, `QueueConsumeError`, `QueueValidationError`.
+  - Current implementation uses generic `Error` with good logging but does not define or throw these specific classes.
+
+- **Retry / resilience behavior**
+  - No explicit retry logic for transient connection or publish failures (not strictly required for Day 8–9 but called out as a consideration).
+  - Connection is established on module init; if RabbitMQ is down at startup, API will fail-fast rather than retry or lazily connect on first publish.
+
+- **Health checks / observability**
+  - No dedicated health check endpoints or methods that expose RabbitMQ connection health beyond logs.
+  - No metrics around queue depth or publish/consume rates (out of scope for this PRD but worth noting).
+
+- **Testing (unit & integration)**
+  - PRD calls for:
+    - Unit tests for `QueueService` (`queue.service.spec.ts`) with mocked `amqplib`.
+    - Integration/manual tests verifying queue declaration, persistence, and end-to-end flow.
+  - At code level, there is currently **no dedicated test file for `QueueService` or worker**; end-to-end behavior is verified manually via `nx serve api` + `nx serve worker` and RabbitMQ UI/logs.
+
+- **Validation depth in worker**
+  - Worker currently assumes the message has the expected shape; it parses JSON and logs whatever fields exist.
+  - PRD mentions validating message structure before processing; current validation is minimal (JSON parse + logging) but does not explicitly check for required fields (`videoId`, `s3Key`, `resolutions`) before acking.
+
+## Summary
+
+For Day 8–9, the **core functional path is implemented and working**:
+API connects to RabbitMQ, declares a durable `transcode_queue`, publishes persistent jobs after upload, worker connects and consumes from the same queue, and logs each job while acknowledging messages.  
+
+What remains are mostly **non-functional and robustness enhancements** (custom error classes, optional retry/health checks, stricter worker payload validation, and tests) that can be scheduled for later days without blocking the basic transcoding queue workflow.
+
+
diff --git a/docs/done/DAY8-9-PRD-RABBITMQ-INTEGRATION.md b/docs/done/DAY8-9-PRD-RABBITMQ-INTEGRATION.md
new file mode 100644
index 0000000..12c6c74
--- /dev/null
+++ b/docs/done/DAY8-9-PRD-RABBITMQ-INTEGRATION.md
@@ -0,0 +1,1224 @@
+# Product Requirements Document: RabbitMQ Integration
+
+## Executive Summary
+
+This document defines the requirements for implementing RabbitMQ message queue integration for the StreamForge video transcoding platform. The queue service will enable asynchronous job processing by publishing transcoding jobs to a durable message queue, while a separate worker application will consume and process these jobs. This integration is a critical component that decouples the API layer from CPU-intensive transcoding operations, enabling scalable and resilient video processing.
+
+At a high level, the implementation will be completed in the following steps:
+
+1. **Create Queue module & service in the API**  
+   Define `queue.module.ts` and `queue.service.ts`, wire `ConfigService`, and set up basic logging.
+2. **Implement RabbitMQ connection & queue declaration**  
+   Manage the RabbitMQ connection/channel lifecycle and declare a durable `transcode_queue` on init.
+3. **Implement `publishTranscodeJob()` in `QueueService`**  
+   Validate inputs, serialize job data to JSON, and publish persistent messages to the queue with proper error handling.
+4. **Integrate `QueueService` into `VideosService`**  
+   After successful upload and DB save, publish a transcode job and update video status to `QUEUED`.
+5. **Generate and scaffold the worker application**  
+   Create an Nx NestJS worker app (`apps/worker`) with its own `main.ts` and configuration for RabbitMQ.
+6. **Implement worker consumer logic**  
+   Connect to RabbitMQ, consume jobs from `transcode_queue`, parse JSON, log job details, and acknowledge messages.
+7. **Test and verify end-to-end**  
+   Use unit tests and manual flows (upload → queue → worker logs) to ensure reliability, error handling, and correct status transitions.
+
+**Timeline**: Day 8-9 (4-6 hours)  
+**Effort Estimate**: 4-6 hours  
+**Priority**: High (Blocking Day 10-11 FFmpeg transcoding implementation)
+
+---
+
+## Background & Context
+
+### Why RabbitMQ Integration is Needed
+
+StreamForge requires asynchronous job processing to handle CPU-intensive video transcoding operations. Processing videos synchronously in the API would cause:
+- Long HTTP request timeouts (transcoding can take minutes)
+- Poor user experience (blocking requests)
+- Inability to scale transcoding independently
+- Resource contention on API servers
+
+RabbitMQ provides a message broker that:
+- Enables asynchronous job processing
+- Supports durable queues (survive restarts)
+- Allows horizontal scaling of workers
+- Provides message persistence and delivery guarantees
+- Offers management UI for monitoring
+
+### Integration with Existing System
+
+The queue service integrates with:
+- **Video Entity** (`apps/api/src/app/videos/entities/video.entity.ts`): The `status` field tracks job state (`UPLOADED` → `QUEUED` → `PROCESSING`)
+- **Videos Service** (`apps/api/src/app/videos/videos.service.ts`): After successful upload, publishes job to queue
+- **Configuration** (`apps/api/src/config/configuration.ts`): RabbitMQ connection settings are already defined
+- **Docker Infrastructure** (`docker-compose.yml`): RabbitMQ container is already configured and running
+- **Future Worker** (Day 10-11): Worker will consume jobs and perform transcoding
+
+### Architecture Context
+
+The queue service follows the StreamForge architecture principle: **Workers Do Heavy Lifting**. The NestJS API only receives uploads and queues jobs. It never does heavy processing. This separation enables:
+- Fast API response times (upload completes quickly)
+- Independent scaling of API and workers
+- Fault tolerance (workers can restart without affecting API)
+- Support for multiple worker instances processing jobs in parallel
+
+---
+
+## Objectives & Goals
+
+### Primary Objectives
+
+1. **Job Publishing**: Enable API to publish transcoding jobs to RabbitMQ queue
+2. **Queue Management**: Create and manage durable `transcode_queue` for job persistence
+3. **Worker Foundation**: Set up separate worker application to consume jobs
+4. **Integration**: Seamlessly integrate queue publishing into video upload workflow
+5. **Message Reliability**: Ensure jobs are persisted and not lost on restarts
+
+### Success Criteria
+
+- ✅ Queue service successfully connects to RabbitMQ on module initialization
+- ✅ `transcode_queue` is declared as durable and persists across restarts
+- ✅ Jobs can be published with video metadata (videoId, s3Key, resolutions)
+- ✅ Worker application can consume jobs from queue
+- ✅ Jobs are logged when received by worker (no processing yet)
+- ✅ Video status updates to `QUEUED` after job publishing
+- ✅ Service integrates seamlessly with existing NestJS application structure
+- ✅ Test: Upload video → Check RabbitMQ UI → See job in queue → Worker logs it
+
+### Key Deliverables
+
+- `apps/api/src/app/queue/queue.module.ts` - NestJS module for queue service
+- `apps/api/src/app/queue/queue.service.ts` - Core queue service with publishing methods
+- `apps/worker/src/main.ts` - Worker application with RabbitMQ consumer
+- Updated `apps/api/src/app/videos/videos.service.ts` - Integration with queue service
+- Working connection to RabbitMQ with queue declaration
+- Test verification: Upload video → Job appears in queue → Worker receives and logs job
+
+---
+
+## Functional Requirements
+
+### FR1: Queue Module Initialization
+
+**Requirement**: The queue module must initialize the RabbitMQ connection when the module is loaded.
+
+**Details**:
+- Connection should be established using configuration from `ConfigService`
+- Connection parameters: host, port, username, password
+- Connection should be validated on initialization
+- Connection errors should be logged and handled gracefully
+- Connection should be established lazily (on first use) or eagerly (on module init)
+
+**Implementation Notes**:
+- Use `amqplib` package for RabbitMQ connection
+- Connection can be established in `onModuleInit()` lifecycle hook
+- Store connection and channel as private class properties
+- Handle connection failures gracefully (log error, allow retry)
+
+### FR2: Queue Connection Management
+
+**Requirement**: The service must manage RabbitMQ connection and channel lifecycle.
+
+**Details**:
+- Establish connection to RabbitMQ broker
+- Create and manage channel for publishing messages
+- Handle connection errors and reconnection logic (basic implementation)
+- Close connection gracefully on module destruction
+- Support connection health checks
+
+**Connection Management**:
+- Connection should be established once and reused
+- Channel should be created per connection
+- Handle connection drops and channel errors
+- Log connection state changes
+
+### FR3: Job Publishing
+
+**Requirement**: `publishTranscodeJob(videoId, s3Key, resolutions)` method must publish jobs to queue.
+
+**Method Signature**:
+```typescript
+publishTranscodeJob(
+  videoId: string,
+  s3Key: string,
+  resolutions: string[]
+): Promise<void>
+```
+
+**Details**:
+- Accept video metadata as parameters
+- Serialize job data to JSON format
+- Publish message to `transcode_queue`
+- Ensure message persistence (persistent delivery mode)
+- Return void on success
+- Handle publishing errors appropriately
+
+**Parameters**:
+- `videoId`: UUID of the video entity
+- `s3Key`: MinIO object key where raw video is stored (e.g., `raw-videos/{videoId}.mp4`)
+- `resolutions`: Array of resolution strings (e.g., `['360p', '720p', '1080p']`)
+
+**Message Format**:
+```json
+{
+  "videoId": "123e4567-e89b-12d3-a456-426614174000",
+  "s3Key": "raw-videos/123e4567-e89b-12d3-a456-426614174000.mp4",
+  "resolutions": ["360p", "720p", "1080p"]
+}
+```
+
+**Returns**: Promise resolving to void
+
+**Errors**: Should throw descriptive errors for:
+- Connection failures
+- Channel errors
+- Publishing failures
+- Invalid parameters
+
+### FR4: Queue Declaration
+
+**Requirement**: The service must declare `transcode_queue` as a durable queue.
+
+**Details**:
+- Declare queue on module initialization or first publish
+- Queue name: `transcode_queue` (configurable via environment variable)
+- Queue should be durable (survives RabbitMQ restarts)
+- Queue should persist messages (survives broker restarts)
+- Queue declaration should be idempotent (safe to call multiple times)
+- Log queue declaration status
+
+**Queue Configuration**:
+- `durable: true` - Queue survives broker restarts
+- `autoDelete: false` - Queue is not deleted when unused
+- No message TTL initially (messages persist until consumed)
+- No priority queue initially (FIFO processing)
+
+### FR5: Worker Application Setup
+
+**Requirement**: A separate NestJS worker application must be created in the monorepo.
+
+**Details**:
+- Generate worker app using Nx: `nx generate @nx/nest:application worker`
+- Worker should be a standalone NestJS application
+- Worker should have its own `main.ts` entry point
+- Worker should connect to RabbitMQ independently
+- Worker should be runnable separately from API: `nx serve worker`
+
+**Application Structure**:
+- `apps/worker/src/main.ts` - Entry point
+- `apps/worker/project.json` - Nx project configuration
+- Worker should bootstrap NestJS application
+- Worker should handle graceful shutdown
+
+### FR6: Worker Consumer Setup
+
+**Requirement**: Worker must consume jobs from `transcode_queue` and log received jobs.
+
+**Details**:
+- Connect to RabbitMQ using same configuration as API
+- Declare and bind to `transcode_queue`
+- Consume messages from queue
+- Parse JSON message payload
+- Log received job details (videoId, s3Key, resolutions)
+- Acknowledge messages after successful receipt
+- Handle message parsing errors gracefully
+- No transcoding processing yet (just logging)
+
+**Consumer Configuration**:
+- `noAck: false` - Manual acknowledgment required
+- `prefetch: 1` - Process one job at a time (for now)
+- Acknowledge message after logging (not after processing)
+- Handle consumer errors and log them
+
+**Logging Format**:
+```
+[Worker] Received transcode job: videoId={videoId}, s3Key={s3Key}, resolutions={resolutions}
+```
+
+### FR7: Integration with Videos Service
+
+**Requirement**: Videos service must publish jobs after successful video upload.
+
+**Details**:
+- Inject QueueService into VideosService
+- After successful MinIO upload and database record creation
+- Call `queueService.publishTranscodeJob(videoId, s3Key, resolutions)`
+- Update video status to `QUEUED` after successful job publishing
+- Handle queue publishing errors (log error, but don't fail upload)
+- Default resolutions: `['360p', '720p', '1080p']` (can be configurable later)
+
+**Integration Flow**:
+1. Video uploaded to MinIO → Status: `UPLOADED`
+2. Database record created
+3. Job published to queue → Status: `QUEUED`
+4. Worker consumes job → Status: `PROCESSING` (future)
+5. Transcoding completes → Status: `COMPLETED` (future)
+
+**Error Handling**:
+- If queue publishing fails, log error but don't fail the upload
+- Video status remains `UPLOADED` if queue publishing fails
+- Consider retry logic for queue publishing (optional for Day 8-9)
+
+### FR8: Error Handling & Logging
+
+**Requirement**: All queue operations must handle errors appropriately and log important events.
+
+**Details**:
+- Catch and log RabbitMQ connection errors
+- Catch and log channel errors
+- Catch and log publishing errors
+- Catch and log consumer errors
+- Provide descriptive error messages
+- Use NestJS Logger for consistent logging
+- Log connection establishment
+- Log queue declaration
+- Log job publishing (with videoId, not full message)
+- Log job consumption (with videoId)
+
+**Error Types**:
+- `QueueConnectionError`: RabbitMQ connection failures
+- `QueuePublishError`: Job publishing failures
+- `QueueConsumeError`: Job consumption failures
+- `QueueValidationError`: Invalid parameters
+
+---
+
+## Technical Specifications
+
+### Technology Stack
+
+- **RabbitMQ Client Library**: `amqplib` package (v0.10.9, already installed)
+- **Node.js**: Native support for async/await
+- **NestJS**: Module and service patterns
+- **TypeScript**: Full type safety
+- **Nx**: Monorepo application generation
+
+### Configuration Requirements
+
+The service will use configuration from `apps/api/src/config/configuration.ts`:
+
+```typescript
+rabbitmq: {
+  host: string,        // e.g., 'localhost'
+  port: number,        // e.g., 5672
+  user: string,        // e.g., 'admin'
+  password: string,    // e.g., 'admin'
+  queueName: string,   // 'transcode_queue'
+}
+```
+
+### Queue Configuration
+
+**Queue Name**: `transcode_queue` (configurable via `RABBITMQ_QUEUE_NAME`)
+
+**Queue Properties**:
+- `durable: true` - Queue survives broker restarts
+- `autoDelete: false` - Queue persists when unused
+- No arguments initially (no TTL, priority, etc.)
+
+**Message Properties**:
+- `persistent: true` - Messages survive broker restarts
+- `contentType: 'application/json'` - JSON message format
+- `deliveryMode: 2` - Persistent delivery mode
+
+### Message Format
+
+**Job Message Structure**:
+```typescript
+interface TranscodeJob {
+  videoId: string;           // UUID of video entity
+  s3Key: string;             // MinIO object key (e.g., 'raw-videos/{videoId}.mp4')
+  resolutions: string[];     // Array of resolution strings (e.g., ['360p', '720p', '1080p'])
+}
+```
+
+**JSON Serialization**:
+- Use `JSON.stringify()` to serialize job object
+- Use `JSON.parse()` to deserialize in worker
+- Validate message structure in worker before processing
+
+### RabbitMQ Connection
+
+**Connection URL Format**:
+```
+amqp://{user}:{password}@{host}:{port}
+```
+
+**Example**:
+```
+amqp://admin:admin@localhost:5672
+```
+
+**Connection Options**:
+- Use `amqplib.connect()` with connection URL
+- Handle connection errors
+- Support connection retry (basic implementation)
+
+**Channel Management**:
+- Create channel from connection: `connection.createChannel()`
+- Handle channel errors
+- Reuse channel for multiple publishes
+- Close channel on module destruction
+
+### amqplib Usage Patterns
+
+**Connection**:
+```typescript
+import * as amqp from 'amqplib';
+
+const connection = await amqp.connect(connectionUrl);
+const channel = await connection.createChannel();
+```
+
+**Queue Declaration**:
+```typescript
+await channel.assertQueue(queueName, { durable: true });
+```
+
+**Publishing**:
+```typescript
+const message = JSON.stringify(jobData);
+channel.sendToQueue(queueName, Buffer.from(message), { persistent: true });
+```
+
+**Consuming**:
+```typescript
+await channel.consume(queueName, (msg) => {
+  if (msg) {
+    const jobData = JSON.parse(msg.content.toString());
+    // Process job
+    channel.ack(msg);
+  }
+}, { noAck: false });
+```
+
+---
+
+## Architecture & Design
+
+### Module Structure
+
+```
+apps/api/src/app/queue/
+├── queue.module.ts      # NestJS module definition
+└── queue.service.ts      # Core queue service implementation
+```
+
+### Module Definition (`queue.module.ts`)
+
+```typescript
+@Module({
+  imports: [ConfigModule],  // Already global, but explicit for clarity
+  providers: [QueueService],
+  exports: [QueueService], // Export for use in other modules
+})
+export class QueueModule {}
+```
+
+### Service Lifecycle
+
+1. **Module Initialization**: QueueModule is imported into AppModule
+2. **Service Construction**: QueueService is instantiated
+3. **OnModuleInit**: Connection to RabbitMQ is established (optional - can be lazy)
+4. **Queue Declaration**: `transcode_queue` is declared as durable
+5. **Ready State**: Service is ready to publish jobs
+6. **OnModuleDestroy**: Connection is closed gracefully
+
+### Integration Points
+
+**With AppModule**:
+- QueueModule will be imported into `apps/api/src/app/app.module.ts`
+- Service will be available for injection in other modules
+
+**With VideosModule**:
+- VideosService will inject QueueService
+- After video upload, `publishTranscodeJob()` will be called
+- Video status will be updated to `QUEUED`
+
+**With Configuration**:
+- Uses ConfigService to access RabbitMQ configuration
+- Configuration is already loaded globally via ConfigModule
+
+**With Worker Application**:
+- Worker connects to same RabbitMQ instance
+- Worker consumes from same `transcode_queue`
+- Worker and API are decoupled (can run independently)
+
+### Dependency Injection
+
+```typescript
+@Injectable()
+export class QueueService implements OnModuleInit, OnModuleDestroy {
+  private connection: amqp.Connection;
+  private channel: amqp.Channel;
+  
+  constructor(
+    private configService: ConfigService,
+    private logger: Logger,
+  ) {}
+  
+  async onModuleInit() {
+    await this.initializeConnection();
+    await this.declareQueue();
+  }
+  
+  async onModuleDestroy() {
+    await this.closeConnection();
+  }
+}
+```
+
+### Worker Application Structure
+
+```
+apps/worker/
+├── src/
+│   └── main.ts           # Worker entry point with consumer
+├── project.json          # Nx project configuration
+└── tsconfig.json         # TypeScript configuration
+```
+
+**Worker main.ts Structure**:
+```typescript
+async function bootstrap() {
+  // Connect to RabbitMQ
+  // Declare queue
+  // Consume messages
+  // Log received jobs
+  // Handle graceful shutdown
+}
+
+bootstrap();
+```
+
+### Error Handling Strategy
+
+**Connection Errors**:
+- Log error with context
+- Throw descriptive exception
+- Application startup may fail if RabbitMQ is unavailable (fail-fast approach)
+- Or: Lazy connection (connect on first publish)
+
+**Publishing Errors**:
+- Catch channel errors
+- Log error with context (videoId, queue name)
+- Throw appropriate exception for caller to handle
+- Consider retry logic (optional)
+
+**Consuming Errors**:
+- Catch message parsing errors
+- Log error and reject message (nack)
+- Catch processing errors
+- Log error and handle appropriately
+
+**Error Types**:
+- `QueueConnectionError`: RabbitMQ connection failures
+- `QueuePublishError`: Job publishing failures
+- `QueueConsumeError`: Job consumption failures
+- `QueueValidationError`: Invalid parameters
+
+---
+
+## Non-Functional Requirements
+
+### Performance
+
+- **Publishing Latency**: Job publishing should complete in < 100ms
+- **Connection Reuse**: Connection should be established once and reused
+- **Message Size**: Messages are small (JSON, < 1KB), no performance concerns
+- **Concurrent Publishing**: Support multiple concurrent job publishes
+
+### Reliability
+
+- **Message Persistence**: Jobs must survive RabbitMQ restarts (durable queue, persistent messages)
+- **Connection Retry**: Consider retry logic for transient connection errors
+- **Error Recovery**: Service should recover from temporary RabbitMQ unavailability
+- **Idempotency**: Queue declaration should be idempotent
+- **Graceful Shutdown**: Close connections gracefully on application shutdown
+
+### Security
+
+- **Credentials Management**: Credentials stored in environment variables, not hardcoded
+- **Access Control**: RabbitMQ user should have appropriate permissions
+- **Input Validation**: Validate job parameters before publishing
+- **Message Validation**: Validate message structure in worker
+
+### Scalability
+
+- **Horizontal Scaling**: Multiple API instances can publish to same queue
+- **Worker Scaling**: Multiple worker instances can consume from same queue (round-robin)
+- **Queue Growth**: Queue can handle thousands of pending jobs
+- **Future Load Balancing**: Design supports future worker load balancing
+
+---
+
+## Dependencies
+
+### External Dependencies
+
+- **amqplib** (v0.10.9): Already installed in `package.json`
+  - Provides RabbitMQ client library
+  - Supports promises and async/await
+  - Handles connection management
+
+- **@types/amqplib** (v0.10.8): Already installed in devDependencies
+  - Provides TypeScript type definitions
+
+### Internal Dependencies
+
+- **@nestjs/config**: Already installed and configured
+  - Provides ConfigService for accessing configuration
+  - ConfigModule is already global in AppModule
+
+- **@nestjs/common**: Already installed
+  - Provides Logger, Injectable, OnModuleInit, OnModuleDestroy decorators
+  - Provides exception classes
+
+- **@nx/nest**: Already installed
+  - Provides Nx generator for creating NestJS applications
+  - Used to generate worker application
+
+### Infrastructure Dependencies
+
+- **RabbitMQ Docker Container**: Already configured in `docker-compose.yml`
+  - Running on `localhost:5672` (AMQP port)
+  - Management UI on `localhost:15672`
+  - Default credentials: `admin`/`admin`
+  - Must be running before API/Worker starts (or handle connection failures gracefully)
+
+---
+
+## Testing Requirements
+
+### Unit Testing
+
+**QueueService Tests**:
+- Mock amqplib connection and channel
+- Test connection initialization
+- Test queue declaration logic
+- Test `publishTranscodeJob()` method
+- Test error handling scenarios
+- Test with various job parameters
+
+**Test File**: `apps/api/src/app/queue/queue.service.spec.ts`
+
+### Integration Testing
+
+**RabbitMQ Integration Tests**:
+- Use test RabbitMQ instance or Docker container
+- Test actual connection establishment
+- Test queue declaration
+- Test job publishing
+- Test message persistence (restart RabbitMQ, verify queue exists)
+- Verify messages appear in RabbitMQ management UI
+
+**Test Approach**:
+- Start RabbitMQ container
+- Publish test job
+- Verify job appears in queue (via management UI or consumer)
+- Consume job and verify content
+- Test error scenarios (connection failures, etc.)
+
+### Manual Verification Steps
+
+1. **Start Infrastructure**:
+   ```bash
+   docker-compose up -d
+   ```
+
+2. **Verify RabbitMQ Running**:
+   - Check `http://localhost:15672` (RabbitMQ Management UI)
+   - Login with default credentials (`admin`/`admin`)
+   - Verify connection is working
+
+3. **Test Queue Declaration**:
+   - Start API application
+   - Check RabbitMQ UI → Queues tab
+   - Verify `transcode_queue` exists and is durable
+
+4. **Test Job Publishing**:
+   - Upload video via API endpoint
+   - Check RabbitMQ UI → Queues tab → `transcode_queue`
+   - Verify message count increases
+   - Click on queue → View messages
+   - Verify message content matches expected JSON format
+
+5. **Test Worker Consumption**:
+   - Start worker application: `nx serve worker`
+   - Upload video via API endpoint
+   - Check worker logs for received job message
+   - Check RabbitMQ UI → Verify message is consumed (removed from queue)
+
+### Test Data Requirements
+
+- Test video file for upload (small file, 5-10 MB)
+- Various video IDs (UUIDs)
+- Different s3Key formats
+- Different resolution arrays (empty, single, multiple)
+
+---
+
+## Implementation Details
+
+### File Structure
+
+```
+apps/api/src/app/queue/
+├── queue.module.ts           # Module definition
+├── queue.service.ts          # Service implementation
+└── queue.service.spec.ts     # Unit tests (optional for Day 8-9)
+
+apps/worker/
+├── src/
+│   └── main.ts               # Worker entry point
+├── project.json              # Nx project configuration
+└── tsconfig.json             # TypeScript configuration
+```
+
+### Code Organization
+
+**queue.module.ts**:
+- Module decorator
+- Imports ConfigModule
+- Provides and exports QueueService
+
+**queue.service.ts**:
+- Injectable service class
+- Implements OnModuleInit, OnModuleDestroy
+- Private connection and channel instances
+- Public method: `publishTranscodeJob()`
+- Private helper methods: `initializeConnection()`, `declareQueue()`, `closeConnection()`
+
+**worker/src/main.ts**:
+- Async bootstrap function
+- RabbitMQ connection setup
+- Queue declaration
+- Message consumer setup
+- Job logging
+- Graceful shutdown handling
+
+### Key Implementation Patterns
+
+**Connection Initialization**:
+```typescript
+async onModuleInit() {
+  await this.initializeConnection();
+  await this.declareQueue();
+}
+
+private async initializeConnection() {
+  const host = this.configService.get<string>('rabbitmq.host');
+  const port = this.configService.get<number>('rabbitmq.port');
+  const user = this.configService.get<string>('rabbitmq.user');
+  const password = this.configService.get<string>('rabbitmq.password');
+  
+  const connectionUrl = `amqp://${user}:${password}@${host}:${port}`;
+  this.connection = await amqp.connect(connectionUrl);
+  this.channel = await this.connection.createChannel();
+}
+```
+
+**Queue Declaration**:
+```typescript
+private async declareQueue() {
+  const queueName = this.configService.get<string>('rabbitmq.queueName');
+  await this.channel.assertQueue(queueName, { durable: true });
+  this.logger.log(`Queue declared: ${queueName}`);
+}
+```
+
+**Job Publishing**:
+```typescript
+async publishTranscodeJob(
+  videoId: string,
+  s3Key: string,
+  resolutions: string[]
+): Promise<void> {
+  const queueName = this.configService.get<string>('rabbitmq.queueName');
+  const jobData = { videoId, s3Key, resolutions };
+  const message = JSON.stringify(jobData);
+  
+  const sent = this.channel.sendToQueue(
+    queueName,
+    Buffer.from(message),
+    { persistent: true }
+  );
+  
+  if (!sent) {
+    throw new QueuePublishError(`Failed to publish job for video ${videoId}`);
+  }
+  
+  this.logger.log(`Published transcode job: videoId=${videoId}`);
+}
+```
+
+**Worker Consumer**:
+```typescript
+async function consumeJobs() {
+  const channel = await connection.createChannel();
+  const queueName = 'transcode_queue';
+  
+  await channel.assertQueue(queueName, { durable: true });
+  
+  await channel.consume(queueName, (msg) => {
+    if (msg) {
+      try {
+        const jobData = JSON.parse(msg.content.toString());
+        console.log(`[Worker] Received transcode job:`, jobData);
+        channel.ack(msg);
+      } catch (error) {
+        console.error(`[Worker] Failed to parse job:`, error);
+        channel.nack(msg, false, false); // Reject and don't requeue
+      }
+    }
+  }, { noAck: false });
+}
+```
+
+### Configuration Usage
+
+Access configuration via ConfigService:
+```typescript
+const host = this.configService.get<string>('rabbitmq.host');
+const port = this.configService.get<number>('rabbitmq.port');
+const user = this.configService.get<string>('rabbitmq.user');
+const password = this.configService.get<string>('rabbitmq.password');
+const queueName = this.configService.get<string>('rabbitmq.queueName');
+```
+
+---
+
+## Risks & Considerations
+
+### Connection Failures
+
+**Risk**: RabbitMQ container may not be running when API/Worker starts.
+
+**Mitigation**:
+- Handle connection errors gracefully
+- Log clear error messages
+- Consider lazy connection (connect on first use)
+- Document requirement for RabbitMQ to be running
+- Consider health check endpoint
+
+### Message Loss
+
+**Risk**: Messages may be lost if queue is not durable or messages are not persistent.
+
+**Mitigation**:
+- Ensure queue is declared with `durable: true`
+- Ensure messages are published with `persistent: true`
+- Test message persistence (restart RabbitMQ, verify messages survive)
+
+### Message Parsing Errors
+
+**Risk**: Worker may receive malformed messages or fail to parse JSON.
+
+**Mitigation**:
+- Validate message structure in worker
+- Handle JSON parsing errors gracefully
+- Reject malformed messages (nack, don't requeue)
+- Log parsing errors for debugging
+
+### Queue Declaration Failures
+
+**Risk**: Queue declaration may fail due to permissions or RabbitMQ issues.
+
+**Mitigation**:
+- Handle "queue already exists" errors gracefully (idempotent)
+- Log warnings for expected errors
+- Throw exceptions for unexpected errors
+- Verify RabbitMQ user has appropriate permissions
+
+### Worker Consumption Errors
+
+**Risk**: Worker may crash while processing jobs, losing messages.
+
+**Mitigation**:
+- Acknowledge messages only after successful processing (for future transcoding)
+- For Day 8-9: Acknowledge after logging (safe)
+- Handle consumer errors and log them
+- Consider message TTL for failed jobs (future)
+
+### Concurrent Publishing
+
+**Risk**: Multiple API instances publishing concurrently may cause issues.
+
+**Mitigation**:
+- RabbitMQ handles concurrent publishes natively
+- Channel is thread-safe for publishing
+- No additional locking required
+
+### Worker Scaling
+
+**Risk**: Multiple workers may process same job or cause load balancing issues.
+
+**Mitigation**:
+- RabbitMQ handles round-robin distribution automatically
+- Each message is delivered to one consumer only
+- No additional coordination required
+
+---
+
+## Acceptance Criteria
+
+### Definition of Done
+
+The RabbitMQ Integration implementation is complete when:
+
+1. ✅ **Module Created**: `queue.module.ts` exists and is properly structured
+2. ✅ **Service Created**: `queue.service.ts` implements `publishTranscodeJob()` method
+3. ✅ **Connection Established**: Service connects to RabbitMQ on module initialization
+4. ✅ **Queue Declared**: `transcode_queue` is declared as durable
+5. ✅ **Publishing Works**: `publishTranscodeJob()` successfully publishes jobs
+6. ✅ **Worker Created**: Worker application exists and can be run independently
+7. ✅ **Worker Connects**: Worker connects to RabbitMQ successfully
+8. ✅ **Worker Consumes**: Worker consumes jobs from `transcode_queue`
+9. ✅ **Worker Logs**: Worker logs received job details
+10. ✅ **Integration Works**: Videos service publishes jobs after upload
+11. ✅ **Status Updates**: Video status updates to `QUEUED` after publishing
+12. ✅ **Error Handling**: All methods handle errors appropriately
+13. ✅ **Logging**: Important operations are logged
+14. ✅ **Integration**: Module is imported into AppModule
+15. ✅ **Testing**: Upload video → Job appears in queue → Worker logs it
+
+### Verification Checklist
+
+**Setup Verification**:
+- [ ] RabbitMQ Docker container is running (`docker-compose up -d`)
+- [ ] RabbitMQ management UI accessible at `http://localhost:15672`
+- [ ] API application starts without errors
+- [ ] Queue module loads successfully
+- [ ] Worker application can be started: `nx serve worker`
+
+**Queue Verification**:
+- [ ] `transcode_queue` exists in RabbitMQ management UI
+- [ ] Queue is marked as durable in management UI
+- [ ] Queue persists after RabbitMQ restart
+- [ ] Queue declaration is idempotent (safe to call multiple times)
+
+**Publishing Verification**:
+- [ ] Job can be published via `publishTranscodeJob()`
+- [ ] Published job appears in RabbitMQ management UI
+- [ ] Message content matches expected JSON format
+- [ ] Message is marked as persistent
+- [ ] Multiple jobs can be published concurrently
+
+**Worker Verification**:
+- [ ] Worker connects to RabbitMQ successfully
+- [ ] Worker declares and binds to `transcode_queue`
+- [ ] Worker consumes jobs from queue
+- [ ] Worker logs received job details correctly
+- [ ] Jobs are removed from queue after consumption
+- [ ] Worker handles message parsing errors gracefully
+
+**Integration Verification**:
+- [ ] QueueModule is imported in AppModule
+- [ ] QueueService can be injected in VideosService
+- [ ] Videos service publishes job after upload
+- [ ] Video status updates to `QUEUED` after publishing
+- [ ] Upload → Queue → Worker flow works end-to-end
+
+**Error Handling Verification**:
+- [ ] Connection errors are logged appropriately
+- [ ] Publishing errors are handled gracefully
+- [ ] Worker handles malformed messages correctly
+- [ ] Service handles RabbitMQ unavailability gracefully
+
+**Performance Verification**:
+- [ ] Job publishing completes in < 100ms
+- [ ] Multiple concurrent publishes work correctly
+- [ ] Worker can consume jobs efficiently
+
+---
+
+## Architecture Diagram
+
+```mermaid
+graph TB
+    AppModule[AppModule] --> QueueModule[QueueModule]
+    QueueModule --> QueueService[QueueService]
+    QueueService --> ConfigService[ConfigService]
+    QueueService --> RabbitMQConnection[RabbitMQ Connection]
+    RabbitMQConnection --> RabbitMQContainer[RabbitMQ Container<br/>localhost:5672]
+    
+    QueueService --> TranscodeQueue[transcode_queue<br/>Durable Queue]
+    
+    VideosModule[VideosModule] -.->|Uses| QueueService
+    VideosService[VideosService] -->|Publishes Jobs| QueueService
+    
+    WorkerApp[Worker Application<br/>apps/worker] --> WorkerConnection[RabbitMQ Connection]
+    WorkerConnection --> RabbitMQContainer
+    WorkerConnection -->|Consumes| TranscodeQueue
+    
+    UploadFlow[Video Upload] --> VideosService
+    VideosService -->|1. Upload to MinIO| MinIO[MinIO Storage]
+    VideosService -->|2. Create DB Record| PostgreSQL[PostgreSQL]
+    VideosService -->|3. Publish Job| QueueService
+    QueueService -->|4. Job in Queue| TranscodeQueue
+    TranscodeQueue -->|5. Worker Consumes| WorkerApp
+    WorkerApp -->|6. Log Job| Logs[Worker Logs]
+    
+    style QueueService fill:#e1f5ff
+    style RabbitMQContainer fill:#fff4e1
+    style TranscodeQueue fill:#e8f5e9
+    style WorkerApp fill:#f3e5f5
+```
+
+---
+
+## Message Flow Diagram
+
+```mermaid
+sequenceDiagram
+    participant Client
+    participant API as API/VideosService
+    participant Queue as QueueService
+    participant RMQ as RabbitMQ
+    participant Worker as Worker App
+    
+    Client->>API: POST /test-video (upload)
+    API->>API: Upload to MinIO
+    API->>API: Create DB record (status: UPLOADED)
+    API->>Queue: publishTranscodeJob(videoId, s3Key, resolutions)
+    Queue->>RMQ: Declare transcode_queue (durable)
+    Queue->>RMQ: Publish JSON message (persistent)
+    RMQ-->>Queue: Message published
+    Queue-->>API: Job published
+    API->>API: Update status to QUEUED
+    API-->>Client: 201 Created (video record)
+    
+    Note over RMQ: Message in queue
+    
+    Worker->>RMQ: Connect and consume from transcode_queue
+    RMQ->>Worker: Deliver message
+    Worker->>Worker: Parse JSON message
+    Worker->>Worker: Log job details
+    Worker->>RMQ: Acknowledge message
+    RMQ->>RMQ: Remove message from queue
+    
+    Note over Worker: Job logged (no processing yet)
+```
+
+---
+
+## Next Steps (Day 10-11 Integration)
+
+After completing this PRD implementation, the queue integration will be used in Day 10-11 for:
+
+1. **FFmpeg Transcoding**: Worker will process jobs and transcode videos
+2. **Status Updates**: Worker will update video status to `PROCESSING` → `COMPLETED`/`FAILED`
+3. **Progress Tracking**: Worker will report progress to Redis (Day 12-13)
+4. **Error Handling**: Worker will handle transcoding failures and update status
+
+The queue service is designed to be a foundational component that enables asynchronous video processing, supporting the entire transcoding pipeline.
+
+---
+
+## Document Version
+
+**Version**: 1.0  
+**Date**: 2024  
+**Author**: StreamForge Development Team  
+**Status**: Draft for Review
+
+---
+
+## Manual Testing Points
+
+### Test Point 1: Queue Declaration and Module Initialization
+
+**Objective**: Verify that the queue is automatically declared when the API starts and the queue module initializes correctly.
+
+**Steps**:
+1. Ensure RabbitMQ container is running: `docker-compose up -d`
+2. Delete `transcode_queue` from RabbitMQ Management UI (if it exists)
+3. Start the NestJS API application: `nx serve api` (or equivalent)
+4. Check the application logs for queue declaration messages
+5. Open RabbitMQ Management UI at `http://localhost:15672` and verify:
+   - Login with default credentials (`admin`/`admin`)
+   - Navigate to Queues tab
+   - Verify `transcode_queue` exists
+   - Verify queue is marked as "Durable"
+   - Queue should be empty (0 messages ready)
+6. Restart the API application and verify no errors occur (idempotent queue declaration)
+
+**Expected Result**: 
+- API starts successfully without errors
+- `transcode_queue` is created automatically
+- Logs show queue declaration messages
+- Queue is marked as durable in management UI
+- Restarting the API does not cause errors (queue already exists)
+
+---
+
+### Test Point 2: Job Publishing Workflow
+
+**Objective**: Verify that jobs can be published to the queue after video upload and messages appear correctly in RabbitMQ.
+
+**Steps**:
+1. Ensure RabbitMQ container and API are running
+2. Upload a test video file via API endpoint: `POST /test-video`
+   - Use Postman, curl, or similar tool
+   - Upload a small test video file (5-10 MB)
+3. Check API logs for job publishing messages
+4. Open RabbitMQ Management UI:
+   - Navigate to Queues tab
+   - Click on `transcode_queue`
+   - Verify message count increased (should show 1 message ready)
+5. Click "Get messages" to view the message:
+   - Verify message payload is valid JSON
+   - Verify message contains: `videoId`, `s3Key`, `resolutions`
+   - Verify `videoId` matches the uploaded video ID
+   - Verify `s3Key` matches the MinIO object key
+   - Verify `resolutions` is an array (e.g., `["360p", "720p", "1080p"]`)
+6. Check database to verify video status is `QUEUED`
+7. Upload multiple videos and verify multiple messages in queue
+
+**Expected Result**:
+- Video upload completes successfully
+- Job is published to queue
+- Message appears in RabbitMQ management UI
+- Message content matches expected JSON format
+- Video status in database is `QUEUED`
+- Multiple jobs can be published successfully
+
+---
+
+### Test Point 3: Worker Consumption and Logging
+
+**Objective**: Verify that the worker application can consume jobs from the queue and log received job details.
+
+**Steps**:
+1. Ensure RabbitMQ container is running
+2. Ensure API is running and has published at least one job to queue
+3. Start the worker application in a separate terminal: `nx serve worker`
+4. Check worker logs for connection messages
+5. Verify worker connects to RabbitMQ successfully
+6. Check worker logs for job consumption messages:
+   - Should see log: `[Worker] Received transcode job: videoId={...}, s3Key={...}, resolutions={...}`
+   - Verify logged videoId matches published job
+   - Verify logged s3Key matches published job
+   - Verify logged resolutions match published job
+7. Check RabbitMQ Management UI:
+   - Navigate to Queues tab → `transcode_queue`
+   - Verify message count decreased (message was consumed)
+   - Verify message was removed from queue
+8. Publish another job from API and verify worker consumes it immediately
+9. Stop worker and publish a job, then restart worker:
+   - Verify job is still in queue (persistent)
+   - Verify worker consumes the job after restart
+
+**Expected Result**:
+- Worker connects to RabbitMQ successfully
+- Worker consumes jobs from queue
+- Worker logs job details correctly
+- Jobs are removed from queue after consumption
+- Jobs persist in queue if worker is stopped
+- Worker consumes persisted jobs after restart
+
+---
+
+### Test Point 4: Error Handling and Edge Cases
+
+**Objective**: Verify that the queue service and worker handle errors gracefully and validate inputs correctly.
+
+**Steps**:
+1. **Test Connection Failure**:
+   - Stop RabbitMQ container: `docker-compose stop rabbitmq`
+   - Try to start API application
+   - Verify appropriate error is logged
+   - Verify API handles connection failure gracefully (or fails fast with clear error)
+
+2. **Test Queue Publishing with Invalid Parameters**:
+   - Try to publish job with empty videoId
+   - Try to publish job with invalid s3Key
+   - Verify appropriate validation errors are thrown
+
+3. **Test Worker with Malformed Message**:
+   - Manually publish a malformed message to queue via RabbitMQ Management UI
+   - Start worker and verify it handles parsing error gracefully
+   - Verify malformed message is rejected (nack, not requeued)
+   - Verify error is logged
+
+4. **Test Multiple Workers**:
+   - Start two worker instances simultaneously
+   - Publish multiple jobs (5-10 jobs)
+   - Verify jobs are distributed between workers (round-robin)
+   - Verify each job is consumed by only one worker
+   - Verify all jobs are eventually consumed
+
+5. **Test Queue Persistence**:
+   - Publish a job to queue
+   - Restart RabbitMQ container: `docker-compose restart rabbitmq`
+   - Verify queue still exists after restart
+   - Verify message is still in queue (persistent)
+   - Start worker and verify it consumes the persisted message
+
+**Expected Result**:
+- Connection failures are handled gracefully with clear error messages
+- Invalid parameters are validated and appropriate errors are thrown
+- Malformed messages are rejected and logged
+- Multiple workers can consume jobs in parallel
+- Queue and messages persist across RabbitMQ restarts
+- All errors are logged with context
+
+---
+
+### Test Point 5: End-to-End Integration Flow
+
+**Objective**: Verify the complete flow from video upload to worker consumption works correctly.
+
+**Steps**:
+1. Ensure all infrastructure is running: `docker-compose up -d`
+2. Start API application: `nx serve api`
+3. Start worker application: `nx serve worker` (separate terminal)
+4. Upload a video file via API: `POST /test-video`
+5. Monitor the complete flow:
+   - **Step 1**: Check API logs - video uploaded to MinIO
+   - **Step 2**: Check database - video record created with status `UPLOADED`
+   - **Step 3**: Check API logs - job published to queue
+   - **Step 4**: Check database - video status updated to `QUEUED`
+   - **Step 5**: Check RabbitMQ UI - message in queue
+   - **Step 6**: Check worker logs - job received and logged
+   - **Step 7**: Check RabbitMQ UI - message consumed (removed from queue)
+6. Verify no errors occurred in any step
+7. Upload multiple videos and verify all are processed correctly
+
+**Expected Result**:
+- Complete flow works end-to-end without errors
+- All steps complete successfully
+- Video status transitions correctly: `UPLOADED` → `QUEUED`
+- Job appears in queue and is consumed by worker
+- Worker logs job details correctly
+- Multiple videos can be processed in sequence
+- System handles concurrent uploads correctly
+
+---
+
+## Additional Notes
+
+### RabbitMQ Management UI Access
+
+- **URL**: `http://localhost:15672`
+- **Default Username**: `admin`
+- **Default Password**: `admin`
+- **Useful Features**:
+  - Queues tab: View all queues and message counts
+  - Queue details: View messages, inspect content
+  - Connections tab: View active connections
+  - Channels tab: View active channels
+
+### Development Tips
+
+- **Queue Inspection**: Use RabbitMQ Management UI to inspect queue contents during development
+- **Message Testing**: Manually publish test messages via Management UI for testing
+- **Connection Debugging**: Check Connections tab in Management UI to verify API/Worker connections
+- **Log Monitoring**: Monitor both API and Worker logs simultaneously during testing
+
+### Common Issues
+
+- **Connection Refused**: Ensure RabbitMQ container is running (`docker-compose ps`)
+- **Queue Not Found**: Ensure queue is declared before consuming (worker should declare queue)
+- **Messages Not Persisting**: Verify queue is durable and messages are published with `persistent: true`
+- **Worker Not Consuming**: Verify worker is connected and bound to correct queue name
+
diff --git a/docs/PRD/MINIO-SIGNATURE-ISSUE-REPORT.md b/docs/done/MINIO-SIGNATURE-ISSUE-REPORT.md
similarity index 100%
rename from docs/PRD/MINIO-SIGNATURE-ISSUE-REPORT.md
rename to docs/done/MINIO-SIGNATURE-ISSUE-REPORT.md
diff --git a/docs/PRD/PRD-IMPLEMENTATION-STATUS-REPORT.md b/docs/done/PRD-IMPLEMENTATION-STATUS-REPORT.md
similarity index 100%
rename from docs/PRD/PRD-IMPLEMENTATION-STATUS-REPORT.md
rename to docs/done/PRD-IMPLEMENTATION-STATUS-REPORT.md
diff --git a/docs/PRD/PRD-MINIO-STORAGE.md b/docs/done/PRD-MINIO-STORAGE.md
similarity index 100%
rename from docs/PRD/PRD-MINIO-STORAGE.md
rename to docs/done/PRD-MINIO-STORAGE.md
diff --git a/nx.json b/nx.json
index 2ae2ebb..55ca150 100644
--- a/nx.json
+++ b/nx.json
@@ -39,7 +39,7 @@
       "options": {
         "targetName": "test"
       },
-      "exclude": ["apps/api-e2e/**/*"]
+      "exclude": ["apps/api-e2e/**/*", "apps/worker-e2e/**/*"]
     }
   ]
 }