docs(roadmap): update roadmap with new features and completed items

.cursorrules

···
 - Use guard clauses at the beginning of functions to handle edge cases
 - **Prefer ternary operations** over if/else for simple conditional assignments
 - Use ternary for inline conditionals: `condition ? valueIfTrue : valueIfFalse`
+- **If statements should have proper formatting**: curly brackets and whitespace
+- **Always use curly braces for if/else statements** - never omit braces even for single-line statements
+- **Always add a newline after if/else keywords** - format as: `if (condition) {\n  // code\n}` not `if (condition) { // code }`
+- **Prefer ternary expressions** over if statements when possible for cleaner code
 
 ### Destructuring & Assignment
 - **Prefer destructuring** for object and array access
 - Use destructuring in function parameters: `({ id, name }) => ...`
 - Use destructuring for imports: `import { Component } from 'library'`
 - Prefer object spread over Object.assign: `{ ...obj, newProp: value }`
+- **Use object property shorthand** when variable names match object keys
+- Example: Use `{ where }` instead of `{ where: whereClause }`
+- Name variables appropriately to enable shorthand syntax (e.g., `where` not `whereClause`)
+
+### Exports
+- **Prefer named exports** over default exports for consistency and better refactoring support
+- Use `export const Component = () => {}` instead of `export default function Component() {}`
+- Named exports make imports explicit and enable better IDE support
+- Exception: Only use default exports when required by frameworks (e.g., Next.js pages)
 
 ### Variable Declarations
 - **Prefer `const`** over `let` where possible
···
 - Extract inline SVGs to separate icon components
 - **Prefer CVA (Class Variance Authority) for dynamic styling configurations**
 - Use CVA for conditional styling patterns instead of manual className concatenation
+- **Prefer single state object over multiple useState calls**
+- Use `useState` with object state when managing multiple related values
+- Example: `const [state, setState] = useState({ items: [], loading: false, error: null })`
 
 ### NestJS/Backend
 - Use dependency injection properly with regular imports (not `import type`)
···
 - **Use `getOrThrow()` for configuration values instead of manual error throwing**
 - Inject ConfigService where needed for environment variable access
 - Use proper type annotations with `getOrThrow<Type>("VARIABLE_NAME")`
+- **One injectable service/class per file** - keep services focused and maintainable
+- **Extract domain mapping logic to separate mapper files** - services should not contain `toDomain()` methods
+- **Services should contain pure domain logic** - no GraphQL concerns (connections, edges, pageInfo)
+- **GraphQL resolvers handle connection composition** - services only provide `findMany()` and `count()` methods
 
 ### GraphQL
 - **Prefer `.graphql` files for queries and mutations** instead of inline strings
···
 - Prefer specific error types over generic Error
 - Use optional chaining (`?.`) for safe property access
 - Handle errors at the appropriate level of abstraction
+- **Use `notFound()` utility for consistent 404 errors**
+- **Include property and value in error messages**: `notFound("Entity", "property", value)`
+- **Prefer ternary expressions with `notFound()` for early returns**: `return entity ?? notFound("Entity", "id", id)`
 
 ### Code Organization
 - Group related functionality together
 - Use barrel exports (`index.ts`) for clean imports
 - Prefer composition over inheritance
 - Keep functions small and focused on single responsibility
+
+### Comments
+- **Avoid inline comments** - code should be self-documenting through clear naming and structure
+- Use descriptive variable and function names instead of comments
+- Only add comments when absolutely necessary to explain complex business logic or non-obvious behavior
+- Prefer JSDoc comments for public APIs and complex functions when documentation is needed
+
+### Import Management
+- **Prefer TypeScript path aliases over relative directory traversal**
+- Use `@/` alias for all imports within the project
+- Avoid relative imports like `../`, `../../`, `../../../`
+- Use absolute paths with aliases: `@/modules/entity/entity.service`
+- This improves maintainability and reduces import path complexity
 
 ### Performance
 - Use `useMemo` and `useCallback` judiciously in React
···
     animated: false,
   },
 });
+
+// TypeScript path aliases for imports
+import { CompanyService } from "@/modules/job-experience/company/company.service";
+import { BasePaginationArgs } from "@/modules/base/pagination.types";
+import { User } from "@/modules/auth/user.entity";
+
+// Error handling with notFound utility
+async findByIdOrFail(id: string): Promise<Company> {
+  const company = await this.findById(id);
+  return company ?? notFound("Company", "id", id);
+}
+
+// Proper if statement formatting (when ternary isn't suitable)
+if (user.isActive) {
+  return processUser(user);
+}
+
+// If/else with proper formatting
+if (user.isActive) {
+  return processUser(user);
+} else {
+  return null;
+}
+
+// Ternary expressions for simple conditionals
+const statusColor = isActive ? 'green' : 'red';
+const message = user ? `Hello ${user.name}` : 'Hello Guest';
 ```
 
 ### Avoid ❌
···
 
 // Direct process.env access without proper validation
 const port = process.env["PORT"] || "3000";
+
+// Relative directory traversal imports
+import { CompanyService } from "../company/company.service";
+import { BasePaginationArgs } from "../../../base/pagination.types";
+import { User } from "../../auth/user.entity";
+
+// Verbose error handling
+async findByIdOrFail(id: string): Promise<Company> {
+  const company = await this.findById(id);
+  if (!company) {
+    throw new NotFoundException(`Company with id ${id} not found`);
+  }
+  return company;
+}
+
+// Poor if statement formatting
+if(user.isActive)return processUser(user);
+
+// Missing curly braces
+if (user.isActive) return processUser(user);
+
+// Missing newline after if
+if (user.isActive) { return processUser(user); }
+
+// Verbose conditionals that could be ternary
+let statusColor;
+if (isActive) {
+  statusColor = 'green';
+} else {
+  statusColor = 'red';
+}
 ```
 
 ## Project-Specific Rules
···
 - Use arrow functions for resolvers
 - Prefer early returns for validation
 - Use destructuring for resolver parameters
+- **Prefer GraphQL Relay-style connections over arrays** for list queries
+- Use `Connection` types with `edges`, `pageInfo`, and `totalCount` for paginated data
+- Only return arrays for small, non-paginated lists (e.g., enum values, small reference data)
+- Resolvers should compose connections from service `findMany()` and `count()` methods using `PaginationService`
 
 ### Three-Layer Architecture
 **Prefer GraphQL -> Domain Entity -> Prisma Entity separation**
···
 - **Only use IDs for Prisma operations** - extract IDs from entities at the service boundary
 - **OrFail delegation**: Implement `findByXOrFail` methods by delegating to the corresponding non-throwing `findByX` method and only handling the error-throwing responsibility (prefer early return style). This avoids duplication and ensures consistent behavior.
 - **Maximise mapper usage**: Services must use their injected mappers (`toDomain`, `mapToDomain`, and any specialized helpers) for all conversions from Prisma to domain, including joined/`include` cases. Avoid manual `new Entity(...)` in services.
+- **Use PaginationService.buildQueryOptions()** for cursor-based pagination instead of manual cursor logic. This method handles all after/before/first/last logic generically.
+- **Connection classes must handle their own edge management**: All GraphQL connection types must include a static `fromPaginationResult()` factory method that handles edge creation and domain mapping. This keeps edge management logic within the connection class and follows the established pattern used by other connections in the codebase.
 
 #### Mapping Functions
 - **`fromDomain()`** - Domain entity to GraphQL type
 - **`toDomain()`** - Prisma model to domain entity  
 - **`mapToDomain()`** - Array of Prisma models to domain entities
+- **`fromDomain()` MUST always accept domain entities, never Prisma entities**
+- GraphQL types should only work with domain entities, not Prisma models
+- If relations are needed, domain entities should include them as optional properties
 - Keep resolvers focused on GraphQL concerns
 - Keep domain logic in domain entities
 - Keep database operations in Prisma services
···
 - **When making commits, check if any roadmap items were completed and check them off**
 - Review ROADMAP.md for relevant completed features and update checkboxes accordingly
 
