Backend Developer

Overview

This skill provides expertise in TypeScript backend development with Node.js, NestJS, and modern server-side technologies. Apply this skill when building APIs, implementing database integrations, fixing backend bugs, optimizing performance, or ensuring backend security.

Core Development Principles

TypeScript Configuration

Essential Setup:

• •Enable TypeScript strict mode for maximum type safety
• •Configure backend-optimized tsconfig.json settings
• •Leverage advanced types for better code safety
• •Use TypeScript utility types for code reuse

Architecture Patterns

Layered Architecture:

• •Implement proper separation: controllers → services → repositories → models
• •Use dependency injection and inversion of control principles
• •Apply SOLID principles and clean architecture patterns
• •Structure by domain boundaries in clear modules

Async/Await Best Practices

Consistent Usage:

• •Use async/await consistently throughout codebase
• •Handle promises properly with try/catch blocks
• •Implement proper error boundaries and graceful degradation
• •Apply error handling at appropriate abstraction levels

NestJS Development Guidelines

Service Architecture

Controller and Service Separation:

• •Keep controllers lean, delegate business logic to services
• •Follow SOLID principles, especially Single Responsibility
• •Use constructor injection for all dependencies
• •Implement interfaces for repositories and external services

Example Implementation:

// ✅ Good - Single Responsibility
@Controller('users')
export class UsersController {
  constructor(private readonly userService: UserService) {}

  @Post()
  async create(@Body() dto: CreateUserDto) {
    return this.userService.create(dto);
  }
}

@Injectable()
export class UserService {
  constructor(private readonly userRepository: IUserRepository) {}

  async create(dto: CreateUserDto) {
    return this.userRepository.create(dto);
  }
}

// ✅ Good - Dependency Inversion
@Module({
  providers: [
    { provide: 'UserRepository', useClass: TypeOrmUserRepository }
  ],
})
export class UsersModule {}

Dependency Injection

Best Practices:

• •Always use constructor injection
• •Inject interfaces, not concrete implementations
• •Define clear provider tokens for dependency resolution
• •Use custom providers for complex dependency scenarios

TypeORM Patterns

Entity-First Design

Schema Definition:

• •Drive database schema through TypeORM entities
• •Use decorators for columns, relationships, and constraints
• •Implement entity lifecycle hooks (BeforeInsert, BeforeUpdate) for validation

Example:

@Entity('users')
export class UserEntity {
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @Column()
  email: string;

  @BeforeInsert()
  @BeforeUpdate()
  validateData() {
    // Validation logic here
    if (!this.email.includes('@')) {
      throw new Error('Invalid email');
    }
  }
}

Repository Pattern

Data Access Encapsulation:

• •Create custom repositories for complex queries
• •Encapsulate data access logic
• •Use query builders for type-safe dynamic queries

Example:

@Injectable()
export class CustomUserRepository extends Repository<UserEntity> {
  async findActiveUsers(): Promise<UserEntity[]> {
    return this.createQueryBuilder('user')
      .where('user.isActive = :isActive', { isActive: true })
      .orderBy('user.createdAt', 'DESC')
      .getMany();
  }
}

Performance Optimization

Async Operation Parallelization

Critical Pattern: When multiple independent async operations can run concurrently, use Promise.all() to parallelize them for significant performance gains (15-40% latency reduction).

Example:

// ✅ Good - Parallelized independent operations (~40% faster)
async searchByAccount(account: Account): Promise<ContactData[]> {
  const startTime = Date.now();

  // Parallelize independent operations that don't depend on each other
  const [domainResult, keywordsResult] = await Promise.all([
    // Operation 1: Domain lookup
    this.domainService.findDomain(account.domain).then(result => {
      this.logger.log(`Domain lookup completed in ${Date.now() - startTime}ms`);
      return result;
    }),

    // Operation 2: Keywords generation
    this.keywordService.generateKeywords(account).then(result => {
      this.logger.log(`Keywords generation completed in ${Date.now() - startTime}ms`);
      return result;
    })
  ]);

  // Use results for subsequent operations
  return this.processContactData(domainResult, keywordsResult);
}

// ❌ Bad - Sequential operations (unnecessary wait time)
async searchByAccount(account: Account): Promise<ContactData[]> {
  const domainResult = await this.domainService.findDomain(account.domain);
  const keywordsResult = await this.keywordService.generateKeywords(account);

  return this.processContactData(domainResult, keywordsResult);
}

Key Benefits:

• •15-40% latency reduction for independent operations
• •Better resource utilization
• •Improved user experience with faster responses
• •Reduced total execution time

Performance Monitoring Integration

Comprehensive Metrics: Always measure and monitor performance improvements with proper metrics.

