Forem: CodeFalconX

Comparison: Freight Management System vs Fleet Management System vs Transportation Management System

CodeFalconX — Thu, 12 Mar 2026 16:19:25 +0000

Logistics and transportation operations use different types of systems
depending on the business model. Three commonly used systems are:

Freight Management System (FMS)
Fleet Management System
Transportation Management System (TMS)

Although these systems are related, they serve different operational
purposes.

1. Freight Management System (FMS)

Definition

A Freight Management System is designed to manage the commercial and
operational processes of freight movement, including shipper orders,
pricing, vendor selection, shipment execution, and billing.

It is commonly used by:

Freight forwarders
Logistics companies
Third‑party logistics providers (3PL)
Freight brokers

Core Focus

The system focuses on freight transactions and logistics operations
rather than vehicles.

Typical Modules

Customer order management
Freight pricing / tariff management
Vendor management
Shipment planning
Dispatch management
Freight cost calculation
Billing and invoicing
Shipment tracking

Example Workflow

Shipper → Create shipment order →\
System calculates freight price →\
Vendor / transporter assigned →\
Shipment executed →\
Billing generated

Key Users

Freight forwarders
Logistics companies
3PL providers
Cargo owners (BCO)

2. Fleet Management System

Definition

A Fleet Management System manages vehicles and drivers used in
transportation operations.

The primary goal is to monitor and optimize vehicle usage.

Core Focus

The system focuses on vehicle operations and maintenance, not freight
transactions.

Typical Modules

Vehicle registration
Driver management
GPS tracking
Fuel monitoring
Vehicle maintenance
Insurance tracking
Driver behavior monitoring
Route history

Example Workflow

Vehicle assigned →\
Driver assigned →\
GPS tracking monitors vehicle →\
Fuel and maintenance recorded

Key Users

Trucking companies
Delivery companies
Logistics transporters
Corporate vehicle fleets

3. Transportation Management System (TMS)

Definition

A Transportation Management System is a strategic system used to plan,
optimize, and manage transportation networks.

It focuses on logistics optimization and planning, often for large
enterprises.

Core Focus

The system focuses on:

Route optimization
Carrier selection
Freight planning
Cost optimization

Typical Modules

Transportation planning
Route optimization
Carrier management
Load consolidation
Shipment tracking
Freight cost optimization
Analytics and reporting

Example Workflow

Order received →\
System optimizes route →\
Select carrier →\
Create shipment plan →\
Track delivery

Key Users

Manufacturers
Retail companies
Large supply chain organizations
Global logistics companies

Key Differences

Aspect	Freight Management System	Fleet Management System	Transportation Management System
Primary Focus	Freight transactions	Vehicles and drivers	Transportation optimization
Main Users	Freight forwarders, 3PL	Trucking companies	Enterprises, large logistics
Vehicle Tracking	Limited	Core feature	Optional
Pricing Management	Core feature	Not available	Sometimes
Route Optimization	Basic	Limited	Advanced
Shipment Management	Yes	Limited	Yes
Billing & Invoicing	Yes	No	Sometimes
Fleet Maintenance	No	Core feature	No

Real‑World Example

A logistics ecosystem might use all three systems together.

Example:

Freight Management System
- Receives shipment order from shipper\
- Calculates freight price\
- Assigns transporter
Transportation Management System
- Optimizes routes\
- Consolidates shipments
Fleet Management System
- Tracks trucks\
- Monitors fuel and driver behavior

Simple Analogy

System	Analogy
Fleet Management	Managing airplanes and pilots
Freight Management	Managing cargo shipments
Transportation Management	Planning flight routes and schedules

Summary

Freight Management System → manages shipments and logistics business processes\
Fleet Management System → manages vehicles and drivers\
Transportation Management System → manages transportation planning and optimization

Reference:

https://www.sap.com/sea/products/scm/transportation-logistics/what-is-a-tms.html

Gin vs Spring Boot: A Detailed Comparison

CodeFalconX — Fri, 16 Jan 2026 00:01:19 +0000

When choosing a backend framework, Gin (Go) and Spring Boot (Java) are often compared for their performance, scalability, and ecosystem.

But beyond REST APIs and microservices, event sourcing and CQRS (Command Query Responsibility Segregation) are increasingly relevant for systems requiring auditability, state reconstruction, and distributed consistency.

Let’s see how both frameworks perform across key dimensions — including event sourcing support.

1. Overview

Aspect	Gin	Spring Boot
Language	Go (Golang)	Java
Type	Lightweight HTTP web framework	Full-stack application framework
Primary Use	High-performance APIs and microservices	Enterprise-grade applications and microservices
Philosophy	Minimal, fast, and simple	Convention-over-configuration with rich tooling

2. Performance

Gin: Ultra-fast due to Go’s compiled nature and minimal abstractions. Ideal for low-latency services.
Spring Boot: JVM adds overhead but offers steady and reliable performance for large systems.

Winner: Gin (for raw throughput)

3. Ease of Development

Gin: Simpler syntax but requires manual setup for complex features.
Spring Boot: Rich tooling, auto-configuration, and ecosystem support speed up development.

Winner: Spring Boot (developer experience)

4. Architecture and Ecosystem

Gin: Lightweight; developers combine independent Go libraries for logging, config, and ORM.
Spring Boot: Fully integrated ecosystem (Spring Data, Spring Security, Spring Cloud) — ideal for cohesive enterprise apps.

Winner: Spring Boot

5. Concurrency and Scalability

Gin: Uses goroutines for lightweight concurrency — highly efficient and straightforward.
Spring Boot: Java threads are heavier, though newer JVM improvements (like Project Loom) are helping close the gap.

Winner: Gin (native concurrency)

6. Learning Curve

Gin: Quick to learn for Go developers.
Spring Boot: Requires understanding of Java and the Spring ecosystem.

Winner: Gin (simplicity)

7. Deployment

Gin: Builds to a single binary — perfect for Docker and cloud-native environments.
Spring Boot: Runs as a fat JAR/WAR; more resources needed but excellent support for CI/CD and Kubernetes.

Winner: Gin (lightweight deployments)

8. Event Sourcing Support

Aspect	Gin (Go)	Spring Boot (Java)
Native Support	None; needs custom implementation	Strong ecosystem with dedicated frameworks
Community Libraries	Libraries like `EventStore`, `go-eventful`, or Kafka integrations can be used manually	Mature tools like Axon Framework, Eventuate, and Spring Cloud Stream provide built-in support
Complexity	Requires manual modeling of aggregates, event stores, and replay logic	Frameworks handle aggregates, event publishing, projection updates, and snapshots
Best For	Lightweight, custom event-driven microservices	Full-fledged event-sourced systems in enterprises

Explanation:

Gin gives developers full control but little built-in support — you’ll often need to define your own event store, message broker integration, and state replay logic.
Spring Boot, through integrations like Axon Framework, provides first-class support for event sourcing and CQRS, including aggregate management, command buses, and event handlers — ideal for systems that need consistency guarantees and historical traceability.

Winner: Spring Boot (robust event sourcing support)

9. Ideal Use Cases

Use Case	Best Framework
High-performance microservices	Gin
RESTful APIs	Both
Enterprise event-driven apps	Spring Boot
Lightweight event-driven systems	Gin (with custom setup)
Complex business domains (DDD + CQRS)	Spring Boot

10. Community and Support

Gin: Active, but smaller.
Spring Boot: Massive enterprise community with commercial and open-source backing.

Winner: Spring Boot

Summary Table

Category	Winner
Performance	Gin
Developer Experience	Spring Boot
Ecosystem	Spring Boot
Concurrency	Gin
Learning Curve	Gin
Deployment	Gin
Event Sourcing	Spring Boot
Community Support	Spring Boot

Final Thoughts

Gin is best for lightweight, fast microservices or custom event-driven architectures where developers prefer control and performance.
Spring Boot shines when building enterprise-grade applications that need event sourcing, CQRS, and domain-driven design support out of the box.

In short:

Gin = Simplicity + Performance + Flexibility
Spring Boot = Robustness + Ecosystem + Event Sourcing Readiness

Reference:

Gin https://gin-gonic.com/
Spring Boot https://spring.io/projects/spring-boot
Axon Framework https://www.axoniq.io/framework

Model Context Protocol (MCP) — Integrating AI LLMs with Modern DevOps Systems

CodeFalconX — Fri, 09 Jan 2026 18:09:51 +0000

What is MCP?

The Model Context Protocol (MCP) is a standardized framework that enables Large Language Models (LLMs) to interact directly with live systems in software engineering environments. By connecting AI with continuous integration (CI/CD), static analysis, ticket management, and databases, MCP transforms traditional development workflows into intelligent, automated ecosystems.

Why MCP Matters

AI models like LLMs are powerful, but they often work in isolation without awareness of your actual development environment, pipelines, or data. MCP solves this by creating a secure bridge between AI and your tools, enabling:

Real-time context — AI understands your current project state
Automated actions — AI can trigger builds, create tickets, query databases
Better decisions — AI recommendations based on live system data
Full traceability — Every AI action is logged and auditable

How MCP Works

MCP acts as a middleware layer with four key components:

