diff --git a/PRISMA_TO_RAW_QUERY_MIGRATION_PLAN.md b/PRISMA_TO_RAW_QUERY_MIGRATION_PLAN.md
new file mode 100644
index 00000000..dfa30a01
--- /dev/null
+++ b/PRISMA_TO_RAW_QUERY_MIGRATION_PLAN.md
@@ -0,0 +1,969 @@
+# 🚀 Prisma → Raw Query 완전 전환 계획서
+
+## 📋 프로젝트 개요
+
+### 🎯 목적
+
+현재 Node.js 백엔드에서 Prisma ORM을 완전히 제거하고 Raw Query 방식으로 전환하여 **완전 동적 테이블 생성 및 관리 시스템**을 구축합니다.
+
+### 🔍 현재 상황 분석
+
+- **총 42개 파일**에서 Prisma 사용
+- **386개의 Prisma 호출** (ORM + Raw Query 혼재)
+- **150개 이상의 테이블** 정의 (schema.prisma)
+- **복잡한 트랜잭션 및 동적 쿼리** 다수 존재
+
+---
+
+## 📊 Prisma 사용 현황 분석
+
+### 1. **Prisma 사용 파일 분류**
+
+#### 🔴 **High Priority (핵심 서비스)**
+
+```
+backend-node/src/services/
+├── authService.ts                    # 인증 (5개 호출)
+├── dynamicFormService.ts             # 동적 폼 (14개 호출)
+├── dataflowControlService.ts         # 제어관리 (6개 호출)
+├── multiConnectionQueryService.ts    # 다중 연결 (4개 호출)
+├── tableManagementService.ts         # 테이블 관리 (34개 호출)
+├── screenManagementService.ts        # 화면 관리 (40개 호출)
+└── ddlExecutionService.ts            # DDL 실행 (4개 호출)
+```
+
+#### 🟡 **Medium Priority (관리 기능)**
+
+```
+backend-node/src/services/
+├── adminService.ts                   # 관리자 (3개 호출)
+├── multilangService.ts               # 다국어 (22개 호출)
+├── commonCodeService.ts              # 공통코드 (13개 호출)
+├── externalDbConnectionService.ts    # 외부DB (15개 호출)
+├── batchService.ts                   # 배치 (13개 호출)
+└── eventTriggerService.ts            # 이벤트 (6개 호출)
+```
+
+#### 🟢 **Low Priority (부가 기능)**
+
+```
+backend-node/src/services/
+├── layoutService.ts                  # 레이아웃 (8개 호출)
+├── componentStandardService.ts       # 컴포넌트 (11개 호출)
+├── templateStandardService.ts        # 템플릿 (8개 호출)
+├── collectionService.ts              # 컬렉션 (11개 호출)
+└── referenceCacheService.ts          # 캐시 (3개 호출)
+```
+
+### 2. **복잡도별 분류**
+
+#### 🔥 **매우 복잡 (트랜잭션 + 동적 쿼리)**
+
+- `dataflowControlService.ts` - 복잡한 제어 로직
+- `enhancedDataflowControlService.ts` - 다중 연결 제어
+- `dynamicFormService.ts` - UPSERT 및 동적 테이블 처리
+- `multiConnectionQueryService.ts` - 외부 DB 연결
+
+#### 🟠 **복잡 (Raw Query 혼재)**
+
+- `tableManagementService.ts` - 테이블 메타데이터 관리
+- `screenManagementService.ts` - 화면 정의 관리
+- `eventTriggerService.ts` - JSON 검색 쿼리
+
+#### 🟡 **중간 (단순 CRUD)**
+
+- `authService.ts` - 사용자 인증
+- `adminService.ts` - 관리자 메뉴
+- `commonCodeService.ts` - 코드 관리
+
+---
+
+## 🏗️ Raw Query 아키텍처 설계
+
+### 1. **새로운 데이터베이스 매니저**
+
+```typescript
+// config/databaseManager.ts
+import { Pool, PoolClient } from "pg";
+
+export class DatabaseManager {
+  private static pool: Pool;
+
+  static initialize() {
+    this.pool = new Pool({
+      host: process.env.DB_HOST,
+      port: parseInt(process.env.DB_PORT || "5432"),
+      database: process.env.DB_NAME,
+      user: process.env.DB_USER,
+      password: process.env.DB_PASSWORD,
+      max: 20,
+      idleTimeoutMillis: 30000,
+      connectionTimeoutMillis: 2000,
+    });
+  }
+
+  // 기본 쿼리 실행
+  static async query(text: string, params?: any[]): Promise<any[]> {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(text, params);
+      return result.rows;
+    } finally {
+      client.release();
+    }
+  }
+
+  // 트랜잭션 실행
+  static async transaction<T>(
+    callback: (client: PoolClient) => Promise<T>
+  ): Promise<T> {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await callback(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+
+  // 연결 종료
+  static async close() {
+    await this.pool.end();
+  }
+}
+```
+
+### 2. **동적 쿼리 빌더**
+
+```typescript
+// utils/queryBuilder.ts
+export class QueryBuilder {
+  // SELECT 쿼리 빌더
+  static select(
+    tableName: string,
+    options: {
+      columns?: string[];
+      where?: Record<string, any>;
+      orderBy?: string;
+      limit?: number;
+      offset?: number;
+      joins?: Array<{
+        type: "INNER" | "LEFT" | "RIGHT";
+        table: string;
+        on: string;
+      }>;
+    } = {}
+  ) {
+    const {
+      columns = ["*"],
+      where = {},
+      orderBy,
+      limit,
+      offset,
+      joins = [],
+    } = options;
+
+    let query = `SELECT ${columns.join(", ")} FROM ${tableName}`;
+    const params: any[] = [];
+    let paramIndex = 1;
+
+    // JOIN 처리
+    joins.forEach((join) => {
+      query += ` ${join.type} JOIN ${join.table} ON ${join.on}`;
+    });
+
+    // WHERE 조건
+    if (Object.keys(where).length > 0) {
+      const whereClause = Object.keys(where)
+        .map((key) => `${key} = $${paramIndex++}`)
+        .join(" AND ");
+      query += ` WHERE ${whereClause}`;
+      params.push(...Object.values(where));
+    }
+
+    // ORDER BY
+    if (orderBy) {
+      query += ` ORDER BY ${orderBy}`;
+    }
+
+    // LIMIT/OFFSET
+    if (limit) {
+      query += ` LIMIT $${paramIndex++}`;
+      params.push(limit);
+    }
+    if (offset) {
+      query += ` OFFSET $${paramIndex++}`;
+      params.push(offset);
+    }
+
+    return { query, params };
+  }
+
+  // INSERT 쿼리 빌더
+  static insert(
+    tableName: string,
+    data: Record<string, any>,
+    options: {
+      returning?: string[];
+      onConflict?: {
+        columns: string[];
+        action: "DO NOTHING" | "DO UPDATE";
+        updateSet?: string[];
+      };
+    } = {}
+  ) {
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = values.map((_, index) => `$${index + 1}`).join(", ");
+
+    let query = `INSERT INTO ${tableName} (${columns.join(
+      ", "
+    )}) VALUES (${placeholders})`;
+
+    // ON CONFLICT 처리 (UPSERT)
+    if (options.onConflict) {
+      const {
+        columns: conflictColumns,
+        action,
+        updateSet,
+      } = options.onConflict;
+      query += ` ON CONFLICT (${conflictColumns.join(", ")}) ${action}`;
+
+      if (action === "DO UPDATE" && updateSet) {
+        const setClause = updateSet
+          .map((col) => `${col} = EXCLUDED.${col}`)
+          .join(", ");
+        query += ` SET ${setClause}`;
+      }
+    }
+
+    // RETURNING 처리
+    if (options.returning) {
+      query += ` RETURNING ${options.returning.join(", ")}`;
+    }
+
+    return { query, params: values };
+  }
+
+  // UPDATE 쿼리 빌더
+  static update(
+    tableName: string,
+    data: Record<string, any>,
+    where: Record<string, any>
+  ) {
+    const setClause = Object.keys(data)
+      .map((key, index) => `${key} = $${index + 1}`)
+      .join(", ");
+
+    const whereClause = Object.keys(where)
+      .map((key, index) => `${key} = $${Object.keys(data).length + index + 1}`)
+      .join(" AND ");
+
+    const query = `UPDATE ${tableName} SET ${setClause} WHERE ${whereClause} RETURNING *`;
+    const params = [...Object.values(data), ...Object.values(where)];
+
+    return { query, params };
+  }
+
+  // DELETE 쿼리 빌더
+  static delete(tableName: string, where: Record<string, any>) {
+    const whereClause = Object.keys(where)
+      .map((key, index) => `${key} = $${index + 1}`)
+      .join(" AND ");
+
+    const query = `DELETE FROM ${tableName} WHERE ${whereClause} RETURNING *`;
+    const params = Object.values(where);
+
+    return { query, params };
+  }
+}
+```
+
+### 3. **타입 안전성 보장**
+
+```typescript
+// types/database.ts
+export interface QueryResult<T = any> {
+  rows: T[];
+  rowCount: number;
+  command: string;
+}
+
+export interface TableSchema {
+  tableName: string;
+  columns: ColumnDefinition[];
+}
+
+export interface ColumnDefinition {
+  name: string;
+  type: string;
+  nullable?: boolean;
+  defaultValue?: string;
+  isPrimaryKey?: boolean;
+}
+
+// 런타임 검증
+export class DatabaseValidator {
+  static validateTableName(tableName: string): boolean {
+    return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tableName) && tableName.length <= 63;
+  }
+
+  static validateColumnName(columnName: string): boolean {
+    return (
+      /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(columnName) && columnName.length <= 63
+    );
+  }
+
+  static sanitizeInput(input: any): any {
+    if (typeof input === "string") {
+      return input.replace(/[';--]/g, "");
+    }
+    return input;
+  }
+
+  static validateWhereClause(where: Record<string, any>): boolean {
+    return Object.keys(where).every((key) => this.validateColumnName(key));
+  }
+}
+```
+
+---
+
+## 📅 단계별 마이그레이션 계획
+
+### **Phase 1: 기반 구조 구축 (1주)**
+
+#### 1.1 새로운 데이터베이스 아키텍처 구현
+
+- [ ] `DatabaseManager` 클래스 구현
+- [ ] `QueryBuilder` 유틸리티 구현
+- [ ] 타입 정의 및 검증 로직 구현
+- [ ] 연결 풀 및 트랜잭션 관리
+
+#### 1.2 테스트 환경 구축
+
+- [ ] 단위 테스트 작성
+- [ ] 통합 테스트 환경 구성
+- [ ] 성능 벤치마크 도구 준비
+
+### **Phase 2: 핵심 서비스 전환 (2주)**
+
+#### 2.1 인증 서비스 전환 (우선순위 1)
+
+```typescript
+// 기존 Prisma 코드
+const userInfo = await prisma.user_info.findUnique({
+  where: { user_id: userId },
+});
+
+// 새로운 Raw Query 코드
+const { query, params } = QueryBuilder.select("user_info", {
+  where: { user_id: userId },
+});
+const userInfo = await DatabaseManager.query(query, params);
+```
+
+#### 2.2 동적 폼 서비스 전환 (우선순위 2)
+
+- [ ] UPSERT 로직 Raw Query로 전환
+- [ ] 동적 테이블 처리 로직 개선
+- [ ] 트랜잭션 처리 최적화
+
+#### 2.3 제어관리 서비스 전환 (우선순위 3)
+
+- [ ] 복잡한 조건부 쿼리 전환
+- [ ] 다중 테이블 업데이트 로직 개선
+- [ ] 에러 핸들링 강화
+
+### **Phase 3: 관리 기능 전환 (1.5주)**
+
+#### 3.1 테이블 관리 서비스
+
+- [ ] 메타데이터 조회 쿼리 전환
+- [ ] 동적 컬럼 추가/삭제 로직
+- [ ] 인덱스 관리 기능
+
+#### 3.2 화면 관리 서비스
+
+- [ ] JSON 데이터 처리 최적화
+- [ ] 복잡한 조인 쿼리 전환
+- [ ] 캐싱 메커니즘 구현
+
+#### 3.3 다국어 서비스
+
+- [ ] 재귀 쿼리 (WITH RECURSIVE) 전환
+- [ ] 번역 데이터 관리 최적화
+
+### **Phase 4: 부가 기능 전환 (1주)**
+
+#### 4.1 배치 및 외부 연결
+
+- [ ] 배치 스케줄러 전환
+- [ ] 외부 DB 연결 관리
+- [ ] 로그 및 모니터링
+
+#### 4.2 표준 관리 기능
+
+- [ ] 컴포넌트 표준 관리
+- [ ] 템플릿 표준 관리
+- [ ] 레이아웃 관리
+
+### **Phase 5: Prisma 완전 제거 (0.5주)**
+
+#### 5.1 Prisma 의존성 제거
+
+- [ ] `package.json`에서 Prisma 제거
+- [ ] `schema.prisma` 파일 삭제
+- [ ] 관련 설정 파일 정리
+
+#### 5.2 최종 검증 및 최적화
+
+- [ ] 전체 기능 테스트
+- [ ] 성능 최적화
+- [ ] 문서화 업데이트
+
+---
+
+## 🔄 마이그레이션 전략
+
+### 1. **점진적 전환 방식**
+
+#### 단계별 전환
+
+```typescript
+// 1단계: 기존 Prisma 코드 유지하면서 Raw Query 병행
+class AuthService {
+  // 기존 방식 (임시 유지)
+  async loginWithPrisma(userId: string) {
+    return await prisma.user_info.findUnique({
+      where: { user_id: userId },
+    });
+  }
+
+  // 새로운 방식 (점진적 도입)
+  async loginWithRawQuery(userId: string) {
+    const { query, params } = QueryBuilder.select("user_info", {
+      where: { user_id: userId },
+    });
+    return await DatabaseManager.query(query, params);
+  }
+}
+
+// 2단계: 기존 메서드를 새로운 방식으로 교체
+class AuthService {
+  async login(userId: string) {
+    return await this.loginWithRawQuery(userId);
+  }
+}
+
+// 3단계: 기존 코드 완전 제거
+```
+
+### 2. **호환성 레이어**
+
+```typescript
+// utils/prismaCompatibility.ts
+export class PrismaCompatibilityLayer {
+  // 기존 Prisma 호출을 Raw Query로 변환하는 어댑터
+  static async findUnique(model: string, options: any) {
+    const { where } = options;
+    const { query, params } = QueryBuilder.select(model, { where });
+    const results = await DatabaseManager.query(query, params);
+    return results[0] || null;
+  }
+
+  static async findMany(model: string, options: any = {}) {
+    const { where, orderBy, take: limit, skip: offset } = options;
+    const { query, params } = QueryBuilder.select(model, {
+      where,
+      orderBy,
+      limit,
+      offset,
+    });
+    return await DatabaseManager.query(query, params);
+  }
+
+  static async create(model: string, options: any) {
+    const { data } = options;
+    const { query, params } = QueryBuilder.insert(model, data, {
+      returning: ["*"],
+    });
+    const results = await DatabaseManager.query(query, params);
+    return results[0];
+  }
+}
+```
+
+### 3. **테스트 전략**
+
+#### 병렬 테스트
+
+```typescript
+// tests/migration.test.ts
+describe("Prisma to Raw Query Migration", () => {
+  test("AuthService: 동일한 결과 반환", async () => {
+    const userId = "test_user";
+
+    // 기존 Prisma 결과
+    const prismaResult = await authService.loginWithPrisma(userId);
+
+    // 새로운 Raw Query 결과
+    const rawQueryResult = await authService.loginWithRawQuery(userId);
+
+    // 결과 비교
+    expect(rawQueryResult).toEqual(prismaResult);
+  });
+});
+```
+
+---
+
+## 🚨 위험 요소 및 대응 방안
+
+### 1. **데이터 일관성 위험**
+
+#### 위험 요소
+
+- 트랜잭션 처리 미스
+- 타입 변환 오류
+- NULL 처리 차이
+
+#### 대응 방안
+
+```typescript
+// 엄격한 트랜잭션 관리
+export class TransactionManager {
+  static async executeInTransaction<T>(
+    operations: ((client: PoolClient) => Promise<T>)[]
+  ): Promise<T[]> {
+    return await DatabaseManager.transaction(async (client) => {
+      const results: T[] = [];
+      for (const operation of operations) {
+        const result = await operation(client);
+        results.push(result);
+      }
+      return results;
+    });
+  }
+}
+
+// 타입 안전성 검증
+export class TypeConverter {
+  static toPostgresType(value: any, expectedType: string): any {
+    switch (expectedType) {
+      case "integer":
+        return parseInt(value) || null;
+      case "decimal":
+        return parseFloat(value) || null;
+      case "boolean":
+        return Boolean(value);
+      case "timestamp":
+        return value ? new Date(value) : null;
+      default:
+        return value;
+    }
+  }
+}
+```
+
+### 2. **성능 저하 위험**
+
+#### 위험 요소
+
+- 연결 풀 관리 미흡
+- 쿼리 최적화 부족
+- 캐싱 메커니즘 부재
+
+#### 대응 방안
+
+```typescript
+// 연결 풀 최적화
+export class ConnectionPoolManager {
+  private static readonly DEFAULT_POOL_CONFIG = {
+    min: 2,
+    max: 20,
+    acquireTimeoutMillis: 30000,
+    createTimeoutMillis: 30000,
+    destroyTimeoutMillis: 5000,
+    idleTimeoutMillis: 30000,
+    reapIntervalMillis: 1000,
+    createRetryIntervalMillis: 200,
+  };
+}
+
+// 쿼리 캐싱
+export class QueryCache {
+  private static cache = new Map<string, { data: any; timestamp: number }>();
+  private static readonly CACHE_TTL = 5 * 60 * 1000; // 5분
+
+  static get(key: string): any | null {
+    const cached = this.cache.get(key);
+    if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
+      return cached.data;
+    }
+    this.cache.delete(key);
+    return null;
+  }
+
+  static set(key: string, data: any): void {
+    this.cache.set(key, { data, timestamp: Date.now() });
+  }
+}
+```
+
+### 3. **개발 생산성 저하**
+
+#### 위험 요소
+
+- 타입 안전성 부족
+- 디버깅 어려움
+- 코드 복잡성 증가
+
+#### 대응 방안
+
+```typescript
+// 개발자 친화적 인터페이스
+export class DatabaseORM {
+  // Prisma와 유사한 인터페이스 제공
+  user_info = {
+    findUnique: (options: { where: Record<string, any> }) =>
+      PrismaCompatibilityLayer.findUnique("user_info", options),
+
+    findMany: (options?: any) =>
+      PrismaCompatibilityLayer.findMany("user_info", options),
+
+    create: (options: { data: Record<string, any> }) =>
+      PrismaCompatibilityLayer.create("user_info", options),
+  };
+
+  // 다른 테이블들도 동일한 패턴으로 구현
+}
+
+// 디버깅 도구
+export class QueryLogger {
+  static log(query: string, params: any[], executionTime: number) {
+    if (process.env.NODE_ENV === "development") {
+      console.log(`🔍 Query: ${query}`);
+      console.log(`📊 Params: ${JSON.stringify(params)}`);
+      console.log(`⏱️  Time: ${executionTime}ms`);
+    }
+  }
+}
+```
+
+---
+
+## 📈 성능 최적화 전략
+
+### 1. **연결 풀 최적화**
+
+```typescript
+// config/optimizedPool.ts
+export class OptimizedPoolConfig {
+  static getConfig() {
+    return {
+      // 환경별 최적화된 설정
+      max: process.env.NODE_ENV === "production" ? 20 : 5,
+      min: process.env.NODE_ENV === "production" ? 5 : 2,
+
+      // 연결 타임아웃 최적화
+      acquireTimeoutMillis: 30000,
+      createTimeoutMillis: 30000,
+
+      // 유휴 연결 관리
+      idleTimeoutMillis: 600000, // 10분
+
+      // 연결 검증
+      testOnBorrow: true,
+      validationQuery: "SELECT 1",
+    };
+  }
+}
+```
+
+### 2. **쿼리 최적화**
+
+```typescript
+// utils/queryOptimizer.ts
+export class QueryOptimizer {
+  // 인덱스 힌트 추가
+  static addIndexHint(query: string, indexName: string): string {
+    return query.replace(
+      /FROM\s+(\w+)/i,
+      `FROM $1 /*+ INDEX($1 ${indexName}) */`
+    );
+  }
+
+  // 쿼리 분석 및 최적화 제안
+  static analyzeQuery(query: string): QueryAnalysis {
+    return {
+      hasIndex: this.checkIndexUsage(query),
+      estimatedRows: this.estimateRowCount(query),
+      suggestions: this.generateOptimizationSuggestions(query),
+    };
+  }
+}
+```
+
+### 3. **캐싱 전략**
+
+```typescript
+// utils/smartCache.ts
+export class SmartCache {
+  private static redis: Redis; // Redis 클라이언트
+
+  // 테이블별 캐시 전략
+  static async get(key: string, tableName: string): Promise<any> {
+    const cacheConfig = this.getCacheConfig(tableName);
+
+    if (!cacheConfig.enabled) return null;
+
+    const cached = await this.redis.get(key);
+    return cached ? JSON.parse(cached) : null;
+  }
+
+  static async set(key: string, data: any, tableName: string): Promise<void> {
+    const cacheConfig = this.getCacheConfig(tableName);
+
+    if (cacheConfig.enabled) {
+      await this.redis.setex(key, cacheConfig.ttl, JSON.stringify(data));
+    }
+  }
+
+  private static getCacheConfig(tableName: string) {
+    const configs = {
+      user_info: { enabled: true, ttl: 300 }, // 5분
+      menu_info: { enabled: true, ttl: 600 }, // 10분
+      dynamic_tables: { enabled: false, ttl: 0 }, // 동적 테이블은 캐시 안함
+    };
+
+    return configs[tableName] || { enabled: false, ttl: 0 };
+  }
+}
+```
+
+---
+
+## 🧪 테스트 전략
+
+### 1. **단위 테스트**
+
+```typescript
+// tests/unit/queryBuilder.test.ts
+describe("QueryBuilder", () => {
+  test("SELECT 쿼리 생성", () => {
+    const { query, params } = QueryBuilder.select("user_info", {
+      where: { user_id: "test" },
+      limit: 10,
+    });
+
+    expect(query).toBe("SELECT * FROM user_info WHERE user_id = $1 LIMIT $2");
+    expect(params).toEqual(["test", 10]);
+  });
+
+  test("복잡한 JOIN 쿼리", () => {
+    const { query, params } = QueryBuilder.select("user_info", {
+      joins: [
+        {
+          type: "LEFT",
+          table: "dept_info",
+          on: "user_info.dept_code = dept_info.dept_code",
+        },
+      ],
+      where: { "user_info.status": "active" },
+    });
+
+    expect(query).toContain("LEFT JOIN dept_info");
+    expect(query).toContain("WHERE user_info.status = $1");
+  });
+});
+```
+
+### 2. **통합 테스트**
+
+```typescript
+// tests/integration/migration.test.ts
+describe("Migration Integration Tests", () => {
+  let prismaService: any;
+  let rawQueryService: any;
+
+  beforeAll(async () => {
+    // 테스트 데이터베이스 설정
+    await setupTestDatabase();
+  });
+
+  test("동일한 결과 반환 - 사용자 조회", async () => {
+    const testUserId = "integration_test_user";
+
+    const prismaResult = await prismaService.getUser(testUserId);
+    const rawQueryResult = await rawQueryService.getUser(testUserId);
+
+    expect(normalizeResult(rawQueryResult)).toEqual(
+      normalizeResult(prismaResult)
+    );
+  });
+
+  test("트랜잭션 일관성 - 복잡한 업데이트", async () => {
+    const testData = {
+      /* 테스트 데이터 */
+    };
+
+    // Prisma 트랜잭션
+    const prismaResult = await prismaService.complexUpdate(testData);
+
+    // Raw Query 트랜잭션
+    const rawQueryResult = await rawQueryService.complexUpdate(testData);
+
+    expect(rawQueryResult.success).toBe(prismaResult.success);
+  });
+});
+```
+
+### 3. **성능 테스트**
+
+```typescript
+// tests/performance/benchmark.test.ts
+describe("Performance Benchmarks", () => {
+  test("대량 데이터 조회 성능", async () => {
+    const iterations = 1000;
+
+    // Prisma 성능 측정
+    const prismaStart = Date.now();
+    for (let i = 0; i < iterations; i++) {
+      await prismaService.getLargeDataset();
+    }
+    const prismaTime = Date.now() - prismaStart;
+
+    // Raw Query 성능 측정
+    const rawQueryStart = Date.now();
+    for (let i = 0; i < iterations; i++) {
+      await rawQueryService.getLargeDataset();
+    }
+    const rawQueryTime = Date.now() - rawQueryStart;
+
+    console.log(`Prisma: ${prismaTime}ms, Raw Query: ${rawQueryTime}ms`);
+
+    // Raw Query가 더 빠르거나 비슷해야 함
+    expect(rawQueryTime).toBeLessThanOrEqual(prismaTime * 1.1);
+  });
+});
+```
+
+---
+
+## 📋 체크리스트
+
+### **Phase 1: 기반 구조 (1주)**
+
+- [ ] DatabaseManager 클래스 구현
+- [ ] QueryBuilder 유틸리티 구현
+- [ ] 타입 정의 및 검증 로직
+- [ ] 연결 풀 설정 및 최적화
+- [ ] 트랜잭션 관리 시스템
+- [ ] 에러 핸들링 메커니즘
+- [ ] 로깅 및 모니터링 도구
+- [ ] 단위 테스트 작성
+
+### **Phase 2: 핵심 서비스 (2주)**
+
+- [ ] AuthService 전환 및 테스트
+- [ ] DynamicFormService 전환 (UPSERT 포함)
+- [ ] DataflowControlService 전환 (복잡한 로직)
+- [ ] MultiConnectionQueryService 전환
+- [ ] TableManagementService 전환
+- [ ] ScreenManagementService 전환
+- [ ] DDLExecutionService 전환
+- [ ] 통합 테스트 실행
+
+### **Phase 3: 관리 기능 (1.5주)**
+
+- [ ] AdminService 전환
+- [ ] MultiLangService 전환 (재귀 쿼리)
+- [ ] CommonCodeService 전환
+- [ ] ExternalDbConnectionService 전환
+- [ ] BatchService 및 관련 서비스 전환
+- [ ] EventTriggerService 전환
+- [ ] 기능별 테스트 완료
+
+### **Phase 4: 부가 기능 (1주)**
+
+- [ ] LayoutService 전환
+- [ ] ComponentStandardService 전환
+- [ ] TemplateStandardService 전환
+- [ ] CollectionService 전환
+- [ ] ReferenceCacheService 전환
+- [ ] 기타 컨트롤러 전환
+- [ ] 전체 기능 테스트
+
+### **Phase 5: 완전 제거 (0.5주)**
+
+- [ ] Prisma 의존성 제거
+- [ ] schema.prisma 삭제
+- [ ] 관련 설정 파일 정리
+- [ ] 문서 업데이트
+- [ ] 최종 성능 테스트
+- [ ] 배포 준비
+
+---
+
+## 🎯 성공 기준
+
+### **기능적 요구사항**
+
+- [ ] 모든 기존 기능이 동일하게 작동
+- [ ] 동적 테이블 생성/관리 완벽 지원
+- [ ] 트랜잭션 일관성 보장
+- [ ] 에러 처리 및 복구 메커니즘
+
+### **성능 요구사항**
+
+- [ ] 기존 대비 성능 저하 없음 (±10% 이내)
+- [ ] 메모리 사용량 최적화
+- [ ] 연결 풀 효율성 개선
+- [ ] 쿼리 실행 시간 단축
+
+### **품질 요구사항**
+
+- [ ] 코드 커버리지 90% 이상
+- [ ] 모든 테스트 케이스 통과
+- [ ] 타입 안전성 보장
+- [ ] 보안 검증 완료
+
+---
+
+## 📚 참고 자료
+
+### **기술 문서**
+
+- [PostgreSQL 공식 문서](https://www.postgresql.org/docs/)
+- [Node.js pg 라이브러리](https://node-postgres.com/)
+- [SQL 쿼리 최적화 가이드](https://use-the-index-luke.com/)
+
+### **내부 문서**
+
+- [현재 데이터베이스 스키마](backend-node/prisma/schema.prisma)
+- [기존 Java 시스템 구조](src/com/pms/)
+- [동적 테이블 생성 계획서](테이블_동적_생성_기능_개발_계획서.md)
+
+---
+
+## ⚠️ 주의사항
+
+1. **데이터 백업**: 마이그레이션 전 전체 데이터베이스 백업 필수
+2. **점진적 전환**: 한 번에 모든 것을 바꾸지 말고 단계별로 진행
+3. **철저한 테스트**: 각 단계마다 충분한 테스트 수행
+4. **롤백 계획**: 문제 발생 시 즉시 롤백할 수 있는 계획 수립
+5. **모니터링**: 전환 후 성능 및 안정성 지속 모니터링
+
+---
+
+**총 예상 기간: 6주**
+**핵심 개발자: 2-3명**
+**위험도: 중간 (적절한 계획과 테스트로 관리 가능)**
+
+이 계획을 통해 Prisma를 완전히 제거하고 진정한 동적 데이터베이스 시스템을 구축할 수 있습니다! 🚀