Getting Started with Microservices: Building with Shared TypeScript Packages and GitLab Registry

Introduction: The Day My Node.js Monolith Became Unmaintainable

Two years ago, I was working on a personal project—a comprehensive task management application that started as a simple Express.js monolith. Users, tasks, notifications, file uploads, reporting—everything in one TypeScript codebase. For months, it was perfect. Fast development, easy debugging, straightforward deployment.

Then my user base grew from 50 to 5,000 users, and my simple app became a nightmare.

Every new feature required touching multiple parts of the codebase. A small change to the notification system would break the user authentication. Database queries for reports would slow down the entire application. Deployment became an all-or-nothing gamble—one bug could bring down the entire platform.

I knew I needed to break it apart, but I was terrified of code duplication. How do you share common logic between services? How do you maintain consistent types across multiple TypeScript projects? How do you version and distribute shared code?

That crisis led me to discover the power of microservices with shared npm packages, and it completely transformed how I build scalable applications. Today, I want to share my journey from a single monolith to a distributed system with reusable TypeScript packages published to GitLab's package registry.

Why I Chose Microservices for My Task Management Platform

Before diving into the technical implementation, let me share why microservices made sense for my growing project and when you might consider the same transition:

The Problems I Faced with My Monolith

My pain points:

• Scaling bottlenecks: File uploads would consume all server resources, affecting user logins

• Development conflicts: Multiple features couldn't be developed simultaneously

• Technology lock-in: Stuck with the same Node.js version and dependencies across all features

• Deployment anxiety: One bad commit could break everything

• Team coordination: As I brought on contributors, merge conflicts became frequent

The Microservices Solution I Implemented

This architecture solved my core problems:

• Independent scaling: Each service scales based on its specific needs

• Technology flexibility: Different services can use different Node.js versions

• Isolated deployments: Updates to one service don't affect others

• Team autonomy: Different developers can own different services

• Fault isolation: One service failure doesn't cascade to others

Phase 1: Building My First Microservice with Shared Types

Let me walk you through how I extracted my first service from the monolith—the User Service—and how I handled shared code that multiple services would need.

Creating the Shared Types Package

First, I created a shared types package that would contain common interfaces, types, and utilities that multiple services would use:

// packages/shared-types/src/index.ts
export interface User {
  id: string;
  email: string;
  username: string;
  createdAt: Date;
  updatedAt: Date;
  isActive: boolean;
  roles: UserRole[];
}

export interface UserRole {
  id: string;
  name: string;
  permissions: Permission[];
}

export interface Permission {
  id: string;
  resource: string;
  action: string;
}

export interface Task {
  id: string;
  title: string;
  description: string;
  status: TaskStatus;
  assigneeId: string;
  creatorId: string;
  projectId: string;
  dueDate?: Date;
  createdAt: Date;
  updatedAt: Date;
}

export enum TaskStatus {
  TODO = 'todo',
  IN_PROGRESS = 'in_progress',
  REVIEW = 'review',
  DONE = 'done'
}

export interface Project {
  id: string;
  name: string;
  description: string;
  ownerId: string;
  memberIds: string[];
  createdAt: Date;
  updatedAt: Date;
}

// API Response types
export interface ApiResponse<T> {
  success: boolean;
  data?: T;
  error?: string;
  timestamp: Date;
}

export interface PaginatedResponse<T> {
  items: T[];
  totalCount: number;
  page: number;
  pageSize: number;
  hasNext: boolean;
  hasPrevious: boolean;
}

// Event types for inter-service communication
export interface DomainEvent {
  id: string;
  type: string;
  aggregateId: string;
  version: number;
  timestamp: Date;
  data: any;
}

export interface UserCreatedEvent extends DomainEvent {
  type: 'USER_CREATED';
  data: {
    userId: string;
    email: string;
    username: string;
  };
}

export interface TaskCreatedEvent extends DomainEvent {
  type: 'TASK_CREATED';
  data: {
    taskId: string;
    title: string;
    assigneeId: string;
    projectId: string;
  };
}

// Validation schemas using zod
import { z } from 'zod';

export const CreateUserSchema = z.object({
  email: z.string().email(),
  username: z.string().min(3).max(50),
  password: z.string().min(8).max(100),
});

