diff --git a/middleware/.env.example b/middleware/.env.example
new file mode 100644
index 00000000..a43bfd3e
--- /dev/null
+++ b/middleware/.env.example
@@ -0,0 +1,18 @@
+# Prometheus Metrics Plugin Configuration
+# Copy this file to .env and configure as needed
+
+# API key for /metrics endpoint protection (optional)
+# If set, requires Bearer token authentication on /metrics
+METRICS_API_KEY=your-secure-api-key-here
+
+# Enable/disable default Node.js metrics (CPU, memory, event loop)
+ENABLE_DEFAULT_METRICS=true
+
+# Enable HTTP request duration tracking
+ENABLE_HTTP_DURATION=true
+
+# Enable HTTP request counter
+ENABLE_HTTP_REQUESTS=true
+
+# Enable HTTP error counter
+ENABLE_HTTP_ERRORS=true
diff --git a/middleware/docs/PLUGIN_DEVELOPMENT.md b/middleware/docs/PLUGIN_DEVELOPMENT.md
new file mode 100644
index 00000000..ff994c76
--- /dev/null
+++ b/middleware/docs/PLUGIN_DEVELOPMENT.md
@@ -0,0 +1,392 @@
+# Plugin Development Guide
+
+This guide walks you through creating, testing, and publishing plugins for the MindBlock middleware system.
+
+## Table of Contents
+
+- [Prerequisites](#prerequisites)
+- [Getting Started](#getting-started)
+- [Creating Your First Plugin](#creating-your-first-plugin)
+- [Testing Your Plugin](#testing-your-plugin)
+- [Publishing Your Plugin](#publishing-your-plugin)
+- [Best Practices](#best-practices)
+
+## Prerequisites
+
+Before you start, ensure you have:
+
+- Node.js 18+ installed
+- npm or yarn package manager
+- Basic understanding of TypeScript and NestJS
+- Git for version control
+
+## Getting Started
+
+### Clone the Repository
+
+```bash
+git clone https://github.com/mindblock/middleware.git
+cd middleware
+npm install
+```
+
+### Explore the Starter Template
+
+We provide a starter template at `packages/plugin-starter/` with everything you need:
+
+```bash
+ls packages/plugin-starter/
+# ├── src/
+# │   └── index.ts          # Main plugin file
+# ├── tests/
+# │   └── plugin.test.ts    # Test file
+# ├── package.json          # Pre-configured for publishing
+# └── README.md             # Documentation template
+```
+
+## Creating Your First Plugin
+
+### Step 1: Use the Starter Template
+
+Copy the starter template to your new plugin directory:
+
+```bash
+cp -r packages/plugin-starter my-awesome-plugin
+cd my-awesome-plugin
+```
+
+### Step 2: Update Package Configuration
+
+Edit `package.json`:
+
+```json
+{
+  "name": "@your-org/my-awesome-plugin",
+  "version": "1.0.0",
+  "description": "An awesome plugin for MindBlock",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": ["mindblock", "plugin", "middleware"],
+  "license": "MIT",
+  "peerDependencies": {
+    "@mindblock/middleware": ">=0.1.0"
+  }
+}
+```
+
+### Step 3: Implement Your Plugin
+
+Edit `src/index.ts`:
+
+```typescript
+import { IPlugin, PluginPriority } from '@mindblock/middleware/common';
+
+export interface MyPluginConfig {
+  apiKey?: string;
+  timeout?: number;
+  enabled?: boolean;
+}
+
+export class MyAwesomePlugin implements IPlugin {
+  readonly name = 'my-awesome-plugin';
+  readonly version = '1.0.0';
+  readonly priority = PluginPriority.NORMAL;
+  
+  private config: MyPluginConfig;
+  
+  constructor(config: MyPluginConfig = {}) {
+    this.config = {
+      timeout: 5000,
+      enabled: true,
+      ...config,
+    };
+  }
+  
+  async onInit(): Promise<void> {
+    console.log(`[${this.name}] Initializing...`);
+    
+    // Initialize your plugin here
+    // - Set up connections
+    // - Load configuration
+    // - Register handlers
+    
+    console.log(`[${this.name}] Initialized successfully`);
+  }
+  
+  async onDestroy(): Promise<void> {
+    console.log(`[${this.name}] Cleaning up...`);
+    
+    // Clean up resources
+    // - Close connections
+    // - Clear timers
+    // - Release memory
+    
+    console.log(`[${this.name}] Cleanup complete`);
+  }
+  
+  // Add your custom methods here
+  async doSomething(): Promise<void> {
+    // Your plugin logic
+  }
+}
+```
+
+### Step 4: Build Your Plugin
+
+```bash
+npm run build
+```
+
+## Testing Your Plugin
+
+### Unit Testing
+
+The starter template includes Jest configuration. Write tests in `tests/`:
+
+```typescript
+// tests/plugin.test.ts
+import { MyAwesomePlugin } from '../src';
+import { createPluginTestContext, testPluginLifecycle } from '@mindblock/middleware/common';
+
+describe('MyAwesomePlugin', () => {
+  it('should initialize successfully', async () => {
+    const plugin = new MyAwesomePlugin({ enabled: true });
+    await expect(plugin.onInit()).resolves.not.toThrow();
+  });
+  
+  it('should clean up on destroy', async () => {
+    const plugin = new MyAwesomePlugin();
+    await plugin.onInit();
+    await expect(plugin.onDestroy()).resolves.not.toThrow();
+  });
+  
+  it('should work with test context', async () => {
+    const ctx = createPluginTestContext({
+      config: { apiKey: 'test-key' },
+    });
+    
+    const plugin = new MyAwesomePlugin(ctx.config);
+    await plugin.onInit();
+    
+    expect(ctx.logger.log).toHaveBeenCalled();
+  });
+  
+  it('should follow lifecycle order', async () => {
+    const plugin = new MyAwesomePlugin();
+    const result = await testPluginLifecycle(plugin);
+    
+    expect(result.initCalled).toBe(true);
+    expect(result.destroyCalled).toBe(true);
+    expect(result.executionOrder).toEqual(['onInit', 'onDestroy']);
+  });
+});
+```
+
+### Run Tests
+
+```bash
+npm test
+```
+
+### Run with Coverage
+
+```bash
+npm run test:cov
+```
+
+## Publishing Your Plugin
+
+### Step 1: Prepare for Publishing
+
+Update your README.md with:
+- Plugin description
+- Installation instructions
+- Usage examples
+- Configuration options
+- API reference
+
+### Step 2: Build Distribution
+
+```bash
+npm run build
+```
+
+### Step 3: Test Locally
+
+```bash
+npm pack
+# Creates a .tgz file you can test in another project
+```
+
+### Step 4: Publish to npm
+
+```bash
+npm publish --access public
+```
+
+For scoped packages (@your-org/):
+```bash
+npm publish --access public
+```
+
+### Step 5: Verify Publication
+
+Check your package on npmjs.com:
+```
+https://www.npmjs.com/package/@your-org/my-awesome-plugin
+```
+
+## Best Practices
+
+### 1. Follow Plugin Lifecycle
+
+Always implement both `onInit` and `onDestroy`:
+
+```typescript
+async onInit(): Promise<void> {
+  // Setup code
+}
+
+async onDestroy(): Promise<void> {
+  // Cleanup code - even if nothing to clean up
+}
+```
+
+### 2. Handle Errors Gracefully
+
+```typescript
+async onInit(): Promise<void> {
+  try {
+    // Initialization logic
+  } catch (error) {
+    console.error(`[${this.name}] Init failed:`, error);
+    throw error; // Re-throw to prevent broken plugin from loading
+  }
+}
+```
+
+### 3. Use Appropriate Priority
+
+```typescript
+readonly priority = PluginPriority.CRITICAL; // Core functionality
+readonly priority = PluginPriority.HIGH;     // Important features
+readonly priority = PluginPriority.NORMAL;   // Standard plugins
+readonly priority = PluginPriority.LOW;      // Optional enhancements
+```
+
+### 4. Document Dependencies
+
+```typescript
+readonly dependencies = ['prometheus-metrics'];
+```
+
+### 5. Keep Plugins Focused
+
+Each plugin should do one thing well. Avoid monolithic plugins.
+
+### 6. Use Configuration Objects
+
+```typescript
+constructor(config: MyPluginConfig = {}) {
+  this.config = {
+    default: 'value',
+    ...config,
+  };
+}
+```
+
+### 7. Write Comprehensive Tests
+
+Aim for >80% code coverage. Test:
+- Happy path
+- Edge cases
+- Error conditions
+- Lifecycle methods
+
+### 8. Follow Semantic Versioning
+
+- MAJOR.MINOR.PATCH (e.g., 1.2.3)
+- MAJOR: Breaking changes
+- MINOR: New features (backward compatible)
+- PATCH: Bug fixes
+
+### 9. Export Types
+
+Always export TypeScript types for better DX:
+
+```typescript
+export interface MyPluginConfig { ... }
+export type MyPluginOptions = Partial<MyPluginConfig>;
+```
+
+### 10. Provide Examples
+
+Include usage examples in your README:
+
+```typescript
+import { MyAwesomePlugin } from '@your-org/my-awesome-plugin';
+
+const plugin = new MyAwesomePlugin({
+  apiKey: process.env.API_KEY,
+  timeout: 10000,
+});
+
+await plugin.onInit();
+```
+
+## Example Plugin Structure
+
+```
+my-awesome-plugin/
+├── src/
+│   ├── index.ts              # Main plugin class
+│   ├── types.ts              # Type definitions
+│   └── utils.ts              # Helper functions
+├── tests/
+│   ├── plugin.test.ts        # Unit tests
+│   └── integration.test.ts   # Integration tests
+├── docs/
+│   └── API.md                # API documentation
+├── .gitignore
+├── package.json
+├── tsconfig.json
+├── jest.config.js
+└── README.md
+```
+
+## Troubleshooting
+
+### Plugin Not Initializing
+
+Check that:
+- `onInit()` is implemented
+- No unhandled errors in `onInit()`
+- Plugin is registered with PluginManager
+
+### Tests Failing
+
+Ensure:
+- Mock contexts are properly configured
+- Async code is awaited
+- Resources are cleaned up
+
+### Publishing Issues
+
+Verify:
+- Package name is unique
+- You have npm publish permissions
+- All files are included in `files` array in package.json
+
+## Next Steps
+
+- Browse existing plugins for inspiration
+- Join the MindBlock community
+- Contribute to the plugin ecosystem
+- Share your plugins with the community!
+
+## Resources
+
+- [Plugin Interface Documentation](../src/common/plugin.interface.ts)
+- [Plugin Manager Implementation](../src/common/plugin.manager.ts)
+- [Testing Utilities](../src/common/plugin-testing.utils.ts)
+- [Example: Prometheus Metrics Plugin](../src/monitoring/prometheus.plugin.ts)
diff --git a/middleware/jest.e2e.config.ts b/middleware/jest.e2e.config.ts
new file mode 100644
index 00000000..573dc545
--- /dev/null
+++ b/middleware/jest.e2e.config.ts
@@ -0,0 +1,21 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/tests/e2e/**/*.test.ts', '**/tests/e2e/**/*.spec.ts'],
+  collectCoverageFrom: ['src/**/*.ts'],
+  coverageDirectory: 'coverage/e2e',
+  coverageThreshold: {
+    global: {
+      branches: 60,
+      functions: 60,
+      lines: 60,
+      statements: 60,
+    },
+  },
+  setupFilesAfterEnv: ['<rootDir>/tests/setup.ts'],
+  moduleNameMapper: {
+    '^@mindblock/middleware/(.*)$': '<rootDir>/src/$1',
+  },
+  testTimeout: 30000, // E2E tests may take even longer
+};
diff --git a/middleware/jest.integration.config.ts b/middleware/jest.integration.config.ts
new file mode 100644
index 00000000..09c4e591
--- /dev/null
+++ b/middleware/jest.integration.config.ts
@@ -0,0 +1,21 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/tests/integration/**/*.test.ts', '**/tests/integration/**/*.spec.ts'],
+  collectCoverageFrom: ['src/**/*.ts'],
+  coverageDirectory: 'coverage/integration',
+  coverageThreshold: {
+    global: {
+      branches: 70,
+      functions: 70,
+      lines: 70,
+      statements: 70,
+    },
+  },
+  setupFilesAfterEnv: ['<rootDir>/tests/setup.ts'],
+  moduleNameMapper: {
+    '^@mindblock/middleware/(.*)$': '<rootDir>/src/$1',
+  },
+  testTimeout: 10000, // Integration tests may take longer
+};
diff --git a/middleware/jest.unit.config.ts b/middleware/jest.unit.config.ts
new file mode 100644
index 00000000..1a09ad08
--- /dev/null
+++ b/middleware/jest.unit.config.ts
@@ -0,0 +1,20 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/tests/unit/**/*.test.ts', '**/tests/unit/**/*.spec.ts'],
+  collectCoverageFrom: ['src/**/*.ts'],
+  coverageDirectory: 'coverage/unit',
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80,
+    },
+  },
+  setupFilesAfterEnv: ['<rootDir>/tests/setup.ts'],
+  moduleNameMapper: {
+    '^@mindblock/middleware/(.*)$': '<rootDir>/src/$1',
+  },
+};
diff --git a/middleware/package.json b/middleware/package.json
index 0ba0c3a3..3c989583 100644
--- a/middleware/package.json
+++ b/middleware/package.json
@@ -7,9 +7,15 @@
   "private": true,
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "test": "jest --passWithNoTests",
+    "test": "npm run test:unit && npm run test:integration && npm run test:e2e",
+    "test:unit": "jest --config jest.unit.config.ts",
+    "test:integration": "jest --config jest.integration.config.ts",
+    "test:e2e": "jest --config jest.e2e.config.ts",
     "test:watch": "jest --watch --passWithNoTests",
     "test:cov": "jest --coverage --passWithNoTests",
+    "test:unit:cov": "jest --config jest.unit.config.ts --coverage",
+    "test:integration:cov": "jest --config jest.integration.config.ts --coverage",
+    "test:e2e:cov": "jest --config jest.e2e.config.ts --coverage",
     "lint": "eslint -c eslint.config.mjs \"src/**/*.ts\" \"tests/**/*.ts\"",
     "lint:fix": "eslint -c eslint.config.mjs \"src/**/*.ts\" \"tests/**/*.ts\" --fix",
     "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
@@ -25,12 +31,15 @@
     "express": "^5.1.0",
     "jsonwebtoken": "^9.0.2",
     "micromatch": "^4.0.8",
+    "prom-client": "^15.1.3",
     "stellar-sdk": "^13.1.0"
   },
   "devDependencies": {
+    "@nestjs/testing": "^11.0.12",
     "@types/express": "^5.0.0",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.7",
+    "@types/supertest": "^6.0.2",
     "@typescript-eslint/eslint-plugin": "^8.20.0",
     "@typescript-eslint/parser": "^8.20.0",
     "eslint": "^9.18.0",
@@ -38,6 +47,7 @@
     "globals": "^16.0.0",
     "jest": "^29.7.0",
     "prettier": "^3.4.2",
+    "supertest": "^7.0.0",
     "ts-jest": "^29.2.5",
     "typescript": "^5.7.3",
     "typescript-eslint": "^8.20.0"
diff --git a/middleware/packages/plugin-starter/.gitignore b/middleware/packages/plugin-starter/.gitignore
new file mode 100644
index 00000000..bc29f6aa
--- /dev/null
+++ b/middleware/packages/plugin-starter/.gitignore
@@ -0,0 +1,27 @@
+# Dependencies
+node_modules/
+
+# Build output
+dist/
+
+# Test coverage
+coverage/
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+
+# Environment variables
+.env
+.env.local
+
+# Package lock (optional - remove if you want to commit it)
+# package-lock.json
diff --git a/middleware/packages/plugin-starter/README.md b/middleware/packages/plugin-starter/README.md
new file mode 100644
index 00000000..159ed3c5
--- /dev/null
+++ b/middleware/packages/plugin-starter/README.md
@@ -0,0 +1,276 @@
+# My Starter Plugin
+
+A starter template for creating MindBlock middleware plugins.
+
+## Description
+
+This is a **template plugin** designed to help you get started with MindBlock plugin development. Copy this directory, customize it, and create your own plugins!
+
+## Features
+
+- ✅ Implements the IPlugin interface
+- ✅ Lifecycle hooks (onInit, onDestroy)
+- ✅ Configuration support
+- ✅ TypeScript types included
+- ✅ Jest test setup
+- ✅ Ready to publish to npm
+
+## Installation
+
+```bash
+npm install @mindblock/plugin-starter
+```
+
+## Usage
+
+```typescript
+import { MyStarterPlugin } from '@mindblock/plugin-starter';
+
+// Create plugin instance
+const plugin = new MyStarterPlugin({
+  apiKey: process.env.API_KEY,
+  timeout: 10000,
+  enabled: true,
+});
+
+// Initialize
+await plugin.onInit();
+
+// Use plugin methods
+await plugin.doSomething();
+
+// Cleanup
+await plugin.onDestroy();
+```
+
+## Configuration
+
+The plugin accepts the following configuration options:
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `apiKey` | string | `undefined` | Optional API key |
+| `timeout` | number | `5000` | Timeout in milliseconds |
+| `enabled` | boolean | `true` | Enable/disable plugin |
+
+## API Reference
+
+### Constructor
+
+```typescript
+new MyStarterPlugin(config?: MyStarterPluginConfig)
+```
+
+### Properties
+
+- `name: string` - Plugin identifier
+- `version: string` - Plugin version
+- `priority: PluginPriority` - Initialization priority
+
+### Methods
+
+#### onInit()
+
+Initialize the plugin. Called by PluginManager during initialization phase.
+
+```typescript
+await plugin.onInit();
+```
+
+#### onDestroy()
+
+Clean up plugin resources. Called by PluginManager during shutdown.
+
+```typescript
+await plugin.onDestroy();
+```
+
+#### doSomething()
+
+Example custom method - replace with your plugin's functionality.
+
+```typescript
+await plugin.doSomething();
+```
+
+## Development
+
+### Clone and Setup
+
+```bash
+git clone https://github.com/mindblock/middleware.git
+cd middleware/packages/plugin-starter
+npm install
+```
+
+### Build
+
+```bash
+npm run build
+```
+
+### Test
+
+```bash
+npm test
+```
+
+### Test with Coverage
+
+```bash
+npm run test:cov
+```
+
+### Watch Mode
+
+```bash
+npm run test:watch
+```
+
+## Creating Your Own Plugin
+
+1. **Copy this template**:
+   ```bash
+   cp -r packages/plugin-starter my-awesome-plugin
+   cd my-awesome-plugin
+   ```
+
+2. **Update package.json**:
+   - Change `name` to your plugin name
+   - Update `description`
+   - Update `author`
+
+3. **Rename the plugin class**:
+   - Replace `MyStarterPlugin` with your plugin name
+   - Update the `name` property
+
+4. **Implement your logic**:
+   - Add your initialization code in `onInit()`
+   - Add cleanup code in `onDestroy()`
+   - Add custom methods
+
+5. **Write tests**:
+   - Update `tests/plugin.test.ts`
+   - Aim for >80% coverage
+
+6. **Publish**:
+   ```bash
+   npm run build
+   npm publish --access public
+   ```
+
+## Plugin Guidelines
+
+### Lifecycle Order
+
+Plugins are initialized in this order:
+1. By priority (CRITICAL → HIGH → NORMAL → LOW)
+2. By registration time within same priority
+
+Plugins are destroyed in **reverse** order.
+
+### Priority Levels
+
+```typescript
+import { PluginPriority } from '@mindblock/middleware/common';
+
+readonly priority = PluginPriority.CRITICAL; // Core plugins first
+readonly priority = PluginPriority.HIGH;     // Important plugins
+readonly priority = PluginPriority.NORMAL;   // Standard plugins
+readonly priority = PluginPriority.LOW;      // Optional plugins last
+```
+
+### Dependencies
+
+Declare plugin dependencies:
+
+```typescript
+readonly dependencies = ['prometheus-metrics', 'logging'];
+```
+
+### Best Practices
+
+- ✅ Keep plugins focused on one responsibility
+- ✅ Handle errors gracefully
+- ✅ Clean up all resources in `onDestroy()`
+- ✅ Use appropriate priority levels
+- ✅ Document your API
+- ✅ Write comprehensive tests
+- ✅ Follow semantic versioning
+
+## Troubleshooting
+
+### Plugin Not Initializing
+
+Check that:
+- `onInit()` doesn't throw unhandled errors
+- Plugin is registered with PluginManager
+- All dependencies are satisfied
+
+### Tests Failing
+
+Ensure:
+- Mock contexts are configured correctly
+- Async code is properly awaited
+- Resources are cleaned up between tests
+
+## Examples
+
+### Basic Plugin
+
+```typescript
+import { IPlugin } from '@mindblock/middleware/common';
+
+export class MyPlugin implements IPlugin {
+  readonly name = 'my-plugin';
+  readonly version = '1.0.0';
+  
+  async onInit(): Promise<void> {
+    console.log('Plugin initialized');
+  }
+  
+  async onDestroy(): Promise<void> {
+    console.log('Plugin destroyed');
+  }
+}
+```
+
+### Plugin with Configuration
+
+```typescript
+export class ConfigurablePlugin implements IPlugin {
+  private config: MyConfig;
+  
+  constructor(config: MyConfig) {
+    this.config = { timeout: 5000, ...config };
+  }
+  
+  async onInit(): Promise<void> {
+    // Use this.config
+  }
+}
+```
+
+### Plugin with Dependencies
+
+```typescript
+export class DependentPlugin implements IPlugin {
+  readonly name = 'dependent-plugin';
+  readonly dependencies = ['database', 'cache'];
+  
+  async onInit(): Promise<void> {
+    // database and cache plugins are already initialized
+  }
+}
+```
+
+## Resources
+
+- [Full Plugin Development Guide](../../docs/PLUGIN_DEVELOPMENT.md)
+- [Plugin Interface](../../src/common/plugin.interface.ts)
+- [Plugin Manager](../../src/common/plugin.manager.ts)
+- [Testing Utilities](../../src/common/plugin-testing.utils.ts)
+
+## License
+
+MIT
diff --git a/middleware/packages/plugin-starter/jest.config.js b/middleware/packages/plugin-starter/jest.config.js
new file mode 100644
index 00000000..a40d1315
--- /dev/null
+++ b/middleware/packages/plugin-starter/jest.config.js
@@ -0,0 +1,19 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/tests/**/*.test.ts'],
+  collectCoverageFrom: ['src/**/*.ts'],
+  coverageDirectory: 'coverage',
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80,
+    },
+  },
+  moduleNameMapper: {
+    '^@mindblock/middleware/(.*)$': '<rootDir>/../../src/$1',
+  },
+};
diff --git a/middleware/packages/plugin-starter/package.json b/middleware/packages/plugin-starter/package.json
new file mode 100644
index 00000000..afd526a4
--- /dev/null
+++ b/middleware/packages/plugin-starter/package.json
@@ -0,0 +1,47 @@
+{
+  "name": "@mindblock/plugin-starter",
+  "version": "1.0.0",
+  "description": "Starter template for creating MindBlock middleware plugins",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "prepublishOnly": "npm run build",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "mindblock",
+    "middleware",
+    "plugin",
+    "starter",
+    "template"
+  ],
+  "author": "Your Name <your.email@example.com>",
+  "license": "MIT",
+  "peerDependencies": {
+    "@mindblock/middleware": ">=0.1.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.7",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.3"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mindblock/middleware.git",
+    "directory": "packages/plugin-starter"
+  },
+  "bugs": {
+    "url": "https://github.com/mindblock/middleware/issues"
+  },
+  "homepage": "https://github.com/mindblock/middleware#readme"
+}
diff --git a/middleware/packages/plugin-starter/src/index.ts b/middleware/packages/plugin-starter/src/index.ts
new file mode 100644
index 00000000..535929bb
--- /dev/null
+++ b/middleware/packages/plugin-starter/src/index.ts
@@ -0,0 +1,77 @@
+/**
+ * My Starter Plugin
+ * 
+ * This is a starter template for creating MindBlock middleware plugins.
+ * Replace this with your plugin's actual implementation.
+ */
+
+import { IPlugin, PluginPriority } from '@mindblock/middleware/common';
+
+export interface MyStarterPluginConfig {
+  /** Optional API key */
+  apiKey?: string;
+  
+  /** Timeout in milliseconds */
+  timeout?: number;
+  
+  /** Enable/disable plugin */
+  enabled?: boolean;
+}
+
+export class MyStarterPlugin implements IPlugin {
+  readonly name = 'my-starter-plugin';
+  readonly version = '1.0.0';
+  readonly priority = PluginPriority.NORMAL;
+  
+  private config: MyStarterPluginConfig;
+  
+  constructor(config: MyStarterPluginConfig = {}) {
+    this.config = {
+      timeout: 5000,
+      enabled: true,
+      ...config,
+    };
+  }
+  
+  async onInit(): Promise<void> {
+    console.log(`[${this.name}] Initializing...`);
+    
+    // TODO: Add your initialization logic here
+    // Examples:
+    // - Set up database connections
+    // - Load configuration
+    // - Register event handlers
+    // - Initialize external services
+    
+    if (this.config.enabled) {
+      console.log(`[${this.name}] Plugin enabled with timeout: ${this.config.timeout}ms`);
+    }
+    
+    console.log(`[${this.name}] Initialized successfully`);
+  }
+  
+  async onDestroy(): Promise<void> {
+    console.log(`[${this.name}] Cleaning up...`);
+    
+    // TODO: Add your cleanup logic here
+    // Examples:
+    // - Close database connections
+    // - Clear timers/intervals
+    // - Release resources
+    // - Flush buffers
+    
+    console.log(`[${this.name}] Cleanup complete`);
+  }
+  
+  /**
+   * Example method - replace with your plugin's functionality
+   */
+  async doSomething(): Promise<void> {
+    if (!this.config.enabled) {
+      throw new Error('Plugin is disabled');
+    }
+    
+    // TODO: Implement your plugin logic here
+    console.log(`[${this.name}] Doing something...`);
+  }
+}
diff --git a/middleware/packages/plugin-starter/tests/plugin.test.ts b/middleware/packages/plugin-starter/tests/plugin.test.ts
new file mode 100644
index 00000000..9cee27ed
--- /dev/null
+++ b/middleware/packages/plugin-starter/tests/plugin.test.ts
@@ -0,0 +1,111 @@
+import { MyStarterPlugin } from '../src';
+import { 
+  createPluginTestContext, 
+  testPluginLifecycle,
+  createMockPlugin 
+} from '@mindblock/middleware/common';
+
+describe('MyStarterPlugin', () => {
+  let plugin: MyStarterPlugin;
+
+  beforeEach(() => {
+    plugin = new MyStarterPlugin();
+  });
+
+  describe('constructor', () => {
+    it('should create plugin with default config', () => {
+      expect(plugin.name).toBe('my-starter-plugin');
+      expect(plugin.version).toBe('1.0.0');
+    });
+
+    it('should accept custom config', () => {
+      const customPlugin = new MyStarterPlugin({
+        apiKey: 'test-key',
+        timeout: 10000,
+        enabled: false,
+      });
+
+      expect(customPlugin).toBeDefined();
+    });
+  });
+
+  describe('onInit', () => {
+    it('should initialize successfully', async () => {
+      await expect(plugin.onInit()).resolves.not.toThrow();
+    });
+
+    it('should work with test context', async () => {
+      const ctx = createPluginTestContext({
+        config: { apiKey: 'test-key' },
+      });
+
+      const testPlugin = new MyStarterPlugin(ctx.config);
+      await testPlugin.onInit();
+
+      // Plugin should initialize without errors
+      expect(ctx.logger.log).toBeDefined();
+    });
+  });
+
+  describe('onDestroy', () => {
+    it('should destroy after init', async () => {
+      await plugin.onInit();
+      await expect(plugin.onDestroy()).resolves.not.toThrow();
+    });
+
+    it('should cleanup resources', async () => {
+      await plugin.onInit();
+      await plugin.onDestroy();
+      
+      // Add assertions for cleanup if needed
+    });
+  });
+
+  describe('lifecycle', () => {
+    it('should follow correct lifecycle order', async () => {
+      const result = await testPluginLifecycle(plugin);
+
+      expect(result.initCalled).toBe(true);
+      expect(result.destroyCalled).toBe(true);
+      expect(result.executionOrder).toEqual(['onInit', 'onDestroy']);
+    });
+
+    it('should handle lifecycle errors gracefully', async () => {
+      const result = await testPluginLifecycle(plugin);
+      
+      expect(result.initError).toBeUndefined();
+      expect(result.destroyError).toBeUndefined();
+    });
+  });
+
+  describe('doSomething', () => {
+    beforeEach(async () => {
+      await plugin.onInit();
+    });
+
+    it('should execute when enabled', async () => {
+      await expect(plugin.doSomething()).resolves.not.toThrow();
+    });
+
+    it('should throw when disabled', async () => {
+      const disabledPlugin = new MyStarterPlugin({ enabled: false });
+      await disabledPlugin.onInit();
+
+      await expect(disabledPlugin.doSomething()).rejects.toThrow('Plugin is disabled');
+    });
+  });
+
+  describe('mock plugin creation', () => {
+    it('should create mock plugin for testing', () => {
+      const mockPlugin = createMockPlugin({
+        name: 'TestPlugin',
+        version: '2.0.0',
+        onInit: jest.fn().mockResolvedValue(undefined),
+        onDestroy: jest.fn().mockResolvedValue(undefined),
+      });
+
+      expect(mockPlugin.name).toBe('TestPlugin');
+      expect(mockPlugin.version).toBe('2.0.0');
+    });
+  });
+});
diff --git a/middleware/packages/plugin-starter/tsconfig.json b/middleware/packages/plugin-starter/tsconfig.json
new file mode 100644
index 00000000..fe57ab6f
--- /dev/null
+++ b/middleware/packages/plugin-starter/tsconfig.json
@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": false,
+    "inlineSourceMap": true,
+    "inlineSources": true,
+    "experimentalDecorators": true,
+    "strictPropertyInitialization": false,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}
diff --git a/middleware/src/common/index.ts b/middleware/src/common/index.ts
index c8bbaeb0..e633306b 100644
--- a/middleware/src/common/index.ts
+++ b/middleware/src/common/index.ts
@@ -1,3 +1,4 @@
-// Placeholder: common exports (interfaces, types, constants, utils) will live here.
-
-export const __commonPlaceholder = true;
+// Common utilities and interfaces
+export * from './plugin.interface';
+export * from './plugin.manager';
+export * from './plugin-testing.utils';
diff --git a/middleware/src/common/plugin-testing.utils.ts b/middleware/src/common/plugin-testing.utils.ts
new file mode 100644
index 00000000..08501f63
--- /dev/null
+++ b/middleware/src/common/plugin-testing.utils.ts
@@ -0,0 +1,173 @@
+import { IPlugin } from '../../src/common/plugin.interface';
+
+/**
+ * Mock plugin context for unit testing plugins without NestJS
+ */
+export interface MockPluginContext {
+  /** Plugin configuration */
+  config: Record<string, any>;
+  
+  /** Logger mock */
+  logger: {
+    log: jest.Mock;
+    warn: jest.Mock;
+    error: jest.Mock;
+    debug: jest.Mock;
+  };
+  
+  /** Metrics registry mock (if plugin uses metrics) */
+  metrics?: {
+    incrementHttpRequest?: jest.Mock;
+    recordHttpDuration?: jest.Mock;
+    incrementHttpError?: jest.Mock;
+  };
+}
+
+/**
+ * Create a mock plugin context for unit testing
+ * 
+ * @example
+ * ```typescript
+ * const ctx = createPluginTestContext({
+ *   config: { apiKey: 'test-key' },
+ * });
+ * 
+ * const plugin = new MyPlugin(ctx.config);
+ * await plugin.onInit?.();
+ * 
+ * expect(ctx.logger.log).toHaveBeenCalledWith('Plugin initialized');
+ * ```
+ */
+export function createPluginTestContext(
+  overrides?: Partial<MockPluginContext>
+): MockPluginContext {
+  return {
+    config: {},
+    logger: {
+      log: jest.fn(),
+      warn: jest.fn(),
+      error: jest.fn(),
+      debug: jest.fn(),
+    },
+    metrics: {
+      incrementHttpRequest: jest.fn(),
+      recordHttpDuration: jest.fn(),
+      incrementHttpError: jest.fn(),
+    },
+    ...overrides,
+  };
+}
+
+/**
+ * Helper to test plugin lifecycle
+ */
+export interface PluginLifecycleTestResult {
+  initCalled: boolean;
+  destroyCalled: boolean;
+  unRegisterCalled: boolean;
+  initError?: Error;
+  destroyError?: Error;
+  unRegisterError?: Error;
+  executionOrder: string[];
+}
+
+/**
+ * Test a plugin's complete lifecycle
+ * 
+ * @param plugin - The plugin instance to test
+ * @returns Test result with lifecycle information
+ * 
+ * @example
+ * ```typescript
+ * const plugin = new MyPlugin();
+ * const result = await testPluginLifecycle(plugin);
+ * 
+ * expect(result.initCalled).toBe(true);
+ * expect(result.destroyCalled).toBe(true);
+ * expect(result.executionOrder).toEqual(['onInit', 'onDestroy']);
+ * ```
+ */
+export async function testPluginLifecycle(
+  plugin: IPlugin
+): Promise<PluginLifecycleTestResult> {
+  const result: PluginLifecycleTestResult = {
+    initCalled: false,
+    destroyCalled: false,
+    unRegisterCalled: false,
+    executionOrder: [],
+  };
+
+  // Test onInit
+  try {
+    if (plugin.onInit) {
+      await plugin.onInit();
+      result.initCalled = true;
+      result.executionOrder.push('onInit');
+    }
+  } catch (error) {
+    result.initError = error instanceof Error ? error : new Error(String(error));
+  }
+
+  // Test onDestroy
+  try {
+    if (plugin.onDestroy) {
+      await plugin.onDestroy();
+      result.destroyCalled = true;
+      result.executionOrder.push('onDestroy');
+    }
+  } catch (error) {
+    result.destroyError = error instanceof Error ? error : new Error(String(error));
+  }
+
+  // Test onUnregister
+  try {
+    if (plugin.onUnregister) {
+      await plugin.onUnregister();
+      result.unRegisterCalled = true;
+      result.executionOrder.push('onUnregister');
+    }
+  } catch (error) {
+    result.unRegisterError = error instanceof Error ? error : new Error(String(error));
+  }
+
+  return result;
+}
+
+/**
+ * Create a mock plugin for testing plugin manager
+ */
+export interface MockPluginOptions {
+  name?: string;
+  version?: string;
+  onInit?: jest.Mock;
+  onDestroy?: jest.Mock;
+  onUnregister?: jest.Mock;
+  dependencies?: string[];
+  priority?: number;
+}
+
+/**
+ * Create a mock plugin instance for testing
+ */
+export function createMockPlugin(options: MockPluginOptions = {}): IPlugin {
+  const mockPlugin: IPlugin = {
+    name: options.name || 'MockPlugin',
+    version: options.version || '1.0.0',
+    dependencies: options.dependencies,
+    priority: options.priority as any,
+  };
+
+  if (options.onInit) {
+    mockPlugin.onInit = options.onInit;
+  }
+
+  if (options.onDestroy) {
+    mockPlugin.onDestroy = options.onDestroy;
+  }
+
+  if (options.onUnregister) {
+    mockPlugin.onUnregister = options.onUnregister;
+  }
+
+  return mockPlugin;
+}
diff --git a/middleware/src/common/plugin.interface.ts b/middleware/src/common/plugin.interface.ts
new file mode 100644
index 00000000..da42e568
--- /dev/null
+++ b/middleware/src/common/plugin.interface.ts
@@ -0,0 +1,40 @@
+/**
+ * Plugin lifecycle interface for defining initialization and destruction order
+ */
+export enum PluginPriority {
+  CRITICAL = 0,    // Core plugins that must initialize first
+  HIGH = 1,        // Important plugins
+  NORMAL = 2,      // Standard plugins
+  LOW = 3,         // Optional plugins that can wait
+}
+
+export interface IPlugin {
+  /** Unique identifier for the plugin */
+  readonly name: string;
+  
+  /** Version of the plugin */
+  readonly version: string;
+  
+  /** Priority level determining initialization order */
+  readonly priority?: PluginPriority;
+  
+  /** Dependencies that must be initialized before this plugin */
+  readonly dependencies?: string[];
+  
+  /** Initialize the plugin - called in registration order */
+  onInit?(): Promise<void>;
+  
+  /** Destroy the plugin - called in reverse registration order */
+  onDestroy?(): Promise<void>;
+  
+  /** Called when plugin is about to be unregistered */
+  onUnregister?(): Promise<void>;
+}
+
+export interface PluginRegistration {
+  plugin: IPlugin;
+  registeredAt: number;
+  initialized: boolean;
+  destroyed: boolean;
+  error?: Error;
+}
diff --git a/middleware/src/common/plugin.manager.ts b/middleware/src/common/plugin.manager.ts
new file mode 100644
index 00000000..322fdcfb
--- /dev/null
+++ b/middleware/src/common/plugin.manager.ts
@@ -0,0 +1,304 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { IPlugin, PluginPriority, PluginRegistration } from './plugin.interface';
+
+/**
+ * PluginManager handles the lifecycle of plugins ensuring correct initialization
+ * and destruction order based on priority and dependencies.
+ * 
+ * Features:
+ * - onInit() called in registration order (by priority)
+ * - onDestroy() called in reverse registration order
+ * - Dependency validation to prevent circular dependencies
+ * - Error handling for plugin lifecycle methods
+ */
+@Injectable()
+export class PluginManager {
+  private readonly logger = new Logger(PluginManager.name);
+  private readonly plugins: Map<string, PluginRegistration> = new Map();
+  private initializationOrder: string[] = [];
+  
+  /**
+   * Register a plugin with the manager
+   * @param plugin - The plugin to register
+   * @throws Error if plugin name already exists or circular dependency detected
+   */
+  async register(plugin: IPlugin): Promise<void> {
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Plugin "${plugin.name}" is already registered`);
+    }
+    
+    // Validate dependencies exist and no circular dependencies
+    this.validateDependencies(plugin);
+    
+    const registration: PluginRegistration = {
+      plugin,
+      registeredAt: Date.now(),
+      initialized: false,
+      destroyed: false,
+    };
+    
+    this.plugins.set(plugin.name, registration);
+    this.logger.log(`Plugin "${plugin.name}" v${plugin.version} registered`);
+    
+    // Initialize immediately if manager is already initialized
+    if (this.initializationOrder.length > 0) {
+      await this.initializePlugin(registration);
+    }
+  }
+  
+  /**
+   * Unregister a plugin, destroying it first if initialized
+   * @param pluginName - Name of the plugin to unregister
+   */
+  async unregister(pluginName: string): Promise<void> {
+    const registration = this.plugins.get(pluginName);
+    if (!registration) {
+      this.logger.warn(`Plugin "${pluginName}" not found, skipping unregister`);
+      return;
+    }
+    
+    try {
+      // Destroy if initialized
+      if (registration.initialized && !registration.destroyed) {
+        await this.destroyPlugin(registration);
+      }
+      
+      // Call onUnregister if defined
+      if (registration.plugin.onUnregister) {
+        await registration.plugin.onUnregister();
+      }
+      
+      this.plugins.delete(pluginName);
+      this.initializationOrder = this.initializationOrder.filter(name => name !== pluginName);
+      this.logger.log(`Plugin "${pluginName}" unregistered`);
+    } catch (error) {
+      this.logger.error(
+        `Error unregistering plugin "${pluginName}": ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  
+  /**
+   * Initialize all registered plugins in the correct order
+   * Order: by priority (CRITICAL → HIGH → NORMAL → LOW), then by registration time
+   */
+  async initializeAll(): Promise<void> {
+    this.logger.log('Initializing all plugins...');
+    
+    // Sort plugins by priority and registration order
+    const sortedPlugins = Array.from(this.plugins.values()).sort((a, b) => {
+      const priorityA = a.plugin.priority ?? PluginPriority.NORMAL;
+      const priorityB = b.plugin.priority ?? PluginPriority.NORMAL;
+      
+      if (priorityA !== priorityB) {
+        return priorityA - priorityB;
+      }
+      
+      // Same priority: use registration order
+      return a.registeredAt - b.registeredAt;
+    });
+    
+    // Initialize each plugin in order
+    for (const registration of sortedPlugins) {
+      if (!registration.initialized && !registration.destroyed) {
+        await this.initializePlugin(registration);
+      }
+    }
+    
+    this.logger.log(`Successfully initialized ${this.initializationOrder.length} plugins`);
+  }
+  
+  /**
+   * Destroy all plugins in reverse order
+   */
+  async destroyAll(): Promise<void> {
+    this.logger.log('Destroying all plugins in reverse order...');
+    
+    // Destroy in reverse initialization order
+    for (let i = this.initializationOrder.length - 1; i >= 0; i--) {
+      const pluginName = this.initializationOrder[i];
+      const registration = this.plugins.get(pluginName);
+      
+      if (registration && registration.initialized && !registration.destroyed) {
+        await this.destroyPlugin(registration);
+      }
+    }
+    
+    this.logger.log('All plugins destroyed');
+  }
+  
+  /**
+   * Get a plugin by name
+   */
+  getPlugin<T extends IPlugin>(name: string): T | undefined {
+    const registration = this.plugins.get(name);
+    return registration?.plugin as T;
+  }
+  
+  /**
+   * Check if a plugin is registered
+   */
+  hasPlugin(name: string): boolean {
+    return this.plugins.has(name);
+  }
+  
+  /**
+   * Get all registered plugins
+   */
+  getAllPlugins(): IPlugin[] {
+    return Array.from(this.plugins.values()).map(reg => reg.plugin);
+  }
+  
+  /**
+   * Get initialization status
+   */
+  getInitializationStatus(): { initialized: string[]; pending: string[]; failed: string[] } {
+    const initialized: string[] = [];
+    const pending: string[] = [];
+    const failed: string[] = [];
+    
+    for (const [name, registration] of this.plugins) {
+      if (registration.error) {
+        failed.push(name);
+      } else if (registration.initialized) {
+        initialized.push(name);
+      } else {
+        pending.push(name);
+      }
+    }
+    
+    return { initialized, pending, failed };
+  }
+  
+  /**
+   * Validate that dependencies don't create circular references
+   */
+  private validateDependencies(plugin: IPlugin): void {
+    if (!plugin.dependencies || plugin.dependencies.length === 0) {
+      return;
+    }
+    
+    // Check if all dependencies are registered
+    for (const depName of plugin.dependencies) {
+      if (!this.plugins.has(depName)) {
+        this.logger.warn(
+          `Plugin "${plugin.name}" depends on "${depName}" which is not yet registered. ` +
+          'Ensure it is registered before this plugin.'
+        );
+      }
+    }
+    
+    // Check for circular dependencies using DFS
+    const visited = new Set<string>();
+    const recursionStack = new Set<string>();
+    
+    const hasCycle = (currentName: string): boolean => {
+      if (recursionStack.has(currentName)) {
+        return true;
+      }
+      
+      if (visited.has(currentName)) {
+        return false;
+      }
+      
+      visited.add(currentName);
+      recursionStack.add(currentName);
+      
+      const currentReg = this.plugins.get(currentName);
+      if (currentReg && currentReg.plugin.dependencies) {
+        for (const dep of currentReg.plugin.dependencies) {
+          if (hasCycle(dep)) {
+            return true;
+          }
+        }
+      }
+      
+      recursionStack.delete(currentName);
+      return false;
+    };
+    
+    // Temporarily add current plugin to check for cycles
+    this.plugins.set(plugin.name, {
+      plugin,
+      registeredAt: Date.now(),
+      initialized: false,
+      destroyed: false,
+    });
+    
+    if (hasCycle(plugin.name)) {
+      this.plugins.delete(plugin.name);
+      throw new Error(
+        `Circular dependency detected involving plugin "${plugin.name}". ` +
+        `Dependencies: ${plugin.dependencies.join(', ')}`
+      );
+    }
+    
+    this.plugins.delete(plugin.name);
+  }
+  
+  /**
+   * Initialize a single plugin with error handling
+   */
+  private async initializePlugin(registration: PluginRegistration): Promise<void> {
+    const { plugin } = registration;
+    
+    try {
+      this.logger.log(`Initializing plugin "${plugin.name}"...`);
+      
+      // Initialize dependencies first
+      if (plugin.dependencies) {
+        for (const depName of plugin.dependencies) {
+          const depReg = this.plugins.get(depName);
+          if (depReg && !depReg.initialized && !depReg.destroyed) {
+            this.logger.log(
+              `Initializing dependency "${depName}" before "${plugin.name}"`
+            );
+            await this.initializePlugin(depReg);
+          }
+        }
+      }
+      
+      // Call onInit if defined
+      if (plugin.onInit) {
+        await plugin.onInit();
+      }
+      
+      registration.initialized = true;
+      this.initializationOrder.push(plugin.name);
+      this.logger.log(`Plugin "${plugin.name}" initialized successfully`);
+    } catch (error) {
+      registration.error = error instanceof Error ? error : new Error(String(error));
+      this.logger.error(
+        `Failed to initialize plugin "${plugin.name}": ${registration.error.message}`
+      );
+      throw registration.error;
+    }
+  }
+  
+  /**
+   * Destroy a single plugin with error handling
+   */
+  private async destroyPlugin(registration: PluginRegistration): Promise<void> {
+    const { plugin } = registration;
+    
+    try {
+      this.logger.log(`Destroying plugin "${plugin.name}"...`);
+      
+      if (plugin.onDestroy) {
+        await plugin.onDestroy();
+      }
+      
+      registration.destroyed = true;
+      this.initializationOrder = this.initializationOrder.filter(
+        name => name !== plugin.name
+      );
+      this.logger.log(`Plugin "${plugin.name}" destroyed successfully`);
+    } catch (error) {
+      this.logger.error(
+        `Failed to destroy plugin "${plugin.name}": ${error instanceof Error ? error.message : String(error)}`
+      );
+      // Don't throw on destroy errors - continue with other plugins
+    }
+  }
+}
diff --git a/middleware/src/monitoring/index.ts b/middleware/src/monitoring/index.ts
index 3c90977c..4323b0b2 100644
--- a/middleware/src/monitoring/index.ts
+++ b/middleware/src/monitoring/index.ts
@@ -4,3 +4,5 @@ export * from './correlation-logger.service';
 export * from './correlation.module';
 export * from './correlation-exception-filter';
 export * from './correlation-propagation.utils';
+export * from './prometheus.plugin';
+export * from './metrics.middleware';
diff --git a/middleware/src/monitoring/metrics.middleware.ts b/middleware/src/monitoring/metrics.middleware.ts
new file mode 100644
index 00000000..ae08f1a4
--- /dev/null
+++ b/middleware/src/monitoring/metrics.middleware.ts
@@ -0,0 +1,50 @@
+import { Injectable } from '@nestjs/common';
+import { PrometheusMetricsPlugin } from './prometheus.plugin';
+
+/**
+ * Express middleware that integrates Prometheus metrics collection
+ * 
+ * Usage:
+ * ```ts
+ * const metricsPlugin = new PrometheusMetricsPlugin();
+ * await metricsPlugin.onInit();
+ * 
+ * // Use in Express app
+ * app.use(metricsPlugin.createMiddleware());
+ * 
+ * // Or register /metrics endpoint
+ * app.get('/metrics', metricsPlugin.createMetricsMiddleware());
+ * ```
+ */
+@Injectable()
+export class MetricsMiddleware {
+  constructor(private readonly plugin: PrometheusMetricsPlugin) {}
+  
+  /**
+   * Get the full metrics tracking middleware
+   */
+  use(routeOverride?: string) {
+    return this.plugin.createMiddleware(routeOverride);
+  }
+  
+  /**
+   * Get just the timing middleware
+   */
+  timing(routeOverride?: string) {
+    return this.plugin.createTimingMiddleware(routeOverride);
+  }
+  
+  /**
+   * Get just the request tracking middleware
+   */
+  tracking(routeOverride?: string) {
+    return this.plugin.createRequestTrackingMiddleware(routeOverride);
+  }
+  
+  /**
+   * Get the /metrics endpoint handler
+   */
+  endpoint() {
+    return this.plugin.createMetricsMiddleware();
+  }
+}
diff --git a/middleware/src/monitoring/prometheus.plugin.ts b/middleware/src/monitoring/prometheus.plugin.ts
new file mode 100644
index 00000000..0a065638
--- /dev/null
+++ b/middleware/src/monitoring/prometheus.plugin.ts
@@ -0,0 +1,276 @@
+import { Injectable, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
+import * as client from 'prom-client';
+import { IPlugin, PluginPriority } from '../common/plugin.interface';
+
+export interface MetricsPluginConfig {
+  /** Enable default metrics (CPU, memory, etc.) */
+  enableDefaultMetrics?: boolean;
+  
+  /** Enable HTTP request duration histogram */
+  enableHttpDuration?: boolean;
+  
+  /** Enable HTTP request counter */
+  enableHttpRequests?: boolean;
+  
+  /** Enable HTTP error counter */
+  enableHttpErrors?: boolean;
+  
+  /** API key for /metrics endpoint protection */
+  metricsApiKey?: string;
+  
+  /** Custom labels to add to all metrics */
+  customLabels?: Record<string, string>;
+}
+
+/**
+ * PrometheusMetricsPlugin provides comprehensive metrics collection and exposition
+ * 
+ * Features:
+ * - Three standard Prometheus metrics:
+ *   1. http_requests_total (counter) - Total HTTP requests by method/route/status
+ *   2. http_request_duration_seconds (histogram) - Request duration with p50/p95/p99
+ *   3. http_errors_total (counter) - Total errors by type
+ * - Optional /metrics endpoint within plugin
+ * - Optional API key protection via METRICS_API_KEY env var
+ * - Default Node.js metrics (CPU, memory, event loop lag)
+ * - Custom labels support
+ * - Low overhead (< 0.5ms per request)
+ */
+@Injectable()
+export class PrometheusMetricsPlugin implements IPlugin, OnModuleInit, OnModuleDestroy {
+  readonly name = 'prometheus-metrics';
+  readonly version = '1.0.0';
+  readonly priority = PluginPriority.HIGH;
+  
+  private register: client.Registry;
+  private httpRequestCounter?: client.Counter<string>;
+  private httpDurationHistogram?: client.Histogram<string>;
+  private httpErrorCounter?: client.Counter<string>;
+  private config: MetricsPluginConfig;
+  private metricsEndpointRegistered = false;
+  
+  constructor(config: MetricsPluginConfig = {}) {
+    this.config = {
+      enableDefaultMetrics: true,
+      enableHttpDuration: true,
+      enableHttpRequests: true,
+      enableHttpErrors: true,
+      metricsApiKey: process.env.METRICS_API_KEY,
+      ...config,
+    };
+    
+    this.register = new client.Registry();
+  }
+  
+  async onInit(): Promise<void> {
+    // Add custom labels if provided
+    if (this.config.customLabels) {
+      Object.entries(this.config.customLabels).forEach(([key, value]) => {
+        this.register.setDefaultLabels({ [key]: value });
+      });
+    }
+    
+    // Enable default metrics
+    if (this.config.enableDefaultMetrics) {
+      client.collectDefaultMetrics({ register: this.register });
+    }
+    
+    // Create HTTP request counter
+    if (this.config.enableHttpRequests) {
+      this.httpRequestCounter = new client.Counter({
+        name: 'http_requests_total',
+        help: 'Total number of HTTP requests',
+        labelNames: ['method', 'route', 'status'],
+        registers: [this.register],
+      });
+    }
+    
+    // Create HTTP duration histogram
+    if (this.config.enableHttpDuration) {
+      this.httpDurationHistogram = new client.Histogram({
+        name: 'http_request_duration_seconds',
+        help: 'HTTP request duration in seconds',
+        labelNames: ['method', 'route'],
+        buckets: [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10], // p50/p95/p99 optimized
+        registers: [this.register],
+      });
+    }
+    
+    // Create HTTP error counter
+    if (this.config.enableHttpErrors) {
+      this.httpErrorCounter = new client.Counter({
+        name: 'http_errors_total',
+        help: 'Total number of HTTP errors',
+        labelNames: ['method', 'route', 'error_type'],
+        registers: [this.register],
+      });
+    }
+    
+    console.log(`[${this.name}] Plugin initialized`);
+  }
+  
+  async onDestroy(): Promise<void> {
+    try {
+      await this.register.clear();
+      console.log(`[${this.name}] Plugin destroyed, metrics cleared`);
+    } catch (error) {
+      console.error(`[${this.name}] Error during cleanup:`, error);
+    }
+  }
+  
+  /**
+   * Get the metrics registry for use in middleware
+   */
+  getRegistry(): client.Registry {
+    return this.register;
+  }
+  
+  /**
+   * Increment HTTP request counter
+   */
+  incrementHttpRequest(method: string, route: string, status: number): void {
+    if (this.httpRequestCounter) {
+      this.httpRequestCounter.inc({ method, route, status });
+    }
+  }
+  
+  /**
+   * Record HTTP request duration
+   */
+  recordHttpDuration(method: string, route: string, durationSeconds: number): void {
+    if (this.httpDurationHistogram) {
+      this.httpDurationHistogram.observe({ method, route }, durationSeconds);
+    }
+  }
+  
+  /**
+   * Increment HTTP error counter
+   */
+  incrementHttpError(method: string, route: string, errorType: string): void {
+    if (this.httpErrorCounter) {
+      this.httpErrorCounter.inc({ method, route, errorType });
+    }
+  }
+  
+  /**
+   * Get metrics in Prometheus exposition format
+   */
+  async getMetrics(): Promise<string> {
+    return await this.register.metrics();
+  }
+  
+  /**
+   * Create Express middleware for the /metrics endpoint
+   */
+  createMetricsMiddleware(): (req: any, res: any, next: any) => void {
+    const apiKey = this.config.metricsApiKey;
+    
+    return (req: any, res: any, next: any) => {
+      // Check if this is the /metrics endpoint
+      if (req.path !== '/metrics') {
+        return next();
+      }
+      
+      // Only handle GET requests
+      if (req.method !== 'GET') {
+        return next();
+      }
+      
+      // Check API key if configured
+      if (apiKey) {
+        const authHeader = req.headers.authorization;
+        if (!authHeader || !authHeader.startsWith('Bearer ')) {
+          return res.status(401).json({ error: 'Unauthorized' });
+        }
+        
+        const token = authHeader.substring(7);
+        if (token !== apiKey) {
+          return res.status(403).json({ error: 'Forbidden' });
+        }
+      }
+      
+      // Return metrics
+      this.register.metrics()
+        .then((metrics: string) => {
+          res.set('Content-Type', this.register.contentType);
+          res.send(metrics);
+        })
+        .catch((err: Error) => {
+          res.status(500).json({ error: 'Failed to retrieve metrics' });
+        });
+    };
+  }
+  
+  /**
+   * Create timing middleware wrapper for measuring request duration
+   */
+  createTimingMiddleware(routeOverride?: string): (req: any, res: any, next: any) => void {
+    return (req: any, res: any, next: any) => {
+      if (!this.httpDurationHistogram) {
+        return next();
+      }
+      
+      const startTime = Date.now();
+      const method = req.method;
+      
+      // Track response finish
+      res.on('finish', () => {
+        const duration = (Date.now() - startTime) / 1000; // Convert to seconds
+        const route = routeOverride || req.route?.path || req.path || 'unknown';
+        this.recordHttpDuration(method, route, duration);
+      });
+      
+      next();
+    };
+  }
+  
+  /**
+   * Create request tracking middleware
+   */
+  createRequestTrackingMiddleware(routeOverride?: string): (req: any, res: any, next: any) => void {
+    return (req: any, res: any, next: any) => {
+      if (!this.httpRequestCounter) {
+        return next();
+      }
+      
+      const method = req.method;
+      const route = routeOverride || req.route?.path || req.path || 'unknown';
+      
+      // Track response finish to get status code
+      res.on('finish', () => {
+        const status = res.statusCode;
+        this.incrementHttpRequest(method, route, status);
+        
+        // Track 4xx and 5xx as errors
+        if (status >= 400) {
+          const errorType = status >= 500 ? 'server_error' : 'client_error';
+          this.incrementHttpError(method, route, errorType);
+        }
+      });
+      
+      next();
+    };
+  }
+  
+  /**
+   * Get a complete middleware factory that combines all tracking
+   */
+  createMiddleware(routeOverride?: string): (req: any, res: any, next: any) => void {
+    const timingMiddleware = this.createTimingMiddleware(routeOverride);
+    const trackingMiddleware = this.createRequestTrackingMiddleware(routeOverride);
+    
+    return (req: any, res: any, next: any) => {
+      timingMiddleware(req, res, () => {
+        trackingMiddleware(req, res, next);
+      });
+    };
+  }
+  
+  onModuleInit(): void {
+    this.onInit();
+  }
+  
+  onModuleDestroy(): void {
+    this.onDestroy();
+  }
+}
diff --git a/middleware/src/plugins/metrics/grafana-dashboard.json b/middleware/src/plugins/metrics/grafana-dashboard.json
new file mode 100644
index 00000000..b06c7a7c
--- /dev/null
+++ b/middleware/src/plugins/metrics/grafana-dashboard.json
@@ -0,0 +1,400 @@
+{
+  "annotations": {
+    "list": []
+  },
+  "editable": true,
+  "fiscalYearStartMonth": 0,
+  "graphTooltip": 0,
+  "id": null,
+  "links": [],
+  "liveNow": false,
+  "panels": [
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_PROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "never",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          },
+          "unit": "reqps"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 0
+      },
+      "id": 1,
+      "options": {
+        "legend": {
+          "calcs": ["mean", "max"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "desc"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "expr": "rate(http_requests_total[5m])",
+          "legendFormat": "{{method}} {{route}} {{status}}",
+          "refId": "A"
+        }
+      ],
+      "title": "HTTP Request Rate",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_PROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "never",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          },
+          "unit": "s"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 0
+      },
+      "id": 2,
+      "options": {
+        "legend": {
+          "calcs": ["mean", "max"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "desc"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "expr": "histogram_quantile(0.50, rate(http_request_duration_seconds_bucket[5m]))",
+          "legendFormat": "p50",
+          "refId": "A"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "expr": "histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))",
+          "legendFormat": "p95",
+          "refId": "B"
+        },
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "expr": "histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m]))",
+          "legendFormat": "p99",
+          "refId": "C"
+        }
+      ],
+      "title": "HTTP Request Duration (Percentiles)",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_PROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "palette-classic"
+          },
+          "custom": {
+            "axisCenteredZero": false,
+            "axisColorMode": "text",
+            "axisLabel": "",
+            "axisPlacement": "auto",
+            "barAlignment": 0,
+            "drawStyle": "line",
+            "fillOpacity": 10,
+            "gradientMode": "none",
+            "hideFrom": {
+              "legend": false,
+              "tooltip": false,
+              "viz": false
+            },
+            "lineInterpolation": "linear",
+            "lineWidth": 1,
+            "pointSize": 5,
+            "scaleDistribution": {
+              "type": "linear"
+            },
+            "showPoints": "never",
+            "spanNulls": false,
+            "stacking": {
+              "group": "A",
+              "mode": "none"
+            },
+            "thresholdsStyle": {
+              "mode": "off"
+            }
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "red",
+                "value": 80
+              }
+            ]
+          },
+          "unit": "reqps"
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 8
+      },
+      "id": 3,
+      "options": {
+        "legend": {
+          "calcs": ["mean", "max"],
+          "displayMode": "table",
+          "placement": "bottom",
+          "showLegend": true
+        },
+        "tooltip": {
+          "mode": "multi",
+          "sort": "desc"
+        }
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "expr": "rate(http_errors_total[5m])",
+          "legendFormat": "{{method}} {{route}} {{error_type}}",
+          "refId": "A"
+        }
+      ],
+      "title": "HTTP Error Rate",
+      "type": "timeseries"
+    },
+    {
+      "datasource": {
+        "type": "prometheus",
+        "uid": "${DS_PROMETHEUS}"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "color": {
+            "mode": "thresholds"
+          },
+          "mappings": [],
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "yellow",
+                "value": 1
+              },
+              {
+                "color": "red",
+                "value": 10
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 8
+      },
+      "id": 4,
+      "options": {
+        "colorMode": "value",
+        "graphMode": "area",
+        "justifyMode": "auto",
+        "orientation": "auto",
+        "reduceOptions": {
+          "calcs": ["lastNotNull"],
+          "fields": "",
+          "values": false
+        },
+        "textMode": "auto"
+      },
+      "targets": [
+        {
+          "datasource": {
+            "type": "prometheus",
+            "uid": "${DS_PROMETHEUS}"
+          },
+          "expr": "sum(rate(http_errors_total[5m]))",
+          "legendFormat": "Total Errors/sec",
+          "refId": "A"
+        }
+      ],
+      "title": "Current Error Rate",
+      "type": "stat"
+    }
+  ],
+  "refresh": "5s",
+  "schemaVersion": 38,
+  "style": "dark",
+  "tags": ["mindblock", "http", "middleware"],
+  "templating": {
+    "list": [
+      {
+        "current": {},
+        "hide": 0,
+        "includeAll": false,
+        "label": "Prometheus",
+        "multi": false,
+        "name": "DS_PROMETHEUS",
+        "options": [],
+        "query": "prometheus",
+        "refresh": 1,
+        "regex": "",
+        "skipUrlSync": false,
+        "type": "datasource"
+      }
+    ]
+  },
+  "time": {
+    "from": "now-1h",
+    "to": "now"
+  },
+  "timepicker": {},
+  "timezone": "browser",
+  "title": "MindBlock Middleware Metrics",
+  "uid": "mindblock-middleware",
+  "version": 1,
+  "weekStart": ""
+}
diff --git a/middleware/tests/README.md b/middleware/tests/README.md
new file mode 100644
index 00000000..cdc42a6c
--- /dev/null
+++ b/middleware/tests/README.md
@@ -0,0 +1,412 @@
+# Middleware Testing Guide
+
+This document explains the testing structure, utilities, and best practices for the MindBlock middleware package.
+
+## Table of Contents
+
+- [Test Tiers](#test-tiers)
+- [Running Tests](#running-tests)
+- [Test Utilities](#test-utilities)
+- [Writing Tests](#writing-tests)
+- [Best Practices](#best-practices)
+
+## Test Tiers
+
+We use three tiers of testing to ensure comprehensive coverage at different levels:
+
+### Unit Tests (`tests/unit/`)
+
+**Purpose**: Test individual components in isolation
+
+**Configuration**: `jest.unit.config.ts`
+
+**Coverage Thresholds**:
+- Branches: 80%
+- Functions: 80%
+- Lines: 80%
+- Statements: 80%
+
+**When to use**: 
+- Testing pure functions
+- Testing class methods with mocked dependencies
+- Testing middleware logic without full NestJS app
+
+**Example**:
+```typescript
+import { PluginManager } from '../../../src/common/plugin.manager';
+
+describe('PluginManager', () => {
+  it('should register a plugin successfully', () => {
+    const manager = new PluginManager();
+    expect(manager.hasPlugin('TestPlugin')).toBe(false);
+  });
+});
+```
+
+### Integration Tests (`tests/integration/`)
+
+**Purpose**: Test interactions between multiple components
+
+**Configuration**: `jest.integration.config.ts`
+
+**Coverage Thresholds**:
+- Branches: 70%
+- Functions: 70%
+- Lines: 70%
+- Statements: 70%
+
+**Timeout**: 10 seconds
+
+**When to use**:
+- Testing middleware chains
+- Testing services with their dependencies
+- Testing plugin lifecycle with PluginManager
+
+**Example**:
+```typescript
+import { createTestApp } from '../utils/create-test-app';
+import { MetricsMiddleware } from '../../src/monitoring/metrics.middleware';
+
+describe('MetricsMiddleware Integration', () => {
+  it('should track requests across middleware chain', async () => {
+    const app = await createTestApp({
+      middlewares: [MetricsMiddleware],
+    });
+    
+    await app.init();
+    // ... test integration
+    await app.close();
+  });
+});
+```
+
+### E2E Tests (`tests/e2e/`)
+
+**Purpose**: Test complete application flows
+
+**Configuration**: `jest.e2e.config.ts`
+
+**Coverage Thresholds**:
+- Branches: 60%
+- Functions: 60%
+- Lines: 60%
+- Statements: 60%
+
+**Timeout**: 30 seconds
+
+**When to use**:
+- Testing full HTTP request/response cycles
+- Testing multiple middleware working together
+- Testing real-world scenarios
+
+**Example**:
+```typescript
+import { createTestApp, createTestRequest } from '../utils';
+import { PrometheusMetricsPlugin } from '../../src/monitoring/prometheus.plugin';
+
+describe('Prometheus Metrics E2E', () => {
+  it('should expose /metrics endpoint with valid format', async () => {
+    const plugin = new PrometheusMetricsPlugin();
+    await plugin.onInit();
+    
+    const app = await createTestApp({
+      providers: [plugin],
+    });
+    
+    await app.init();
+    const request = createTestRequest(app);
+    
+    await request.get('/metrics')
+      .expect(200)
+      .expect('Content-Type', /text\/plain/);
+    
+    await app.close();
+  });
+});
+```
+
+## Running Tests
+
+### Run all tests
+```bash
+npm test
+```
+
+### Run specific test tier
+```bash
+npm run test:unit           # Unit tests only
+npm run test:integration    # Integration tests only
+npm run test:e2e           # E2E tests only
+```
+
+### Run with coverage
+```bash
+npm run test:cov            # All tests with coverage
+npm run test:unit:cov       # Unit tests with coverage
+npm run test:integration:cov # Integration tests with coverage
+npm run test:e2e:cov        # E2E tests with coverage
+```
+
+### Watch mode
+```bash
+npm run test:watch
+```
+
+## Test Utilities
+
+### Mock Factories
+
+Located in `tests/utils/mock-express.ts`
+
+#### `mockRequest(overrides?)`
+Create a typed mock Express request object.
+
+```typescript
+import { mockRequest } from '../utils';
+
+const req = mockRequest({
+  method: 'POST',
+  path: '/api/users',
+  body: { name: 'John' },
+});
+```
+
+#### `mockResponse(overrides?)`
+Create a typed mock Express response object.
+
+```typescript
+import { mockResponse } from '../utils';
+
+const res = mockResponse();
+res.status.mockReturnValue(res); // Chainable
+
+// Check if status was called
+expect(res.status).toHaveBeenCalledWith(200);
+```
+
+#### `mockNext()`
+Create a typed mock next function.
+
+```typescript
+import { mockNext } from '../utils';
+
+const next = mockNext();
+middleware(req, res, next);
+expect(next).toHaveBeenCalled();
+```
+
+#### `createMiddlewareTestContext(overrides?)`
+Create complete test context for middleware testing.
+
+```typescript
+import { createMiddlewareTestContext } from '../utils';
+
+const { req, res, next } = createMiddlewareTestContext({
+  req: { method: 'POST' },
+  res: { statusCode: 201 },
+});
+```
+
+### Test App Factory
+
+Located in `tests/utils/create-test-app.ts`
+
+#### `createTestApp(options)`
+Create a minimal NestJS test application.
+
+```typescript
+import { createTestApp } from '../utils';
+
+const app = await createTestApp({
+  middlewares: [SomeMiddleware],
+  providers: [SomeService],
+  controllers: [SomeController],
+});
+
+await app.init();
+// ... run tests
+await app.close();
+```
+
+#### `createMockExecutionContext(handler?, type?)`
+Create a mock execution context for testing guards/interceptors.
+
+```typescript
+import { createMockExecutionContext } from '../utils';
+
+const context = createMockExecutionContext(null, 'http');
+guard.canActivate(context);
+```
+
+#### `createTestRequest(app)`
+Create a supertest wrapper for testing HTTP endpoints.
+
+```typescript
+import { createTestApp, createTestRequest } from '../utils';
+
+const app = await createTestApp({ controllers: [MyController] });
+await app.init();
+
+const request = createTestRequest(app);
+await request.get('/users').expect(200);
+
+await app.close();
+```
+
+## Writing Tests
+
+### File Naming Conventions
+
+- Unit tests: `*.test.ts` or `*.spec.ts` in `tests/unit/`
+- Integration tests: `*.test.ts` or `*.spec.ts` in `tests/integration/`
+- E2E tests: `*.test.ts` or `*.spec.ts` in `tests/e2e/`
+
+### Test Structure
+
+```typescript
+describe('ComponentName', () => {
+  let component: ComponentName;
+
+  beforeEach(() => {
+    component = new ComponentName();
+  });
+
+  describe('methodName', () => {
+    it('should do something', async () => {
+      // Arrange
+      const input = 'test';
+
+      // Act
+      const result = await component.methodName(input);
+
+      // Assert
+      expect(result).toBe('expected');
+    });
+
+    it('should handle edge case', async () => {
+      // Test edge cases
+    });
+  });
+});
+```
+
+## Best Practices
+
+### 1. Use Typed Mocks
+Always use our typed mock factories instead of plain objects:
+
+```typescript
+// ✅ Good
+const { req, res, next } = createMiddlewareTestContext();
+
+// ❌ Bad
+const req = { method: 'GET' };
+```
+
+### 2. Test Edge Cases
+Don't just test the happy path:
+
+```typescript
+it('should handle empty input', () => {});
+it('should handle null values', () => {});
+it('should handle malformed data', () => {});
+```
+
+### 3. Keep Tests Isolated
+Each test should be independent:
+
+```typescript
+beforeEach(() => {
+  // Reset state
+});
+
+afterEach(async () => {
+  // Cleanup
+});
+```
+
+### 4. Use Descriptive Test Names
+Test names should describe behavior:
+
+```typescript
+// ✅ Good
+it('should reject duplicate plugin registration', () => {});
+
+// ❌ Bad
+it('test duplicate', () => {});
+```
+
+### 5. Test Async Code Properly
+Always await promises and handle errors:
+
+```typescript
+it('should throw on invalid input', async () => {
+  await expect(component.invalidMethod()).rejects.toThrow('Error message');
+});
+```
+
+### 6. Mock External Dependencies
+Isolate the unit under test:
+
+```typescript
+const mockService = {
+  getData: jest.fn().mockResolvedValue({ id: 1 }),
+};
+```
+
+### 7. Clean Up Resources
+Always close apps and clear mocks:
+
+```typescript
+afterEach(async () => {
+  await app.close();
+  jest.clearAllMocks();
+});
+```
+
+## Debugging Tests
+
+### Run single test file
+```bash
+npx jest tests/unit/specific.test.ts
+```
+
+### Run test by pattern
+```bash
+npx jest -t "should register plugin"
+```
+
+### Debug with verbose output
+```bash
+npx jest --verbose
+```
+
+### Watch specific file
+```bash
+npx jest --watch tests/unit/specific.test.ts
+```
+
+## Coverage Reports
+
+View HTML coverage report:
+```bash
+npm run test:unit:cov
+open coverage/unit/index.html
+```
+
+## Troubleshooting
+
+### Tests running slow
+- Check if you're properly closing apps in `afterEach`
+- Reduce timeouts in integration/E2E tests if possible
+- Mock heavy external dependencies
+
+### Type errors in tests
+- Ensure you're using typed mock factories
+- Import types from correct locations
+- Check that devDependencies are installed
+
+### Coverage not meeting thresholds
+- Run coverage report to see uncovered lines
+- Add tests for edge cases
+- Test error handling paths
diff --git a/middleware/tests/unit/common/plugin.manager.test.ts b/middleware/tests/unit/common/plugin.manager.test.ts
new file mode 100644
index 00000000..43777d4e
--- /dev/null
+++ b/middleware/tests/unit/common/plugin.manager.test.ts
@@ -0,0 +1,348 @@
+import { PluginManager } from '../../../src/common/plugin.manager';
+import { IPlugin, PluginPriority } from '../../../src/common/plugin.interface';
+
+describe('PluginManager', () => {
+  let manager: PluginManager;
+
+  beforeEach(() => {
+    manager = new PluginManager();
+  });
+
+  afterEach(async () => {
+    await manager.destroyAll();
+  });
+
+  describe('registration', () => {
+    it('should register a plugin successfully', async () => {
+      const plugin: IPlugin = {
+        name: 'TestPlugin',
+        version: '1.0.0',
+      };
+
+      await expect(manager.register(plugin)).resolves.not.toThrow();
+      expect(manager.hasPlugin('TestPlugin')).toBe(true);
+    });
+
+    it('should reject duplicate plugin registration', async () => {
+      const plugin: IPlugin = {
+        name: 'DuplicatePlugin',
+        version: '1.0.0',
+      };
+
+      await manager.register(plugin);
+      await expect(manager.register(plugin)).rejects.toThrow(
+        'Plugin "DuplicatePlugin" is already registered'
+      );
+    });
+
+    it('should handle plugins with priority', async () => {
+      const criticalPlugin: IPlugin = {
+        name: 'CriticalPlugin',
+        version: '1.0.0',
+        priority: PluginPriority.CRITICAL,
+      };
+
+      const lowPlugin: IPlugin = {
+        name: 'LowPlugin',
+        version: '1.0.0',
+        priority: PluginPriority.LOW,
+      };
+
+      await manager.register(lowPlugin);
+      await manager.register(criticalPlugin);
+
+      expect(manager.hasPlugin('CriticalPlugin')).toBe(true);
+      expect(manager.hasPlugin('LowPlugin')).toBe(true);
+    });
+  });
+
+  describe('initialization order', () => {
+    it('should initialize plugins in registration order', async () => {
+      const initOrder: string[] = [];
+
+      const plugin1: IPlugin = {
+        name: 'FirstPlugin',
+        version: '1.0.0',
+        onInit: async () => {
+          initOrder.push('FirstPlugin');
+        },
+      };
+
+      const plugin2: IPlugin = {
+        name: 'SecondPlugin',
+        version: '1.0.0',
+        onInit: async () => {
+          initOrder.push('SecondPlugin');
+        },
+      };
+
+      await manager.register(plugin1);
+      await manager.register(plugin2);
+      await manager.initializeAll();
+
+      expect(initOrder).toEqual(['FirstPlugin', 'SecondPlugin']);
+    });
+
+    it('should initialize plugins by priority (CRITICAL first)', async () => {
+      const initOrder: string[] = [];
+
+      const normalPlugin: IPlugin = {
+        name: 'NormalPlugin',
+        version: '1.0.0',
+        priority: PluginPriority.NORMAL,
+        onInit: async () => {
+          initOrder.push('NormalPlugin');
+        },
+      };
+
+      const criticalPlugin: IPlugin = {
+        name: 'CriticalPlugin',
+        version: '1.0.0',
+        priority: PluginPriority.CRITICAL,
+        onInit: async () => {
+          initOrder.push('CriticalPlugin');
+        },
+      };
+
+      const highPlugin: IPlugin = {
+        name: 'HighPlugin',
+        version: '1.0.0',
+        priority: PluginPriority.HIGH,
+        onInit: async () => {
+          initOrder.push('HighPlugin');
+        },
+      };
+
+      await manager.register(normalPlugin);
+      await manager.register(criticalPlugin);
+      await manager.register(highPlugin);
+      await manager.initializeAll();
+
+      expect(initOrder).toEqual(['CriticalPlugin', 'HighPlugin', 'NormalPlugin']);
+    });
+
+    it('should call onDestroy in reverse registration order', async () => {
+      const destroyOrder: string[] = [];
+
+      const plugin1: IPlugin = {
+        name: 'FirstPlugin',
+        version: '1.0.0',
+        onDestroy: async () => {
+          destroyOrder.push('FirstPlugin');
+        },
+      };
+
+      const plugin2: IPlugin = {
+        name: 'SecondPlugin',
+        version: '1.0.0',
+        onDestroy: async () => {
+          destroyOrder.push('SecondPlugin');
+        },
+      };
+
+      await manager.register(plugin1);
+      await manager.register(plugin2);
+      await manager.initializeAll();
+      await manager.destroyAll();
+
+      expect(destroyOrder).toEqual(['SecondPlugin', 'FirstPlugin']);
+    });
+  });
+
+  describe('dependencies', () => {
+    it('should warn about missing dependencies but still register', async () => {
+      const plugin: IPlugin = {
+        name: 'DependentPlugin',
+        version: '1.0.0',
+        dependencies: ['MissingDependency'],
+      };
+
+      await expect(manager.register(plugin)).resolves.not.toThrow();
+      expect(manager.hasPlugin('DependentPlugin')).toBe(true);
+    });
+
+    it('should detect circular dependencies', async () => {
+      const pluginA: IPlugin = {
+        name: 'PluginA',
+        version: '1.0.0',
+        dependencies: ['PluginB'],
+      };
+
+      const pluginB: IPlugin = {
+        name: 'PluginB',
+        version: '1.0.0',
+        dependencies: ['PluginA'],
+      };
+
+      await manager.register(pluginA);
+      await expect(manager.register(pluginB)).rejects.toThrow(
+        'Circular dependency detected'
+      );
+    });
+
+    it('should initialize dependencies before dependent plugin', async () => {
+      const initOrder: string[] = [];
+
+      const dependency: IPlugin = {
+        name: 'Dependency',
+        version: '1.0.0',
+        onInit: async () => {
+          initOrder.push('Dependency');
+        },
+      };
+
+      const dependent: IPlugin = {
+        name: 'Dependent',
+        version: '1.0.0',
+        dependencies: ['Dependency'],
+        onInit: async () => {
+          initOrder.push('Dependent');
+        },
+      };
+
+      await manager.register(dependency);
+      await manager.register(dependent);
+      await manager.initializeAll();
+
+      expect(initOrder).toEqual(['Dependency', 'Dependent']);
+    });
+  });
+
+  describe('lifecycle management', () => {
+    it('should handle initialization errors gracefully', async () => {
+      const failingPlugin: IPlugin = {
+        name: 'FailingPlugin',
+        version: '1.0.0',
+        onInit: async () => {
+          throw new Error('Initialization failed');
+        },
+      };
+
+      await expect(manager.register(failingPlugin)).resolves.not.toThrow();
+      await expect(manager.initializeAll()).rejects.toThrow('Initialization failed');
+
+      const status = manager.getInitializationStatus();
+      expect(status.failed).toContain('FailingPlugin');
+    });
+
+    it('should continue destroying other plugins if one fails', async () => {
+      const destroyOrder: string[] = [];
+
+      const failingPlugin: IPlugin = {
+        name: 'FailingPlugin',
+        version: '1.0.0',
+        onDestroy: async () => {
+          throw new Error('Destroy failed');
+        },
+      };
+
+      const successPlugin: IPlugin = {
+        name: 'SuccessPlugin',
+        version: '1.0.0',
+        onDestroy: async () => {
+          destroyOrder.push('SuccessPlugin');
+        },
+      };
+
+      await manager.register(failingPlugin);
+      await manager.register(successPlugin);
+      await manager.initializeAll();
+
+      await expect(manager.destroyAll()).resolves.not.toThrow();
+      expect(destroyOrder).toContain('SuccessPlugin');
+    });
+
+    it('should unregister a plugin and destroy it if initialized', async () => {
+      let destroyed = false;
+
+      const plugin: IPlugin = {
+        name: 'TemporaryPlugin',
+        version: '1.0.0',
+        onDestroy: async () => {
+          destroyed = true;
+        },
+      };
+
+      await manager.register(plugin);
+      await manager.initializeAll();
+      await manager.unregister('TemporaryPlugin');
+
+      expect(destroyed).toBe(true);
+      expect(manager.hasPlugin('TemporaryPlugin')).toBe(false);
+    });
+
+    it('should call onUnregister when unregistering', async () => {
+      let unregistered = false;
+
+      const plugin: IPlugin = {
+        name: 'CleanupPlugin',
+        version: '1.0.0',
+        onUnregister: async () => {
+          unregistered = true;
+        },
+      };
+
+      await manager.register(plugin);
+      await manager.unregister('CleanupPlugin');
+
+      expect(unregistered).toBe(true);
+    });
+  });
+
+  describe('status and retrieval', () => {
+    it('should return correct initialization status', async () => {
+      const plugin1: IPlugin = {
+        name: 'Plugin1',
+        version: '1.0.0',
+      };
+
+      const plugin2: IPlugin = {
+        name: 'Plugin2',
+        version: '1.0.0',
+        onInit: async () => {
+          throw new Error('Failed');
+        },
+      };
+
+      await manager.register(plugin1);
+      await manager.register(plugin2);
+      await manager.initializeAll().catch(() => {});
+
+      const status = manager.getInitializationStatus();
+      expect(status.initialized).toContain('Plugin1');
+      expect(status.failed).toContain('Plugin2');
+    });
+
+    it('should retrieve plugin by name', async () => {
+      const plugin: IPlugin = {
+        name: 'RetrievablePlugin',
+        version: '2.0.0',
+      };
+
+      await manager.register(plugin);
+      const retrieved = manager.getPlugin<IPlugin>('RetrievablePlugin');
+
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.name).toBe('RetrievablePlugin');
+      expect(retrieved?.version).toBe('2.0.0');
+    });
+
+    it('should return all registered plugins', async () => {
+      const plugins: IPlugin[] = [
+        { name: 'Plugin1', version: '1.0.0' },
+        { name: 'Plugin2', version: '1.0.0' },
+        { name: 'Plugin3', version: '1.0.0' },
+      ];
+
+      for (const plugin of plugins) {
+        await manager.register(plugin);
+      }
+
+      const allPlugins = manager.getAllPlugins();
+      expect(allPlugins).toHaveLength(3);
+      expect(allPlugins.map(p => p.name)).toEqual(
+        expect.arrayContaining(['Plugin1', 'Plugin2', 'Plugin3'])
+      );
+    });
+  });
+});
diff --git a/middleware/tests/utils/create-test-app.ts b/middleware/tests/utils/create-test-app.ts
new file mode 100644
index 00000000..291a3c83
--- /dev/null
+++ b/middleware/tests/utils/create-test-app.ts
@@ -0,0 +1,156 @@
+import { INestApplication, ExecutionContext } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import * as request from 'supertest';
+
+/**
+ * Options for creating a test application
+ */
+export interface CreateTestAppOptions {
+  /** Middleware classes to apply */
+  middlewares?: any[];
+  
+  /** Providers to include */
+  providers?: any[];
+  
+  /** Controllers to include */
+  controllers?: any[];
+  
+  /** Guards to apply */
+  guards?: any[];
+  
+  /** Filters to apply */
+  filters?: any[];
+  
+  /** Interceptors to apply */
+  interceptors?: any[];
+  
+  /** Pipes to apply */
+  pipes?: any[];
+}
+
+/**
+ * Create a minimal NestJS test application with specified middleware
+ * 
+ * @param options - Configuration options for the test app
+ * @returns Promise resolving to the test application
+ * 
+ * @example
+ * ```ts
+ * const app = await createTestApp({
+ *   middlewares: [SomeMiddleware],
+ *   providers: [SomeService],
+ * });
+ * 
+ * await app.init();
+ * // ... run tests
+ * await app.close();
+ * ```
+ */
+export async function createTestApp(
+  options: CreateTestAppOptions = {}
+): Promise<INestApplication> {
+  const {
+    middlewares = [],
+    providers = [],
+    controllers = [],
+    guards = [],
+    filters = [],
+    interceptors = [],
+    pipes = [],
+  } = options;
+
+  // Create testing module
+  const moduleFixture: TestingModule = await Test.createTestingModule({
+    controllers,
+    providers: [
+      ...providers,
+      // Add common testing utilities if needed
+    ],
+  }).compile();
+
+  const app = moduleFixture.createNestApplication();
+
+  // Apply global middleware
+  if (middlewares.length > 0) {
+    middlewares.forEach(middleware => {
+      app.use(middleware);
+    });
+  }
+
+  // Apply global guards
+  if (guards.length > 0) {
+    app.useGlobalGuards(...guards);
+  }
+
+  // Apply global filters
+  if (filters.length > 0) {
+    app.useGlobalFilters(...filters);
+  }
+
+  // Apply global interceptors
+  if (interceptors.length > 0) {
+    app.useGlobalInterceptors(...interceptors);
+  }
+
+  // Apply global pipes
+  if (pipes.length > 0) {
+    app.useGlobalPipes(...pipes);
+  }
+
+  return app;
+}
+
+/**
+ * Create a mock execution context for testing guards/interceptors
+ */
+export function createMockExecutionContext(
+  handler?: any,
+  type: string = 'http'
+): ExecutionContext {
+  return {
+    getType: () => type as any,
+    getClass: () => class {},
+    getHandler: () => handler || (() => {}),
+    getArgs: () => [],
+    getArgByIndex: () => null,
+    switchToRpc: () => ({
+      getContext: () => null,
+      getData: () => null,
+    }),
+    switchToHttp: () => ({
+      getRequest: () => null,
+      getResponse: () => null,
+      getNext: () => null,
+    }),
+    switchToWs: () => ({
+      getClient: () => null,
+      getData: () => null,
+    }),
+  };
+}
+
+/**
+ * Wrapper for supertest that provides better typing
+ */
+export interface TestRequest {
+  get(path: string): request.Test;
+  post(path: string): request.Test;
+  put(path: string): request.Test;
+  delete(path: string): request.Test;
+  patch(path: string): request.Test;
+}
+
+/**
+ * Create a supertest wrapper for an Express-like app
+ */
+export function createTestRequest(app: INestApplication): TestRequest {
+  const httpServer = app.getHttpServer();
+  
+  return {
+    get: (path: string) => request(httpServer).get(path),
+    post: (path: string) => request(httpServer).post(path),
+    put: (path: string) => request(httpServer).put(path),
+    delete: (path: string) => request(httpServer).delete(path),
+    patch: (path: string) => request(httpServer).patch(path),
+  };
+}
diff --git a/middleware/tests/utils/index.ts b/middleware/tests/utils/index.ts
new file mode 100644
index 00000000..e322062b
--- /dev/null
+++ b/middleware/tests/utils/index.ts
@@ -0,0 +1,11 @@
+/**
+ * Test utilities index
+ * 
+ * Provides typed mock factories and test app creation utilities
+ */
+
+// Express mocks
+export * from './mock-express';
+
+// Test app factory
+export * from './create-test-app';
diff --git a/middleware/tests/utils/mock-express.ts b/middleware/tests/utils/mock-express.ts
new file mode 100644
index 00000000..81ed9bad
--- /dev/null
+++ b/middleware/tests/utils/mock-express.ts
@@ -0,0 +1,103 @@
+import { Response, NextFunction } from 'express';
+
+/**
+ * Mock Express request object with proper typing
+ */
+export interface MockRequest {
+  method: string;
+  url: string;
+  path: string;
+  params: Record<string, any>;
+  query: Record<string, any>;
+  body: any;
+  headers: Record<string, string>;
+  route?: {
+    path: string;
+  };
+  on: jest.Mock;
+}
+
+/**
+ * Create a typed mock Express request
+ */
+export function mockRequest(overrides?: Partial<MockRequest>): MockRequest {
+  return {
+    method: 'GET',
+    url: '/test',
+    path: '/test',
+    params: {},
+    query: {},
+    body: undefined,
+    headers: {},
+    route: undefined,
+    on: jest.fn(),
+    ...overrides,
+  };
+}
+
+/**
+ * Mock Express response object with proper typing
+ */
+export interface MockResponse extends Partial<Response> {
+  statusCode: number;
+  statusMessage: string;
+  headersSent: boolean;
+  json: jest.Mock<MockResponse, [any]>;
+  send: jest.Mock<MockResponse, [any]>;
+  set: jest.Mock<MockResponse, [string | Record<string, string>, string?]>;
+  status: jest.Mock<MockResponse, [number]>;
+  end: jest.Mock<MockResponse, [any?]>;
+  on: jest.Mock;
+}
+
+/**
+ * Create a typed mock Express response
+ */
+export function mockResponse(overrides?: Partial<MockResponse>): MockResponse {
+  const res: MockResponse = {
+    statusCode: 200,
+    statusMessage: 'OK',
+    headersSent: false,
+    json: jest.fn().mockReturnThis(),
+    send: jest.fn().mockReturnThis(),
+    set: jest.fn().mockReturnThis(),
+    status: jest.fn().mockReturnThis(),
+    end: jest.fn().mockReturnThis(),
+    on: jest.fn(),
+    ...overrides,
+  };
+  
+  return res;
+}
+
+/**
+ * Create a typed mock Express next function
+ */
+export function mockNext(): jest.Mock {
+  return jest.fn();
+}
+
+/**
+ * Create a complete Express middleware test context
+ */
+export interface MiddlewareTestContext {
+  req: MockRequest;
+  res: MockResponse;
+  next: jest.Mock;
+}
+
+/**
+ * Create a complete test context for middleware testing
+ */
+export function createMiddlewareTestContext(
+  overrides?: {
+    req?: Partial<MockRequest>;
+    res?: Partial<MockResponse>;
+  }
+): MiddlewareTestContext {
+  return {
+    req: mockRequest(overrides?.req),
+    res: mockResponse(overrides?.res),
+    next: mockNext(),
+  };
+}