Framework Comparison: Microservice Implementation

Same functionality, different frameworks: E-commerce microservice (User + Order services) implemented in Lokstra vs NestJS vs Spring Boot

This document compares how the same microservice application would be implemented across three popular enterprise frameworks, focusing on real code patterns and architectural differences.

🎯 Application Requirements

We’re building an e-commerce system with:

Services:

1. User Service - Manages user data
2. Order Service - Manages orders, depends on User Service

Deployment Patterns:

1. Monolith - Both services in one process
2. Microservices - Separate services with HTTP communication

Endpoints:

GET    /users           # List users
GET    /users/{id}      # Get user by ID
GET    /orders/{id}     # Get order by ID  
GET    /users/{id}/orders  # Get user's orders (cross-service)

🏗️ Architecture Comparison

Lokstra (Go)

Single Binary + YAML Config
├─ config.yaml (deployment topology)
├─ main.go (service registration) 
├─ service/ (business logic)
├─ contract/ (interfaces)
└─ repository/ (data access)

Features:
✅ Zero-code deployment switching
✅ Auto-generated REST APIs
✅ Type-safe lazy DI
✅ Convention-based routing

NestJS (TypeScript)

Multiple Apps + Environment Config
├─ apps/monolith/ (all services)
├─ apps/user-service/ (user only)
├─ apps/order-service/ (order only)
├─ libs/shared/ (common code)
└─ Different builds for different deployments

Features:
✅ Rich decorator ecosystem
✅ Familiar Angular patterns  
✅ Good TypeScript integration
❌ Requires code changes for deployment switching

Spring Boot (Java)

Multiple JARs + Profile Config  
├─ monolith/ (all services)
├─ user-service/ (user microservice)
├─ order-service/ (order microservice)
├─ shared/ (common entities)
└─ Different builds for different deployments

Features:
✅ Mature Java ecosystem
✅ Rich Spring ecosystem
✅ Auto-configuration
❌ Requires different artifacts per deployment

📝 Code Comparison: Service Implementation

Lokstra - Clean & Simple

User Service:

// contract/user_contract.go
type UserService interface {
    GetByID(p *GetUserParams) (*model.User, error)
    List(p *ListUsersParams) ([]*model.User, error)
}

// service/user_service.go
type UserServiceImpl struct {
    userRepo repository.UserRepository
}

func (s *UserServiceImpl) GetByID(p *GetUserParams) (*model.User, error) {
    return s.userRepo.GetByID(p.ID)
}

func (s *UserServiceImpl) List(p *ListUsersParams) ([]*model.User, error) {
    return s.userRepo.List()
}

// repository/user_repository.go - PostgreSQL implementation
type UserRepositoryPostgres struct {
    db *sql.DB
}

func (r *UserRepositoryPostgres) GetByID(id int) (*model.User, error) {
    query := `SELECT id, name, email, created_at FROM users WHERE id = $1`
    row := r.db.QueryRow(query, id)
    
    var user model.User
    err := row.Scan(&user.ID, &user.Name, &user.Email, &user.CreatedAt)
    if err != nil {
        if err == sql.ErrNoRows {
            return nil, fmt.Errorf("user not found: %d", id)
        }
        return nil, fmt.Errorf("failed to get user: %w", err)
    }
    return &user, nil
}

func (r *UserRepositoryPostgres) List() ([]*model.User, error) {
    query := `SELECT id, name, email, created_at FROM users ORDER BY created_at DESC`
    rows, err := r.db.Query(query)
    if err != nil {
        return nil, fmt.Errorf("failed to list users: %w", err)
    }
    defer rows.Close()
    
    var users []*model.User
    for rows.Next() {
        var user model.User
        err := rows.Scan(&user.ID, &user.Name, &user.Email, &user.CreatedAt)
        if err != nil {
            return nil, fmt.Errorf("failed to scan user: %w", err)
        }
        users = append(users, &user)
    }
    return users, nil
}

Order Service with Cross-Service Call:

type OrderServiceImpl struct {
    orderRepo repository.OrderRepository 
    userSvc   contract.UserService // Interface! Auto-resolves local/remote
}

func (s *OrderServiceImpl) GetByID(p *GetOrderParams) (*model.OrderWithUser, error) {
    order, err := s.orderRepo.GetByID(p.ID)
    if err != nil {
        return nil, err
    }
    
    // Cross-service call - automatically local or HTTP based on deployment!
    user, err := s.userSvc.GetByID(&GetUserParams{ID: order.UserID})
    if err != nil {
        return nil, err
    }
    
    return &model.OrderWithUser{Order: order, User: user}, nil
}