export const CreateTaskSchema = z.object({
  title: z.string().min(1).max(200),
  description: z.string().max(1000),
  assigneeId: z.string().uuid(),
  projectId: z.string().uuid(),
  dueDate: z.date().optional(),
});

export type CreateUserRequest = z.infer<typeof CreateUserSchema>;
export type CreateTaskRequest = z.infer<typeof CreateTaskSchema>;

Setting Up the Package.json for the Shared Package

{
  "name": "@my-task-app/shared-types",
  "version": "1.0.0",
  "description": "Shared types and interfaces for the task management microservices",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
  "scripts": {
    "build": "tsc",
    "prepublishOnly": "npm run build",
    "test": "jest",
    "lint": "eslint src/**/*.ts",
    "type-check": "tsc --noEmit"
  },
  "dependencies": {
    "zod": "^3.22.0"
  },
  "devDependencies": {
    "@types/node": "^20.0.0",
    "typescript": "^5.0.0",
    "eslint": "^8.50.0",
    "@typescript-eslint/eslint-plugin": "^6.0.0",
    "@typescript-eslint/parser": "^6.0.0",
    "jest": "^29.7.0",
    "@types/jest": "^29.5.0",
    "ts-jest": "^29.1.0"
  },
  "publishConfig": {
    "registry": "https://gitlab.com/api/v4/projects/YOUR_PROJECT_ID/packages/npm/"
  },
  "files": [
    "dist"
  ]
}

TypeScript Configuration for the Shared Package

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "lib": ["ES2020"],
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true,
    "removeComments": false,
    "resolveJsonModule": true
  },
  "include": [
    "src/**/*"
  ],
  "exclude": [
    "node_modules",
    "dist",
    "**/*.test.ts"
  ]
}

Phase 2: Building the User Service

Now let me show you how I built my first microservice using the shared types:

User Service Architecture

// services/user-service/src/types/index.ts
import { User, CreateUserRequest, UserCreatedEvent } from '@my-task-app/shared-types';

export interface UserRepository {
  create(userData: CreateUserRequest): Promise<User>;
  findById(id: string): Promise<User | null>;
  findByEmail(email: string): Promise<User | null>;
  update(id: string, updates: Partial<User>): Promise<User>;
  delete(id: string): Promise<void>;
}

export interface UserService {
  createUser(userData: CreateUserRequest): Promise<User>;
  getUserById(id: string): Promise<User | null>;
  updateUser(id: string, updates: Partial<User>): Promise<User>;
  deleteUser(id: string): Promise<void>;
}

User Service Implementation

// services/user-service/src/services/UserService.ts
import { v4 as uuidv4 } from 'uuid';
import bcrypt from 'bcrypt';
import { 
  User, 
  CreateUserRequest, 
  UserCreatedEvent,
  CreateUserSchema 
} from '@my-task-app/shared-types';
import { UserRepository } from '../types';
import { EventPublisher } from '../events/EventPublisher';

export class UserServiceImpl implements UserService {
  constructor(
    private userRepository: UserRepository,
    private eventPublisher: EventPublisher
  ) {}

  async createUser(userData: CreateUserRequest): Promise<User> {
    // Validate input using shared schema
    const validatedData = CreateUserSchema.parse(userData);

    // Check if user already exists
    const existingUser = await this.userRepository.findByEmail(validatedData.email);
    if (existingUser) {
      throw new Error('User with this email already exists');
    }

    // Hash password
    const hashedPassword = await bcrypt.hash(validatedData.password, 10);

    // Create user
    const newUser: User = {
      id: uuidv4(),
      email: validatedData.email,
      username: validatedData.username,
      createdAt: new Date(),
      updatedAt: new Date(),
      isActive: true,
      roles: [] // Default to no roles
    };

    const createdUser = await this.userRepository.create({
      ...newUser,
      password: hashedPassword
    });

    // Publish domain event
    const event: UserCreatedEvent = {
      id: uuidv4(),
      type: 'USER_CREATED',
      aggregateId: createdUser.id,
      version: 1,
      timestamp: new Date(),
      data: {
        userId: createdUser.id,
        email: createdUser.email,
        username: createdUser.username
      }
    };

    await this.eventPublisher.publish(event);

    return createdUser;
  }

  async getUserById(id: string): Promise<User | null> {
    return this.userRepository.findById(id);
  }

