diff --git a/backend/.github/workflows/migrations.yml b/backend/.github/workflows/migrations.yml
new file mode 100644
index 00000000..a0082f77
--- /dev/null
+++ b/backend/.github/workflows/migrations.yml
@@ -0,0 +1,222 @@
+name: Database Migrations
+
+on:
+  push:
+    branches: [ main, develop ]
+    paths:
+      - 'src/database/migrations/**'
+  pull_request:
+    branches: [ main ]
+    paths:
+      - 'src/database/migrations/**'
+  workflow_dispatch:
+    inputs:
+      action:
+        description: 'Migration action'
+        required: true
+        default: 'status'
+        type: choice
+        options:
+        - status
+        - run
+        - validate
+      environment:
+        description: 'Target environment'
+        required: true
+        default: 'staging'
+        type: choice
+        options:
+        - staging
+        - production
+
+env:
+  NODE_VERSION: '18'
+  POSTGRES_VERSION: '15'
+
+jobs:
+  test-migrations:
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:${{ env.POSTGRES_VERSION }}
+        env:
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_USER: postgres
+          POSTGRES_DB: test_migrations
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ env.NODE_VERSION }}
+        cache: 'npm'
+        cache-dependency-path: 'package-lock.json'
+
+    - name: Install dependencies
+      run: |
+        cd backend
+        npm ci
+
+    - name: Wait for PostgreSQL
+      run: |
+        until pg_isready -h localhost -p 5432 -U postgres; do
+          echo "Waiting for PostgreSQL..."
+          sleep 2
+        done
+
+    - name: Validate migration files
+      run: |
+        cd backend
+        npm run migration:validate
+      env:
+        DB_HOST: localhost
+        DB_PORT: 5432
+        DB_USERNAME: postgres
+        DB_PASSWORD: postgres
+        DB_DATABASE: test_migrations
+        DB_LOGGING: false
+
+    - name: Check migration status
+      run: |
+        cd backend
+        npm run migration:status
+      env:
+        DB_HOST: localhost
+        DB_PORT: 5432
+        DB_USERNAME: postgres
+        DB_PASSWORD: postgres
+        DB_DATABASE: test_migrations
+        DB_LOGGING: false
+
+    - name: Run migrations (test)
+      run: |
+        cd backend
+        npm run migration:run
+      env:
+        DB_HOST: localhost
+        DB_PORT: 5432
+        DB_USERNAME: postgres
+        DB_PASSWORD: postgres
+        DB_DATABASE: test_migrations
+        DB_LOGGING: false
+
+    - name: Test rollback functionality
+      run: |
+        cd backend
+        npm run migration:rollback
+        npm run migration:run
+      env:
+        DB_HOST: localhost
+        DB_PORT: 5432
+        DB_USERNAME: postgres
+        DB_PASSWORD: postgres
+        DB_DATABASE: test_migrations
+        DB_LOGGING: false
+
+  deploy-migrations:
+    needs: test-migrations
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    environment: staging
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ env.NODE_VERSION }}
+        cache: 'npm'
+        cache-dependency-path: 'package-lock.json'
+
+    - name: Install dependencies
+      run: |
+        cd backend
+        npm ci
+
+    - name: Run migrations on staging
+      run: |
+        cd backend
+        npm run migration:run
+      env:
+        DB_HOST: ${{ secrets.STAGING_DB_HOST }}
+        DB_PORT: ${{ secrets.STAGING_DB_PORT }}
+        DB_USERNAME: ${{ secrets.STAGING_DB_USERNAME }}
+        DB_PASSWORD: ${{ secrets.STAGING_DB_PASSWORD }}
+        DB_DATABASE: ${{ secrets.STAGING_DB_DATABASE }}
+        DB_LOGGING: true
+
+  production-migrations:
+    needs: test-migrations
+    runs-on: ubuntu-latest
+    if: github.event_name == 'workflow_dispatch' && github.event.inputs.environment == 'production'
+    environment: production
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ env.NODE_VERSION }}
+        cache: 'npm'
+        cache-dependency-path: 'package-lock.json'
+
+    - name: Install dependencies
+      run: |
+        cd backend
+        npm ci
+
+    - name: Validate migrations before production
+      run: |
+        cd backend
+        npm run migration:validate
+      env:
+        DB_HOST: ${{ secrets.PRODUCTION_DB_HOST }}
+        DB_PORT: ${{ secrets.PRODUCTION_DB_PORT }}
+        DB_USERNAME: ${{ secrets.PRODUCTION_DB_USERNAME }}
+        DB_PASSWORD: ${{ secrets.PRODUCTION_DB_PASSWORD }}
+        DB_DATABASE: ${{ secrets.PRODUCTION_DB_DATABASE }}
+        DB_LOGGING: false
+
+    - name: Check migration status
+      run: |
+        cd backend
+        npm run migration:status
+      env:
+        DB_HOST: ${{ secrets.PRODUCTION_DB_HOST }}
+        DB_PORT: ${{ secrets.PRODUCTION_DB_PORT }}
+        DB_USERNAME: ${{ secrets.PRODUCTION_DB_USERNAME }}
+        DB_PASSWORD: ${{ secrets.PRODUCTION_DB_PASSWORD }}
+        DB_DATABASE: ${{ secrets.PRODUCTION_DB_DATABASE }}
+        DB_LOGGING: false
+
+    - name: Run migrations on production
+      run: |
+        cd backend
+        npm run migration:run
+      env:
+        DB_HOST: ${{ secrets.PRODUCTION_DB_HOST }}
+        DB_PORT: ${{ secrets.PRODUCTION_DB_PORT }}
+        DB_USERNAME: ${{ secrets.PRODUCTION_DB_USERNAME }}
+        DB_PASSWORD: ${{ secrets.PRODUCTION_DB_PASSWORD }}
+        DB_DATABASE: ${{ secrets.PRODUCTION_DB_DATABASE }}
+        DB_LOGGING: true
+
+    - name: Notify migration completion
+      if: always()
+      run: |
+        echo "Migration process completed for production environment"
+        # Add notification logic here (Slack, email, etc.)
diff --git a/backend/README_MIGRATIONS.md b/backend/README_MIGRATIONS.md
new file mode 100644
index 00000000..1076938c
--- /dev/null
+++ b/backend/README_MIGRATIONS.md
@@ -0,0 +1,280 @@
+# Quick Start Guide - Database Migration System
+
+This guide provides quick instructions for using the database migration system in the PetChain application.
+
+## Prerequisites
+
+- Node.js 18+
+- PostgreSQL database
+- Environment variables configured
+
+## Environment Setup
+
+Create environment files for different environments:
+
+```bash
+# Development (.env)
+DB_HOST=localhost
+DB_PORT=5432
+DB_USERNAME=postgres
+DB_PASSWORD=postgres
+DB_DATABASE=petchain_dev
+DB_LOGGING=true
+
+# Staging (.env.staging)
+DB_HOST=staging-db.example.com
+DB_PORT=5432
+DB_USERNAME=staging_user
+DB_PASSWORD=staging_password
+DB_DATABASE=petchain_staging
+DB_LOGGING=false
+
+# Production (.env.production)
+DB_HOST=prod-db.example.com
+DB_PORT=5432
+DB_USERNAME=prod_user
+DB_PASSWORD=prod_password
+DB_DATABASE=petchain_prod
+DB_LOGGING=false
+```
+
+## Basic Usage
+
+### 1. Check Migration Status
+
+```bash
+npm run migration:status
+```
+
+### 2. Create a New Migration
+
+```bash
+npm run migration:generate add-user-profile
+```
+
+This creates a new file in `src/database/migrations/` with the template.
+
+### 3. Edit the Migration File
+
+Open the generated migration file and add your schema changes:
+
+```typescript
+public async up(queryRunner: QueryRunner): Promise<void> {
+  await queryRunner.query(`
+    CREATE TABLE user_profiles (
+      id uuid NOT NULL DEFAULT gen_random_uuid(),
+      user_id uuid NOT NULL,
+      bio text,
+      avatar_url varchar(500),
+      created_at TIMESTAMP NOT NULL DEFAULT now(),
+      updated_at TIMESTAMP NOT NULL DEFAULT now(),
+      CONSTRAINT PK_user_profiles PRIMARY KEY (id),
+      CONSTRAINT FK_user_profiles_user FOREIGN KEY (user_id) REFERENCES users(id)
+    )
+  `);
+}
+
+public async down(queryRunner: QueryRunner): Promise<void> {
+  await queryRunner.query(`DROP TABLE user_profiles`);
+}
+```
+
+### 4. Validate the Migration
+
+```bash
+npm run migration:validate
+```
+
+### 5. Run the Migration
+
+```bash
+npm run migration:run
+```
+
+### 6. Verify the Migration
+
+```bash
+npm run migration:status
+```
+
+## Rollback Operations
+
+### Rollback Last Migration
+
+```bash
+npm run migration:rollback
+```
+
+### Rollback to Specific Version
+
+```bash
+npm run migration:rollback -- --to=1739000000000-pets-schema-and-sharing
+```
+
+## Deployment
+
+### Deploy to Staging
+
+```bash
+./scripts/migration-deploy.sh --env staging --action run
+```
+
+### Deploy to Production (Dry Run)
+
+```bash
+./scripts/migration-deploy.sh --env production --action run --dry-run
+```
+
+### Deploy to Production
+
+```bash
+./scripts/migration-deploy.sh --env production --action run
+```
+
+## Common Scenarios
+
+### Adding a New Column
+
+```bash
+npm run migration:generate add-email-to-users
+```
+
+```typescript
+public async up(queryRunner: QueryRunner): Promise<void> {
+  await queryRunner.query(`
+    ALTER TABLE users ADD COLUMN IF NOT EXISTS email varchar(255) NULL
+  `);
+}
+
+public async down(queryRunner: QueryRunner): Promise<void> {
+  await queryRunner.query(`ALTER TABLE users DROP COLUMN email`);
+}
+```
+
+### Creating a New Table
+
+```bash
+npm run migration:generate create-categories-table
+```
+
+```typescript
+public async up(queryRunner: QueryRunner): Promise<void> {
+  await queryRunner.query(`
+    CREATE TABLE categories (
+      id uuid NOT NULL DEFAULT gen_random_uuid(),
+      name varchar(100) NOT NULL,
+      description text,
+      created_at TIMESTAMP NOT NULL DEFAULT now(),
+      CONSTRAINT PK_categories PRIMARY KEY (id),
+      CONSTRAINT UQ_categories_name UNIQUE (name)
+    )
+  `);
+  
+  await queryRunner.query(`
+    CREATE INDEX IDX_categories_name ON categories (name)
+  `);
+}
+
+public async down(queryRunner: QueryRunner): Promise<void> {
+  await queryRunner.query(`DROP INDEX IF EXISTS IDX_categories_name`);
+  await queryRunner.query(`DROP TABLE categories`);
+}
+```
+
+### Adding Foreign Key Constraint
+
+```bash
+npm run migration:generate add-post-author-constraint
+```
+
+```typescript
+public async up(queryRunner: QueryRunner): Promise<void> {
+  await queryRunner.query(`
+    ALTER TABLE posts 
+    ADD CONSTRAINT FK_posts_author 
+    FOREIGN KEY (author_id) REFERENCES users(id) 
+    ON DELETE SET NULL
+  `);
+}
+
+public async down(queryRunner: QueryRunner): Promise<void> {
+  await queryRunner.query(`ALTER TABLE posts DROP CONSTRAINT FK_posts_author`);
+}
+```
+
+## API Usage
+
+You can also manage migrations via the REST API:
+
+### Get Migration Status
+
+```bash
+curl -X GET http://localhost:3000/migrations/status
+```
+
+### Run Migrations
+
+```bash
+curl -X POST http://localhost:3000/migrations/run
+```
+
+### Rollback Migration
+
+```bash
+curl -X DELETE http://localhost:3000/migrations/rollback
+```
+
+## Troubleshooting
+
+### Migration Failed
+
+1. Check the error message
+2. Fix the issue in the migration file
+3. Rollback if needed: `npm run migration:rollback`
+4. Fix and re-run: `npm run migration:run`
+
+### Database Connection Issues
+
+1. Verify database is running
+2. Check environment variables
+3. Test connection: `npm run migration:status`
+
+### Validation Errors
+
+1. Run `npm run migration:validate` to see specific errors
+2. Ensure migration file implements `MigrationInterface`
+3. Check that both `up()` and `down()` methods exist
+
+## Best Practices
+
+1. **Always test migrations** in development first
+2. **Write rollback logic** for every migration
+3. **Use descriptive names** for migrations
+4. **Keep migrations small** and focused
+5. **Backup before production** deployments
+6. **Review migrations** in pull requests
+
+## Getting Help
+
+- Run `npm run migration:help` for CLI help
+- Check the full documentation: `docs/MIGRATION_SYSTEM.md`
+- Review migration files in `src/database/migrations/` for examples
+
+## Environment Variables Reference
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `DB_HOST` | Database host | localhost |
+| `DB_PORT` | Database port | 5432 |
+| `DB_USERNAME` | Database username | postgres |
+| `DB_PASSWORD` | Database password | postgres |
+| `DB_DATABASE` | Database name | petchain |
+| `DB_LOGGING` | Enable query logging | false |
+
+## Migration File Naming
+
+Migrations use timestamp-based naming: `{timestamp}-{description}.ts`
+
+Example: `1739000000000-add-user-profile.ts`
+
+The timestamp ensures proper ordering of migrations.
diff --git a/backend/docs/MIGRATION_SYSTEM.md b/backend/docs/MIGRATION_SYSTEM.md
new file mode 100644
index 00000000..477ce3ff
--- /dev/null
+++ b/backend/docs/MIGRATION_SYSTEM.md
@@ -0,0 +1,365 @@
+# Database Migration System
+
+This document describes the robust database migration system implemented for the PetChain application using TypeORM with automated execution, rollback capabilities, and CI/CD integration.
+
+## Overview
+
+The migration system provides:
+- **Version Control**: Track database schema changes over time
+- **Automated Execution**: Run migrations programmatically via CLI or API
+- **Rollback Capabilities**: Safely revert migrations when needed
+- **CI/CD Integration**: Automated testing and deployment of migrations
+- **Comprehensive Testing**: Validation and testing procedures for migrations
+
+## Architecture
+
+### Core Components
+
+1. **MigrationService** (`src/modules/migration/migration.service.ts`)
+   - Core service handling all migration operations
+   - Provides status checking, execution, rollback, and validation
+   - Handles database connection management
+
+2. **MigrationController** (`src/modules/migration/migration.controller.ts`)
+   - REST API endpoints for migration management
+   - Swagger documentation for all endpoints
+   - HTTP status codes and error handling
+
+3. **MigrationCliService** (`src/modules/migration/migration-cli.service.ts`)
+   - Command-line interface for migration operations
+   - Colored output and detailed logging
+   - Help system and command validation
+
+4. **CLI Entry Point** (`src/modules/migration/cli.ts`)
+   - NestJS application context for CLI operations
+   - Error handling and graceful shutdown
+
+## Usage
+
+### Command Line Interface
+
+The system provides npm scripts for easy access:
+
+```bash
+# Check migration status
+npm run migration:status
+
+# Run pending migrations
+npm run migration:run
+
+# Rollback last migration
+npm run migration:rollback
+
+# Generate new migration file
+npm run migration:generate <migration-name>
+
+# Validate all migration files
+npm run migration:validate
+
+# Show help
+npm run migration:help
+```
+
+### Advanced CLI Options
+
+```bash
+# Run migrations without transaction
+npm run migration:run -- --no-transaction
+
+# Rollback to specific version
+npm run migration:rollback -- --to=1739000000000-pets-schema-and-sharing
+
+# Generate migration with specific name
+npm run migration:generate add-user-preferences
+```
+
+### REST API Endpoints
+
+The migration system exposes the following endpoints:
+
+#### GET /migrations/status
+Returns current migration status including executed and pending migrations.
+
+**Response:**
+```json
+{
+  "pending": ["migration1", "migration2"],
+  "executed": ["migration3", "migration4"],
+  "lastExecuted": "migration4",
+  "totalPending": 2,
+  "totalExecuted": 2
+}
+```
+
+#### POST /migrations/run
+Executes all pending migrations.
+
+**Query Parameters:**
+- `transaction` (optional): Run migrations in a transaction (default: true)
+
+**Response:**
+```json
+[
+  {
+    "success": true,
+    "migration": "migration1",
+    "duration": 150
+  }
+]
+```
+
+#### DELETE /migrations/rollback
+Rolls back the last executed migration.
+
+**Response:**
+```json
+{
+  "success": true,
+  "rolledBack": ["migration1"],
+  "duration": 75
+}
+```
+
+#### DELETE /migrations/rollback-to-version
+Rolls back to a specific migration version.
+
+**Query Parameters:**
+- `version` (required): Target migration version
+
+#### POST /migrations/generate
+Generates a new migration file.
+
+**Request Body:**
+```json
+{
+  "name": "add-user-preferences"
+}
+```
+
+**Response:**
+```json
+{
+  "filePath": "/path/to/migration/file.ts"
+}
+```
+
+#### GET /migrations/validate
+Validates all migration files for correct structure.
+
+**Response:**
+```json
+{
+  "valid": true,
+  "errors": []
+}
+```
+
+## Migration File Structure
+
+All migration files follow this naming convention:
+```
+{timestamp}-{description}.ts
+```
+
+Example: `1739000000000-pets-schema-and-sharing.ts`
+
+### Migration Template
+
+```typescript
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class ExampleMigration1739000000000 implements MigrationInterface {
+  name = '1739000000000-example-migration';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Add your migration logic here
+    await queryRunner.query(`
+      CREATE TABLE example_table (
+        id uuid NOT NULL DEFAULT gen_random_uuid(),
+        name varchar(255) NOT NULL,
+        created_at TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT PK_example_table PRIMARY KEY (id)
+      )
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    // Add your rollback logic here
+    await queryRunner.query(`DROP TABLE example_table`);
+  }
+}
+```
+
+## Best Practices
+
+### Writing Migrations
+
+1. **Always implement down() method**: Ensure migrations can be rolled back
+2. **Use IF EXISTS/IF NOT EXISTS**: Make migrations idempotent where possible
+3. **Use transactions**: Wrap multiple operations in transactions
+4. **Test rollbacks**: Verify that down() methods work correctly
+5. **Use descriptive names**: Make migration names clear and specific
+
+### Migration Validation
+
+The system automatically validates migrations for:
+- Implementation of `MigrationInterface`
+- Presence of `up()` method
+- Presence of `down()` method
+- Correct file naming convention
+
+### Error Handling
+
+- Migrations run in transactions by default
+- Failed migrations trigger automatic rollback
+- Detailed error messages and logging
+- Graceful handling of connection issues
+
+## CI/CD Integration
+
+### GitHub Actions Workflow
+
+The system includes a comprehensive GitHub Actions workflow (`.github/workflows/migrations.yml`) that:
+
+1. **Tests migrations** on every push/PR to migration files
+2. **Validates migration structure** and syntax
+3. **Runs migrations** against test database
+4. **Tests rollback functionality**
+5. **Deploys to staging** automatically on main branch
+6. **Allows manual production deployment** via workflow dispatch
+
+### Environment Configuration
+
+Configure environment variables for each environment:
+
+```bash
+# Database Configuration
+DB_HOST=localhost
+DB_PORT=5432
+DB_USERNAME=postgres
+DB_PASSWORD=postgres
+DB_DATABASE=petchain
+DB_LOGGING=false
+```
+
+### Deployment Script
+
+Use the provided deployment script for safe migrations:
+
+```bash
+# Deploy to staging
+./scripts/migration-deploy.sh --env staging --action run
+
+# Dry run on production
+./scripts/migration-deploy.sh --env production --action run --dry-run
+
+# Deploy with automatic rollback on failure
+./scripts/migration-deploy.sh --env staging --action run --rollback-on-failure
+```
+
+## Testing
+
+### Unit Tests
+
+Run unit tests for migration services:
+
+```bash
+npm test -- migration.test.ts
+```
+
+### Integration Tests
+
+The CI/CD pipeline includes comprehensive integration tests:
+- Migration execution against test database
+- Rollback functionality testing
+- Validation testing
+- Error scenario testing
+
+### Manual Testing
+
+1. **Test in development**: Always test migrations in development first
+2. **Staging validation**: Run migrations against staging database
+3. **Production readiness**: Validate production deployment before execution
+
+## Monitoring and Logging
+
+### Logging Levels
+
+- **INFO**: Migration execution status, completion times
+- **WARN**: Validation errors, skipped operations
+- **ERROR**: Migration failures, connection issues
+
+### Monitoring Metrics
+
+Track these metrics for migration health:
+- Migration execution time
+- Success/failure rates
+- Rollback frequency
+- Database connection issues
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Connection timeouts**: Check database connectivity and credentials
+2. **Migration conflicts**: Ensure no concurrent migration executions
+3. **Rollback failures**: Verify down() methods are correct
+4. **Validation errors**: Check migration file structure and naming
+
+### Recovery Procedures
+
+1. **Failed migrations**: Use rollback or manual intervention
+2. **Database corruption**: Restore from backup (automatically created)
+3. **Stuck migrations**: Check migrations table and manually update status
+
+## Security Considerations
+
+- **Database credentials**: Store securely in environment variables
+- **Migration access**: Limit migration execution to authorized users
+- **Audit logging**: Track all migration operations
+- **Backup strategy**: Always backup before production migrations
+
+## Performance Optimization
+
+- **Batch operations**: Group related SQL operations
+- **Index management**: Add/remove indexes efficiently
+- **Large datasets**: Consider chunking large data migrations
+- **Connection pooling**: Optimize database connection settings
+
+## Version Control Strategy
+
+### Branch Strategy
+
+- **Feature branches**: Create migrations in feature branches
+- **Main branch**: Merge tested migrations to main
+- **Production releases**: Tag releases with migration versions
+
+### Migration Dependencies
+
+- **Order dependencies**: Ensure migrations run in correct order
+- **Cross-table dependencies**: Handle foreign key constraints properly
+- **Data migrations**: Separate schema and data migrations when possible
+
+## Future Enhancements
+
+Planned improvements to the migration system:
+
+1. **Migration scheduling**: Schedule migrations for specific times
+2. **Multi-database support**: Support for different database types
+3. **Migration dependencies**: Define explicit migration dependencies
+4. **Advanced rollback**: Point-in-time rollback capabilities
+5. **Performance monitoring**: Built-in performance metrics and alerts
+
+## Support
+
+For issues or questions about the migration system:
+
+1. Check this documentation
+2. Review error logs and messages
+3. Run validation commands
+4. Contact the development team
+
+---
+
+**Last Updated**: 2025-01-09
+**Version**: 1.0.0
diff --git a/backend/package.json b/backend/package.json
index 1a751639..3c899955 100644
--- a/backend/package.json
+++ b/backend/package.json
@@ -18,7 +18,13 @@
     "test:cov": "jest --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
     "test:e2e": "jest --config ./test/jest-e2e.json",
-    "seed:breeds": "ts-node -r tsconfig-paths/register src/scripts/seed-breeds.ts"
+    "seed:breeds": "ts-node -r tsconfig-paths/register src/scripts/seed-breeds.ts",
+    "migration:status": "ts-node -r tsconfig-paths/register src/modules/migration/cli.ts status",
+    "migration:run": "ts-node -r tsconfig-paths/register src/modules/migration/cli.ts run",
+    "migration:rollback": "ts-node -r tsconfig-paths/register src/modules/migration/cli.ts rollback",
+    "migration:generate": "ts-node -r tsconfig-paths/register src/modules/migration/cli.ts generate",
+    "migration:validate": "ts-node -r tsconfig-paths/register src/modules/migration/cli.ts validate",
+    "migration:help": "ts-node -r tsconfig-paths/register src/modules/migration/cli.ts help"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.972.0",
diff --git a/backend/scripts/migration-deploy.sh b/backend/scripts/migration-deploy.sh
new file mode 100755
index 00000000..caf1efd4
--- /dev/null
+++ b/backend/scripts/migration-deploy.sh
@@ -0,0 +1,206 @@
+#!/bin/bash
+
+# Migration Deployment Script
+# This script handles database migrations for different environments
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Default values
+ENVIRONMENT="staging"
+ACTION="status"
+DRY_RUN=false
+BACKUP_DB=true
+ROLLBACK_ON_FAILURE=false
+
+# Parse command line arguments
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --env)
+      ENVIRONMENT="$2"
+      shift 2
+      ;;
+    --action)
+      ACTION="$2"
+      shift 2
+      ;;
+    --dry-run)
+      DRY_RUN=true
+      shift
+      ;;
+    --no-backup)
+      BACKUP_DB=false
+      shift
+      ;;
+    --rollback-on-failure)
+      ROLLBACK_ON_FAILURE=true
+      shift
+      ;;
+    -h|--help)
+      echo "Usage: $0 [options]"
+      echo ""
+      echo "Options:"
+      echo "  --env <environment>     Target environment (staging|production) [default: staging]"
+      echo "  --action <action>       Migration action (status|run|rollback|validate) [default: status]"
+      echo "  --dry-run               Show what would be done without executing"
+      echo "  --no-backup             Skip database backup"
+      echo "  --rollback-on-failure   Automatically rollback on migration failure"
+      echo "  -h, --help              Show this help message"
+      echo ""
+      echo "Examples:"
+      echo "  $0 --env staging --action run"
+      echo "  $0 --env production --action status --dry-run"
+      echo "  $0 --env staging --action rollback --rollback-on-failure"
+      exit 0
+      ;;
+    *)
+      echo "Unknown option: $1"
+      exit 1
+      ;;
+  esac
+done
+
+# Validate environment
+if [[ "$ENVIRONMENT" != "staging" && "$ENVIRONMENT" != "production" ]]; then
+  echo -e "${RED}Error: Environment must be 'staging' or 'production'${NC}"
+  exit 1
+fi
+
+# Validate action
+if [[ "$ACTION" != "status" && "$ACTION" != "run" && "$ACTION" != "rollback" && "$ACTION" != "validate" ]]; then
+  echo -e "${RED}Error: Action must be 'status', 'run', 'rollback', or 'validate'${NC}"
+  exit 1
+fi
+
+# Load environment variables
+ENV_FILE=".env.${ENVIRONMENT}"
+if [[ ! -f "$ENV_FILE" ]]; then
+  echo -e "${RED}Error: Environment file $ENV_FILE not found${NC}"
+  exit 1
+fi
+
+echo -e "${BLUE}Loading environment from $ENV_FILE${NC}"
+export $(cat "$ENV_FILE" | xargs)
+cd backend
+
+# Function to create database backup
+create_backup() {
+  if [[ "$BACKUP_DB" != true ]]; then
+    echo -e "${YELLOW}Skipping database backup${NC}"
+    return
+  fi
+
+  echo -e "${BLUE}Creating database backup...${NC}"
+  BACKUP_FILE="backup_${ENVIRONMENT}_$(date +%Y%m%d_%H%M%S).sql"
+  
+  if [[ "$DRY_RUN" == true ]]; then
+    echo -e "${YELLOW}[DRY RUN] Would create backup: $BACKUP_FILE${NC}"
+    return
+  fi
+
+  PGPASSWORD="$DB_PASSWORD" pg_dump \
+    -h "$DB_HOST" \
+    -p "$DB_PORT" \
+    -U "$DB_USERNAME" \
+    -d "$DB_DATABASE" \
+    --clean \
+    --if-exists \
+    --no-owner \
+    --no-privileges \
+    > "../backups/$BACKUP_FILE"
+
+  if [[ $? -eq 0 ]]; then
+    echo -e "${GREEN}✅ Backup created: ../backups/$BACKUP_FILE${NC}"
+  else
+    echo -e "${RED}❌ Backup failed${NC}"
+    exit 1
+  fi
+}
+
+# Function to run migration command
+run_migration_command() {
+  local cmd=$1
+  local description=$2
+
+  echo -e "${BLUE}$description...${NC}"
+  
+  if [[ "$DRY_RUN" == true ]]; then
+    echo -e "${YELLOW}[DRY RUN] Would execute: npm run migration:$cmd${NC}"
+    return
+  fi
+
+  if npm run migration:$cmd; then
+    echo -e "${GREEN}✅ $description completed successfully${NC}"
+    return 0
+  else
+    echo -e "${RED}❌ $description failed${NC}"
+    return 1
+  fi
+}
+
+# Function to handle rollback on failure
+handle_failure() {
+  if [[ "$ROLLBACK_ON_FAILURE" == true && "$ACTION" == "run" ]]; then
+    echo -e "${YELLOW}Attempting rollback due to failure...${NC}"
+    run_migration_command "rollback" "Rolling back migrations"
+  fi
+}
+
+# Main execution
+main() {
+  echo -e "${BLUE}=== Migration Deployment Script ===${NC}"
+  echo -e "${BLUE}Environment: $ENVIRONMENT${NC}"
+  echo -e "${BLUE}Action: $ACTION${NC}"
+  echo -e "${BLUE}Dry Run: $DRY_RUN${NC}"
+  echo -e "${BLUE}Backup DB: $BACKUP_DB${NC}"
+  echo -e "${BLUE}Rollback on Failure: $ROLLBACK_ON_FAILURE${NC}"
+  echo ""
+
+  # Create backups directory if it doesn't exist
+  mkdir -p ../backups
+
+  # Create backup before running migrations
+  if [[ "$ACTION" == "run" ]]; then
+    create_backup
+  fi
+
+  # Execute the requested action
+  case $ACTION in
+    "status")
+      run_migration_command "status" "Checking migration status"
+      ;;
+    "validate")
+      run_migration_command "validate" "Validating migrations"
+      ;;
+    "run")
+      if run_migration_command "run" "Running migrations"; then
+        echo -e "${GREEN}🎉 Migration deployment completed successfully!${NC}"
+      else
+        handle_failure
+        exit 1
+      fi
+      ;;
+    "rollback")
+      if run_migration_command "rollback" "Rolling back migrations"; then
+        echo -e "${GREEN}🎉 Rollback completed successfully!${NC}"
+      else
+        exit 1
+      fi
+      ;;
+  esac
+
+  echo ""
+  echo -e "${BLUE}=== Migration deployment completed ===${NC}"
+}
+
+# Error handling
+trap 'echo -e "\n${RED}❌ Script interrupted${NC}"; exit 1' INT TERM
+
+# Run main function
+main
diff --git a/backend/src/app.module.ts b/backend/src/app.module.ts
index f8fabcd2..956397ef 100644
--- a/backend/src/app.module.ts
+++ b/backend/src/app.module.ts
@@ -55,6 +55,7 @@ import { NotificationsModule } from './modules/notifications/notifications.modul
 import { AnalyticsModule } from './modules/analytics/analytics.module';
 import { SmsModule } from './modules/sms/sms.module';
 import { WebSocketModule } from './websocket/websocket.module';
+import { MigrationModule } from './modules/migration/migration.module';
 
 @Module({
   imports: [
@@ -134,6 +135,7 @@ ThrottlerModule.forRoot([{
     AnalyticsModule,
     SmsModule,
     WebSocketModule,
+    MigrationModule,
   ],
   controllers: [AppController],
   providers: [AppService],
diff --git a/backend/src/auth/auth.module.ts b/backend/src/auth/auth.module.ts
index 04d3ffcc..b9844b78 100644
--- a/backend/src/auth/auth.module.ts
+++ b/backend/src/auth/auth.module.ts
@@ -22,7 +22,6 @@ import { RoleAuditLog } from './entities/role-audit-log.entity';
 import { FailedLoginAttempt } from './entities/failed-login-attempt.entity';
 import { EMAIL_SERVICE } from './interfaces/email-service.interface';
 import { RolesService } from './services/roles.service';
-import { RolesController } from './controllers/roles.controller';
 import { PermissionsService } from './services/permissions.service';
 import { RolesPermissionsSeeder } from './seeds/roles-permissions.seed';
 import { RedisService } from './services/redis.service';
diff --git a/backend/src/modules/migration/cli.ts b/backend/src/modules/migration/cli.ts
new file mode 100644
index 00000000..500d632c
--- /dev/null
+++ b/backend/src/modules/migration/cli.ts
@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from '../../app.module';
+import { MigrationCliService } from './migration-cli.service';
+
+async function bootstrap() {
+  const app = await NestFactory.createApplicationContext(AppModule, {
+    logger: ['error', 'warn'],
+  });
+
+  const migrationCli = app.get(MigrationCliService);
+  
+  const args = process.argv.slice(2);
+  const [command, ...commandArgs] = args;
+
+  if (!command) {
+    console.error('❌ No command provided.');
+    await migrationCli.runCommand('help', []);
+    await app.close();
+    process.exit(1);
+  }
+
+  try {
+    await migrationCli.runCommand(command, commandArgs);
+  } catch (error) {
+    console.error('❌ Migration command failed:', error.message);
+    process.exit(1);
+  } finally {
+    await app.close();
+  }
+}
+
+bootstrap().catch(error => {
+  console.error('❌ Bootstrap failed:', error);
+  process.exit(1);
+});
diff --git a/backend/src/modules/migration/migration-cli.service.ts b/backend/src/modules/migration/migration-cli.service.ts
new file mode 100644
index 00000000..3bc476ed
--- /dev/null
+++ b/backend/src/modules/migration/migration-cli.service.ts
@@ -0,0 +1,215 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { MigrationService } from './migration.service';
+import { MigrationStatus, MigrationResult, RollbackResult } from './migration.service';
+
+@Injectable()
+export class MigrationCliService {
+  private readonly logger = new Logger(MigrationCliService.name);
+
+  constructor(private readonly migrationService: MigrationService) {}
+
+  async runCommand(command: string, args: string[]): Promise<void> {
+    try {
+      switch (command) {
+        case 'status':
+          await this.showStatus();
+          break;
+        case 'run':
+          await this.runMigrations(args);
+          break;
+        case 'rollback':
+          await this.rollbackMigration(args);
+          break;
+        case 'generate':
+          await this.generateMigration(args);
+          break;
+        case 'validate':
+          await this.validateMigrations();
+          break;
+        case 'help':
+          this.showHelp();
+          break;
+        default:
+          this.logger.error(`Unknown command: ${command}`);
+          this.showHelp();
+          process.exit(1);
+      }
+    } catch (error) {
+      this.logger.error(`Command failed: ${error.message}`, error);
+      process.exit(1);
+    }
+  }
+
+  private async showStatus(): Promise<void> {
+    console.log('\n📊 Migration Status\n');
+    
+    const status: MigrationStatus = await this.migrationService.getMigrationStatus();
+    
+    console.log(`✅ Executed migrations: ${status.totalExecuted}`);
+    if (status.executed.length > 0) {
+      status.executed.forEach(migration => {
+        console.log(`   - ${migration}`);
+      });
+    }
+    
+    console.log(`\n⏳ Pending migrations: ${status.totalPending}`);
+    if (status.pending.length > 0) {
+      status.pending.forEach(migration => {
+        console.log(`   - ${migration}`);
+      });
+    }
+    
+    if (status.lastExecuted) {
+      console.log(`\n🕐 Last executed: ${status.lastExecuted}`);
+    }
+    
+    console.log('\n');
+  }
+
+  private async runMigrations(args: string[]): Promise<void> {
+    const useTransaction = !args.includes('--no-transaction');
+    
+    console.log('\n🚀 Running migrations...\n');
+    
+    const results: MigrationResult[] = await this.migrationService.runMigrations({
+      transaction: useTransaction,
+    });
+    
+    if (results.length === 0) {
+      console.log('✅ No pending migrations to run.\n');
+      return;
+    }
+    
+    const successCount = results.filter(r => r.success).length;
+    const failureCount = results.filter(r => !r.success).length;
+    
+    console.log(`\n📋 Migration Results:`);
+    console.log(`✅ Success: ${successCount}`);
+    console.log(`❌ Failed: ${failureCount}`);
+    
+    results.forEach(result => {
+      const icon = result.success ? '✅' : '❌';
+      const duration = `${result.duration}ms`;
+      console.log(`   ${icon} ${result.migration} (${duration})`);
+      
+      if (!result.success && result.error) {
+        console.log(`      Error: ${result.error}`);
+      }
+    });
+    
+    if (failureCount > 0) {
+      console.log('\n❌ Some migrations failed. Check the errors above.\n');
+      process.exit(1);
+    } else {
+      console.log('\n🎉 All migrations executed successfully!\n');
+    }
+  }
+
+  private async rollbackMigration(args: string[]): Promise<void> {
+    const toVersion = args.find(arg => arg.startsWith('--to='))?.split('=')[1];
+    
+    console.log('\n🔄 Rolling back migrations...\n');
+    
+    let result: RollbackResult;
+    
+    if (toVersion) {
+      console.log(`Rolling back to version: ${toVersion}`);
+      result = await this.migrationService.rollbackToVersion(toVersion);
+    } else {
+      console.log('Rolling back last migration...');
+      result = await this.migrationService.rollbackLastMigration();
+    }
+    
+    if (result.success) {
+      if (result.rolledBack.length === 0) {
+        console.log('✅ No migrations to rollback.\n');
+      } else {
+        console.log(`✅ Successfully rolled back ${result.rolledBack.length} migration(s):`);
+        result.rolledBack.forEach(migration => {
+          console.log(`   - ${migration}`);
+        });
+        console.log(`\n⏱️  Duration: ${result.duration}ms\n`);
+      }
+    } else {
+      console.log(`❌ Rollback failed: ${result.error}`);
+      console.log(`\n⏱️  Duration: ${result.duration}ms\n`);
+      process.exit(1);
+    }
+  }
+
+  private async generateMigration(args: string[]): Promise<void> {
+    const name = args[0];
+    
+    if (!name) {
+      console.error('❌ Migration name is required.');
+      console.log('Usage: npm run migration:generate <migration-name>\n');
+      process.exit(1);
+    }
+    
+    console.log(`\n📝 Generating migration: ${name}\n`);
+    
+    try {
+      const filePath = await this.migrationService.generateMigration(name);
+      console.log(`✅ Migration generated successfully:`);
+      console.log(`   ${filePath}\n`);
+    } catch (error) {
+      console.error(`❌ Failed to generate migration: ${error.message}\n`);
+      process.exit(1);
+    }
+  }
+
+  private async validateMigrations(): Promise<void> {
+    console.log('\n🔍 Validating migrations...\n');
+    
+    const result = await this.migrationService.validateMigrations();
+    
+    if (result.valid) {
+      console.log('✅ All migrations are valid!\n');
+    } else {
+      console.log(`❌ Found ${result.errors.length} validation error(s):`);
+      result.errors.forEach(error => {
+        console.log(`   - ${error}`);
+      });
+      console.log('\n');
+      process.exit(1);
+    }
+  }
+
+  private showHelp(): void {
+    console.log(`
+📚 Migration CLI Help
+
+Usage: npm run migration:<command> [options]
+
+Commands:
+  status              Show migration status
+  run                 Run pending migrations
+  rollback            Rollback last migration
+  rollback --to=<version>  Rollback to specific version
+  generate <name>     Generate new migration file
+  validate            Validate all migration files
+  help                Show this help message
+
+Options:
+  --no-transaction    Run migrations without transaction (for 'run' command)
+  --to=<version>      Target version for rollback (for 'rollback' command)
+
+Examples:
+  npm run migration:status
+  npm run migration:run
+  npm run migration:run -- --no-transaction
+  npm run migration:rollback
+  npm run migration:rollback -- --to=1739000000000-pets-schema-and-sharing
+  npm run migration:generate add-user-preferences
+  npm run migration:validate
+
+Environment Variables:
+  DB_HOST             Database host (default: localhost)
+  DB_PORT             Database port (default: 5432)
+  DB_USERNAME         Database username (default: postgres)
+  DB_PASSWORD         Database password (default: postgres)
+  DB_DATABASE         Database name (default: petchain)
+  DB_LOGGING          Enable query logging (default: false)
+`);
+  }
+}
diff --git a/backend/src/modules/migration/migration.controller.ts b/backend/src/modules/migration/migration.controller.ts
new file mode 100644
index 00000000..44181bb1
--- /dev/null
+++ b/backend/src/modules/migration/migration.controller.ts
@@ -0,0 +1,148 @@
+import { 
+  Controller, 
+  Get, 
+  Post, 
+  Delete, 
+  Query, 
+  Body, 
+  HttpCode, 
+  HttpStatus,
+  Logger 
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiResponse, ApiQuery } from '@nestjs/swagger';
+import { MigrationService, MigrationStatus, MigrationResult, RollbackResult } from './migration.service';
+
+@ApiTags('migrations')
+@Controller('migrations')
+export class MigrationController {
+  private readonly logger = new Logger(MigrationController.name);
+
+  constructor(private readonly migrationService: MigrationService) {}
+
+  @Get('status')
+  @ApiOperation({ summary: 'Get migration status' })
+  @ApiResponse({ status: 200, description: 'Migration status retrieved successfully' })
+  async getStatus(): Promise<MigrationStatus> {
+    return this.migrationService.getMigrationStatus();
+  }
+
+  @Post('run')
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'Run pending migrations' })
+  @ApiResponse({ status: 200, description: 'Migrations executed successfully' })
+  @ApiResponse({ status: 500, description: 'Migration execution failed' })
+  @ApiQuery({ name: 'transaction', required: false, type: Boolean, description: 'Run migrations in a transaction' })
+  async runMigrations(@Query('transaction') transaction?: string): Promise<MigrationResult[]> {
+    const useTransaction = transaction !== 'false';
+    this.logger.log(`Starting migration execution (transaction: ${useTransaction})`);
+    
+    try {
+      const results = await this.migrationService.runMigrations({ transaction: useTransaction });
+      
+      const successCount = results.filter(r => r.success).length;
+      const failureCount = results.filter(r => !r.success).length;
+      
+      this.logger.log(`Migration execution completed: ${successCount} success, ${failureCount} failed`);
+      
+      return results;
+    } catch (error) {
+      this.logger.error('Migration execution failed', error);
+      throw error;
+    }
+  }
+
+  @Delete('rollback')
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'Rollback the last migration' })
+  @ApiResponse({ status: 200, description: 'Migration rolled back successfully' })
+  @ApiResponse({ status: 500, description: 'Rollback failed' })
+  async rollbackLast(): Promise<RollbackResult> {
+    this.logger.log('Starting rollback of last migration');
+    
+    try {
+      const result = await this.migrationService.rollbackLastMigration();
+      
+      if (result.success) {
+        this.logger.log(`Rollback completed: ${result.rolledBack.length} migrations rolled back`);
+      } else {
+        this.logger.error('Rollback failed', result.error);
+      }
+      
+      return result;
+    } catch (error) {
+      this.logger.error('Rollback failed', error);
+      throw error;
+    }
+  }
+
+  @Delete('rollback-to-version')
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'Rollback to a specific migration version' })
+  @ApiResponse({ status: 200, description: 'Rollback to version completed successfully' })
+  @ApiResponse({ status: 400, description: 'Invalid target version' })
+  @ApiResponse({ status: 500, description: 'Rollback failed' })
+  @ApiQuery({ name: 'version', required: true, type: String, description: 'Target migration version' })
+  async rollbackToVersion(@Query('version') version: string): Promise<RollbackResult> {
+    this.logger.log(`Starting rollback to version: ${version}`);
+    
+    try {
+      const result = await this.migrationService.rollbackToVersion(version);
+      
+      if (result.success) {
+        this.logger.log(`Rollback to version ${version} completed: ${result.rolledBack.length} migrations rolled back`);
+      } else {
+        this.logger.error(`Rollback to version ${version} failed`, result.error);
+      }
+      
+      return result;
+    } catch (error) {
+      this.logger.error(`Rollback to version ${version} failed`, error);
+      throw error;
+    }
+  }
+
+  @Post('generate')
+  @ApiOperation({ summary: 'Generate a new migration file' })
+  @ApiResponse({ status: 201, description: 'Migration file generated successfully' })
+  @ApiResponse({ status: 400, description: 'Invalid migration name' })
+  async generateMigration(@Body('name') name: string): Promise<{ filePath: string }> {
+    if (!name || typeof name !== 'string' || name.trim().length === 0) {
+      throw new Error('Migration name is required and must be a non-empty string');
+    }
+
+    this.logger.log(`Generating new migration: ${name}`);
+    
+    try {
+      const filePath = await this.migrationService.generateMigration(name.trim());
+      this.logger.log(`Migration generated successfully: ${filePath}`);
+      
+      return { filePath };
+    } catch (error) {
+      this.logger.error(`Failed to generate migration: ${name}`, error);
+      throw error;
+    }
+  }
+
+  @Get('validate')
+  @ApiOperation({ summary: 'Validate all migration files' })
+  @ApiResponse({ status: 200, description: 'Migration validation completed' })
+  async validateMigrations(): Promise<{ valid: boolean; errors: string[] }> {
+    this.logger.log('Starting migration validation');
+    
+    try {
+      const result = await this.migrationService.validateMigrations();
+      
+      if (result.valid) {
+        this.logger.log('All migrations are valid');
+      } else {
+        this.logger.warn(`Migration validation failed with ${result.errors.length} errors`);
+        result.errors.forEach(error => this.logger.warn(error));
+      }
+      
+      return result;
+    } catch (error) {
+      this.logger.error('Migration validation failed', error);
+      throw error;
+    }
+  }
+}
diff --git a/backend/src/modules/migration/migration.module.ts b/backend/src/modules/migration/migration.module.ts
new file mode 100644
index 00000000..df295a4d
--- /dev/null
+++ b/backend/src/modules/migration/migration.module.ts
@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { MigrationController } from './migration.controller';
+import { MigrationService } from './migration.service';
+import { ConfigModule } from '@nestjs/config';
+
+@Module({
+  imports: [ConfigModule],
+  controllers: [MigrationController],
+  providers: [MigrationService],
+  exports: [MigrationService],
+})
+export class MigrationModule {}
diff --git a/backend/src/modules/migration/migration.service.ts b/backend/src/modules/migration/migration.service.ts
new file mode 100644
index 00000000..12f59e91
--- /dev/null
+++ b/backend/src/modules/migration/migration.service.ts
@@ -0,0 +1,339 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { DataSource, DataSourceOptions } from 'typeorm';
+import { ConfigService } from '@nestjs/config';
+import { MigrationExecutor } from 'typeorm/migration/MigrationExecutor';
+import { Migration } from 'typeorm/migration/Migration';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+
+export interface MigrationStatus {
+  pending: string[];
+  executed: string[];
+  lastExecuted?: string;
+  totalPending: number;
+  totalExecuted: number;
+}
+
+export interface MigrationResult {
+  success: boolean;
+  migration?: string;
+  error?: string;
+  duration: number;
+}
+
+export interface RollbackResult {
+  success: boolean;
+  rolledBack: string[];
+  error?: string;
+  duration: number;
+}
+
+@Injectable()
+export class MigrationService implements OnModuleInit {
+  private readonly logger = new Logger(MigrationService.name);
+  private dataSource: DataSource;
+
+  constructor(private readonly configService: ConfigService) {}
+
+  async onModuleInit() {
+    await this.initializeDataSource();
+  }
+
+  private async initializeDataSource(): Promise<void> {
+    const dbConfig = this.configService.get<DataSourceOptions>('database');
+    if (!dbConfig) {
+      throw new Error('Database configuration not found');
+    }
+
+    this.dataSource = new DataSource(dbConfig);
+    try {
+      await this.dataSource.initialize();
+      this.logger.log('Database connection initialized for migration service');
+    } catch (error) {
+      this.logger.error('Failed to initialize database connection', error);
+      throw error;
+    }
+  }
+
+  async getMigrationStatus(): Promise<MigrationStatus> {
+    if (!this.dataSource.isInitialized) {
+      await this.initializeDataSource();
+    }
+
+    const migrationExecutor = new MigrationExecutor(this.dataSource);
+    const executedMigrations = await migrationExecutor.getExecutedMigrations();
+    const pendingMigrations = await migrationExecutor.getPendingMigrations();
+
+    const executed = executedMigrations.map(m => m.name);
+    const pending = pendingMigrations.map(m => m.name);
+
+    return {
+      pending,
+      executed,
+      lastExecuted: executed.length > 0 ? executed[executed.length - 1] : undefined,
+      totalPending: pending.length,
+      totalExecuted: executed.length,
+    };
+  }
+
+  async runMigrations(options: { transaction?: boolean } = {}): Promise<MigrationResult[]> {
+    if (!this.dataSource.isInitialized) {
+      await this.initializeDataSource();
+    }
+
+    const status = await this.getMigrationStatus();
+    if (status.totalPending === 0) {
+      this.logger.log('No pending migrations to run');
+      return [];
+    }
+
+    this.logger.log(`Running ${status.totalPending} pending migrations...`);
+    const results: MigrationResult[] = [];
+
+    try {
+      const migrationExecutor = new MigrationExecutor(this.dataSource);
+      
+      if (options.transaction !== false) {
+        await this.dataSource.query('BEGIN');
+      }
+
+      for (const migration of status.pending) {
+        const startTime = Date.now();
+        try {
+          await migrationExecutor.executePendingMigrations();
+          const duration = Date.now() - startTime;
+          
+          results.push({
+            success: true,
+            migration,
+            duration,
+          });
+          
+          this.logger.log(`Migration ${migration} executed successfully (${duration}ms)`);
+          break; // executePendingMigrations runs all pending migrations at once
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          results.push({
+            success: false,
+            migration,
+            error: error.message,
+            duration,
+          });
+          
+          this.logger.error(`Migration ${migration} failed`, error);
+          
+          if (options.transaction !== false) {
+            await this.dataSource.query('ROLLBACK');
+          }
+          break;
+        }
+      }
+
+      if (options.transaction !== false && results.every(r => r.success)) {
+        await this.dataSource.query('COMMIT');
+        this.logger.log('All migrations committed successfully');
+      }
+
+      return results;
+    } catch (error) {
+      this.logger.error('Failed to run migrations', error);
+      if (options.transaction !== false) {
+        await this.dataSource.query('ROLLBACK');
+      }
+      throw error;
+    }
+  }
+
+  async rollbackLastMigration(): Promise<RollbackResult> {
+    if (!this.dataSource.isInitialized) {
+      await this.initializeDataSource();
+    }
+
+    const startTime = Date.now();
+    const status = await this.getMigrationStatus();
+    
+    if (status.totalExecuted === 0) {
+      this.logger.log('No migrations to rollback');
+      return {
+        success: true,
+        rolledBack: [],
+        duration: Date.now() - startTime,
+      };
+    }
+
+    this.logger.log('Rolling back last migration...');
+    
+    try {
+      await this.dataSource.query('BEGIN');
+      
+      const migrationExecutor = new MigrationExecutor(this.dataSource);
+      const lastMigration = status.executed[status.executed.length - 1];
+      
+      await migrationExecutor.undoLastMigration();
+      
+      await this.dataSource.query('COMMIT');
+      
+      const duration = Date.now() - startTime;
+      this.logger.log(`Migration ${lastMigration} rolled back successfully (${duration}ms)`);
+      
+      return {
+        success: true,
+        rolledBack: [lastMigration],
+        duration,
+      };
+    } catch (error) {
+      await this.dataSource.query('ROLLBACK');
+      this.logger.error('Failed to rollback migration', error);
+      
+      return {
+        success: false,
+        rolledBack: [],
+        error: error.message,
+        duration: Date.now() - startTime,
+      };
+    }
+  }
+
+  async rollbackToVersion(targetVersion: string): Promise<RollbackResult> {
+    if (!this.dataSource.isInitialized) {
+      await this.initializeDataSource();
+    }
+
+    const startTime = Date.now();
+    const status = await this.getMigrationStatus();
+    
+    const targetIndex = status.executed.indexOf(targetVersion);
+    if (targetIndex === -1) {
+      throw new Error(`Migration version ${targetVersion} not found in executed migrations`);
+    }
+
+    const migrationsToRollback = status.executed.slice(targetIndex + 1);
+    
+    if (migrationsToRollback.length === 0) {
+      this.logger.log(`No migrations to rollback to version ${targetVersion}`);
+      return {
+        success: true,
+        rolledBack: [],
+        duration: Date.now() - startTime,
+      };
+    }
+
+    this.logger.log(`Rolling back ${migrationsToRollback.length} migrations to version ${targetVersion}...`);
+    
+    try {
+      await this.dataSource.query('BEGIN');
+      
+      const migrationExecutor = new MigrationExecutor(this.dataSource);
+      const rolledBack: string[] = [];
+      
+      for (const migration of migrationsToRollback.reverse()) {
+        await migrationExecutor.undoLastMigration();
+        rolledBack.push(migration);
+        this.logger.log(`Migration ${migration} rolled back`);
+      }
+      
+      await this.dataSource.query('COMMIT');
+      
+      const duration = Date.now() - startTime;
+      this.logger.log(`Successfully rolled back to version ${targetVersion} (${duration}ms)`);
+      
+      return {
+        success: true,
+        rolledBack,
+        duration,
+      };
+    } catch (error) {
+      await this.dataSource.query('ROLLBACK');
+      this.logger.error('Failed to rollback migrations', error);
+      
+      return {
+        success: false,
+        rolledBack: [],
+        error: error.message,
+        duration: Date.now() - startTime,
+      };
+    }
+  }
+
+  async generateMigration(name: string): Promise<string> {
+    const timestamp = Date.now();
+    const migrationName = `${timestamp}-${name}`;
+    const migrationPath = path.join(
+      process.cwd(),
+      'src',
+      'database',
+      'migrations',
+      `${migrationName}.ts`
+    );
+
+    const template = `import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class ${this.toPascalCase(name)}${timestamp} implements MigrationInterface {
+  name = '${migrationName}';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Add your migration logic here
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    // Add your rollback logic here
+  }
+}
+`;
+
+    await fs.writeFile(migrationPath, template, 'utf-8');
+    this.logger.log(`Generated migration file: ${migrationPath}`);
+    
+    return migrationPath;
+  }
+
+  async validateMigrations(): Promise<{ valid: boolean; errors: string[] }> {
+    const errors: string[] = [];
+    
+    try {
+      const migrationPath = path.join(process.cwd(), 'src', 'database', 'migrations');
+      const files = await fs.readdir(migrationPath);
+      const migrationFiles = files.filter(file => file.endsWith('.ts'));
+
+      for (const file of migrationFiles) {
+        const filePath = path.join(migrationPath, file);
+        const content = await fs.readFile(filePath, 'utf-8');
+        
+        if (!content.includes('implements MigrationInterface')) {
+          errors.push(`Migration ${file} does not implement MigrationInterface`);
+        }
+        
+        if (!content.includes('public async up(')) {
+          errors.push(`Migration ${file} missing up() method`);
+        }
+        
+        if (!content.includes('public async down(')) {
+          errors.push(`Migration ${file} missing down() method`);
+        }
+      }
+
+      return {
+        valid: errors.length === 0,
+        errors,
+      };
+    } catch (error) {
+      errors.push(`Failed to validate migrations: ${error.message}`);
+      return {
+        valid: false,
+        errors,
+      };
+    }
+  }
+
+  private toPascalCase(str: string): string {
+    return str
+      .replace(/(?:^|[-_])(\w)/g, (_, char) => char.toUpperCase())
+      .replace(/[-_]/g, '');
+  }
+
+  async onModuleDestroy() {
+    if (this.dataSource.isInitialized) {
+      await this.dataSource.destroy();
+    }
+  }
+}
diff --git a/backend/src/modules/migration/migration.test.ts b/backend/src/modules/migration/migration.test.ts
new file mode 100644
index 00000000..04d369e9
--- /dev/null
+++ b/backend/src/modules/migration/migration.test.ts
@@ -0,0 +1,354 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ConfigService } from '@nestjs/config';
+import { MigrationService } from './migration.service';
+import { DataSource } from 'typeorm';
+import { MigrationController } from './migration.controller';
+
+describe('MigrationService', () => {
+  let service: MigrationService;
+  let mockConfigService: jest.Mocked<ConfigService>;
+  let mockDataSource: jest.Mocked<DataSource> & { isInitialized?: boolean };
+
+  const mockDatabaseConfig = {
+    type: 'postgres',
+    host: 'localhost',
+    port: 5432,
+    username: 'test',
+    password: 'test',
+    database: 'test_db',
+    entities: ['**/*.entity{.ts,.js}'],
+    migrations: ['**/migrations/**/*{.ts,.js}'],
+    synchronize: false,
+    logging: false,
+  };
+
+  beforeEach(async () => {
+    mockConfigService = {
+      get: jest.fn(),
+    } as any;
+
+    mockDataSource = {
+      initialize: jest.fn().mockResolvedValue(undefined),
+      isInitialized: false,
+      destroy: jest.fn().mockResolvedValue(undefined),
+      query: jest.fn(),
+    } as any;
+
+    // Set isInitialized as writable property
+    Object.defineProperty(mockDataSource, 'isInitialized', {
+      value: false,
+      writable: true,
+      configurable: true
+    });
+
+    mockConfigService.get.mockReturnValue(mockDatabaseConfig);
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        MigrationService,
+        {
+          provide: ConfigService,
+          useValue: mockConfigService,
+        },
+      ],
+    }).compile();
+
+    service = module.get<MigrationService>(MigrationService);
+    
+    service['dataSource'] = mockDataSource;
+  });
+
+  afterEach(async () => {
+    await service.onModuleDestroy();
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('onModuleInit', () => {
+    it('should initialize data source when not initialized', async () => {
+      service['dataSource'] = null as any;
+      
+      await service.onModuleInit();
+      
+      expect(mockDataSource.initialize).toHaveBeenCalled();
+    });
+
+    it('should not initialize data source when already initialized', async () => {
+      service['dataSource'] = mockDataSource;
+      Object.defineProperty(mockDataSource, 'isInitialized', {
+        value: true,
+        writable: true,
+        configurable: true
+      });
+      
+      await service.onModuleInit();
+      
+      expect(mockDataSource.initialize).not.toHaveBeenCalled();
+    });
+
+    it('should throw error when database config is not found', async () => {
+      mockConfigService.get.mockReturnValue(null);
+      service['dataSource'] = null as any;
+      
+      await expect(service.onModuleInit()).rejects.toThrow('Database configuration not found');
+    });
+  });
+
+  describe('generateMigration', () => {
+    it('should generate migration file with correct format', async () => {
+      const migrationName = 'test-migration';
+      const fs = require('fs/promises');
+      jest.spyOn(fs, 'writeFile').mockResolvedValue(undefined);
+      
+      const result = await service.generateMigration(migrationName);
+      
+      expect(result).toContain('test-migration');
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining(`${migrationName}.ts`),
+        expect.stringContaining('implements MigrationInterface'),
+        'utf-8'
+      );
+    });
+
+    it('should convert migration name to PascalCase for class name', async () => {
+      const migrationName = 'test-migration_name';
+      const fs = require('fs/promises');
+      jest.spyOn(fs, 'writeFile').mockResolvedValue(undefined);
+      
+      await service.generateMigration(migrationName);
+      
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.stringContaining('TestMigrationName'),
+        'utf-8'
+      );
+    });
+  });
+
+  describe('validateMigrations', () => {
+    it('should validate migration files successfully', async () => {
+      const fs = require('fs/promises');
+      jest.spyOn(fs, 'readdir').mockResolvedValue(['123-test.ts']);
+      jest.spyOn(fs, 'readFile').mockResolvedValue(`
+        import { MigrationInterface, QueryRunner } from 'typeorm';
+        
+        export class Test123 implements MigrationInterface {
+          public async up(queryRunner: QueryRunner): Promise<void> {}
+          public async down(queryRunner: QueryRunner): Promise<void> {}
+        }
+      `);
+      
+      const result = await service.validateMigrations();
+      
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should detect missing MigrationInterface', async () => {
+      const fs = require('fs/promises');
+      jest.spyOn(fs, 'readdir').mockResolvedValue(['123-test.ts']);
+      jest.spyOn(fs, 'readFile').mockResolvedValue(`
+        export class Test123 {
+          public async up(queryRunner: QueryRunner): Promise<void> {}
+          public async down(queryRunner: QueryRunner): Promise<void> {}
+        }
+      `);
+      
+      const result = await service.validateMigrations();
+      
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Migration 123-test.ts does not implement MigrationInterface');
+    });
+
+    it('should detect missing up method', async () => {
+      const fs = require('fs/promises');
+      jest.spyOn(fs, 'readdir').mockResolvedValue(['123-test.ts']);
+      jest.spyOn(fs, 'readFile').mockResolvedValue(`
+        import { MigrationInterface, QueryRunner } from 'typeorm';
+        
+        export class Test123 implements MigrationInterface {
+          public async down(queryRunner: QueryRunner): Promise<void> {}
+        }
+      `);
+      
+      const result = await service.validateMigrations();
+      
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Migration 123-test.ts missing up() method');
+    });
+
+    it('should detect missing down method', async () => {
+      const fs = require('fs/promises');
+      jest.spyOn(fs, 'readdir').mockResolvedValue(['123-test.ts']);
+      jest.spyOn(fs, 'readFile').mockResolvedValue(`
+        import { MigrationInterface, QueryRunner } from 'typeorm';
+        
+        export class Test123 implements MigrationInterface {
+          public async up(queryRunner: QueryRunner): Promise<void> {}
+        }
+      `);
+      
+      const result = await service.validateMigrations();
+      
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Migration 123-test.ts missing down() method');
+    });
+  });
+
+  describe('toPascalCase', () => {
+    it('should convert snake_case to PascalCase', () => {
+      const result = service['toPascalCase']('test_migration_name');
+      expect(result).toBe('TestMigrationName');
+    });
+
+    it('should convert kebab-case to PascalCase', () => {
+      const result = service['toPascalCase']('test-migration-name');
+      expect(result).toBe('TestMigrationName');
+    });
+
+    it('should handle mixed case', () => {
+      const result = service['toPascalCase']('test-Migration_name');
+      expect(result).toBe('TestMigrationName');
+    });
+
+    it('should handle single word', () => {
+      const result = service['toPascalCase']('test');
+      expect(result).toBe('Test');
+    });
+  });
+});
+
+describe('MigrationController', () => {
+  let controller: MigrationController;
+  let mockMigrationService: jest.Mocked<MigrationService>;
+
+  beforeEach(async () => {
+    mockMigrationService = {
+      getMigrationStatus: jest.fn(),
+      runMigrations: jest.fn(),
+      rollbackLastMigration: jest.fn(),
+      rollbackToVersion: jest.fn(),
+      generateMigration: jest.fn(),
+      validateMigrations: jest.fn(),
+    } as any;
+
+    controller = new MigrationController(mockMigrationService);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  describe('getStatus', () => {
+    it('should return migration status', async () => {
+      const mockStatus = {
+        pending: ['migration1'],
+        executed: ['migration2'],
+        totalPending: 1,
+        totalExecuted: 1,
+      };
+      
+      mockMigrationService.getMigrationStatus.mockResolvedValue(mockStatus);
+      
+      const result = await controller.getStatus();
+      
+      expect(result).toEqual(mockStatus);
+      expect(mockMigrationService.getMigrationStatus).toHaveBeenCalled();
+    });
+  });
+
+  describe('runMigrations', () => {
+    it('should run migrations with transaction by default', async () => {
+      const mockResults = [
+        { success: true, migration: 'migration1', duration: 100 },
+      ];
+      
+      mockMigrationService.runMigrations.mockResolvedValue(mockResults);
+      
+      const result = await controller.runMigrations();
+      
+      expect(result).toEqual(mockResults);
+      expect(mockMigrationService.runMigrations).toHaveBeenCalledWith({ transaction: true });
+    });
+
+    it('should run migrations without transaction when specified', async () => {
+      const mockResults = [
+        { success: true, migration: 'migration1', duration: 100 },
+      ];
+      
+      mockMigrationService.runMigrations.mockResolvedValue(mockResults);
+      
+      const result = await controller.runMigrations('false');
+      
+      expect(result).toEqual(mockResults);
+      expect(mockMigrationService.runMigrations).toHaveBeenCalledWith({ transaction: false });
+    });
+  });
+
+  describe('rollbackLast', () => {
+    it('should rollback last migration', async () => {
+      const mockResult = {
+        success: true,
+        rolledBack: ['migration1'],
+        duration: 50,
+      };
+      
+      mockMigrationService.rollbackLastMigration.mockResolvedValue(mockResult);
+      
+      const result = await controller.rollbackLast();
+      
+      expect(result).toEqual(mockResult);
+      expect(mockMigrationService.rollbackLastMigration).toHaveBeenCalled();
+    });
+  });
+
+  describe('rollbackToVersion', () => {
+    it('should rollback to specific version', async () => {
+      const mockResult = {
+        success: true,
+        rolledBack: ['migration2', 'migration1'],
+        duration: 100,
+      };
+      
+      mockMigrationService.rollbackToVersion.mockResolvedValue(mockResult);
+      
+      const result = await controller.rollbackToVersion('target-version');
+      
+      expect(result).toEqual(mockResult);
+      expect(mockMigrationService.rollbackToVersion).toHaveBeenCalledWith('target-version');
+    });
+  });
+
+  describe('generateMigration', () => {
+    it('should generate migration with valid name', async () => {
+      const mockResult = { filePath: '/path/to/migration.ts' };
+      
+      mockMigrationService.generateMigration.mockResolvedValue(mockResult.filePath);
+      
+      const result = await controller.generateMigration('test-migration');
+      
+      expect(result).toEqual(mockResult);
+      expect(mockMigrationService.generateMigration).toHaveBeenCalledWith('test-migration');
+    });
+
+    it('should throw error for empty name', async () => {
+      await expect(controller.generateMigration('')).rejects.toThrow('Migration name is required');
+      await expect(controller.generateMigration('   ')).rejects.toThrow('Migration name is required');
+    });
+  });
+
+  describe('validateMigrations', () => {
+    it('should validate migrations', async () => {
+      const mockResult = { valid: true, errors: [] };
+      
+      mockMigrationService.validateMigrations.mockResolvedValue(mockResult);
+      
+      const result = await controller.validateMigrations();
+      
+      expect(result).toEqual(mockResult);
+      expect(mockMigrationService.validateMigrations).toHaveBeenCalled();
+    });
+  });
+});
diff --git a/backend/tsconfig.json b/backend/tsconfig.json
index e09d1338..a24efcc8 100644
--- a/backend/tsconfig.json
+++ b/backend/tsconfig.json
@@ -1,28 +1,30 @@
 {
   "compilerOptions": {
-    "ignoreDeprecations": "5.0",
-    "module": "nodenext",
-    "moduleResolution": "nodenext",
-    "resolvePackageJsonExports": true,
-    "esModuleInterop": true,
-    "isolatedModules": true,
+    "module": "commonjs",
+    "moduleResolution": "node",
     "declaration": true,
     "removeComments": true,
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,
     "allowSyntheticDefaultImports": true,
-    "target": "ESNext",
+    "target": "ES2020",
     "sourceMap": true,
     "outDir": "./dist",
     "baseUrl": "./",
     "incremental": true,
     "skipLibCheck": true,
-    "strictNullChecks": true,
-    "forceConsistentCasingInFileNames": true,
+    "strictNullChecks": false,
     "noImplicitAny": false,
     "strictBindCallApply": false,
     "noFallthroughCasesInSwitch": false,
-    "types": ["node", "jest", "jest/globals"]
+    "forceConsistentCasingInFileNames": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "types": ["node", "jest"],
+    "paths": {
+      "@/*": ["src/*"],
+      "@/*/*": ["src/*/*"]
+    }
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]