Database & Registration Setup:

// main.go
func main() {
    // Database connection
    lokstra_registry.RegisterServiceFactory("database", func() *sql.DB {
        dbURL := os.Getenv("DATABASE_URL")
        if dbURL == "" {
            dbURL = "postgres://user:password@localhost/lokstra_db?sslmode=disable"
        }
        
        db, err := sql.Open("postgres", dbURL)
        if err != nil {
            log.Fatal("Failed to connect to database:", err)
        }
        
        // Auto-migrate tables
        if err := migrateDB(db); err != nil {
            log.Fatal("Failed to migrate database:", err)
        }
        
        return db
    })
    
    // Repository registration
    lokstra_registry.RegisterServiceFactory("user-repository", func() repository.UserRepository {
        db := lokstra_registry.GetService[*sql.DB]("database")
        return &repository.UserRepositoryPostgres{DB: db}
    })
    
    // Service registration with auto-router
    lokstra_registry.RegisterServiceType("user-service-factory",
        service.UserServiceFactory,
        service.UserServiceRemoteFactory, // Auto HTTP proxy
        deploy.WithResource("user", "users"),
        deploy.WithConvention("rest"))
    
    // Load config and run
    lokstra_registry.LoadAndBuild([]string{"config.yaml"})
    lokstra_registry.RunServer(*server, 30*time.Second)
}

func migrateDB(db *sql.DB) error {
    query := `
    CREATE TABLE IF NOT EXISTS users (
        id SERIAL PRIMARY KEY,
        name VARCHAR(255) NOT NULL,
        email VARCHAR(255) UNIQUE NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );
    
    CREATE TABLE IF NOT EXISTS orders (
        id SERIAL PRIMARY KEY,
        user_id INTEGER REFERENCES users(id),
        total DECIMAL(10,2) NOT NULL,
        status VARCHAR(50) NOT NULL,
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );`
    
    _, err := db.Exec(query)
    return err
}

// Auto-generates: GET /users, GET /users/{id}, POST /users, etc.

NestJS - Decorator Heavy

User Service:

// libs/shared/src/user/user.entity.ts
export class User {
  id: number;
  name: string;
  email: string;
}

// libs/shared/src/user/dto/get-user.dto.ts
export class GetUserParams {
  @IsNumber()
  id: number;
}

// libs/shared/src/user/user.service.ts
@Injectable()
export class UserService {
  constructor(private userRepository: UserRepository) {}
  
  async getById(params: GetUserParams): Promise<User> {
    return this.userRepository.findById(params.id);
  }
  
  async list(): Promise<User[]> {
    return this.userRepository.findAll();
  }
}

// libs/shared/src/user/user.controller.ts
@Controller('users')
export class UserController {
  constructor(private userService: UserService) {}
  
  @Get()
  async list(): Promise<User[]> {
    return this.userService.list();
  }
  
  @Get(':id')
  async getById(@Param('id', ParseIntPipe) id: number): Promise<User> {
    return this.userService.getById({ id });
  }
}

Order Service with HTTP Client:

// libs/shared/src/order/order.service.ts
@Injectable()
export class OrderService {
  constructor(
    private orderRepository: OrderRepository,
    private httpService: HttpService,
    private configService: ConfigService,
  ) {}
  
  async getById(params: GetOrderParams): Promise<OrderWithUser> {
    const order = await this.orderRepository.findById(params.id);
    
    // Cross-service HTTP call - manual URL construction
    const userServiceUrl = this.configService.get('USER_SERVICE_URL');
    const userResponse = await firstValueFrom(
      this.httpService.get(`${userServiceUrl}/users/${order.userId}`)
    );
    
    return {
      order,
      user: userResponse.data,
    };
  }
}

Module Configuration:

// apps/monolith/src/app.module.ts
@Module({
  imports: [
    UserModule,
    OrderModule,
    HttpModule,
  ],
})
export class MonolithAppModule {}

// apps/user-service/src/app.module.ts  
@Module({
  imports: [UserModule],
})
export class UserServiceModule {}

// apps/order-service/src/app.module.ts
@Module({
  imports: [
    OrderModule,
    HttpModule.register({
      timeout: 5000,
      maxRedirects: 5,
    }),
  ],
})
export class OrderServiceModule {}