  async updateUser(id: string, updates: Partial<User>): Promise<User> {
    const existingUser = await this.userRepository.findById(id);
    if (!existingUser) {
      throw new Error('User not found');
    }

    const updatedUser = await this.userRepository.update(id, {
      ...updates,
      updatedAt: new Date()
    });

    return updatedUser;
  }

  async deleteUser(id: string): Promise<void> {
    const existingUser = await this.userRepository.findById(id);
    if (!existingUser) {
      throw new Error('User not found');
    }

    await this.userRepository.delete(id);
  }
}

User Service HTTP Controllers

// services/user-service/src/controllers/UserController.ts
import { Request, Response } from 'express';
import { ApiResponse } from '@my-task-app/shared-types';
import { UserService } from '../types';

export class UserController {
  constructor(private userService: UserService) {}

  async createUser(req: Request, res: Response): Promise<void> {
    try {
      const user = await this.userService.createUser(req.body);
      
      const response: ApiResponse<User> = {
        success: true,
        data: user,
        timestamp: new Date()
      };

      res.status(201).json(response);
    } catch (error) {
      const response: ApiResponse<null> = {
        success: false,
        error: error.message,
        timestamp: new Date()
      };

      res.status(400).json(response);
    }
  }

  async getUser(req: Request, res: Response): Promise<void> {
    try {
      const { id } = req.params;
      const user = await this.userService.getUserById(id);

      if (!user) {
        const response: ApiResponse<null> = {
          success: false,
          error: 'User not found',
          timestamp: new Date()
        };
        res.status(404).json(response);
        return;
      }

      const response: ApiResponse<User> = {
        success: true,
        data: user,
        timestamp: new Date()
      };

      res.status(200).json(response);
    } catch (error) {
      const response: ApiResponse<null> = {
        success: false,
        error: error.message,
        timestamp: new Date()
      };

      res.status(500).json(response);
    }
  }

  async updateUser(req: Request, res: Response): Promise<void> {
    try {
      const { id } = req.params;
      const user = await this.userService.updateUser(id, req.body);

      const response: ApiResponse<User> = {
        success: true,
        data: user,
        timestamp: new Date()
      };

      res.status(200).json(response);
    } catch (error) {
      const response: ApiResponse<null> = {
        success: false,
        error: error.message,
        timestamp: new Date()
      };

      res.status(400).json(response);
    }
  }

  async deleteUser(req: Request, res: Response): Promise<void> {
    try {
      const { id } = req.params;
      await this.userService.deleteUser(id);

      const response: ApiResponse<null> = {
        success: true,
        timestamp: new Date()
      };

      res.status(204).json(response);
    } catch (error) {
      const response: ApiResponse<null> = {
        success: false,
        error: error.message,
        timestamp: new Date()
      };

      res.status(400).json(response);
    }
  }
}

Phase 3: Setting Up GitLab Package Registry for Shared Code

One of the biggest challenges I faced was how to share common code between my microservices. GitLab's package registry became my solution for versioning and distributing shared TypeScript packages.

Setting Up GitLab Package Registry Authentication

First, I needed to configure authentication for publishing packages to GitLab:

# Create .npmrc file in your project root
echo "@my-task-app:registry=https://gitlab.com/api/v4/projects/YOUR_PROJECT_ID/packages/npm/" >> .npmrc
echo "//gitlab.com/api/v4/projects/YOUR_PROJECT_ID/packages/npm/:_authToken=${CI_JOB_TOKEN}" >> .npmrc

GitLab CI/CD Pipeline for Package Publishing

# .gitlab-ci.yml for shared-types package
stages:
  - test
  - build
  - publish

variables:
  NODE_VERSION: "20"
  NPM_TOKEN: $CI_JOB_TOKEN

test:
  stage: test
  image: node:${NODE_VERSION}
  script:
    - npm ci
    - npm run lint
    - npm run type-check
    - npm test
  coverage: '/Lines\s*:\s*(\d+\.\d+)%/'

build:
  stage: build
  image: node:${NODE_VERSION}
  script:
    - npm ci
    - npm run build
  artifacts:
    paths:
      - dist/
    expire_in: 1 hour