MCP Client — The AI model making requests
MCP Server — Adapters that connect to your tools (Jenkins, Jira, etc.)
Context Manager — Controls what data AI can access
Audit Layer — Tracks all interactions for compliance

When you ask an AI to "trigger the build," MCP validates the request, executes it through the appropriate system, and returns the results — all securely and with full logging.

What You Can Do with MCP

1. Smarter Coding

Connect MCP to your IDE for AI that truly understands your codebase:

Generate code that matches your project structure
Automate refactoring across multiple files
Handle Git operations with CI/CD awareness

2. Automated CI/CD (Jenkins Integration)

Let AI manage your build pipelines:

Trigger and monitor builds on demand
Diagnose failed builds and suggest fixes
Access logs and artifacts directly through conversation
Automate deployment sequences

Example: AI detects a flaky test, restarts the Jenkins job with adjusted parameters, and logs the decision in Jira.

3. Intelligent Code Quality (SonarQube Integration)

Get AI-powered code analysis:

Retrieve quality metrics and vulnerability reports
Correlate issues with specific code changes
Generate fix recommendations aligned with your standards

Example: "Show me all critical security issues and how to fix them" — AI pulls from SonarQube and provides targeted solutions.

4. Streamlined Project Management (Jira Integration)

Automate ticket workflows:

Create tickets automatically when builds fail
Generate sprint summaries and release notes
Link tickets to code changes and test results

Example: Pipeline fails → AI creates a Jira ticket, assigns it to the right team, attaches logs, and suggests the likely cause.

5. Data-Driven Insights (PostgreSQL Integration)

Query your databases conversationally:

Run secure, permission-controlled queries
Analyze trends and generate reports
Automate data validation scripts

Example: "Show me our top 10 customers by revenue this quarter" — AI queries PostgreSQL and returns formatted results.

Security Built-In

MCP takes security seriously:

Role-based access — AI only accesses what it's allowed to
Encrypted connections — TLS 1.3+ for all communications
Session isolation — Each AI interaction is isolated
Complete audit logs — Track every action for compliance

This ensures MCP meets enterprise standards like ISO 27001 and SOC 2.

Key Benefits

Less manual work — Automate repetitive DevOps tasks
Better code quality — AI-guided reviews and analysis
Faster problem solving — AI diagnoses issues using live data
Improved visibility — Connected systems provide unified insights
Enterprise-ready — Secure, scalable, and compliant

The Future of AI-Powered Development

MCP represents a shift toward AI-native software engineering where development, testing, and operations work together intelligently. As it evolves, expect:

Unified dashboards connecting all your DevOps tools
Self-optimizing pipelines that learn from feedback
Collaborative AI agents across teams while maintaining security

MCP makes AI a true collaborator in your development workflow — aware, capable, and ready to help.

References

Jenkins — https://plugins.jenkins.io/mcp-server/
SonarQube — https://www.sonarsource.com/products/sonarqube/mcp-server/
Jira — https://www.atlassian.com/platform/remote-mcp-server
PostgreSQL — https://googleapis.github.io/genai-toolbox/how-to/connect-ide/postgres_mcp/

NGINX --- High Performance Web Server for High Traffic

CodeFalconX — Thu, 08 Jan 2026 07:46:34 +0000

NGINX is a high‑performance web server and reverse proxy originally
created by Igor Sysoev.\
It was designed to solve the C10K problem (handling 10,000+ concurrent
connections efficiently) and was first released in 2004.

Today, NGINX is one of the most widely used web servers in the world,
powering high‑traffic websites and modern cloud‑native architectures.

High Performance & High Traffic

NGINX was built from the ground up to handle high traffic loads with
minimal resource consumption.\
Unlike traditional web servers that rely on thread‑per‑connection or
process‑per‑connection models, NGINX uses a more efficient approach that
scales extremely well.

Key benefits: - Low memory footprint - Excellent CPU utilization -
Stable performance under heavy load

Event‑Driven & Asynchronous Architecture

NGINX uses an event‑driven, asynchronous architecture.

A master process manages configuration and worker processes
Worker processes handle all client connections
Each worker uses an event loop to process multiple requests concurrently

This design allows NGINX to manage thousands of connections without
creating a new thread or process for each request.

One Worker Can Handle Thousands of Connections

Thanks to its event‑driven model: - One worker process can handle
thousands of concurrent connections - Uses OS‑level mechanisms such as
epoll (Linux) and kqueue (BSD/macOS) - Very efficient for
high‑concurrency environments

This makes NGINX ideal for large‑scale systems, APIs, and microservices.

Non‑Blocking I/O & High Throughput

NGINX relies on non‑blocking I/O, meaning: - It never waits (blocks)
for slow network or disk operations - While waiting for one request, it
continues processing others

Advantages: - High throughput - Low latency - Excellent performance
during traffic spikes

Super Fast Static Content Delivery

NGINX is extremely fast at serving static content, such as: -
Images - CSS files - JavaScript files

It uses optimized system calls like sendfile, allowing files to be
sent directly from disk to the network without unnecessary memory
copying.

This results in: - Faster response times - Lower CPU usage - Better user
experience

Summary

NGINX is a powerful and reliable web server because it:

Was created by Igor Sysoev for high‑traffic use cases
Uses event‑driven and asynchronous architecture
Allows one worker to handle thousands of connections
Implements non‑blocking I/O for high throughput
Delivers static content extremely fast

These features make NGINX a perfect choice for modern, scalable, and high‑performance web infrastructures.

Reference: https://nginx.org/

Create MinIO Bucket using Express.js

CodeFalconX — Wed, 31 Dec 2025 18:32:32 +0000

1️⃣ Install Dependencies

npm init -y
npm install express minio dotenv

2️⃣ Project Structure (Recommended)

minio-service/
├── src/
│   ├── app.js
│   ├── minio/
│   │   └── minioClient.js
│   ├── routes/
│   │   └── bucket.routes.js
│   └── services/
│       └── bucket.service.js
├── .env
└── package.json

3️⃣ `.env` Configuration

PORT=3000

MINIO_ENDPOINT=localhost
MINIO_PORT=9000
MINIO_USE_SSL=false
MINIO_ACCESS_KEY=minioadmin
MINIO_SECRET_KEY=minioadmin

4️⃣ MinIO Client (`src/minio/minioClient.js`)

import { Client } from 'minio';
import dotenv from 'dotenv';

dotenv.config();

const minioClient = new Client({
  endPoint: process.env.MINIO_ENDPOINT,
  port: parseInt(process.env.MINIO_PORT),
  useSSL: process.env.MINIO_USE_SSL === 'true',
  accessKey: process.env.MINIO_ACCESS_KEY,
  secretKey: process.env.MINIO_SECRET_KEY,
});

export default minioClient;

5️⃣ Bucket Service (`src/services/bucket.service.js`)

import minioClient from '../minio/minioClient.js';

export async function createBucket(bucketName) {
  const exists = await minioClient.bucketExists(bucketName);

  if (exists) {
    return { created: false, message: 'Bucket already exists' };
  }

  await minioClient.makeBucket(bucketName);
  return { created: true, message: 'Bucket created successfully' };
}

6️⃣ Bucket API Route (`src/routes/bucket.routes.js`)

import express from 'express';
import { createBucket } from '../services/bucket.service.js';

const router = express.Router();

/**
 * POST /api/buckets
 * Body: { "bucketName": "my-new-bucket" }
 */
router.post('/', async (req, res) => {
  try {
    const { bucketName } = req.body;

    if (!bucketName) {
      return res.status(400).json({ message: 'bucketName is required' });
    }

    const result = await createBucket(bucketName);

    return res.status(200).json(result);
  } catch (err) {
    console.error(err);
    return res.status(500).json({
      message: 'Failed to create bucket',
      error: err.message,
    });
  }
});

export default router;

7️⃣ Express App (`src/app.js`)

import express from 'express';
import bucketRoutes from './routes/bucket.routes.js';

const app = express();

app.use(express.json());

app.use('/api/buckets', bucketRoutes);

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`MinIO service running on port ${PORT}`);
});

8️⃣ Run the Application

node src/app.js

9️⃣ Test with CURL or Insomnia

Request

curl -X POST http://localhost:3000/api/buckets \
  -H "Content-Type: application/json" \
  -d '{
    "bucketName": "test-bucket-001"
  }'

Success Response

{
  "created": true,
  "message": "Bucket created successfully"
}

Already Exists

{
  "created": false,
  "message": "Bucket already exists"
}

🔐 Permissions Reminder

The MinIO user must have:

"s3:CreateBucket",
"s3:ListAllMyBuckets"

Otherwise you'll get AccessDenied.

Github: https://github.com/codefalconx/minio-service

Reference: https://www.min.io/

Building a Microservices Order System with Gin, RabbitMQ, and PostgreSQL

CodeFalconX — Tue, 30 Dec 2025 05:17:11 +0000

Architecture Overview
Project Structure
Step 1: Docker Compose Setup
Step 2: Shared Code
Step 3: Order Service
Step 4: Inventory Service
Step 5: Billing Service
Step 6: Notification Service
Step 7: Setup Instructions
Testing the System