Spring Boot - Annotation Based

User Service:

// shared/src/main/java/com/example/shared/entity/User.java
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String name;
    
    @Column(nullable = false)
    private String email;
    
    // constructors, getters, setters
}

// shared/src/main/java/com/example/shared/service/UserService.java
@Service
@Transactional
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Transactional(readOnly = true)
    public User getById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException(id));
    }
    
    @Transactional(readOnly = true)
    public List<User> list() {
        return userRepository.findAll();
    }
}

// user-service/src/main/java/com/example/user/UserController.java
@RestController
@RequestMapping("/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping
    public List<User> list() {
        return userService.list();
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getById(@PathVariable Long id) {
        User user = userService.getById(id);
        return ResponseEntity.ok(user);
    }
}

Order Service with RestTemplate:

// order-service/src/main/java/com/example/order/OrderService.java
@Service
@Transactional
public class OrderService {
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private RestTemplate restTemplate;
    
    @Value("${user-service.url}")
    private String userServiceUrl;
    
    @Transactional(readOnly = true)
    public OrderWithUser getById(Long id) {
        Order order = orderRepository.findById(id)
            .orElseThrow(() -> new OrderNotFoundException(id));
            
        // Cross-service HTTP call - manual URL construction
        String url = userServiceUrl + "/users/" + order.getUserId();
        User user = restTemplate.getForObject(url, User.class);
        
        return new OrderWithUser(order, user);
    }
}

// Configuration for different deployments
@Configuration
public class RestTemplateConfig {
    
    @Bean
    @ConditionalOnProperty(name = "deployment.type", havingValue = "microservice")
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    
    @Bean  
    @ConditionalOnProperty(name = "deployment.type", havingValue = "monolith")
    public RestTemplate noopRestTemplate() {
        // Return no-op for monolith - use direct service calls
        return new RestTemplate();
    }
}

🚀 Deployment Configuration Comparison

Lokstra - Single Binary, YAML Config

config.yaml:

service-definitions:
  # Database connection (shared by all services)
  database:
    type: database-factory
    
  # Repositories (data access layer)
  user-repository:
    type: user-repository-factory
    depends-on: [database]
    
  order-repository:
    type: order-repository-factory
    depends-on: [database]
  
  # Services (business logic layer)
  user-service:
    type: user-service-factory
    depends-on: [user-repository]
  
  order-service:
    type: order-service-factory
    depends-on: [order-repository, user-service]

# Environment configuration
environment:
  DATABASE_URL: ${DATABASE_URL:postgres://user:password@localhost/lokstra_db?sslmode=disable}
  JWT_SECRET: ${JWT_SECRET:your-secret-key}
  EMAIL_PROVIDER: ${EMAIL_PROVIDER:smtp}

deployments:
  development:
    servers:
      dev-server:
        addr: ":3000"
        published-services: [user-service, order-service]
        
  production-monolith:
    servers:
      api-server:
        addr: ":8080"
        published-services: [user-service, order-service]
  
  production-microservices:
    servers:
      user-server:
        addr: ":8001" 
        published-services: [user-service]
      order-server:
        addr: ":8002"
        published-services: [order-service]

Deployment Commands:

# Set database URL (same for all deployments)
export DATABASE_URL="postgres://user:password@localhost/lokstra_db?sslmode=disable"

# Same binary, different configs!
./app -server=development.dev-server                    # Development
./app -server=production-monolith.api-server           # Production monolith
./app -server=production-microservices.user-server     # User microservice
./app -server=production-microservices.order-server    # Order microservice

# Or with Docker
docker run -e DATABASE_URL=postgres://... myapp -server=production-monolith.api-server

NestJS - Different Apps + Environment Config

package.json:

{
  "scripts": {
    "start:monolith": "nest start monolith",
    "start:user-service": "nest start user-service", 
    "start:order-service": "nest start order-service"
  }
}

Environment Files:

# .env.monolith
NODE_ENV=monolith
PORT=3000

# .env.user-service
NODE_ENV=microservice
PORT=3001
SERVICE_NAME=user-service

# .env.order-service  
NODE_ENV=microservice
PORT=3002
SERVICE_NAME=order-service
USER_SERVICE_URL=http://localhost:3001

Deployment Commands:

# Different builds for different deployments
npm run start:monolith
npm run start:user-service
npm run start:order-service

Spring Boot - Different JARs + Profiles

application.yml:

spring:
  profiles:
    active: monolith

---
spring:
  config:
    activate:
      on-profile: monolith
server:
  port: 3000

---  
spring:
  config:
    activate:
      on-profile: user-service
server:
  port: 3001
  
---
spring:
  config:
    activate:
      on-profile: order-service
server:
  port: 3002
user-service:
  url: http://localhost:3001

Deployment Commands:

# Different profiles or JARs
java -jar monolith.jar --spring.profiles.active=monolith
java -jar user-service.jar --spring.profiles.active=user-service  
java -jar order-service.jar --spring.profiles.active=order-service

📊 Detailed Code Metrics

Lines of Code Comparison

Code Reduction: Lokstra is 40-50% less code even with database integration!

File Structure Comparison

⚡ Performance & Resource Usage

Startup Time

Lokstra:     ~50ms  (compiled binary)
NestJS:      ~2-3s  (Node.js + module loading)  
Spring Boot: ~5-8s  (JVM + Spring container)

Memory Usage (Base)

Lokstra:     ~15MB  (efficient Go runtime)
NestJS:      ~80MB  (Node.js V8 engine)
Spring Boot: ~200MB (JVM heap + Spring)

Request Throughput (Simple REST)

Lokstra:     ~20,000 req/s
NestJS:      ~8,000 req/s  
Spring Boot: ~12,000 req/s (after warmup)

🔍 Data Access Comparison

Lokstra: Repository Pattern with SQL

// Repository interface (clean architecture)
type UserRepository interface {
    GetByID(id int) (*model.User, error)
    List() ([]*model.User, error)
    Create(user *model.User) (*model.User, error)
    Update(user *model.User) (*model.User, error)
    Delete(id int) error
}

// PostgreSQL implementation
type UserRepositoryPostgres struct {
    db *sql.DB
}

func (r *UserRepositoryPostgres) GetByID(id int) (*model.User, error) {
    query := `
        SELECT id, name, email, created_at 
        FROM users 
        WHERE id = $1`
    
    var user model.User
    err := r.db.QueryRow(query, id).Scan(
        &user.ID, &user.Name, &user.Email, &user.CreatedAt)
    
    if err == sql.ErrNoRows {
        return nil, fmt.Errorf("user not found: %d", id)
    }
    return &user, err
}

func (r *UserRepositoryPostgres) Create(user *model.User) (*model.User, error) {
    query := `
        INSERT INTO users (name, email) 
        VALUES ($1, $2) 
        RETURNING id, created_at`
    
    err := r.db.QueryRow(query, user.Name, user.Email).Scan(
        &user.ID, &user.CreatedAt)
    return user, err
}

// Factory registration with dependency injection
lokstra_registry.RegisterServiceFactory("user-repository", func() repository.UserRepository {
    db := lokstra_registry.GetService[*sql.DB]("database")
    return &repository.UserRepositoryPostgres{DB: db}
})

// Database connection factory with auto-migration
lokstra_registry.RegisterServiceFactory("database", func() *sql.DB {
    dbURL := os.Getenv("DATABASE_URL")
    if dbURL == "" {
        dbURL = "postgres://user:password@localhost/lokstra_db?sslmode=disable"
    }
    
    db, err := sql.Open("postgres", dbURL)
    if err != nil {
        log.Fatal("Database connection failed:", err)
    }
    
    // Auto-migrate on startup
    if err := migrateDB(db); err != nil {
        log.Fatal("Database migration failed:", err)
    }
    
    return db
})

Lokstra Data Access Features:

• ✅ Interface-based: Easy to mock and test
• ✅ Type-safe: Compile-time guarantees
• ✅ Auto-migration: Database schema managed in code
• ✅ Connection pooling: Built-in PostgreSQL driver features
• ✅ Clean architecture: Repository pattern separation

NestJS: TypeORM Integration

// User entity with decorators
@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column({ unique: true })
  email: string;

  @CreateDateColumn()
  createdAt: Date;

  @OneToMany(() => Order, order => order.user)
  orders: Order[];
}

// Repository with TypeORM
@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
  ) {}

  async findById(id: number): Promise<User> {
    const user = await this.userRepository.findOne({ 
      where: { id },
      relations: ['orders']
    });
    
    if (!user) {
      throw new NotFoundException(`User ${id} not found`);
    }
    return user;
  }

  async create(createUserDto: CreateUserDto): Promise<User> {
    const user = this.userRepository.create(createUserDto);
    return this.userRepository.save(user);
  }

  async findAll(): Promise<User[]> {
    return this.userRepository.find({
      order: { createdAt: 'DESC' }
    });
  }
}