publish:
  stage: publish
  image: node:${NODE_VERSION}
  script:
    - echo "//gitlab.com/api/v4/projects/${CI_PROJECT_ID}/packages/npm/:_authToken=${CI_JOB_TOKEN}" >> .npmrc
    - npm ci
    - npm run build
    - npm publish
  only:
    - main
    - /^v\d+\.\d+\.\d+.*$/
  artifacts:
    reports:
      dotenv: build.env

Version Management Strategy

I developed a semantic versioning strategy for my shared packages:

// scripts/version-manager.ts
import { execSync } from 'child_process';
import fs from 'fs';

interface PackageJson {
  name: string;
  version: string;
  dependencies?: Record<string, string>;
  devDependencies?: Record<string, string>;
}

class VersionManager {
  private packagePath: string;

  constructor(packagePath: string) {
    this.packagePath = packagePath;
  }

  async bumpVersion(type: 'patch' | 'minor' | 'major'): Promise<string> {
    const packageJson = this.readPackageJson();
    const currentVersion = packageJson.version;
    
    // Use npm version to bump
    const newVersion = execSync(`npm version ${type} --no-git-tag-version`, {
      cwd: this.packagePath,
      encoding: 'utf8'
    }).trim().substring(1); // Remove 'v' prefix

    console.log(`Bumped version from ${currentVersion} to ${newVersion}`);
    return newVersion;
  }

  async updateDependents(packageName: string, newVersion: string): Promise<void> {
    const servicesDir = '../services';
    const services = fs.readdirSync(servicesDir);

    for (const service of services) {
      const servicePath = `${servicesDir}/${service}`;
      const packageJsonPath = `${servicePath}/package.json`;

      if (fs.existsSync(packageJsonPath)) {
        const servicePackage = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
        
        if (servicePackage.dependencies?.[packageName]) {
          servicePackage.dependencies[packageName] = `^${newVersion}`;
          fs.writeFileSync(packageJsonPath, JSON.stringify(servicePackage, null, 2));
          console.log(`Updated ${service} to use ${packageName}@${newVersion}`);
        }
      }
    }
  }

  private readPackageJson(): PackageJson {
    const packageJsonPath = `${this.packagePath}/package.json`;
    return JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
  }
}

// Usage script
async function main() {
  const versionType = process.argv[2] as 'patch' | 'minor' | 'major';
  
  if (!['patch', 'minor', 'major'].includes(versionType)) {
    console.error('Usage: npm run version-bump <patch|minor|major>');
    process.exit(1);
  }

  const versionManager = new VersionManager('./packages/shared-types');
  const newVersion = await versionManager.bumpVersion(versionType);
  await versionManager.updateDependents('@my-task-app/shared-types', newVersion);
  
  console.log(`Version bump complete: ${newVersion}`);
}

main().catch(console.error);

Phase 4: Inter-Service Communication with Shared Events

One of the most challenging aspects of my microservices transition was handling communication between services. Here's how I implemented event-driven communication using shared event types:

Event Publisher Implementation

// packages/shared-events/src/EventPublisher.ts
import { DomainEvent } from '@my-task-app/shared-types';
import { EventBus } from './EventBus';

export interface EventPublisher {
  publish(event: DomainEvent): Promise<void>;
  publishBatch(events: DomainEvent[]): Promise<void>;
}

export class RabbitMQEventPublisher implements EventPublisher {
  constructor(private eventBus: EventBus) {}

  async publish(event: DomainEvent): Promise<void> {
    try {
      await this.eventBus.publish(event.type, event);
      console.log(`Published event: ${event.type} for aggregate: ${event.aggregateId}`);
    } catch (error) {
      console.error(`Failed to publish event: ${event.type}`, error);
      throw error;
    }
  }

  async publishBatch(events: DomainEvent[]): Promise<void> {
    const publishPromises = events.map(event => this.publish(event));
    await Promise.all(publishPromises);
  }
}

Service Communication Sequence Diagram

Task Service Implementation

// services/task-service/src/services/TaskService.ts
import { 
  Task, 
  CreateTaskRequest, 
  TaskCreatedEvent,
  CreateTaskSchema 
} from '@my-task-app/shared-types';
import { TaskRepository } from '../types';
import { EventPublisher } from '@my-task-app/shared-events';
import { UserServiceClient } from '../clients/UserServiceClient';