+### Scripts and Automation
+- **Avoid creating one-off scripts in a scripts directory unless explicitly requested**
+- **Prefer running commands directly or using existing package.json scripts**
+- **Only create package.json scripts for operations that will be used repeatedly**
+- **For one-time operations, run commands directly rather than creating script files**
+
+### Monorepo Dependencies
+- **Unless it's specifically monorepo tooling (like Lerna, Nx, Rush), install npm libraries in the sub-projects where they're used**
+- **Avoid relying on root-level node_modules for sub-project dependencies**
+- **Each package should have its own dependencies installed locally for better isolation and reliability**
+
 ### Conventional Commits
 - **Always use conventional commit format**: `type(scope): description`
 - **Types**: `feat:`, `fix:`, `docs:`, `style:`, `refactor:`, `test:`, `chore:`, `perf:`, `ci:`, `build:`
···
   - `docs(api): update GraphQL schema documentation`
   - `refactor(ui): extract toast icons to separate components`
   - `chore(deps): update biome to latest version`
+
+### Docker & Service Health
+- **NEVER use `sleep` commands to wait for Docker services to start**
+- **Always rely on healthchecks and `depends_on` conditions** defined in `docker-compose.yml`
+- Services are configured with `depends_on` and `condition: service_healthy` to ensure proper startup order
+- If a service needs to be restarted, use `docker-compose restart <service>` and trust the healthchecks
+- Check service status with `docker-compose ps` to see health status
+- Only run commands on healthy services using `docker-compose exec`
+- Example: All services have healthchecks (db, server, client) with proper intervals and timeouts
+
+### Post-Refactor Validation
+- **After major refactors** (schema changes, service refactoring, entity changes), always:
+  1. **Run codegen in Docker**: `docker-compose exec client sh -c "cd /app/apps/client && GRAPHQL_ENDPOINT=http://localhost:3000/graphql npm run codegen"`
+  2. **Run TypeScript typecheck**: `docker-compose exec client sh -c "cd /app/apps/client && npx tsc --noEmit"`
+  3. **Fix any type errors** before considering the refactor complete
+  4. **Clean up generated JavaScript files**: `find apps/client -name "*.js" -type f | grep -v node_modules | xargs rm -f`
+- This ensures the frontend remains in sync with backend schema changes and catches type issues early
+
+## Bug Tracking
+
+### Bug Report Format
+When reporting bugs, use this standardized format in `apps/docs/content/KNOWN_BUGS.md`:
+
+```markdown
+### [Bug Title]
+- **File**: `path/to/file.ts`
+- **Issue**: Brief description of the problem
+- **Steps to Reproduce**:
+  1. Step 1
+  2. Step 2
+  3. Step 3
+- **Expected Behavior**: What should happen
+- **Actual Behavior**: What actually happens
+- **Priority**: High/Medium/Low
+- **Status**: Open/In Progress/Fixed
+- **Commit**: `abc1234` (if applicable)
+- **Ticket**: `#123` or `JIRA-456` (if applicable)
+- **PR**: `#789` or `https://github.com/owner/repo/pull/789` (if applicable)
+```
+
+### Bug Management
+- **Track all bugs** in `apps/docs/content/KNOWN_BUGS.md`
+- **Organize by category** (Authentication, UI, Backend, etc.)
+- **Update status** when bugs are fixed
+- **Include file paths** for easy navigation
+- **Use clear, descriptive titles**
+- **Provide reproduction steps** for complex bugs
+- **Mark fixed bugs** with ✅ and fix date

.dockerignore

···
 # Dependencies
 node_modules/
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-pnpm-debug.log*
 
 # Keep packages directory for workspace dependencies
 !packages/
···
 # Build outputs
 dist/
 build/
-.next/
-out/
+.turbo/
+.vite/
 
 # Environment files
 .env
 .env.local
-.env.development.local
-.env.test.local
-.env.production.local
+.env.*.local
 
 # IDE and editor files
 .vscode/
 .idea/
-*.swp
-*.swo
-*~
 
 # OS generated files
 .DS_Store
-.DS_Store?
 ._*
-.Spotlight-V100
-.Trashes
-ehthumbs.db
 Thumbs.db
 
 # Git
···
 # Runtime data
 pids/
 *.pid
-*.seed
-*.pid.lock
+db-data
 
-# Coverage directory used by tools like istanbul
+# Coverage
 coverage/
 *.lcov
 
-# nyc test coverage
-.nyc_output
-
-# Dependency directories
-jspm_packages/
-
-# Optional npm cache directory
-.npm
-
-# Optional eslint cache
-.eslintcache
-
-# Microbundle cache
-.rpt2_cache/
-.rts2_cache_cjs/
-.rts2_cache_es/
-.rts2_cache_umd/
-
-# Optional REPL history
-.node_repl_history
-
-# Output of 'npm pack'
-*.tgz
-
-# Yarn Integrity file
-.yarn-integrity
-
-# parcel-bundler cache (https://parceljs.org/)
-.cache
-.parcel-cache
-
-# Next.js build output
-.next
-
-# Nuxt.js build / generate output
-.nuxt
-
-# Gatsby files
+# Cache directories
 .cache/
-public
-
-# Storybook build outputs
-.out
-.storybook-out
-
-# Temporary folders
-tmp/
-temp/
-
-# Editor directories and files
-.vscode/*
-!.vscode/extensions.json
-.idea
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-*.sw?
-
-# Test files
-test/
-tests/
-__tests__/
-*.test.js
-*.test.ts
-*.spec.js
-*.spec.ts
-
-# Documentation
-docs/
-*.md
-README*
-
-# CI/CD
-.github/
-.gitlab-ci.yml
-.travis.yml
-.circleci/
+.npm/
 
 # Package manager lock files (keep package.json but ignore locks for faster builds)
 package-lock.json
 yarn.lock
 pnpm-lock.yaml
 
-# Generated files
-*.generated.*
-generated/
+# Generated files (will be regenerated in container)
+**/generated/
+apps/client/src/generated/
+apps/server/node_modules/@prisma/client/
+apps/server/prisma/generated/
 
-# Prisma generated client (will be regenerated in container)
-node_modules/@prisma/client/
-
-# Client build artifacts
+# Build artifacts
 apps/client/dist/
-apps/client/build/
-
-# Server build artifacts  
 apps/server/dist/
-apps/server/build/
+packages/**/dist/
 
 # Lerna
 lerna-debug.log

.gitignore

···
+# Dependencies
 node_modules/
+
+# Build outputs
 dist/
+build/
 .turbo/
 .vite/
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# OS generated files
 .DS_Store
+._*
+Thumbs.db
+
+# Logs
 *.log
+logs/
+
+# Coverage
 coverage/
-.env
-.env.*
-apps/client/dist
-apps/server/dist
-packages/**/dist
+*.lcov
+
+# Runtime data
+pids/
+*.pid
 docker/*.pid
 db-data
 
-# Environment files
-.env
-.env.local
-.env.*.local
+# Generated files (exclude from git but keep local copies for syntax highlighting)
+**/generated/
+**/generated-local/
+apps/client/src/generated/
+apps/client/src/generated-local/
+apps/server/node_modules/@prisma/client/
+apps/server/prisma/generated/
+
+# Build artifacts
+apps/client/dist/
+apps/server/dist/
+packages/**/dist/
 
-**/generated/
+# Lerna
+lerna-debug.log

apps/docs/content/KNOWN_BUGS.md

···
+# Known Bugs
+
+This document tracks known bugs and issues in the CV Generator application that need to be addressed.
+
+## Bug Report Template
+
+When reporting new bugs, please use this template:
+
+```markdown
+### [Bug Title]
+
+- **File**: `path/to/file.ts`
+- **Issue**: Brief description of the problem
+- **Steps to Reproduce**:
+  1. Step 1
+  2. Step 2
+  3. Step 3
+- **Expected Behavior**: What should happen
+- **Actual Behavior**: What actually happens
+- **Priority**: High/Medium/Low
+- **Status**: Open/In Progress/Fixed
+- **Commit**: `abc1234` (if applicable)
+- **Ticket**: `#123` or `JIRA-456` (if applicable)
+- **PR**: `#789` or `https://github.com/owner/repo/pull/789` (if applicable)
+```
+
+## Notes
+
+- All bugs marked with ✅ have been resolved
+- Bugs are organized by category for easier navigation
+- When fixing bugs, update the status and add commit/PR information
+- For new bugs, add them to the "Current Open Issues" section
+
+## Current Open Issues
+
+_No open issues at this time._

apps/docs/content/docs/changelog.md

···
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Development Guidelines
+
+### Commit Convention
+
+This project uses [Conventional Commits](https://www.conventionalcommits.org/) format:
+
+- `feat:` A new feature
+- `fix:` A bug fix
+- `docs:` Documentation only changes
+- `style:` Changes that do not affect the meaning of the code
+- `refactor:` A code change that neither fixes a bug nor adds a feature
+- `perf:` A code change that improves performance
+- `test:` Adding missing tests or correcting existing tests
+- `chore:` Changes to the build process or auxiliary tools
+
+### Versioning
+
+- **MAJOR** version when you make incompatible API changes
+- **MINOR** version when you add functionality in a backwards compatible manner
+- **PATCH** version when you make backwards compatible bug fixes
+
+## [Unreleased]
+
+### Added
+
+- Initial project setup with NestJS backend and React frontend
+- Docker containerization with docker-compose
+- GraphQL API with Apollo Server
+- Authentication system with JWT tokens
+- Database schema with Prisma ORM
+- User management and organization features
+- Job experience tracking system
+- Company, role, level, and skill management
+- Toast notification system
+- Error boundary components
+- TypeScript configuration with strict settings
+- Biome linting and formatting configuration
+
+### Changed
+
+- Improved configuration management using `getOrThrow()` instead of manual error throwing
+- Enhanced type safety by prohibiting non-null assertion operators (`!`)
+- Updated entity instantiation patterns to use constructor-based initialization
+- Improved error handling patterns throughout the codebase
+- Application domain entity now requires status and vacancy relations
+- Updated Application.fromDomain to accept domain entities instead of Prisma entities
+- Server status indicator now always visible on login page
+- Navigation section renamed from "Project Management" to "Project"
+- Roadmap restructured: removed "Recently Completed Features" section, all items marked as pending
+
+### Fixed
+
+- Configuration validation issues
+- Type safety improvements
+- Build process optimization
+- Application domain entity type safety with required relations
+- Card component accessibility (replaced div with semantic button)
+- Icon components accessibility (added title and aria-label attributes)
+- TypeScript any types in useAuth hook replaced with proper types
+- Env interpolation plugin now correctly mutates AST nodes
+- Missing env.config.ts in tsconfig.node.json include list
+- Unused variables and parameters in docs components
+
+### Security
+
+- Implemented secure JWT authentication
+- Added proper environment variable validation
+- Enhanced input validation with Zod schemas
+
+## [0.1.0] - 2025-01-19
+
+### Added
+
+- Initial project structure
+- Basic authentication flow
+- Core database entities
+- GraphQL schema definition
+- Docker development environment

apps/docs/content/docs/roadmap.md

···
+# Roadmap
+
+This document outlines the planned features and improvements for the CV Generator project. Items are organized by topic and prioritized for development.
+
+## 🏢 B2C CV Builder Functionality
+
+### Core Features
+
+- [ ] **CV Templates & Design System**
+
+  - [ ] Create responsive CV templates
+  - [ ] Implement design customization options
+  - [x] Add theme selection (professional, creative, minimal)
+  - [x] Support for multiple CV formats (chronological, functional, hybrid)
+  - [x] Navigation active state
+  - [ ] Multiple template rendering formats (Liquid, LaTeX, Handlebars)
+  - [ ] Template engine abstraction layer
+  - [ ] Custom template syntax support
+
+- [ ] **Content Management**
+
+  - [ ] Rich text editor for CV sections
+  - [ ] Drag-and-drop section reordering
+  - [ ] Real-time preview functionality
+  - [ ] Auto-save functionality
+  - [ ] Version history and rollback
+
+- [ ] **Export & Sharing**
+  - [ ] PDF export with high-quality rendering
+  - [ ] Multiple file format support (PDF, DOCX, HTML)
+  - [ ] Shareable CV links
+  - [ ] QR code generation for CV sharing
+  - [ ] Social media integration
+
+### Advanced Features
+
+- [ ] **AI-Powered Enhancements**
+
+  - [ ] AI content suggestions and improvements
+  - [ ] Keyword optimization for ATS systems
+  - [ ] Skills gap analysis
+  - [ ] Industry-specific recommendations
+
+- [ ] **Analytics & Insights**
+  - [ ] CV view tracking and analytics
+  - [ ] Performance metrics dashboard
+  - [ ] ATS compatibility scoring
+  - [ ] Improvement suggestions
+
+### User Experience
+
+- [ ] **Onboarding & Tutorials**
+
+  - [x] Interactive CV creation wizard
+  - [ ] Step-by-step guidance system
+  - [ ] Sample CV library
+  - [ ] Video tutorials and help center
+
+- [ ] **Mobile Experience**
+  - [ ] Mobile-responsive design
+  - [ ] Progressive Web App (PWA) features
+  - [ ] Offline editing capabilities
+  - [ ] Mobile-optimized export options
+
+---
+
+## 🏢 B2B Solution for Managing Groups of Employees
+
+### Organization Management
+
+- [ ] **Organization Management**
+  - [ ] Multi-tenant architecture
+  - [ ] Organization hierarchy management
+  - [ ] Role-based access control (RBAC)
+  - [ ] Granular permission system
+  - [ ] Role assignment and management
+  - [ ] Permission inheritance and delegation
+
+- [ ] **Multi-tenant Architecture**
+
+  - [ ] Department and team structures
+  - [ ] Custom organization branding
+
+- [ ] **Job Experience Management**
+  - [ ] Full CRUD for companies
+  - [ ] Full CRUD for roles
+  - [ ] Full CRUD for levels
+  - [ ] Full CRUD for skills
+
+- [ ] **Vacancy Management**
+  - [x] Job vacancy creation
+  - [ ] Vacancy management interface
+  - [ ] Vacancy search and filtering
+
+- [ ] **Employee Management**
+  - [ ] Bulk employee import/export
+  - [x] Employee profile management
+  - [x] Skills inventory and tracking
+  - [ ] Performance review integration
+  - [x] Employee directory with search and filtering
+
+### HR Analytics & Reporting
+
+- [ ] **Workforce Analytics**
+
+  - [ ] Skills gap analysis across organization
+  - [ ] Employee development tracking
+  - [ ] Career progression insights
+  - [ ] Diversity and inclusion metrics
+  - [ ] Retention and turnover analysis
+
+- [ ] **Reporting Dashboard**
+  - [ ] Custom report builder
+  - [ ] Scheduled report delivery
+  - [ ] Executive summary dashboards
+  - [ ] Compliance reporting
+  - [ ] Export capabilities (PDF, Excel, CSV)
+
+### Integration & Automation
+
+- [ ] **HR System Integrations**
+
+  - [ ] ATS (Applicant Tracking System) integration
+  - [ ] HRIS (Human Resource Information System) sync
+  - [ ] Learning Management System (LMS) integration
+  - [ ] Performance management system integration
+  - [ ] Single Sign-On (SSO) support
+
+- [ ] **Workflow Automation**
+  - [ ] Automated CV updates and reminders
+  - [ ] Approval workflows for CV changes
+  - [ ] Notification system for managers
+  - [ ] Bulk operations and batch processing
+  - [ ] API for custom integrations
+  - [ ] Message queue integration (RabbitMQ, Redis Queue, Bull)
+  - [ ] Asynchronous job processing
+  - [ ] Background task scheduling
+
+### Compliance & Security
+
+- [ ] **Data Privacy & Security**
+
+  - [ ] GDPR compliance features
+  - [ ] Data encryption at rest and in transit
+  - [ ] Audit logging and trail
+  - [ ] Data retention policies
+  - [ ] Backup and disaster recovery
+
+- [ ] **Access Control**
+  - [ ] Granular permission system
+  - [ ] Multi-factor authentication (MFA)
+  - [ ] Session management and timeout
+  - [ ] IP whitelisting and restrictions
+  - [ ] Admin console for system management
+
+---
+
+## 📈 Advertising & Monetization Options
+
+### Freemium Model
+
+- [ ] **Free Tier Features**
+
+  - [ ] Basic CV templates (3-5 options)
+  - [ ] Standard export formats (PDF only)
+  - [ ] Limited customization options
+  - [ ] Basic analytics and insights
+  - [ ] Community support
+
+- [ ] **Premium Tier Features**
+  - [ ] Unlimited template access
+  - [ ] Advanced customization tools
+  - [ ] Multiple export formats (PDF, DOCX, HTML)
+  - [ ] AI-powered content suggestions
+  - [ ] Advanced analytics and ATS optimization
+  - [ ] Priority customer support
+
+### Enterprise Solutions
+
+- [ ] **B2B Subscription Tiers**
+  - [ ] Small business package (up to 50 employees)
+  - [ ] Medium enterprise package (up to 500 employees)
+  - [ ] Large enterprise package (unlimited employees)
+  - [ ] Custom enterprise solutions with dedicated support
+
+### Revenue Streams
+
+- [ ] **Direct Monetization**
+
+  - [ ] Subscription-based pricing models
+  - [ ] Pay-per-use CV generation
+  - [ ] Premium template marketplace
+  - [ ] White-label solutions for partners
+
+- [ ] **Partnership & Integration Revenue**
+  - [ ] Job board partnerships and referrals
+  - [ ] Recruitment agency integrations
+  - [ ] HR software marketplace listings
+  - [ ] Affiliate marketing programs
+
+### Marketing & Growth
+
+- [ ] **User Acquisition**
+
+  - [ ] SEO optimization for CV-related keywords
+  - [ ] Content marketing strategy (CV tips, career advice)
+  - [ ] Social media presence and engagement
+  - [ ] Influencer partnerships and collaborations
+  - [ ] Referral program implementation
+
+- [ ] **Retention & Engagement**
+  - [ ] Email marketing campaigns
+  - [ ] In-app notifications and tips
+  - [ ] Gamification elements (achievements, progress tracking)
+  - [ ] Community features and forums
+  - [ ] Regular feature updates and improvements
+
+---
+
+## 🛠 Technical Infrastructure
+
+### Core Systems
+
+- [ ] **Authentication System**
+  - [x] JWT-based authentication
+  - [x] Refresh token mechanism
+  - [x] User session management
+
+- [ ] **Database System**
+  - [x] PostgreSQL database setup
+  - [x] Prisma ORM integration
+  - [x] Database migrations
+
+- [ ] **GraphQL API**
+  - [x] Apollo Server implementation
+  - [x] GraphQL schema design
+  - [x] Query and mutation resolvers
+
+- [ ] **Frontend Application**
+  - [x] React application setup
+  - [x] TypeScript configuration
+  - [x] Modern UI components
+
+- [ ] **Docker Infrastructure**
+  - [x] Containerization setup
+  - [x] Health checks configuration
+  - [x] Multi-service orchestration
+
+- [ ] **Testing Infrastructure**
+  - [ ] E2E testing setup
+  - [ ] Integration testing
+  - [ ] Test coverage
+
+- [ ] **Code Quality**
+  - [x] Biome linting configuration
+  - [x] TypeScript strict mode
+  - [x] Code formatting standards
+
+- [ ] **Email System**
+  - [ ] Email service integration (SendGrid, AWS SES, SMTP)
+  - [ ] Transactional email templates
+  - [ ] Email notification system
+  - [ ] Email verification and password reset
+  - [ ] Bulk email capabilities
+  - [ ] Email delivery tracking and analytics
+
+### Platform & Scalability
+
+- [ ] **Performance Optimization**
+
+  - [ ] Database query optimization
+  - [ ] Caching strategies (Redis implementation)
+  - [ ] CDN integration for static assets
+  - [ ] Load balancing and auto-scaling
+  - [ ] Performance monitoring and alerting
+
+- [ ] **DevOps & Deployment**
+  - [ ] CI/CD pipeline optimization
+  - [ ] Automated testing (unit, integration, e2e)
+  - [ ] Infrastructure as Code (IaC)
+  - [ ] Blue-green deployment strategy
+  - [ ] Monitoring and logging solutions
+
+### Security & Compliance
+
+- [ ] **Security Enhancements**
+  - [ ] Penetration testing and security audits
+  - [ ] Vulnerability scanning and management
+  - [ ] Security headers and CSP implementation
+  - [ ] Rate limiting and DDoS protection
+  - [ ] Security incident response plan
+
+### Data & Analytics
+
+- [ ] **Data Infrastructure**
+  - [ ] Data warehouse implementation
+  - [ ] ETL processes for analytics
+  - [ ] Real-time analytics pipeline
+  - [ ] Data visualization tools
+  - [ ] Machine learning model deployment
+
+---
+
+_This roadmap is a living document and will be updated regularly based on user feedback, market research, and business priorities._

apps/docs/src/components/ComponentExample.tsx

···
+import type React from "react";
+import { useState } from "react";
+
+/**
+ * Wrapper component for rendering stateful component examples in MDX
+ * Provides useState functionality for components that need state management
+ */
+export const ComponentExample = ({
+  children,
+  className,
+}: {
+  children: React.ReactNode;
+  className?: string;
+}) => {
+  return <div className={className}>{children}</div>;
+};
+
+/**
+ * Hook provider for component examples that need shared state
+ * Components should be available directly from MDX components scope
+ */
+export const ExampleStateProvider = <T,>({
+  children,
+  initialValue,
+}: {
+  children: (value: T, setValue: (value: T) => void) => React.ReactNode;
+  initialValue?: T;
+}) => {
+  const [value, setValue] = useState<T>(initialValue as T);
+  return <>{children(value, setValue)}</>;
+};

apps/docs/src/components/Sidebar.tsx

···
+import { useEffect, useState } from "react";
+import { Link, useLocation } from "react-router-dom";
+import { APP_META, ENV_VARS, NAVIGATION, type NavigationItem } from "../config";
+
+const isDocSection = (
+  item: NavigationItem,
+): item is {
+  title: string;
+  icon?: string;
+  items: Array<{ title: string; slug: string; icon?: string }>;
+} => {
+  return "items" in item && Array.isArray(item.items);
+};
+
+export const Sidebar = () => {
+  const location = useLocation();
+  const currentPath = location.pathname.slice(1); // Remove leading slash
+
+  const [expandedSections, setExpandedSections] = useState<Set<string>>(
+    new Set(),
+  );
+
+  useEffect(() => {
+    const initiallyExpanded = new Set<string>();
+    NAVIGATION.forEach((item) => {
+      if (isDocSection(item)) {
+        const isSectionActive = item.items.some(
+          (doc) => currentPath === doc.slug,
+        );
+        if (isSectionActive) {
+          initiallyExpanded.add(item.title);
+        }
+      }
+    });
+    setExpandedSections(initiallyExpanded);
+  }, [currentPath]);
+
+  const toggleSection = (sectionTitle: string) => {
+    setExpandedSections((prev) => {
+      const next = new Set(prev);
+      if (next.has(sectionTitle)) {
+        next.delete(sectionTitle);
+      } else {
+        next.add(sectionTitle);
+      }
+      return next;
+    });
+  };
+
+  return (
+    <aside className="w-64 bg-ctp-mantle border-r border-ctp-surface0 p-6">
+      <div className="mb-8">
+        <h1 className="text-xl font-bold text-ctp-text">{APP_META.title}</h1>
+        <p className="text-sm text-ctp-subtext0">{APP_META.subtitle}</p>
+      </div>
+
+      <nav className="space-y-4">
+        {NAVIGATION.map((item) => {
+          if (isDocSection(item)) {
+            const isExpanded = expandedSections.has(item.title);
+
+            return (
+              <div key={item.title} className="space-y-1">
+                <button
+                  type="button"
+                  onClick={() => toggleSection(item.title)}
+                  className="flex items-center w-full px-3 py-2 text-xs font-semibold text-ctp-subtext0 uppercase tracking-wider hover:text-ctp-text transition-colors"
+                >
+                  {item.icon && <span className="mr-2">{item.icon}</span>}
+                  {item.title}
+                </button>
+                {isExpanded && (
+                  <div className="ml-2 space-y-1">
+                    {item.items.map((doc) => {
+                      const isActive = currentPath === doc.slug;
+                      return (
+                        <Link
+                          key={doc.slug}
+                          to={`/${doc.slug}`}
+                          className={`block px-3 py-2 rounded-md text-sm transition-colors ${
+                            isActive
+                              ? "bg-ctp-surface0 text-ctp-text font-medium"
+                              : "text-ctp-subtext0 hover:bg-ctp-surface0/50 hover:text-ctp-text"
+                          }`}
+                        >
+                          {doc.icon && <span className="mr-2">{doc.icon}</span>}
+                          {doc.title}
+                        </Link>
+                      );
+                    })}
+                  </div>
+                )}
+              </div>
+            );
+          }
+
+          // Handle flat navigation items (for backward compatibility)
+          const isActive = currentPath === item.slug;
+          return (
+            <Link
+              key={item.slug}
+              to={`/${item.slug}`}
+              className={`block px-3 py-2 rounded-md text-sm transition-colors ${
+                isActive
+                  ? "bg-ctp-surface0 text-ctp-text font-medium"
+                  : "text-ctp-subtext0 hover:bg-ctp-surface0/50 hover:text-ctp-text"
+              }`}
+            >
+              {item.icon && <span className="mr-2">{item.icon}</span>}
+              {item.title}
+            </Link>
+          );
+        })}
+      </nav>
+
+      <div className="mt-8 pt-8 border-t border-ctp-surface0">
+        <a
+          href={ENV_VARS.CLIENT_URL}
+          className="text-sm text-ctp-blue hover:text-ctp-sapphire transition-colors"
+        >
+          {APP_META.backToAppLabel}
+        </a>
+      </div>
+    </aside>
+  );
+};

apps/docs/src/config/env-interpolation-remark-plugin.ts

···
+import type { Root, Text } from "mdast";
+import type { Plugin } from "unified";
+import { visit } from "unist-util-visit";
+import { ENV_VARS } from "./env.config";
+
+/**
+ * Remark plugin to interpolate environment variables in markdown
+ * Replaces {{VARIABLE_NAME}} with actual values from ENV_VARS
+ */
+export const envInterpolationPlugin: Plugin<[], Root> = () => (tree: Root) => {
+  visit(tree, "text", (node: Text) => {
+    if (!node.value) {
+      return;
+    }
+
+    const interpolated = node.value.replace(
+      /\{\{(\w+)\}\}/g,
+      (match, varName) => ENV_VARS[varName] ?? match,
+    );
+
+    if (interpolated !== node.value) {
+      node.value = interpolated;
+    }
+  });
+};

apps/docs/src/config/navigation.config.ts

···
+/**
+ * Documentation navigation configuration
+ *
+ * This file defines the structure and links for the documentation sidebar
+ */
+
+export interface DocLink {
+  title: string;
+  slug: string;
+  icon?: string;
+}
+
+export interface DocSection {
+  title: string;
+  icon?: string;
+  items: DocLink[];
+}
+
+export type NavigationItem = DocSection | DocLink;
+
+/**
+ * Helper function to format component name for display
+ * Converts "searchableselect" to "SearchableSelect", etc.
+ */
+const formatComponentName = (slug: string): string => {
+  const filename = slug.split("/").pop();
+  if (!filename) {
+    return slug;
+  }
+  return filename
+    .split("-")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join("");
+};
+
+/**
+ * Component slugs - manually maintained list of component documentation files
+ * This avoids circular dependencies while ensuring all components are listed
+ */
+const COMPONENT_SLUGS = [
+  "components/badge",
+  "components/button",
+  "components/calendar",
+  "components/card",
+  "components/checkbox",
+  "components/formatteddate",
+  "components/formatteddaterange",
+  "components/iconbutton",
+  "components/pageheader",
+  "components/placeholder",
+  "components/rangeslider",
+  "components/searchableselect",
+  "components/select",
+  "components/statusbadge",
+  "components/table",
+  "components/textarea",
+  "components/textinput",
+];
+
+/**
+ * Get component navigation items
+ */
+const getComponentItems = (): DocLink[] => {
+  const componentDocs = COMPONENT_SLUGS.map((slug) => ({
+    title: formatComponentName(slug),
+    slug,
+  }));
+
+  // Add overview at the top
+  return [
+    { title: "Components Overview", slug: "components" },
+    ...componentDocs,
+  ];
+};
+
+/**
+ * Documentation navigation structure
+ * Supports both sections (groups) and individual links
+ * Order in this array determines the order in the sidebar
+ */
+export const NAVIGATION: NavigationItem[] = [
+  {
+    title: "Architecture",
+    icon: "🏗️",
+    items: [
+      { title: "Architecture Overview", slug: "docs/architecture" },
+      { title: "Frontend Structure", slug: "docs/frontend-structure" },
+      { title: "Docker Strategy", slug: "docs/docker-strategy" },
+    ],
+  },
+  {
+    title: "Project",
+    icon: "📋",
+    items: [
+      { title: "Roadmap", slug: "docs/roadmap" },
+      { title: "Changelog", slug: "docs/changelog" },
+    ],
+  },
+  {
+    title: "API",
+    icon: "🔌",
+    items: [
+      { title: "API Overview", slug: "api" },
+      { title: "GraphQL Architecture", slug: "docs/graphql-architecture" },
+    ],
+  },
+  {
+    title: "Components",
+    icon: "🧩",
+    items: getComponentItems(),
+  },
+];
+
+/**
+ * Flattened list of all navigation links (for backward compatibility)
+ * @deprecated Use NAVIGATION instead
+ */
+export const DOC_LINKS: DocLink[] = NAVIGATION.flatMap((item) => {
+  if ("items" in item) {
+    return item.items;
+  }
+  return [item];
+});
+
+/**
+ * App metadata
+ */
+export const APP_META = {
+  title: "CV Generator",
+  subtitle: "Documentation",
+  backToAppLabel: "← Back to App",
+};

apps/docs/tsconfig.node.json

···
+{
+  "extends": "../../packages/tsconfig/tsconfig.node.json",
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "exactOptionalPropertyTypes": false
+  },
+  "include": [
+    "vite.config.ts",
+    "src/config/env-interpolation-remark-plugin.ts",
+    "src/config/env.config.ts"
+  ]
+}

apps/server/src/modules/application/application.entity.ts

···
+import { BaseEntity } from "@/modules/base/base.entity";
+
+export interface ApplicationStatusRelation {
+  id: string;
+  name: string;
+  description: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface VacancyRelation {
+  id: string;
+  title: string;
+  description: string | null;
+  location: string | null;
+  minSalary: number | null;
+  maxSalary: number | null;
+  company: {
+    name: string;
+  };
+  role: {
+    name: string;
+  };
+  level: {
+    name: string;
+  } | null;
+  jobType: {
+    name: string;
+  } | null;
+}
+
+export interface CVRelation {
+  id: string;
+  title: string;
+}
+
+export class Application extends BaseEntity {
+  userId: string;
+  vacancyId: string;
+  cvId?: string;
+  coverLetter?: string;
+  statusId: string;
+  appliedAt: Date;
+  status: ApplicationStatusRelation;
+  vacancy: VacancyRelation;
+  cv: CVRelation | null;
+
+  constructor(
+    id: string,
+    userId: string,
+    vacancyId: string,
+    statusId: string,
+    appliedAt: Date,
+    createdAt: Date,
+    updatedAt: Date,
+    status: ApplicationStatusRelation,
+    vacancy: VacancyRelation,
+    cv: CVRelation | null = null,
+    cvId?: string,
+    coverLetter?: string,
+  ) {
+    super(id, createdAt, updatedAt);
+    this.userId = userId;
+    this.vacancyId = vacancyId;
+    this.statusId = statusId;
+    this.appliedAt = appliedAt;
+    this.status = status;
+    this.vacancy = vacancy;
+    this.cv = cv;
+
+    if (cvId !== undefined) {
+      this.cvId = cvId;
+    }
+    if (coverLetter !== undefined) {
+      this.coverLetter = coverLetter;
+    }
+  }
+}

apps/server/src/modules/application/application.mapper.ts

···
+import { Injectable } from "@nestjs/common";
+import type { Prisma } from "@prisma/client";
+import type { BaseMapper } from "@/modules/base/mapper.interface";
+import {
+  Application,
+  type ApplicationStatusRelation,
+  type CVRelation,
+  type VacancyRelation,
+} from "./application.entity";
+
+type PrismaApplication = Prisma.ApplicationGetPayload<Record<string, never>>;
+
+type PrismaApplicationWithRelations = Prisma.ApplicationGetPayload<{
+  include: {
+    status: true;
+    vacancy: {
+      include: {
+        company: true;
+        role: true;
+        level: true;
+        jobType: true;
+      };
+    };
+    cv: true;
+  };
+}>;
+
+@Injectable()
+export class ApplicationMapper
+  implements BaseMapper<PrismaApplication, Application>
+{
+  toDomain(prismaApplication: null): null;
+  toDomain(prismaApplication: PrismaApplication): Application;
+  toDomain(prismaApplication: PrismaApplicationWithRelations): Application;
+  toDomain(
+    prismaApplication:
+      | PrismaApplication
+      | PrismaApplicationWithRelations
+      | null,
+  ): Application | null;
+  toDomain(
+    prismaApplication:
+      | PrismaApplication
+      | PrismaApplicationWithRelations
+      | null,
+  ): Application | null {
+    if (!prismaApplication) {
+      return null;
+    }
+
+    const hasRelations =
+      "status" in prismaApplication &&
+      prismaApplication.status !== null &&
+      "vacancy" in prismaApplication &&
+      prismaApplication.vacancy !== null;
+
+    if (!hasRelations) {
+      throw new Error(
+        "Application domain entity requires status and vacancy relations",
+      );
+    }
+
+    const withRelations = prismaApplication as PrismaApplicationWithRelations;
+    const status: ApplicationStatusRelation = {
+      id: withRelations.status.id,
+      name: withRelations.status.name,
+      description: withRelations.status.description,
+      createdAt: withRelations.status.createdAt,
+      updatedAt: withRelations.status.updatedAt,
+    };
+
+    const vacancy: VacancyRelation = {
+      id: withRelations.vacancy.id,
+      title: withRelations.vacancy.title,
+      description: withRelations.vacancy.description,
+      location: withRelations.vacancy.location,
+      minSalary: withRelations.vacancy.minSalary,
+      maxSalary: withRelations.vacancy.maxSalary,
+      company: {
+        name: withRelations.vacancy.company.name,
+      },
+      role: {
+        name: withRelations.vacancy.role.name,
+      },
+      level: withRelations.vacancy.level
+        ? { name: withRelations.vacancy.level.name }
+        : null,
+      jobType: withRelations.vacancy.jobType
+        ? { name: withRelations.vacancy.jobType.name }
+        : null,
+    };
+
+    const cv: CVRelation | null = withRelations.cv
+      ? {
+          id: withRelations.cv.id,
+          title: withRelations.cv.title,
+        }
+      : null;
+
+    return new Application(
+      withRelations.id,
+      withRelations.userId,
+      withRelations.vacancyId,
+      withRelations.statusId,
+      withRelations.appliedAt,
+      withRelations.createdAt,
+      withRelations.updatedAt,
+      status,
+      vacancy,
+      cv,
+      withRelations.cvId ?? undefined,
+      withRelations.coverLetter ?? undefined,
+    );
+  }
+
+  mapToDomain(prismaApplications: PrismaApplication[]): Application[] {
+    return prismaApplications
+      .map((application) => this.toDomain(application))
+      .filter(
+        (application): application is Application => application !== null,
+      );
+  }
+
+  mapToDomainWithRelations(
+    prismaApplications: PrismaApplicationWithRelations[],
+  ): Application[] {
+    return prismaApplications
+      .map((application) => this.toDomain(application))
+      .filter(
+        (application): application is Application => application !== null,
+      );
+  }
+}

apps/server/src/modules/application/application.module.ts

···
+import { Module } from "@nestjs/common";
+import { AuthModule } from "@/modules/auth/auth.module";
+import { DatabaseModule } from "@/modules/database/database.module";
+import { ApplicationMapper } from "./application.mapper";
+import { ApplicationService } from "./application.service";
+import { ApplicationResolver } from "./graphql/application.resolver";
+import { ApplicationUserFieldResolver } from "./graphql/user-field.resolver";
+
+@Module({
+  imports: [DatabaseModule, AuthModule],
+  providers: [
+    ApplicationService,
+    ApplicationMapper,
+    ApplicationResolver,
+    ApplicationUserFieldResolver,
+  ],
+  exports: [ApplicationService, ApplicationMapper],
+})
+export class ApplicationModule {}

apps/server/src/modules/application/application.service.ts

···
+import { Injectable, Logger } from "@nestjs/common";
+import { notFound } from "@/modules/base/not-found.util";
+import { PrismaService } from "@/modules/database/prisma.service";
+import { Application } from "./application.entity";
+import { ApplicationMapper } from "./application.mapper";
+
+@Injectable()
+export class ApplicationService {
+  private readonly logger = new Logger(ApplicationService.name);
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly applicationMapper: ApplicationMapper,
+  ) {}
+
+  async createApplication(
+    userId: string,
+    vacancyId: string,
+    statusId: string,
+    cvId?: string,
+    coverLetter?: string,
+  ): Promise<Application> {
+    this.logger.log(
+      `Creating application for user ${userId} to vacancy ${vacancyId}`,
+    );
+
+    // Check if user already applied to this vacancy
+    const existingApplication = await this.prisma["application"].findFirst({
+      where: {
+        userId,
+        vacancyId,
+      },
+    });
+
+    if (existingApplication) {
+      throw new Error("User has already applied to this vacancy");
+    }
+
+    const application = await this.prisma["application"].create({
+      data: {
+        userId,
+        vacancyId,
+        statusId,
+        cvId: cvId ?? null,
+        coverLetter: coverLetter ?? null,
+      },
+    });
+
+    return this.applicationMapper.toDomain(application);
+  }
+
+  async findApplicationsByUser(userId: string): Promise<Application[]> {
+    this.logger.log(`Finding applications for user: ${userId}`);
+
+    const applications = await this.prisma["application"].findMany({
+      where: { userId },
+      include: {
+        vacancy: {
+          include: {
+            company: true,
+            role: true,
+            level: true,
+            jobType: true,
+          },
+        },
+        status: true,
+        cv: true,
+      },
+      orderBy: { appliedAt: "desc" },
+    });
+
+    return this.applicationMapper.mapToDomainWithRelations(applications);
+  }
+
+  async findById(id: string): Promise<Application | null> {
+    this.logger.log(`Finding application by id: ${id}`);
+
+    const application = await this.prisma["application"].findUnique({
+      where: { id },
+      include: {
+        vacancy: {
+          include: {
+            company: true,
+            role: true,
+            level: true,
+            jobType: true,
+          },
+        },
+        status: true,
+        cv: true,
+      },
+    });
+
+    return application ? this.applicationMapper.toDomain(application) : null;
+  }
+
+  async findByIdOrFail(id: string): Promise<Application> {
+    const application = await this.findById(id);
+    return application ?? notFound("Application", "id", id);
+  }
+
+  async findByIdWithRelations(id: string): Promise<Application | null> {
+    this.logger.log(`Finding application by id with relations: ${id}`);
+
+    const application = await this.prisma["application"].findUnique({
+      where: { id },
+      include: {
+        vacancy: {
+          include: {
+            company: true,
+            role: true,
+            level: true,
+            jobType: true,
+          },
+        },
+        status: true,
+        cv: true,
+      },
+    });
+
+    return application ? this.applicationMapper.toDomain(application) : null;
+  }
+
+  async findApplicationsByUserWithRelations(
+    userId: string,
+  ): Promise<Application[]> {
+    this.logger.log(`Finding applications for user with relations: ${userId}`);
+
+    const applications = await this.prisma["application"].findMany({
+      where: { userId },
+      include: {
+        vacancy: {
+          include: {
+            company: true,
+            role: true,
+            level: true,
+            jobType: true,
+          },
+        },
+        status: true,
+        cv: true,
+      },
+      orderBy: { appliedAt: "desc" },
+    });
+
+    return this.applicationMapper.mapToDomainWithRelations(applications);
+  }
+
+  async updateApplicationStatus(
+    id: string,
+    statusId: string,
+  ): Promise<Application> {
+    this.logger.log(`Updating application ${id} status to ${statusId}`);
+
+    const application = await this.prisma["application"].update({
+      where: { id },
+      data: { statusId },
+    });
+
+    return this.applicationMapper.toDomain(application);
+  }
+
+  async deleteApplication(id: string): Promise<void> {
+    this.logger.log(`Deleting application: ${id}`);
+
+    await this.prisma["application"].delete({
+      where: { id },
+    });
+  }
+}

apps/server/src/modules/application/graphql/application.input.ts

···
+import { Field, ID, InputType } from "@nestjs/graphql";
+
+@InputType()
+export class CreateApplicationInput {
+  @Field(() => ID)
+  vacancyId!: string;
+
+  @Field(() => ID, { nullable: true })
+  cvId?: string | null;
+
+  @Field(() => String, { nullable: true })
+  coverLetter?: string | null;
+}
+
+@InputType()
+export class UpdateApplicationStatusInput {
+  @Field(() => ID)
+  applicationId!: string;
+
+  @Field(() => ID)
+  statusId!: string;
+}

apps/server/src/modules/application/graphql/application.resolver.ts

···
+import { UseGuards } from "@nestjs/common";
+import { Args, Mutation, Query, Resolver } from "@nestjs/graphql";
+import { CurrentUser } from "@/modules/auth/current-user.decorator";
+import { JwtAuthGuard } from "@/modules/auth/jwt-auth.guard";
+import { User } from "@/modules/user/user.entity";
+import { ApplicationService } from "../application.service";
+import {
+  CreateApplicationInput,
+  UpdateApplicationStatusInput,
+} from "./application.input";
+import { Application, ApplicationConnection } from "./application.type";
+
+@Resolver(() => Application)
+@UseGuards(JwtAuthGuard)
+export class ApplicationResolver {
+  constructor(private readonly applicationService: ApplicationService) {}
+
+  @Query(() => ApplicationConnection)
+  async myApplications(
+    @CurrentUser() user: User,
+  ): Promise<ApplicationConnection> {
+    const applications =
+      await this.applicationService.findApplicationsByUserWithRelations(
+        user.id,
+      );
+
+    return new ApplicationConnection({
+      edges: applications.map((app) => Application.fromDomain(app)),
+      totalCount: applications.length,
+    });
+  }
+
+  @Query(() => Application, { nullable: true })
+  async application(
+    @Args("id", { type: () => String }) id: string,
+    @CurrentUser() user: User,
+  ): Promise<Application | null> {
+    const application = await this.applicationService.findByIdWithRelations(id);
+
+    if (!application || application.userId !== user.id) {
+      return null;
+    }
+
+    return Application.fromDomain(application);
+  }
+
+  @Mutation(() => Application)
+  async createApplication(
+    @Args("input") input: CreateApplicationInput,
+    @CurrentUser() user: User,
+  ): Promise<Application> {
+    // Get the default "Applied" status
+    const appliedStatus = await this.applicationService["prisma"][
+      "applicationStatus"
+    ].findFirst({
+      where: { name: "Applied" },
+    });
+
+    if (!appliedStatus) {
+      throw new Error("Application status 'Applied' not found");
+    }
+
+    const application = await this.applicationService.createApplication(
+      user.id,
+      input.vacancyId,
+      appliedStatus.id,
+      input.cvId ?? undefined,
+      input.coverLetter ?? undefined,
+    );
+
+    const fullApplication = await this.applicationService.findByIdWithRelations(
+      application.id,
+    );
+    if (!fullApplication) {
+      throw new Error("Failed to fetch created application");
+    }
+
+    return Application.fromDomain(fullApplication);
+  }
+
+  @Mutation(() => Application)
+  async updateApplicationStatus(
+    @Args("input") input: UpdateApplicationStatusInput,
+    @CurrentUser() user: User,
+  ): Promise<Application> {
+    // Verify the application belongs to the user
+    const existingApplication = await this.applicationService.findById(
+      input.applicationId,
+    );
+    if (!existingApplication || existingApplication.userId !== user.id) {
+      throw new Error("Application not found or access denied");
+    }
+
+    const application = await this.applicationService.updateApplicationStatus(
+      input.applicationId,
+      input.statusId,
+    );
+
+    const fullApplication = await this.applicationService.findByIdWithRelations(
+      application.id,
+    );
+    if (!fullApplication) {
+      throw new Error("Failed to fetch updated application");
+    }
+
+    return Application.fromDomain(fullApplication);
+  }
+
+  @Mutation(() => Boolean)
+  async deleteApplication(
+    @Args("id", { type: () => String }) id: string,
+    @CurrentUser() user: User,
+  ): Promise<boolean> {
+    // Verify the application belongs to the user
+    const existingApplication = await this.applicationService.findById(id);
+    if (!existingApplication || existingApplication.userId !== user.id) {
+      throw new Error("Application not found or access denied");
+    }
+
+    await this.applicationService.deleteApplication(id);
+    return true;
+  }
+}

apps/server/src/modules/application/graphql/application.type.ts

···
+import { Field, ID, Int, ObjectType } from "@nestjs/graphql";
+import { GraphQLDate } from "graphql-scalars";
+import { Application as ApplicationEntity } from "../application.entity";
+
+@ObjectType()
+export class ApplicationStatus {
+  @Field(() => ID)
+  id: string;
+
+  @Field(() => String)
+  name: string;
+
+  @Field(() => String, { nullable: true })
+  description: string | null;
+
+  @Field(() => GraphQLDate)
+  createdAt: Date;
+
+  @Field(() => GraphQLDate)
+  updatedAt: Date;
+
+  constructor(data: {
+    id: string;
+    name: string;
+    description?: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+  }) {
+    this.id = data.id;
+    this.name = data.name;
+    this.description = data.description ?? null;
+    this.createdAt = data.createdAt;
+    this.updatedAt = data.updatedAt;
+  }
+}
+
+@ObjectType()
+export class VacancyInfo {
+  @Field(() => ID)
+  id: string;
+
+  @Field(() => String)
+  title: string;
+
+  @Field(() => String, { nullable: true })
+  description: string | null;
+
+  @Field(() => String, { nullable: true })
+  location: string | null;
+
+  @Field(() => Number, { nullable: true })
+  minSalary: number | null;
+
+  @Field(() => Number, { nullable: true })
+  maxSalary: number | null;
+
+  @Field(() => String)
+  companyName: string;
+
+  @Field(() => String)
+  roleName: string;
+
+  @Field(() => String, { nullable: true })
+  levelName: string | null;
+
+  @Field(() => String, { nullable: true })
+  jobTypeName: string | null;
+
+  constructor(data: {
+    id: string;
+    title: string;
+    description?: string | null;
+    location?: string | null;
+    minSalary?: number | null;
+    maxSalary?: number | null;
+    companyName: string;
+    roleName: string;
+    levelName?: string | null;
+    jobTypeName?: string | null;
+  }) {
+    this.id = data.id;
+    this.title = data.title;
+    this.description = data.description ?? null;
+    this.location = data.location ?? null;
+    this.minSalary = data.minSalary ?? null;
+    this.maxSalary = data.maxSalary ?? null;
+    this.companyName = data.companyName;
+    this.roleName = data.roleName;
+    this.levelName = data.levelName ?? null;
+    this.jobTypeName = data.jobTypeName ?? null;
+  }
+}
+
+@ObjectType()
+export class CVInfo {
+  @Field(() => ID)
+  id: string;
+
+  @Field(() => String)
+  title: string;
+
+  constructor(data: { id: string; title: string }) {
+    this.id = data.id;
+    this.title = data.title;
+  }
+}
+
+@ObjectType()
+export class Application {
+  @Field(() => ID)
+  id: string;
+
+  @Field(() => ID)
+  userId: string;
+
+  @Field(() => ID)
+  vacancyId: string;
+
+  @Field(() => ID, { nullable: true })
+  cvId: string | null;
+
+  @Field(() => String, { nullable: true })
+  coverLetter: string | null;
+
+  @Field(() => ID)
+  statusId: string;
+
+  @Field(() => GraphQLDate)
+  appliedAt: Date;
+
+  @Field(() => GraphQLDate)
+  createdAt: Date;
+
+  @Field(() => GraphQLDate)
+  updatedAt: Date;
+
+  @Field(() => ApplicationStatus)
+  status: ApplicationStatus;
+
+  @Field(() => VacancyInfo)
+  vacancy: VacancyInfo;
+
+  @Field(() => CVInfo, { nullable: true })
+  cv: CVInfo | null;
+
+  constructor(data: {
+    id: string;
+    userId: string;
+    vacancyId: string;
+    cvId?: string | null;
+    coverLetter?: string | null;
+    statusId: string;
+    appliedAt: Date;
+    createdAt: Date;
+    updatedAt: Date;
+    status: ApplicationStatus;
+    vacancy: VacancyInfo;
+    cv?: CVInfo | null;
+  }) {
+    this.id = data.id;
+    this.userId = data.userId;
+    this.vacancyId = data.vacancyId;
+    this.cvId = data.cvId ?? null;
+    this.coverLetter = data.coverLetter ?? null;
+    this.statusId = data.statusId;
+    this.appliedAt = data.appliedAt;
+    this.createdAt = data.createdAt;
+    this.updatedAt = data.updatedAt;
+    this.status = data.status;
+    this.vacancy = data.vacancy;
+    this.cv = data.cv ?? null;
+  }
+
+  static fromDomain(domainApplication: ApplicationEntity): Application {
+    return new Application({
+      id: domainApplication.id,
+      userId: domainApplication.userId,
+      vacancyId: domainApplication.vacancyId,
+      cvId: domainApplication.cvId ?? null,
+      coverLetter: domainApplication.coverLetter ?? null,
+      statusId: domainApplication.statusId,
+      appliedAt: domainApplication.appliedAt,
+      createdAt: domainApplication.createdAt,
+      updatedAt: domainApplication.updatedAt,
+      status: new ApplicationStatus({
+        id: domainApplication.status.id,
+        name: domainApplication.status.name,
+        description: domainApplication.status.description,
+        createdAt: domainApplication.status.createdAt,
+        updatedAt: domainApplication.status.updatedAt,
+      }),
+      vacancy: new VacancyInfo({
+        id: domainApplication.vacancy.id,
+        title: domainApplication.vacancy.title,
+        description: domainApplication.vacancy.description,
+        location: domainApplication.vacancy.location,
+        minSalary: domainApplication.vacancy.minSalary,
+        maxSalary: domainApplication.vacancy.maxSalary,
+        companyName: domainApplication.vacancy.company.name,
+        roleName: domainApplication.vacancy.role.name,
+        levelName: domainApplication.vacancy.level?.name ?? null,
+        jobTypeName: domainApplication.vacancy.jobType?.name ?? null,
+      }),
+      cv: domainApplication.cv
+        ? new CVInfo({
+            id: domainApplication.cv.id,
+            title: domainApplication.cv.title,
+          })
+        : null,
+    });
+  }
+}
+
+@ObjectType()
+export class ApplicationConnection {
+  @Field(() => [Application])
+  edges: Application[];
+
+  @Field(() => Int)
+  totalCount: number;
+
+  constructor(data: { edges: Application[]; totalCount: number }) {
+    this.edges = data.edges;
+    this.totalCount = data.totalCount;
+  }
+}

apps/server/src/modules/application/graphql/user-field.resolver.ts

···
+import { UseGuards } from "@nestjs/common";
+import { Parent, ResolveField, Resolver } from "@nestjs/graphql";
+import { JwtAuthGuard } from "@/modules/auth/jwt-auth.guard";
+import { User } from "@/modules/user/user.type";
+import { ApplicationService } from "../application.service";
+import { Application, ApplicationConnection } from "./application.type";
+
+@Resolver(() => User)
+@UseGuards(JwtAuthGuard)
+export class ApplicationUserFieldResolver {
+  constructor(private readonly applicationService: ApplicationService) {}
+
+  @ResolveField(() => ApplicationConnection, { nullable: true })
+  async applications(@Parent() user: User): Promise<ApplicationConnection> {
+    const applications = await this.applicationService.findApplicationsByUser(
+      user.id,
+    );
+    return new ApplicationConnection({
+      edges: applications.map((app) => Application.fromDomain(app)),
+      totalCount: applications.length,
+    });
+  }
+}

biome.json

···
     "includes": [
       "apps/**/*",
       "packages/**/*",
-      "!**/node_modules",
-      "!**/dist",
-      "!**/build",
-      "!**/coverage",
-      "!**/coverage-unit"
+      "!**/node_modules/**",
+      "!**/dist/**",
+      "!**/build/**",
+      "!**/coverage/**",
+      "!**/coverage-unit/**"
     ],
     "ignoreUnknown": false
   },

package.json

···
     "dev": "lerna run dev --parallel --stream",
     "start": "lerna run start --stream",
     "lint": "lerna run lint --stream",
-    "codegen": "lerna run prisma:generate --scope=@cv/server && lerna run codegen --scope=@cv/client",
+    "codegen": "lerna run prisma:generate --scope=@cv/server && lerna run codegen --scope=@cv/client && node scripts/generate-local-copies.js",
     "prisma:generate": "lerna run prisma:generate --scope=@cv/server",
     "prisma:migrate": "lerna run prisma:migrate --scope=@cv/server",
     "prisma:deploy": "lerna run prisma:deploy --scope=@cv/server",
     "prisma:studio": "lerna run prisma:studio --scope=@cv/server",
-    "seed": "lerna run seed --scope=@cv/server"
+    "seed": "lerna run seed --scope=@cv/server",
+    "generate:local": "node scripts/generate-local-copies.js"
   },
   "dependencies": {
     "@prisma/client": "^6.17.1"

scripts/generate-local-copies.js

···
+#!/usr/bin/env node
+
+/**
+ * Script to generate local copies of generated files for syntax highlighting
+ * These files are excluded from git but needed for IDE support
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const projectRoot = path.join(__dirname, '..');
+
+// Files to copy for local development
+const filesToCopy = [
+  {
+    source: 'apps/client/src/generated/graphql.ts',
+    destination: 'apps/client/src/generated-local/graphql.ts',
+    description: 'GraphQL generated types and hooks'
+  }
+];
+
+// Prisma client files to copy (if they exist)
+const prismaClientPath = path.join(projectRoot, 'apps/server/node_modules/@prisma/client');
+if (fs.existsSync(prismaClientPath)) {
+  const prismaFiles = fs.readdirSync(prismaClientPath, { recursive: true })
+    .filter(file => typeof file === 'string' && file.endsWith('.d.ts'))
+    .slice(0, 5); // Limit to first 5 files to avoid too many copies
+  
+  prismaFiles.forEach(file => {
+    filesToCopy.push({
+      source: `apps/server/node_modules/@prisma/client/${file}`,
+      destination: `apps/server/src/generated-local/prisma/${file}`,
+      description: 'Prisma client types'
+    });
+  });
+}
+
+console.log('🔄 Generating local copies of generated files for syntax highlighting...\n');
+
+filesToCopy.forEach(({ source, destination, description }) => {
+  const sourcePath = path.join(projectRoot, source);
+  const destPath = path.join(projectRoot, destination);
+  const destDir = path.dirname(destPath);
+
+  try {
+    // Create destination directory if it doesn't exist
+    if (!fs.existsSync(destDir)) {
+      fs.mkdirSync(destDir, { recursive: true });
+    }
+
+    // Copy file if source exists
+    if (fs.existsSync(sourcePath)) {
+      fs.copyFileSync(sourcePath, destPath);
+      console.log(`✅ Copied: ${description}`);
+      console.log(`   ${source} → ${destination}`);
+    } else {
+      console.log(`⚠️  Source not found: ${source}`);
+    }
+  } catch (error) {
+    console.error(`❌ Error copying ${source}:`, error.message);
+  }
+});
+
+console.log('\n🎉 Local copies generated successfully!');
+console.log('📝 Note: These files are excluded from git but provide IDE support.');