// Module configuration
@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: process.env.DB_HOST || 'localhost',
      port: parseInt(process.env.DB_PORT) || 5432,
      username: process.env.DB_USER || 'user',
      password: process.env.DB_PASS || 'password',
      database: process.env.DB_NAME || 'nestjs_db',
      entities: [User, Order],
      synchronize: process.env.NODE_ENV !== 'production', // Auto-migrate
    }),
    TypeOrmModule.forFeature([User]),
  ],
  providers: [UserService],
})
export class UserModule {}

NestJS Data Access Features:

• ✅ Rich ORM: TypeORM with decorators and relations
• ✅ Auto-migrations: Schema sync in development
• ✅ Query Builder: Complex queries with type safety
• ✅ Transactions: Built-in transaction support
• ✅ Multiple databases: Support for various databases

Spring Boot: JPA + Hibernate

// User entity with JPA annotations
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String name;
    
    @Column(nullable = false, unique = true)
    private String email;
    
    @CreationTimestamp
    @Column(name = "created_at")
    private LocalDateTime createdAt;
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Order> orders;
    
    // constructors, getters, setters
}

// Repository interface with Spring Data JPA
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
    List<User> findByNameContaining(String name);
    
    @Query("SELECT u FROM User u WHERE u.createdAt >= :date")
    List<User> findUsersCreatedAfter(@Param("date") LocalDateTime date);
    
    @Modifying
    @Query("UPDATE User u SET u.name = :name WHERE u.id = :id")
    int updateUserName(@Param("id") Long id, @Param("name") String name);
}