export class TaskServiceImpl {
  constructor(
    private taskRepository: TaskRepository,
    private eventPublisher: EventPublisher,
    private userServiceClient: UserServiceClient
  ) {}

  async createTask(taskData: CreateTaskRequest): Promise<Task> {
    // Validate input
    const validatedData = CreateTaskSchema.parse(taskData);

    // Verify assignee exists
    const assignee = await this.userServiceClient.getUser(validatedData.assigneeId);
    if (!assignee) {
      throw new Error('Assigned user does not exist');
    }

    // Create task
    const newTask: Task = {
      id: uuidv4(),
      title: validatedData.title,
      description: validatedData.description,
      status: TaskStatus.TODO,
      assigneeId: validatedData.assigneeId,
      creatorId: validatedData.creatorId,
      projectId: validatedData.projectId,
      dueDate: validatedData.dueDate,
      createdAt: new Date(),
      updatedAt: new Date()
    };

    const createdTask = await this.taskRepository.create(newTask);

    // Publish event
    const event: TaskCreatedEvent = {
      id: uuidv4(),
      type: 'TASK_CREATED',
      aggregateId: createdTask.id,
      version: 1,
      timestamp: new Date(),
      data: {
        taskId: createdTask.id,
        title: createdTask.title,
        assigneeId: createdTask.assigneeId,
        projectId: createdTask.projectId
      }
    };

    await this.eventPublisher.publish(event);

    return createdTask;
  }
}

Phase 5: Package Dependency Management Across Services

Managing dependencies across multiple microservices became crucial as my system grew. Here's how I solved dependency management and kept everything in sync:

Automated Dependency Updates

// scripts/update-dependencies.ts
import fs from 'fs';
import path from 'path';
import { execSync } from 'child_process';

interface ServiceDependencies {
  serviceName: string;
  packagePath: string;
  sharedPackages: Record<string, string>;
}

class DependencyManager {
  private servicesDir: string;
  private sharedPackages: string[];

  constructor(servicesDir: string, sharedPackages: string[]) {
    this.servicesDir = servicesDir;
    this.sharedPackages = sharedPackages;
  }

  async scanServices(): Promise<ServiceDependencies[]> {
    const services: ServiceDependencies[] = [];
    const serviceDirs = fs.readdirSync(this.servicesDir);

    for (const serviceDir of serviceDirs) {
      const servicePath = path.join(this.servicesDir, serviceDir);
      const packageJsonPath = path.join(servicePath, 'package.json');

      if (fs.existsSync(packageJsonPath)) {
        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
        const sharedPackages: Record<string, string> = {};

        // Check for shared packages in dependencies
        for (const sharedPkg of this.sharedPackages) {
          if (packageJson.dependencies?.[sharedPkg]) {
            sharedPackages[sharedPkg] = packageJson.dependencies[sharedPkg];
          }
        }

        services.push({
          serviceName: serviceDir,
          packagePath: servicePath,
          sharedPackages
        });
      }
    }

    return services;
  }

  async updateToLatestVersions(): Promise<void> {
    const services = await this.scanServices();
    
    for (const service of services) {
      console.log(`Updating dependencies for ${service.serviceName}...`);
      
      for (const packageName of this.sharedPackages) {
        if (service.sharedPackages[packageName]) {
          try {
            // Get latest version from registry
            const latestVersion = this.getLatestVersion(packageName);
            
            // Update package.json
            await this.updatePackageVersion(
              service.packagePath, 
              packageName, 
              `^${latestVersion}`
            );
            
            console.log(`Updated ${packageName} to ${latestVersion} in ${service.serviceName}`);
          } catch (error) {
            console.error(`Failed to update ${packageName} in ${service.serviceName}:`, error);
          }
        }
      }
      
      // Run npm install
      execSync('npm install', { cwd: service.packagePath });
    }
  }

  private getLatestVersion(packageName: string): string {
    try {
      const result = execSync(`npm view ${packageName} version --registry=https://gitlab.com/api/v4/projects/YOUR_PROJECT_ID/packages/npm/`, {
        encoding: 'utf8'
      });
      return result.trim();
    } catch (error) {
      throw new Error(`Failed to get latest version for ${packageName}`);
    }
  }