// ✅ Good - Comprehensive timing metrics for parallel operations
async getInitialContactData(params: SearchParams): Promise<ContactData> {
  const overallStart = Date.now();
  const salesforceStart = Date.now();
  const providerStart = Date.now();

  const [salesforceContacts, providerContacts] = await Promise.all([
    this.salesforceService.searchContacts(params).then(result => {
      this.metricsService.gauge('salesforce_search.latency', Date.now() - salesforceStart);
      return result;
    }),

    this.providerService.searchContacts(params).then(result => {
      this.metricsService.gauge('provider_search.latency', Date.now() - providerStart);
      return result;
    })
  ]);

  this.metricsService.gauge('parallel_contact_search.latency', Date.now() - overallStart);

  return this.mergeContactData(salesforceContacts, providerContacts);
}

// Track performance improvement metrics
this.metricsService.histogram('contact_discovery.latency_reduction', reductionPercentage);

Performance Optimization Decision Matrix

Key Insight: Always analyze operation dependencies before optimization - independent operations are prime candidates for parallelization.

Database Optimization

Query Performance:

• •Implement proper database indexing
• •Optimize database queries with query builders
• •Use connection pooling and manage connections efficiently
• •Apply proper database migrations and seeding strategies

Connection Management:

• •Configure connection pooling appropriately
• •Monitor connection usage and leaks
• •Implement proper connection lifecycle management
• •Use read replicas for read-heavy operations

API Development

RESTful API Design

Best Practices:

• •Follow REST API design principles
• •Use proper HTTP status codes (200, 201, 400, 401, 404, 500, etc.)
• •Implement proper request validation and sanitization
• •Follow semantic versioning for API endpoints

Error Handling

Comprehensive Strategy:

• •Set up comprehensive error handling with custom error classes
• •Use proper HTTP status codes for different error types
• •Implement proper error boundaries
• •Provide meaningful error messages without exposing sensitive information

Request Validation

Input Sanitization:

• •Implement proper request validation at controller level
• •Use DTOs (Data Transfer Objects) with class-validator
• •Sanitize user inputs to prevent injection attacks
• •Validate both structure and content of requests

Security Best Practices

Authentication & Authorization

Implementation:

• •Implement JWT, OAuth, or session-based auth
• •Apply proper security measures for token management
• •Use proper password hashing (bcrypt, argon2)
• •Implement role-based access control (RBAC)

Security Hardening

Essential Measures:

• •Apply input validation and sanitization
• •Configure CORS properly
• •Use helmet middleware for security headers
• •Implement rate limiting and request throttling
• •Manage environment variables securely
• •Never commit secrets to version control

Logging & Monitoring

Structured Logging

Configuration:

• •Configure structured logging with Winston or similar
• •Use proper logging levels (error, warn, info, debug)
• •Implement request/response logging
• •Include correlation IDs for distributed tracing

Observability

Health Checks:

• •Implement health check endpoints
• •Monitor application metrics
• •Set up alerts for critical errors
• •Track performance metrics over time

Testing Strategy

Test Coverage

Comprehensive Testing:

• •Write unit tests for business logic
• •Implement integration tests for API endpoints
• •Create E2E tests for critical user flows
• •Use Jest, Supertest, or similar frameworks
• •Aim for >80% code coverage for critical paths

Test Organization

Best Practices:

• •Follow AAA pattern (Arrange, Act, Assert)
• •Mock external dependencies properly
• •Use test fixtures and factories
• •Keep tests isolated and independent

Deployment & DevOps

CI/CD Integration

Automation:

• •Implement proper CI/CD pipelines
• •Automate testing and deployment
• •Use environment-based configuration management
• •Implement blue-green or canary deployments

Documentation

API Documentation:

• •Create API documentation with Swagger/OpenAPI
• •Maintain comprehensive README files
• •Document environment variables and configuration
• •Provide setup and deployment instructions

Implementation Workflow

When applying this skill to backend development tasks:

1. •Project Analysis: Assess current backend structure, dependencies, and architecture patterns
2. •Architecture Design: Plan layered architecture with proper separation of concerns
3. •Database Integration: Implement database connections with proper ORM/ODM setup
4. •API Development: Create APIs with proper routing, middleware, and validation
5. •Security Implementation: Apply authentication, authorization, and security hardening
6. •Performance Optimization: Implement caching, parallelization, and query optimization
7. •Testing: Write comprehensive unit, integration, and E2E tests
8. •Logging & Monitoring: Configure structured logging and observability features
9. •Documentation: Create API docs and maintain README files

Common Anti-Patterns to Avoid

Architecture:

• •❌ Fat controllers with business logic
• •❌ Direct database access from controllers
• •❌ Circular dependencies between modules
• •❌ Missing dependency injection

Performance:

• •❌ Sequential execution of independent async operations
• •❌ Missing database indexes on frequently queried columns
• •❌ No connection pooling
• •❌ Missing caching for expensive operations

Security:

• •❌ Storing passwords in plain text
• •❌ Missing input validation
• •❌ Exposing sensitive data in error messages
• •❌ Hardcoded secrets in code

Error Handling:

• •❌ Swallowing errors silently
• •❌ Generic error messages that don't help debugging
• •❌ Missing try/catch blocks for async operations
• •❌ Improper HTTP status codes