Architecture Overview

We'll build 4 independent services:

Order Service: Creates orders and publishes events
Inventory Service: Updates stock levels
Billing Service: Generates invoices and processes payments
Notification Service: Sends email/SMS alerts

Each service has its own PostgreSQL database and communicates via RabbitMQ using a fanout exchange pattern.

Project Structure

order-system/
├── order-service/
│   └── main.go
├── inventory-service/
│   └── main.go
├── billing-service/
│   └── main.go
├── notification-service/
│   └── main.go
├── shared/
│   ├── events/
│   │   └── events.go
│   └── rabbitmq/
│       └── rabbitmq.go
└── docker-compose.yml

Step 1: Docker Compose Setup

Create docker-compose.yml:

# version: '3.8'

services:
  # RabbitMQ
  rabbitmq:
    image: rabbitmq:3-management
    container_name: rabbitmq
    ports:
      - "5672:5672"
      - "15672:15672"
    environment:
      RABBITMQ_DEFAULT_USER: guest
      RABBITMQ_DEFAULT_PASS: guest
    healthcheck:
      test: rabbitmq-diagnostics -q ping
      interval: 30s
      timeout: 10s
      retries: 5

  # PostgreSQL for Order Service
  order-db:
    image: postgres:15
    container_name: order-db
    environment:
      POSTGRES_DB: order_db
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
      - "5436:5432"
    volumes:
      - order-data:/var/lib/postgresql/data

  # PostgreSQL for Inventory Service
  inventory-db:
    image: postgres:15
    container_name: inventory-db
    environment:
      POSTGRES_DB: inventory_db
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
      - "5437:5432"
    volumes:
      - inventory-data:/var/lib/postgresql/data

  # PostgreSQL for Billing Service
  billing-db:
    image: postgres:15
    container_name: billing-db
    environment:
      POSTGRES_DB: billing_db
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
      - "5438:5432"
    volumes:
      - billing-data:/var/lib/postgresql/data

  # PostgreSQL for Notification Service
  notification-db:
    image: postgres:15
    container_name: notification-db
    environment:
      POSTGRES_DB: notification_db
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
      - "5439:5432"
    volumes:
      - notification-data:/var/lib/postgresql/data

volumes:
  order-data:
  inventory-data:
  billing-data:
  notification-data:

Step 2: Shared Code

shared/events/events.go

package events

import "time"

// EventType represents the type of event
type EventType string

const (
    OrderCreated EventType = "order.created"
    OrderUpdated EventType = "order.updated"
    OrderCancelled EventType = "order.cancelled"
)

// OrderCreatedEvent represents an order creation event
type OrderCreatedEvent struct {
    EventID     string    `json:"event_id"`
    EventType   EventType `json:"event_type"`
    Timestamp   time.Time `json:"timestamp"`
    OrderID     string    `json:"order_id"`
    CustomerID  string    `json:"customer_id"`
    Email       string    `json:"email"`
    Phone       string    `json:"phone"`
    TotalAmount float64   `json:"total_amount"`
    Items       []OrderItem `json:"items"`
}

// OrderItem represents an item in the order
type OrderItem struct {
    ProductID string  `json:"product_id"`
    Name      string  `json:"name"`
    Quantity  int     `json:"quantity"`
    Price     float64 `json:"price"`
}

shared/rabbitmq/rabbitmq.go

package rabbitmq

import (
    "encoding/json"
    "fmt"
    "log"

    amqp "github.com/rabbitmq/amqp091-go"
)

type RabbitMQ struct {
    conn    *amqp.Connection
    channel *amqp.Channel
}

func NewRabbitMQ(url string) (*RabbitMQ, error) {
    conn, err := amqp.Dial(url)
    if err != nil {
        return nil, fmt.Errorf("failed to connect to RabbitMQ: %w", err)
    }

    ch, err := conn.Channel()
    if err != nil {
        conn.Close()
        return nil, fmt.Errorf("failed to open channel: %w", err)
    }

    return &RabbitMQ{
        conn:    conn,
        channel: ch,
    }, nil
}

func (r *RabbitMQ) DeclareExchange(name, kind string) error {
    return r.channel.ExchangeDeclare(
        name,
        kind,
        true,  // durable
        false, // auto-deleted
        false, // internal
        false, // no-wait
        nil,   // arguments
    )
}

func (r *RabbitMQ) DeclareQueue(name string) (amqp.Queue, error) {
    return r.channel.QueueDeclare(
        name,
        true,  // durable
        false, // delete when unused
        false, // exclusive
        false, // no-wait
        nil,   // arguments
    )
}

func (r *RabbitMQ) BindQueue(queueName, exchangeName, routingKey string) error {
    return r.channel.QueueBind(
        queueName,
        routingKey,
        exchangeName,
        false, // no-wait
        nil,   // arguments
    )
}

func (r *RabbitMQ) Publish(exchange, routingKey string, body interface{}) error {
    jsonBody, err := json.Marshal(body)
    if err != nil {
        return fmt.Errorf("failed to marshal message: %w", err)
    }

    err = r.channel.Publish(
        exchange,
        routingKey,
        false, // mandatory
        false, // immediate
        amqp.Publishing{
            ContentType: "application/json",
            Body:        jsonBody,
        },
    )
    if err != nil {
        return fmt.Errorf("failed to publish message: %w", err)
    }

    log.Printf("Published message to exchange: %s, routing key: %s", exchange, routingKey)
    return nil
}

func (r *RabbitMQ) Consume(queueName string) (<-chan amqp.Delivery, error) {
    msgs, err := r.channel.Consume(
        queueName,
        "",    // consumer
        false, // auto-ack (manual ack for reliability)
        false, // exclusive
        false, // no-local
        false, // no-wait
        nil,   // args
    )
    if err != nil {
        return nil, fmt.Errorf("failed to register consumer: %w", err)
    }

    return msgs, nil
}

func (r *RabbitMQ) Close() {
    if r.channel != nil {
        r.channel.Close()
    }
    if r.conn != nil {
        r.conn.Close()
    }
}

Step 3: Order Service

order-service/main.go

package main

import (
    "log"
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/google/uuid"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"

    "your-module/shared/events"
    "your-module/shared/rabbitmq"
)

type Order struct {
    ID          string    `gorm:"primaryKey" json:"id"`
    CustomerID  string    `json:"customer_id"`
    Email       string    `json:"email"`
    Phone       string    `json:"phone"`
    TotalAmount float64   `json:"total_amount"`
    Status      string    `json:"status"`
    CreatedAt   time.Time `json:"created_at"`
}

type OrderItem struct {
    ID        uint    `gorm:"primaryKey" json:"id"`
    OrderID   string  `json:"order_id"`
    ProductID string  `json:"product_id"`
    Name      string  `json:"name"`
    Quantity  int     `json:"quantity"`
    Price     float64 `json:"price"`
}

type CreateOrderRequest struct {
    CustomerID string                `json:"customer_id" binding:"required"`
    Email      string                `json:"email" binding:"required,email"`
    Phone      string                `json:"phone" binding:"required"`
    Items      []events.OrderItem    `json:"items" binding:"required,min=1"`
}

var (
    db  *gorm.DB
    mq  *rabbitmq.RabbitMQ
)

func main() {
    // Initialize database
    var err error
    dsn := "host=localhost user=postgres password=postgres dbname=order_db port=5432 sslmode=disable"
    db, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatal("Failed to connect to database:", err)
    }

    // Auto migrate
    db.AutoMigrate(&Order{}, &OrderItem{})

    // Initialize RabbitMQ
    mq, err = rabbitmq.NewRabbitMQ("amqp://guest:guest@localhost:5672/")
    if err != nil {
        log.Fatal("Failed to connect to RabbitMQ:", err)
    }
    defer mq.Close()

    // Declare exchange
    err = mq.DeclareExchange("order_events", "fanout")
    if err != nil {
        log.Fatal("Failed to declare exchange:", err)
    }

    // Initialize Gin
    r := gin.Default()

    // Routes
    r.POST("/orders", createOrder)
    r.GET("/orders/:id", getOrder)
    r.GET("/orders", listOrders)

    log.Println("Order Service running on :8080")
    r.Run(":8080")
}

func createOrder(c *gin.Context) {
    var req CreateOrderRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    // Calculate total amount
    var totalAmount float64
    for _, item := range req.Items {
        totalAmount += item.Price * float64(item.Quantity)
    }

    // Create order
    order := Order{
        ID:          uuid.New().String(),
        CustomerID:  req.CustomerID,
        Email:       req.Email,
        Phone:       req.Phone,
        TotalAmount: totalAmount,
        Status:      "pending",
        CreatedAt:   time.Now(),
    }

    if err := db.Create(&order).Error; err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create order"})
        return
    }

    // Create order items
    for _, item := range req.Items {
        orderItem := OrderItem{
            OrderID:   order.ID,
            ProductID: item.ProductID,
            Name:      item.Name,
            Quantity:  item.Quantity,
            Price:     item.Price,
        }
        db.Create(&orderItem)
    }

    // Publish event
    event := events.OrderCreatedEvent{
        EventID:     uuid.New().String(),
        EventType:   events.OrderCreated,
        Timestamp:   time.Now(),
        OrderID:     order.ID,
        CustomerID:  order.CustomerID,
        Email:       order.Email,
        Phone:       order.Phone,
        TotalAmount: order.TotalAmount,
        Items:       req.Items,
    }

    if err := mq.Publish("order_events", "", event); err != nil {
        log.Printf("Failed to publish event: %v", err)
    }

    c.JSON(http.StatusCreated, order)
}