  private async updatePackageVersion(servicePath: string, packageName: string, version: string): Promise<void> {
    const packageJsonPath = path.join(servicePath, 'package.json');
    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
    
    if (packageJson.dependencies?.[packageName]) {
      packageJson.dependencies[packageName] = version;
    }
    
    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
  }

  async generateDependencyReport(): Promise<void> {
    const services = await this.scanServices();
    const report = {
      scanDate: new Date().toISOString(),
      services: services.map(service => ({
        name: service.serviceName,
        sharedPackages: service.sharedPackages
      }))
    };

    fs.writeFileSync('./dependency-report.json', JSON.stringify(report, null, 2));
    console.log('Dependency report generated: ./dependency-report.json');
  }
}

// Usage
async function main() {
  const dependencyManager = new DependencyManager('./services', [
    '@my-task-app/shared-types',
    '@my-task-app/shared-events',
    '@my-task-app/shared-utils'
  ]);

  const command = process.argv[2];

  switch (command) {
    case 'scan':
      await dependencyManager.generateDependencyReport();
      break;
    case 'update':
      await dependencyManager.updateToLatestVersions();
      break;
    default:
      console.log('Usage: npm run deps <scan|update>');
  }
}

main().catch(console.error);

My Key Learnings and Best Practices

After two years of running my microservices architecture with shared packages, here are the most important lessons I've learned:

1. Start with Clear Boundaries

Don't rush to break everything apart. I spent weeks identifying the right service boundaries:

• Business capabilities: Each service should own a complete business function

• Data ownership: Each service should own its data and never share databases

• Team ownership: Services should align with team structures and responsibilities

2. Shared Package Strategy

My approach to shared packages:

// Good: Domain-agnostic utilities
@my-task-app/shared-types     // Common interfaces and types
@my-task-app/shared-events    // Event publishing/subscribing
@my-task-app/shared-utils     // Validation, formatting, etc.

// Avoid: Business logic in shared packages  
@my-task-app/user-logic       // ❌ Too specific to user service
@my-task-app/task-business    // ❌ Couples services together

3. Version Management

I learned to be very careful with breaking changes:

• Semantic versioning: Patch for bugs, minor for features, major for breaking changes

• Backward compatibility: Keep old versions working for at least one release cycle

• Gradual rollouts: Update services one at a time, not all at once

4. Monitoring and Observability

With multiple services, monitoring became crucial:

// shared-utils/src/monitoring/ServiceMonitor.ts
export class ServiceMonitor {
  static logRequest(serviceName: string, endpoint: string, duration: number) {
    console.log(JSON.stringify({
      timestamp: new Date().toISOString(),
      service: serviceName,
      endpoint,
      duration,
      type: 'request'
    }));
  }

  static logError(serviceName: string, error: Error, context?: any) {
    console.error(JSON.stringify({
      timestamp: new Date().toISOString(),
      service: serviceName,
      error: error.message,
      stack: error.stack,
      context,
      type: 'error'
    }));
  }
}

What This Architecture Gave My Project

The transformation from monolith to microservices with shared packages delivered real benefits:

Development Velocity

• Before: 2-3 days to add a new feature (fear of breaking things)

• After: Same day feature delivery with confidence

Scalability

• Before: Entire app would slow down during file uploads

• After: Each service scales independently based on load

Team Collaboration

• Before: Merge conflicts and coordination overhead

• After: Independent development and deployment

Reliability

• Before: One bug could bring down everything

• After: Isolated failures with graceful degradation

Conclusion: When Microservices Make Sense

Microservices aren't a silver bullet—they come with complexity overhead. But for my growing task management platform, they solved real problems:

• Independent scaling based on actual usage patterns

• Technology flexibility to choose the best tool for each job

• Team autonomy for faster development cycles

• Fault isolation for better overall reliability

The key was having a solid shared package strategy with GitLab's package registry. This let me share common code without coupling services together.

My Advice for Your Project

Start with a monolith, then extract services when you hit real pain points:

1. Identify service boundaries based on business capabilities

2. Create shared packages for common types and utilities

3. Set up package registry for versioning and distribution

4. Implement event-driven communication for service coordination

5. Invest in monitoring and observability from day one

The transition isn't easy, but with the right approach to shared code and dependency management, microservices can unlock the scalability and velocity your growing application needs.

Remember: the goal isn't perfect architecture—it's building systems that can evolve with your needs while maintaining the development velocity that got you there in the first place.