// Service layer with transaction management
@Service
@Transactional
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Transactional(readOnly = true)
    public User findById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new UserNotFoundException("User not found: " + id));
    }
    
    public User create(CreateUserRequest request) {
        User user = new User(request.getName(), request.getEmail());
        return userRepository.save(user);
    }
    
    @Transactional(readOnly = true)
    public List<User> findAll() {
        return userRepository.findAll();
    }
}

// Configuration
spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/springboot_db
    username: ${DB_USER:user}
    password: ${DB_PASS:password}
    driver-class-name: org.postgresql.Driver
    
  jpa:
    hibernate:
      ddl-auto: ${JPA_DDL_AUTO:update}  # Auto-migrate
    show-sql: ${JPA_SHOW_SQL:false}
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
        format_sql: true

Spring Boot Data Access Features:

• ✅ Mature ORM: Hibernate with extensive features
• ✅ Repository abstraction: Spring Data JPA magic methods
• ✅ Transaction management: Declarative transactions
• ✅ Query methods: Method name to SQL conversion
• ✅ Caching: Built-in second-level cache support

Data Access Trade-offs

Choose Lokstra when:

• You prefer simple, direct SQL
• Performance is critical
• Team comfortable with SQL
• Want lightweight data access

Choose NestJS when:

• Need rich ORM features
• TypeScript ecosystem preferred
• Rapid development important
• Complex entity relations

Choose Spring Boot when:

• Maximum ORM features needed
• Enterprise-grade data access
• Team experienced with JPA
• Complex database operations

🎯 Architecture Trade-offs

Lokstra Advantages

• ✅ Minimal boilerplate - Auto-generated REST APIs
• ✅ Deployment flexibility - Zero code changes for topology
• ✅ Type safety - Compile-time guarantees with generics
• ✅ Performance - Fast startup, low memory
• ✅ Simplicity - Fewer concepts to learn

NestJS Advantages

• ✅ Rich ecosystem - Extensive npm packages
• ✅ Familiar patterns - Angular-like decorators
• ✅ TypeScript integration - Full type system
• ✅ Rapid development - Rich CLI and scaffolding
• ✅ Mature tooling - Extensive debugging/testing tools

Spring Boot Advantages

• ✅ Enterprise ecosystem - Massive Java ecosystem
• ✅ Mature framework - Battle-tested in production
• ✅ Rich features - Security, data, cloud integration
• ✅ Team expertise - Large pool of Java developers
• ✅ Enterprise support - Commercial support available

🚀 Real-world Deployment Scenarios

Scenario 1: Startup MVP

Requirements: Fast development, low costs, simple deployment

Recommendation: Lokstra