func getOrder(c *gin.Context) {
    id := c.Param("id")
    var order Order
    if err := db.First(&order, "id = ?", id).Error; err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "Order not found"})
        return
    }

    var items []OrderItem
    db.Where("order_id = ?", id).Find(&items)

    c.JSON(http.StatusOK, gin.H{
        "order": order,
        "items": items,
    })
}

func listOrders(c *gin.Context) {
    var orders []Order
    db.Order("created_at desc").Find(&orders)
    c.JSON(http.StatusOK, orders)
}

Step 4: Inventory Service

inventory-service/main.go

package main

import (
    "encoding/json"
    "log"
    "net/http"

    "github.com/gin-gonic/gin"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"

    "your-module/shared/events"
    "your-module/shared/rabbitmq"
)

type Product struct {
    ID       string `gorm:"primaryKey" json:"id"`
    Name     string `json:"name"`
    Stock    int    `json:"stock"`
    Reserved int    `json:"reserved"`
}

type StockHistory struct {
    ID        uint   `gorm:"primaryKey" json:"id"`
    OrderID   string `json:"order_id"`
    ProductID string `json:"product_id"`
    Quantity  int    `json:"quantity"`
    Action    string `json:"action"`
}

var db *gorm.DB

func main() {
    // Initialize database
    var err error
    dsn := "host=localhost user=postgres password=postgres dbname=inventory_db port=5433 sslmode=disable"
    db, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatal("Failed to connect to database:", err)
    }

    // Auto migrate
    db.AutoMigrate(&Product{}, &StockHistory{})

    // Seed initial products
    seedProducts()

    // Initialize RabbitMQ
    mq, err := rabbitmq.NewRabbitMQ("amqp://guest:guest@localhost:5672/")
    if err != nil {
        log.Fatal("Failed to connect to RabbitMQ:", err)
    }
    defer mq.Close()

    // Declare and bind queue
    queue, err := mq.DeclareQueue("inventory_queue")
    if err != nil {
        log.Fatal("Failed to declare queue:", err)
    }

    err = mq.BindQueue(queue.Name, "order_events", "")
    if err != nil {
        log.Fatal("Failed to bind queue:", err)
    }

    // Start consuming messages
    go consumeOrderEvents(mq)

    // Initialize Gin
    r := gin.Default()

    // Routes
    r.GET("/products", listProducts)
    r.GET("/products/:id", getProduct)
    r.POST("/products", createProduct)
    r.PUT("/products/:id/stock", updateStock)

    log.Println("Inventory Service running on :8081")
    r.Run(":8081")
}

func seedProducts() {
    products := []Product{
        {ID: "prod-1", Name: "Laptop", Stock: 50, Reserved: 0},
        {ID: "prod-2", Name: "Mouse", Stock: 200, Reserved: 0},
        {ID: "prod-3", Name: "Keyboard", Stock: 150, Reserved: 0},
    }

    for _, p := range products {
        db.FirstOrCreate(&p, Product{ID: p.ID})
    }
}

func consumeOrderEvents(mq *rabbitmq.RabbitMQ) {
    msgs, err := mq.Consume("inventory_queue")
    if err != nil {
        log.Fatal("Failed to consume messages:", err)
    }

    log.Println("Waiting for order events...")

    for msg := range msgs {
        var event events.OrderCreatedEvent
        if err := json.Unmarshal(msg.Body, &event); err != nil {
            log.Printf("Error unmarshaling message: %v", err)
            msg.Nack(false, false)
            continue
        }

        log.Printf("Processing order event: %s", event.OrderID)

        // Reserve stock for each item
        tx := db.Begin()
        success := true

        for _, item := range event.Items {
            var product Product
            if err := tx.First(&product, "id = ?", item.ProductID).Error; err != nil {
                log.Printf("Product not found: %s", item.ProductID)
                success = false
                break
            }

            if product.Stock-product.Reserved < item.Quantity {
                log.Printf("Insufficient stock for product: %s", item.ProductID)
                success = false
                break
            }

            // Update reserved stock
            product.Reserved += item.Quantity
            tx.Save(&product)

            // Record history
            history := StockHistory{
                OrderID:   event.OrderID,
                ProductID: item.ProductID,
                Quantity:  item.Quantity,
                Action:    "reserved",
            }
            tx.Create(&history)
        }

        if success {
            tx.Commit()
            log.Printf("Successfully reserved stock for order: %s", event.OrderID)
            msg.Ack(false)
        } else {
            tx.Rollback()
            log.Printf("Failed to reserve stock for order: %s", event.OrderID)
            msg.Nack(false, true)
        }
    }
}

func listProducts(c *gin.Context) {
    var products []Product
    db.Find(&products)
    c.JSON(http.StatusOK, products)
}

func getProduct(c *gin.Context) {
    id := c.Param("id")
    var product Product
    if err := db.First(&product, "id = ?", id).Error; err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "Product not found"})
        return
    }
    c.JSON(http.StatusOK, product)
}

func createProduct(c *gin.Context) {
    var product Product
    if err := c.ShouldBindJSON(&product); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    if err := db.Create(&product).Error; err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create product"})
        return
    }

    c.JSON(http.StatusCreated, product)
}

func updateStock(c *gin.Context) {
    id := c.Param("id")
    var req struct {
        Stock int `json:"stock" binding:"required"`
    }

    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    var product Product
    if err := db.First(&product, "id = ?", id).Error; err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "Product not found"})
        return
    }

    product.Stock = req.Stock
    db.Save(&product)

    c.JSON(http.StatusOK, product)
}

Step 5: Billing Service

billing-service/main.go

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/google/uuid"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"

    "your-module/shared/events"
    "your-module/shared/rabbitmq"
)

type Invoice struct {
    ID          string    `gorm:"primaryKey" json:"id"`
    OrderID     string    `json:"order_id"`
    CustomerID  string    `json:"customer_id"`
    Amount      float64   `json:"amount"`
    Status      string    `json:"status"` // pending, paid, failed
    CreatedAt   time.Time `json:"created_at"`
    PaidAt      *time.Time `json:"paid_at,omitempty"`
}

type Payment struct {
    ID            string    `gorm:"primaryKey" json:"id"`
    InvoiceID     string    `json:"invoice_id"`
    Amount        float64   `json:"amount"`
    PaymentMethod string    `json:"payment_method"`
    Status        string    `json:"status"`
    CreatedAt     time.Time `json:"created_at"`
}

var db *gorm.DB

func main() {
    // Initialize database
    var err error
    dsn := "host=localhost user=postgres password=postgres dbname=billing_db port=5434 sslmode=disable"
    db, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatal("Failed to connect to database:", err)
    }

    // Auto migrate
    db.AutoMigrate(&Invoice{}, &Payment{})

    // Initialize RabbitMQ
    mq, err := rabbitmq.NewRabbitMQ("amqp://guest:guest@localhost:5672/")
    if err != nil {
        log.Fatal("Failed to connect to RabbitMQ:", err)
    }
    defer mq.Close()

    // Declare and bind queue
    queue, err := mq.DeclareQueue("billing_queue")
    if err != nil {
        log.Fatal("Failed to declare queue:", err)
    }

    err = mq.BindQueue(queue.Name, "order_events", "")
    if err != nil {
        log.Fatal("Failed to bind queue:", err)
    }

    // Start consuming messages
    go consumeOrderEvents(mq)

    // Initialize Gin
    r := gin.Default()

    // Routes
    r.GET("/invoices", listInvoices)
    r.GET("/invoices/:id", getInvoice)
    r.POST("/invoices/:id/pay", processPayment)

    log.Println("Billing Service running on :8082")
    r.Run(":8082")
}

func consumeOrderEvents(mq *rabbitmq.RabbitMQ) {
    msgs, err := mq.Consume("billing_queue")
    if err != nil {
        log.Fatal("Failed to consume messages:", err)
    }

    log.Println("Waiting for order events...")

    for msg := range msgs {
        var event events.OrderCreatedEvent
        if err := json.Unmarshal(msg.Body, &event); err != nil {
            log.Printf("Error unmarshaling message: %v", err)
            msg.Nack(false, false)
            continue
        }

        log.Printf("Processing order event: %s", event.OrderID)

        // Create invoice
        invoice := Invoice{
            ID:         uuid.New().String(),
            OrderID:    event.OrderID,
            CustomerID: event.CustomerID,
            Amount:     event.TotalAmount,
            Status:     "pending",
            CreatedAt:  time.Now(),
        }

        if err := db.Create(&invoice).Error; err != nil {
            log.Printf("Failed to create invoice: %v", err)
            msg.Nack(false, true)
            continue
        }

        log.Printf("Invoice created: %s for order: %s", invoice.ID, event.OrderID)
        msg.Ack(false)
    }
}

func listInvoices(c *gin.Context) {
    var invoices []Invoice
    db.Order("created_at desc").Find(&invoices)
    c.JSON(http.StatusOK, invoices)
}

func getInvoice(c *gin.Context) {
    id := c.Param("id")
    var invoice Invoice
    if err := db.First(&invoice, "id = ?", id).Error; err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "Invoice not found"})
        return
    }

    var payments []Payment
    db.Where("invoice_id = ?", id).Find(&payments)

    c.JSON(http.StatusOK, gin.H{
        "invoice":  invoice,
        "payments": payments,
    })
}

func processPayment(c *gin.Context) {
    id := c.Param("id")
    var req struct {
        PaymentMethod string `json:"payment_method" binding:"required"`
    }

    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    var invoice Invoice
    if err := db.First(&invoice, "id = ?", id).Error; err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "Invoice not found"})
        return
    }

    if invoice.Status == "paid" {
        c.JSON(http.StatusBadRequest, gin.H{"error": "Invoice already paid"})
        return
    }

    // Simulate payment processing
    payment := Payment{
        ID:            uuid.New().String(),
        InvoiceID:     invoice.ID,
        Amount:        invoice.Amount,
        PaymentMethod: req.PaymentMethod,
        Status:        "completed",
        CreatedAt:     time.Now(),
    }

    tx := db.Begin()
    if err := tx.Create(&payment).Error; err != nil {
        tx.Rollback()
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Payment processing failed"})
        return
    }

    now := time.Now()
    invoice.Status = "paid"
    invoice.PaidAt = &now
    if err := tx.Save(&invoice).Error; err != nil {
        tx.Rollback()
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update invoice"})
        return
    }

    tx.Commit()

    log.Printf("Payment processed for invoice: %s", invoice.ID)
    c.JSON(http.StatusOK, gin.H{
        "invoice": invoice,
        "payment": payment,
    })
}

Step 6: Notification Service

notification-service/main.go

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/google/uuid"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"

    "your-module/shared/events"
    "your-module/shared/rabbitmq"
)

type Notification struct {
    ID         string    `gorm:"primaryKey" json:"id"`
    OrderID    string    `json:"order_id"`
    CustomerID string    `json:"customer_id"`
    Type       string    `json:"type"` // email, sms
    Recipient  string    `json:"recipient"`
    Subject    string    `json:"subject"`
    Body       string    `json:"body"`
    Status     string    `json:"status"` // pending, sent, failed
    CreatedAt  time.Time `json:"created_at"`
    SentAt     *time.Time `json:"sent_at,omitempty"`
}

var db *gorm.DB

func main() {
    // Initialize database
    var err error
    dsn := "host=localhost user=postgres password=postgres dbname=notification_db port=5435 sslmode=disable"
    db, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatal("Failed to connect to database:", err)
    }

    // Auto migrate
    db.AutoMigrate(&Notification{})

    // Initialize RabbitMQ
    mq, err := rabbitmq.NewRabbitMQ("amqp://guest:guest@localhost:5672/")
    if err != nil {
        log.Fatal("Failed to connect to RabbitMQ:", err)
    }
    defer mq.Close()

    // Declare and bind queue
    queue, err := mq.DeclareQueue("notification_queue")
    if err != nil {
        log.Fatal("Failed to declare queue:", err)
    }

    err = mq.BindQueue(queue.Name, "order_events", "")
    if err != nil {
        log.Fatal("Failed to bind queue:", err)
    }

    // Start consuming messages
    go consumeOrderEvents(mq)

    // Initialize Gin
    r := gin.Default()

    // Routes
    r.GET("/notifications", listNotifications)
    r.GET("/notifications/:id", getNotification)

    log.Println("Notification Service running on :8083")
    r.Run(":8083")
}

func consumeOrderEvents(mq *rabbitmq.RabbitMQ) {
    msgs, err := mq.Consume("notification_queue")
    if err != nil {
        log.Fatal("Failed to consume messages:", err)
    }

    log.Println("Waiting for order events...")

    for msg := range msgs {
        var event events.OrderCreatedEvent
        if err := json.Unmarshal(msg.Body, &event); err != nil {
            log.Printf("Error unmarshaling message: %v", err)
            msg.Nack(false, false)
            continue
        }

        log.Printf("Processing order event: %s", event.OrderID)

        // Send email notification
        emailNotification := Notification{
            ID:         uuid.New().String(),
            OrderID:    event.OrderID,
            CustomerID: event.CustomerID,
            Type:       "email",
            Recipient:  event.Email,
            Subject:    "Order Confirmation",
            Body:       formatEmailBody(event),
            Status:     "pending",
            CreatedAt:  time.Now(),
        }

        if err := db.Create(&emailNotification).Error; err != nil {
            log.Printf("Failed to create email notification: %v", err)
        } else {
            sendEmail(emailNotification.ID)
        }

        // Send SMS notification
        smsNotification := Notification{
            ID:         uuid.New().String(),
            OrderID:    event.OrderID,
            CustomerID: event.CustomerID,
            Type:       "sms",
            Recipient:  event.Phone,
            Subject:    "",
            Body:       formatSMSBody(event),
            Status:     "pending",
            CreatedAt:  time.Now(),
        }

        if err := db.Create(&smsNotification).Error; err != nil {
            log.Printf("Failed to create SMS notification: %v", err)
        } else {
            sendSMS(smsNotification.ID)
        }

        msg.Ack(false)
    }
}

func formatEmailBody(event events.OrderCreatedEvent) string {
    body := fmt.Sprintf(
        "Dear Customer,\n\n"+
            "Thank you for your order!\n\n"+
            "Order ID: %s\n"+
            "Total Amount: $%.2f\n\n"+
            "Items:\n",
        event.OrderID,
        event.TotalAmount,
    )

    for _, item := range event.Items {
        body += fmt.Sprintf("- %s (x%d) - $%.2f\n", item.Name, item.Quantity, item.Price)
    }

    body += "\nWe'll notify you when your order is shipped.\n\nBest regards,\nYour Store"
    return body
}

func formatSMSBody(event events.OrderCreatedEvent) string {
    return fmt.Sprintf(
        "Order confirmed! Order ID: %s. Total: $%.2f. Thank you for your purchase!",
        event.OrderID,
        event.TotalAmount,
    )
}

func sendEmail(notificationID string) {
    var notification Notification
    if err := db.First(&notification, "id = ?", notificationID).Error; err != nil {
        log.Printf("Notification not found: %v", err)
        return
    }

    // Simulate email sending
    log.Printf("Sending email to: %s", notification.Recipient)
    log.Printf("Subject: %s", notification.Subject)
    log.Printf("Body: %s", notification.Body)

    // Update status
    now := time.Now()
    notification.Status = "sent"
    notification.SentAt = &now
    db.Save(&notification)

    log.Printf("Email sent successfully: %s", notificationID)
}

func sendSMS(notificationID string) {
    var notification Notification
    if err := db.First(&notification, "id = ?", notificationID).Error; err != nil {
        log.Printf("Notification not found: %v", err)
        return
    }

    // Simulate SMS sending
    log.Printf("Sending SMS to: %s", notification.Recipient)
    log.Printf("Message: %s", notification.Body)

    // Update status
    now := time.Now()
    notification.Status = "sent"
    notification.SentAt = &now
    db.Save(&notification)

    log.Printf("SMS sent successfully: %s", notificationID)
}

func listNotifications(c *gin.Context) {
    var notifications []Notification
    db.Order("created_at desc").Find(&notifications)
    c.JSON(http.StatusOK, notifications)
}

func getNotification(c *gin.Context) {
    id := c.Param("id")
    var notification Notification
    if err := db.First(&notification, "id = ?", id).Error; err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "Notification not found"})
        return
    }
    c.JSON(http.StatusOK, notification)
}

Step 7: Setup Instructions

Prerequisites

Go 1.21+
Docker & Docker Compose
PostgreSQL client (optional)

1. Initialize Go Modules

For each service directory, run:

# Initialize module
go mod init your-module

# Install dependencies
go get -u github.com/gin-gonic/gin
go get -u gorm.io/gorm
go get -u gorm.io/driver/postgres
go get -u github.com/google/uuid
go get -u github.com/rabbitmq/amqp091-go

2. Start Infrastructure

# Start RabbitMQ and PostgreSQL databases
docker-compose up -d

# Verify services are running
docker ps

3. Access RabbitMQ Management UI

Open browser: http://localhost:15672

Username: guest
Password: guest

4. Run Services

Open 4 separate terminals:

# Terminal 1 - Order Service
cd order-service
go run main.go

# Terminal 2 - Inventory Service
cd inventory-service
go run main.go

# Terminal 3 - Billing Service
cd billing-service
go run main.go

# Terminal 4 - Notification Service
cd notification-service
go run main.go

Testing the System

Create an Order