• Single binary deployment
• Auto-generated APIs reduce development time
• Low resource usage = lower hosting costs
• Easy to start monolith, split to microservices later

Scenario 2: Enterprise Migration

Requirements: Large team, existing Java expertise, complex integrations

Recommendation: Spring Boot

• Team already knows Spring patterns
• Rich enterprise features (Security, Data, etc.)
• Extensive third-party integrations
• Mature tooling and support

Scenario 3: Full-stack TypeScript

Requirements: TypeScript everywhere, rapid prototyping, rich frontend

Recommendation: NestJS

• Shared TypeScript types between frontend/backend
• Angular-like patterns familiar to frontend team
• Rich decorator ecosystem
• Good for full-stack development

Scenario 4: High-performance Microservices

Requirements: Low latency, high throughput, cost efficiency

Recommendation: Lokstra

• Fast startup for auto-scaling
• Low memory usage for container density
• Easy topology changes for optimization
• Built-in service proxy patterns

📈 Migration Path Analysis

From Monolith to Microservices

Lokstra:

# Zero code changes!
./app -server=monolith.api-server           # Before
./app -server=microservices.user-server    # After

NestJS:

// Need to refactor modules, add HTTP clients
@Module({
  imports: [
    HttpModule.register({ /* config */ }), // Add HTTP client
  ],
})
export class OrderModule {}

Spring Boot:

// Need different builds, add RestTemplate config
@ConditionalOnProperty("deployment.type", "microservice")
@Configuration
public class MicroserviceConfig {
    @Bean RestTemplate restTemplate() { /* ... */ }
}

🎓 Learning Curve Analysis

Time to Productivity

Concepts to Learn

Lokstra:

• Go basics, lazy DI, service patterns, YAML config

NestJS:

• TypeScript, decorators, modules, DI container, guards, pipes, interceptors

Spring Boot:

• Java, annotations, IoC container, Spring ecosystem, profiles, auto-configuration

🔍 Code Maintainability

Adding a New Service

Lokstra (3 steps):

// 1. Implement service
type ProductService struct { /* ... */ }
func (s *ProductService) GetByID(p *GetProductParams) (*Product, error) { /* ... */ }

// 2. Register factory  
lokstra_registry.RegisterServiceType("product-service", NewProductService, nil,
    deploy.WithResource("product", "products"))

// 3. Add to config
published-services: [user-service, order-service, product-service]

NestJS (6+ steps):

// 1. Create entity, 2. Create DTOs, 3. Create service, 4. Create controller
// 5. Create module, 6. Add to app module, 7. Update environment config

Spring Boot (8+ steps):

// 1. Create entity, 2. Create repository, 3. Create service, 4. Create controller
// 5. Create config, 6. Update application.yml, 7. Update main class, 8. Build/deploy

Refactoring Impact

Method Rename:

• Lokstra: Auto-updates HTTP routes
• NestJS: Manual update of @Get() decorators
• Spring Boot: Manual update of @GetMapping paths

Adding Cross-service Call:

• Lokstra: Just call interface method (auto local/remote)
• NestJS: Add HTTP client injection and URL configuration
• Spring Boot: Add RestTemplate call and service discovery

🎯 Conclusion & Recommendations

Choose Lokstra When:

• ✅ Performance matters (latency, memory, startup time)
• ✅ Deployment flexibility needed (monolith ↔ microservices)
• ✅ Small to medium team (2-20 developers)
• ✅ Rapid development with minimal boilerplate
• ✅ Cloud-native/containerized deployments
• ✅ Cost optimization important (resource efficiency)

Choose NestJS When:

• ✅ Full-stack TypeScript development
• ✅ Frontend team familiar with Angular patterns
• ✅ Rapid prototyping and rich ecosystem needed
• ✅ Medium complexity applications with moderate scale
• ✅ Good TypeScript tooling important

Choose Spring Boot When:

• ✅ Large enterprise with complex requirements
• ✅ Existing Java expertise and infrastructure
• ✅ Complex integrations with enterprise systems
• ✅ Maximum ecosystem and third-party support needed
• ✅ Long-term maintenance by large teams

📚 Further Reading

• Full Lokstra Example - Complete working code
• Lokstra vs NestJS - Detailed framework comparison
• Lokstra vs Spring Boot - Java framework comparison
• Architecture Patterns - Framework design principles

The same application, three different approaches. Choose based on your team, requirements, and constraints! 🚀