curl -X POST http://localhost:8080/orders \
  -H "Content-Type: application/json" \
  -d '{
    "customer_id": "cust-123",
    "email": "customer@example.com",
    "phone": "+1234567890",
    "items": [
      {
        "product_id": "prod-1",
        "name": "Laptop",
        "quantity": 2,
        "price": 999.99
      },
      {
        "product_id": "prod-2",
        "name": "Mouse",
        "quantity": 1,
        "price": 29.99
      }
    ]
  }'

Check Order

curl http://localhost:8080/orders

Check Inventory

curl http://localhost:8081/products

Check Invoices

curl http://localhost:8082/invoices

Check Notifications

curl http://localhost:8083/notifications

Process Payment

# Replace {invoice_id} with actual ID
curl -X POST http://localhost:8082/invoices/{invoice_id}/pay \
  -H "Content-Type: application/json" \
  -d '{
    "payment_method": "credit_card"
  }'

Architecture Flow

Order Service receives POST request
Order saved to order_db PostgreSQL database
Order Created Event published to RabbitMQ order_events fanout exchange
All three queues receive the event:
- inventory_queue
- billing_queue
- notification_queue
Each service processes independently:
- Inventory Service: Reserves stock
- Billing Service: Creates invoice
- Notification Service: Sends email and SMS

Service Ports

Order Service: http://localhost:8080
Inventory Service: http://localhost:8081
Billing Service: http://localhost:8082
Notification Service: http://localhost:8083
RabbitMQ Management: http://localhost:15672

Database Ports

Order DB: localhost:5436
Inventory DB: localhost:5437
Billing DB: localhost:5438
Notification DB: localhost:5439

Key Features

✅ Event-Driven Architecture: Decoupled services via RabbitMQ
✅ Fanout Exchange: Broadcast events to multiple consumers
✅ Database Per Service: Each service has its own PostgreSQL database
✅ Manual Acknowledgment: Reliable message processing
✅ RESTful APIs: Gin framework for HTTP endpoints
✅ Transaction Management: GORM transactions for data consistency
✅ Error Handling: Proper error handling and logging

Github: https://github.com/codefalconx/gin-rabbitmq-order-system

Reference:

Gin: https://gin-gonic.com/
RabbitMQ: https://www.rabbitmq.com/

How to Install MinIO on Ubuntu (Without Docker)

CodeFalconX — Mon, 29 Dec 2025 16:12:53 +0000

If you want to run a lightweight, self-hosted object storage server on a low-resource system — such as a single-core CPU and 1 GB RAM — MinIO is a perfect choice. This guide walks you through installing MinIO natively on Ubuntu, without using Docker.

🧩 What Is MinIO?

MinIO is an open-source, high-performance object storage system compatible with the Amazon S3 API. It’s often used for managing unstructured data such as photos, videos, logs, and backups. While many tutorials use Docker for deployment, running MinIO directly on Ubuntu is more efficient for small servers.

⚙️ System Requirements

Resource	Minimum
CPU	1 Core
Memory	1 GB RAM
Disk Space	1 GB+ free
OS	Ubuntu 20.04 or newer
Access	sudo privileges

🪜 Step-by-Step Installation

1. Update and Prepare the System

Run the following commands to update the package index and install required tools:

sudo apt update && sudo apt upgrade -y
sudo apt install wget -y

2. Download and Install MinIO Binary

Download the latest MinIO server binary:

wget https://dl.min.io/server/minio/release/linux-amd64/minio

Make it executable and move it to the system path:

chmod +x minio
sudo mv minio /usr/local/bin/

3. Create Data and Config Directories

sudo mkdir -p /usr/local/share/minio
sudo mkdir -p /etc/minio
sudo useradd -r minio-user -s /sbin/nologin
sudo chown -R minio-user:minio-user /usr/local/share/minio /etc/minio

This ensures MinIO runs under a dedicated non-root user for better security.

4. Create a Systemd Service File

Create the MinIO service configuration:

sudo nano /etc/systemd/system/minio.service

sudo vi /etc/systemd/system/minio.service

Paste the following content:

[Unit]
Description=MinIO Object Storage
Documentation=https://docs.min.io
Wants=network-online.target
After=network-online.target

[Service]
User=minio-user
Group=minio-user
ExecStart=/usr/local/bin/minio server /usr/local/share/minio --console-address ":9001"
EnvironmentFile=-/etc/default/minio
Restart=always
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

5. Set MinIO Access Credentials

Create a default environment file to store your root credentials:

sudo nano /etc/default/minio

sudo vi /etc/default/minio

Add the following lines:

MINIO_ROOT_USER=minioadmin
MINIO_ROOT_PASSWORD=minioadmin123

You can change these to more secure credentials.

6. Enable and Start MinIO

Reload the systemd daemon and start the service:

sudo systemctl daemon-reload
sudo systemctl enable minio
sudo systemctl start minio

Check the service status:

sudo systemctl status minio

7. Access the MinIO Console

Open your web browser and navigate to:

http://<your-server-ip>:9001

Username: minioadmin
Password: minioadmin123

You’ll now have access to the MinIO management console.

🧠 Tips for Low-Resource Systems

Since you’re running on only 1 GB RAM, consider these optimizations:

Avoid uploading large files.
Disable the web console if not needed:

  ExecStart=/usr/local/bin/minio server /usr/local/share/minio --console-address ":0"

Use a reverse proxy (like Nginx) to limit request load.
Regularly clean up unused data.

🧩 Useful Commands

Stop MinIO:

sudo systemctl stop minio

Restart MinIO:

sudo systemctl restart minio

View logs:

sudo journalctl -u minio -f

✅ Conclusion

You now have a fully functional MinIO server running natively on Ubuntu — lightweight, efficient, and perfect for low-spec environments. With its S3 compatibility, you can integrate it easily into applications.

Reference: https://www.min.io/

Step-by-step Guide: Creating a PASETO (Platform-Agnostic Security Token) in Express.js

CodeFalconX — Sat, 27 Dec 2025 18:05:13 +0000

The legacy library can’t generate keys itself, but it can import an Ed25519 key.
We’ll generate the key pair once (with tweetnacl, a crypto library) and feed it into paseto.

1. Install dependencies

Run this once:

npm install express paseto tweetnacl dotenv

2. Create a `.env` file

PORT=3000

3. Create an Express Server with PASETO

Create a file named server.js:

import express from "express";
import { V2 } from "paseto";
import nacl from "tweetnacl";
import dotenv from "dotenv";

dotenv.config();

/**
 * Generate an Ed25519 key pair with tweetnacl
 */
console.log("🟡 Generating Ed25519 key pair (v2.public) ...");
const keyPair = nacl.sign.keyPair(); // Uint8Arrays
const privateKey = Buffer.from(keyPair.secretKey);
const publicKey = Buffer.from(keyPair.publicKey);
console.log("✅ Keys ready, starting Express...");

const app = express();
app.use(express.json());

// issue token
app.post("/token", async (req, res) => {
  try {
    const payload = {
      userId: req.body.userId,
      role: req.body.role,
      issuedAt: new Date().toISOString(),
    };

    const token = await V2.sign(payload, privateKey, {
      issuer: "my-app",
      audience: "users",
      expiresIn: "1h",
    });

    res.json({ token });
  } catch (err) {
    console.error("❌ Token generation failed:", err);
    res.status(500).json({ error: err.message });
  }
});

// verify token
app.post("/verify", async (req, res) => {
  try {
    const { token } = req.body;
    const payload = await V2.verify(token, publicKey, {
      issuer: "my-app",
      audience: "users",
    });
    res.json({ valid: true, payload });
  } catch (err) {
    console.error("❌ Verification failed:", err);
    res.status(401).json({ error: "Invalid or expired token" });
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`🚀 Server running on http://localhost:${PORT}`));

4. Run it

node server.js

You should now see:

🟡 Generating Ed25519 key pair (v2.public) ...
✅ Keys ready, starting Express...
🚀 Server running on http://localhost:3000

5. Test the API

You can test using Insomnia or curl:

Generate token:

curl -X POST http://localhost:3000/token \
-H "Content-Type: application/json" \
-d '{"userId":123,"role":"admin"}'

Verify token:

curl -X POST http://localhost:3000/verify \
-H "Content-Type: application/json" \
-d '{"token":"PASTE_YOUR_TOKEN_HERE"}'

✅ Tip: In production, you’d typically store the key pair securely (not generate it every startup). But for demo purposes, this setup is perfect for learning how PASETO works.

Github:

Express Paseto V2 - https://github.com/codefalconx/express-paseto
Express Paseto V3 - https://github.com/codefalconx/express-paseto-v3
Express Paseto V4 - https://github.com/codefalconx/express-paseto-v4

Reference: https://paseto.io/

JWT vs PASETO: A Comprehensive Comparison

CodeFalconX — Fri, 26 Dec 2025 07:54:17 +0000

1. Overview

Feature	JWT (JSON Web Token)	PASETO (Platform-Agnostic Security Token)
Definition	An open standard (RFC 7519) for securely transmitting information as a JSON object.	A newer, opinionated security token format designed to eliminate common JWT pitfalls.
Purpose	Used for authentication, authorization, and data exchange.	Same purposes as JWT, but with stronger cryptographic safety guarantees.
Design Philosophy	Flexible but puts responsibility on developers to choose algorithms correctly.	Secure by design — disallows insecure algorithms and enforces best practices.

2. Structure

Both JWT and PASETO are compact, URL-safe tokens, but differ slightly in structure.

JWT Format:

<Header>.<Payload>.<Signature>

PASETO Format:

vX.local.<payload> (for symmetric encryption)
vX.public.<payload> (for asymmetric signing)

Example:

JWT: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
PASETO: v2.local.DWr6k19Cz3rG...

PASETO includes the version (v1, v2, etc.) and purpose (local, public) directly in the token — making it self-descriptive and versioned for future updates.

3. Security Considerations

Aspect	JWT	PASETO
Algorithm Flexibility	Allows many algorithms (`HS256`, `RS256`, `none`…), which can lead to misuse (e.g., “alg:none” attack).	Restricts algorithms per version (e.g., v2 uses AES-256-GCM and Ed25519). No insecure or deprecated options.
Implementation Safety	Developers must choose and configure algorithms carefully.	Developers can’t misconfigure algorithms — safe defaults only.
Token Validation	Potentially error-prone; requires checking algorithm and signature explicitly.	Safer validation — the version and purpose dictate how to validate.

In short: PASETO prevents developers from making cryptographic mistakes that JWT allows.

4. Performance

Aspect	JWT	PASETO
Size	Typically smaller due to base64 encoding.	Slightly larger due to additional metadata.
Speed	Comparable — depends on algorithm used (HMAC vs. Ed25519).	Usually on par or faster for modern crypto libraries.

5. Adoption and Ecosystem

Aspect	JWT	PASETO
Adoption Level	Very widely used across frameworks, libraries, and APIs.	Gaining traction but still less common.
Tooling Support	Extensive (Auth0, Okta, etc.)	Growing support in popular languages.
Learning Curve	Lower (more examples, tutorials).	Slightly higher (newer and fewer resources).

6. Relative Developer Adoption Interpretation

Metric	JWT	PASETO
Weekly npm downloads	~26.9 M	~23 K
Relative ecosystem size	Huge & mature	Small & growing
GitHub stars (example)	Thousands across many JWT libs	~3.4 K for a major PASETO impl

What this suggests:

Most developers in the JavaScript ecosystem use JWT.
PASETO is still developing — much smaller user base but gaining attention for security benefits.
The difference in usage is ~1000× or more (JWT usage far outpaces PASETO usage today).

7. Use Cases

Scenario	Recommended Token
Legacy systems or existing JWT-based auth flows	✅ JWT
New applications prioritizing strong cryptographic safety	✅ PASETO
Highly regulated or security-sensitive environments (finance, healthcare)	✅ PASETO
Interoperability with third-party APIs	✅ JWT (for now)

8. Example Comparison

JWT Example (HS256):

{
  "alg": "HS256",
  "typ": "JWT"
}
.
{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

PASETO Example (v2.local):

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true,
  "exp": "2025-12-26T00:00:00Z"
}

The main difference: PASETO doesn’t expose or allow algorithm specification in the token itself — preventing “algorithm confusion” attacks.

✅ Summary Table

Feature	JWT	PASETO
Security	⚠️ Depends on implementation	✅ Secure by design
Algorithm Selection	Manual	Enforced and versioned
Ease of Use	Easy but error-prone	Easy and safe
Ecosystem	Mature and widespread	Growing steadily
Backward Compatibility	Strong	Moderate
Recommended for New Systems	❌	✅

🔍 Final Thoughts

JWTs have served as the de facto standard for token-based authentication for years. However, their flexibility can lead to security misconfigurations.

PASETO modernizes the concept by enforcing secure defaults, making it a safer alternative for developers who want simplicity without sacrificing cryptographic integrity.

In short:

If you need wide compatibility — use JWT.

If you want modern security — use PASETO.

Reference:

JWT https://www.jwt.io/
PASETO https://paseto.io/

FastAPI vs Spring Boot: A Comprehensive Comparison

CodeFalconX — Sat, 06 Dec 2025 06:29:06 +0000

Overview

FastAPI is a modern, high-performance Python web framework designed for building APIs quickly with automatic interactive documentation. Released in 2018, it leverages Python type hints and async capabilities.

Spring Boot is a mature, enterprise-grade Java framework that simplifies Spring application development. Part of the larger Spring ecosystem since 2014, it provides comprehensive tools for building production-ready applications.

Aspect	FastAPI	Spring Boot
Language	Python	Java
First Release	2018	2014
Primary Use	Building RESTful APIs with Python	Building microservices and enterprise web apps
Core Philosophy	Simplicity, speed, and modern async support	Convention over configuration, enterprise scalability

Performance

FastAPI excels in raw performance thanks to its async nature and Starlette foundation. Benchmarks show it competing with Node.js and Go frameworks, handling high concurrent loads efficiently. Its async/await syntax allows non-blocking I/O operations ideal for microservices and real-time applications.

Spring Boot traditionally uses blocking I/O but has introduced reactive programming through Spring WebFlux. While generally not as fast as FastAPI in benchmarks, Spring Boot delivers solid performance with excellent scalability options, particularly for enterprise workloads with complex business logic.

Developer Experience

FastAPI offers an exceptional developer experience with minimal boilerplate code. Type hints enable automatic validation, serialization, and interactive documentation through Swagger UI and ReDoc. The learning curve is gentle for Python developers, and you can build functional APIs in minutes.

Spring Boot provides a comprehensive but more complex experience. Its convention-over-configuration approach reduces boilerplate, but the framework's depth means a steeper learning curve. The extensive ecosystem offers solutions for virtually any requirement, though this can feel overwhelming initially. IDE support, particularly in IntelliJ IDEA, is excellent.

Ecosystem and Maturity

FastAPI's ecosystem is growing rapidly with strong integration for async libraries, databases (SQLAlchemy, Tortoise ORM), and modern Python tools. However, it's relatively young compared to Spring Boot.

Spring Boot benefits from decades of Java ecosystem development. The Spring framework offers modules for security, data access, messaging, batch processing, and more. Enterprise integrations are extensive, covering virtually every database, message broker, and third-party service. This maturity translates to proven patterns and extensive community knowledge.

Type Safety and Validation

FastAPI leverages Pydantic models and Python type hints for automatic request/response validation and serialization. Type errors are caught at runtime with clear error messages. The approach feels natural to Python developers and generates excellent documentation.

Spring Boot uses Java's strong static typing with annotations for validation (Bean Validation). Type errors are caught at compile time, providing earlier feedback. The validation is robust though requires more verbose code compared to FastAPI.

Event Sourcing Focus

Feature	FastAPI (Python)	Spring Boot (Java)
Native Event Sourcing Framework	❌ None (custom or external libs)	✅ Axon Framework
CQRS Pattern Support	Manual / via libraries	Built-in (Axon)
Event Bus	Kafka, RabbitMQ, Faust	Axon Server, Kafka, RabbitMQ
Event Replay	Supported via library	Built-in in Axon
DDD Integration	Manual	Strong (Aggregates, Commands, Events)
Use Case	Smaller, flexible, or data-science driven systems	Complex, enterprise-grade systems

Use Cases

Choose FastAPI when:

Building modern, high-performance APIs and microservices
Working with Python-based data science or ML workflows
Needing rapid development and iteration
Prioritizing async/concurrent request handling
Your team is Python-focused

Choose Spring Boot when:

Developing large-scale enterprise applications
Requiring comprehensive security and transaction management
Building complex business logic with proven patterns
Working in organizations with existing Java infrastructure
Needing extensive third-party integrations and mature tooling

Code Example Comparison

FastAPI - Simple REST Endpoint:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.post("/items/")
async def create_item(item: Item):
    return {"item": item, "status": "created"}

Spring Boot - Equivalent Endpoint:

@RestController
@RequestMapping("/items")
public class ItemController {

    @PostMapping
    public ResponseEntity<ItemResponse> createItem(@Valid @RequestBody Item item) {
        return ResponseEntity.ok(new ItemResponse(item, "created"));
    }
}

@Data
public class Item {
    @NotNull
    private String name;
    @NotNull
    private Double price;
}

Documentation

FastAPI automatically generates interactive API documentation with zero additional configuration. Swagger UI and ReDoc are included out of the box, staying perfectly synchronized with your code.

Spring Boot requires additional configuration for Swagger/OpenAPI documentation, typically using SpringDoc or Springfox libraries. The documentation quality is excellent but requires more setup.

Deployment and Operations

FastAPI applications are lightweight and deploy easily to containers, serverless platforms, and traditional servers. Tools like Uvicorn and Gunicorn handle ASGI serving efficiently.

Spring Boot produces self-contained JAR files that include an embedded server, simplifying deployment. The framework includes production-ready features like health checks, metrics, and monitoring through Spring Actuator. Container deployment is straightforward, and the ecosystem includes robust options for cloud-native applications.

Summary Table

Feature	FastAPI	Spring Boot
Language	Python	Java
Performance	Excellent for async I/O	Excellent for CPU-bound & multi-threaded workloads
Learning Curve	Easy	Moderate to steep
Documentation	Auto-generated via OpenAPI	Configurable with annotations
Best For	APIs, ML backends, microservices	Enterprise apps, large-scale systems
Deployment	Lightweight containers, serverless	JVM-based, Kubernetes-ready
Community	Rapidly growing	Mature and extensive

Conclusion

Both frameworks excel in their respective domains. FastAPI shines for modern, async-first APIs with rapid development cycles, while Spring Boot remains the gold standard for enterprise applications requiring comprehensive features, stability, and extensive ecosystem support. Your choice should align with team expertise, performance requirements, and organizational infrastructure.

Hoppscotch — The Open Source API Development Ecosystem

CodeFalconX — Sun, 30 Nov 2025 03:26:01 +0000

🎯 What is Hoppscotch?

Hoppscotch is a free open-source API development ecosystem — essentially a modern API client — that helps developers build, test, document, and collaborate over APIs, all in one place.

🔗 hoppscotch.io

Hoppscotch is platform‑agnostic: available via web, desktop app, or CLI.

🔧 Key Features

REST, GraphQL & More Protocols – Supports REST, GraphQL, WebSocket, MQTT, SSE, and Socket.IO.
Environments & Variables – Manage base URLs, API keys, etc. for multiple environments.
Collections & Folders – Organize your API requests effectively.
Request History & Sharing – Save and share your API requests.
Pre‑request Scripts & Tests – Add logic and validation to API calls.
Code Snippet Generation – Generate snippets for popular languages.
Cross‑Platform & PWA – Works seamlessly across OS and browsers.
Team & Collaboration Tools – Real‑time collaboration and shared workspaces.
Self‑Hosting Option – Run Hoppscotch privately on your own servers.

✅ Why Developers Love Hoppscotch

Simplicity & Speed – Clean, fast UI for testing APIs instantly.
Flexibility & Versatility – Works with multiple protocols and environments.
Open‑Source & Transparent – Free, community-driven, and customizable.
Team Collaboration – Ideal for team-based API projects.
Accessible Anywhere – No heavy installations, browser-ready interface.

📘 Using Hoppscotch for Documentation

Hoppscotch can double as an interactive API documentation hub:

Build a live, interactive API reference through collections.
Maintain consistency with shared environment variables.
Share code examples and live API tests with your team.

🧑‍💻 Who Should Use Hoppscotch?

Developers building or testing APIs (REST, GraphQL, etc.)
Teams needing lightweight, collaborative API tools
Projects prioritizing open-source and privacy
Devs needing quick prototyping or debugging tools
Documentation engineers creating interactive API docs

🎯 Conclusion — Your API Swiss Army Knife

Hoppscotch unifies all essential API tools — testing, collaboration, scripting, and documentation — in one open‑source package.

If you want a fast, free, and modern API platform, Hoppscotch is the one to try.

🔗 Official Site: hoppscotch.io
🔗 GitHub Repo: github.com/hoppscotch/hoppscotch

shadcn/ui vs Ant Design vs MUI: A Modern React Design System Comparison

CodeFalconX — Thu, 20 Nov 2025 15:46:19 +0000

Design System Comparison Matrix

Category	shadcn/ui	Ant Design	Material-UI (MUI)
Philosophy / Core Approach	“Build your own library” — you copy source code for full control and customization.	“Comprehensive enterprise system” — provides everything you need out of the box.	“Google’s Material Design for React” — focuses on visual consistency and ease of use.
Tech Stack	React + Tailwind CSS + Radix UI primitives.	React + Less (styling preprocessor).	React + Emotion (CSS-in-JS) + TypeScript support.
Design Language	Neutral and minimal; intended as a base to build your own.	Enterprise-grade, clean, and data-heavy dashboard friendly.	Google’s Material Design — vibrant, motion-driven, and user-friendly.
Component Depth	~40+ base components; great accessibility but fewer high-level features.	70+ rich components (forms, modals, tables, charts, etc.).	80+ components including advanced layouts, grids, and labs.
Customization & Theming	🔥 Extremely flexible — full code access, Tailwind-based.	Good — theming via Less variables or CSS overrides.	Very strong — theme objects, CSS variables, dark mode, custom palettes.
Accessibility (a11y)	Excellent (Radix UI handles ARIA, keyboard navigation).	Very good, though some older components need fine-tuning.	Excellent — follows WAI-ARIA guidelines, screen reader friendly.
Design Tokens	Uses Tailwind tokens (colors, spacing, radius, etc.)	Built-in Less tokens; some manual mapping needed for dark mode.	Supports full token customization through theme API.
Dark Mode Support	Built-in via Tailwind + CSS variables.	Available but requires theme switch setup.	Native dark mode built into MUI theme provider.
Learning Curve	Moderate to advanced — more setup, but transparent.	Moderate — many components and props to learn.	Easy to moderate — great docs, intuitive APIs.
Performance / Bundle Size	Lightest — tree-shaking and selective import.	Heavier — lots of bundled components.	Optimized with emotion; can tree-shake imports.
Ecosystem & Community	Growing rapidly, supported by modern devs (2023+).	Mature and widely used in enterprise projects.	Huge global community, plugins, templates, and integrations.
TypeScript Support	First-class (built-in).	Good but sometimes manual type extensions needed.	First-class support, well-typed APIs.
Figma / Design Assets	No official Figma kit (yet).	Yes — official Ant Design Figma kit.	Yes — official Material Design + MUI kits.
Documentation Quality	Excellent — concise and modern.	Very detailed but sometimes dense.	Excellent — extensive guides, playgrounds, and code examples.
Ideal Use Case	Custom branded SaaS, modern marketing sites, developer-first apps.	Large enterprise dashboards, CRMs, internal tools.	Consumer apps, startups, admin panels, and mobile-friendly products.
Maturity Level	Newer (2023-2024) but stable and trending.	Very mature (since 2015).	Extremely mature (since 2014).

Summary

Use Case	Best Choice	Why
Highly custom UI, brand-driven, Tailwind stack	⭐ shadcn/ui	You get full control and modern DX; great for startups and design-heavy products.
Enterprise dashboards, data-dense products	🏢 Ant Design	Battle-tested for B2B apps; strong i18n, tables, and complex workflows.
Fast prototyping, strong community, Material aesthetic	💎 Material-UI (MUI)	Well-documented, reliable, and quick to ship polished apps.

Here are the official websites for each design system:

shadcn/ui: https://ui.shadcn.com/
Ant Design: https://ant.design/
MUI (formerly Material-UI): https://mui.com/

Forem: CodeFalconX

Comparison: Freight Management System vs Fleet Management System vs Transportation Management System

1. Freight Management System (FMS)

Definition

Core Focus

Typical Modules

Example Workflow

Key Users

2. Fleet Management System

Definition

Core Focus

Typical Modules

Example Workflow

Key Users

3. Transportation Management System (TMS)

Definition

Core Focus

Typical Modules

Example Workflow

Key Users

Key Differences

Real‑World Example

Simple Analogy

Summary

Gin vs Spring Boot: A Detailed Comparison

1. Overview

2. Performance

3. Ease of Development

4. Architecture and Ecosystem

5. Concurrency and Scalability

6. Learning Curve

7. Deployment

8. Event Sourcing Support

9. Ideal Use Cases

10. Community and Support

Summary Table

Final Thoughts

Model Context Protocol (MCP) — Integrating AI LLMs with Modern DevOps Systems

What is MCP?

Why MCP Matters

How MCP Works

What You Can Do with MCP

1. Smarter Coding

2. Automated CI/CD (Jenkins Integration)

3. Intelligent Code Quality (SonarQube Integration)

4. Streamlined Project Management (Jira Integration)

5. Data-Driven Insights (PostgreSQL Integration)

Security Built-In

Key Benefits

The Future of AI-Powered Development

References

NGINX --- High Performance Web Server for High Traffic

High Performance & High Traffic

Event‑Driven & Asynchronous Architecture

One Worker Can Handle Thousands of Connections

Non‑Blocking I/O & High Throughput

Super Fast Static Content Delivery

Summary

Create MinIO Bucket using Express.js

1️⃣ Install Dependencies

2️⃣ Project Structure (Recommended)

3️⃣ .env Configuration

4️⃣ MinIO Client (src/minio/minioClient.js)

5️⃣ Bucket Service (src/services/bucket.service.js)

6️⃣ Bucket API Route (src/routes/bucket.routes.js)

7️⃣ Express App (src/app.js)

8️⃣ Run the Application

9️⃣ Test with CURL or Insomnia

Request

Success Response

Already Exists

🔐 Permissions Reminder

Building a Microservices Order System with Gin, RabbitMQ, and PostgreSQL

Table of Contents

Architecture Overview

Project Structure

Step 1: Docker Compose Setup

Step 2: Shared Code

shared/events/events.go

shared/rabbitmq/rabbitmq.go

3️⃣ `.env` Configuration

4️⃣ MinIO Client (`src/minio/minioClient.js`)

5️⃣ Bucket Service (`src/services/bucket.service.js`)

6️⃣ Bucket API Route (`src/routes/bucket.routes.js`)

7️⃣ Express App (`src/app.js`)

2. Create a `.env` file