Simple Securities is an imaginary and practical trading microservices system, built with Golang and advanced architecture styles such as Hexagonal Architecture, Domain Driven Design (DDD), CQRS, Event Sourcing, and Event Driven Architecture. It uses Kafka for messaging, gRPC + gRPC Gateway for service communication, and modern tooling for observability, configuration, and testing.

💡 This project is designed as a reference implementation and technical playground, not a production-ready exchange.

🚀 The application is in progress and evolves with new features and improvements.

• ✅ Hexagonal Architecture (ports & adapters)
• ✅ Domain Driven Design (DDD)
• ✅ CQRS Pattern (Command Query Responsibility Segregation)
• ✅ Event Sourcing (durable event store)
• ✅ Event Driven Architecture with Kafka
• ✅ Change Data Capture using Debezium + Kafka
• ✅ gRPC for internal service communication
• ✅ gRPC Gateway for HTTP/REST routing
• ✅ Postgres & EventStoreDB for transactional writes (ACID)
• ✅ MongoDB & ElasticSearch for read models (NoSQL, search)
• ✅ Unit Testing with mocks using Mockery
• ✅ Integration & End-to-End Testing with testcontainers-go
• ✅ Zap structured logging
• ✅ Viper configuration management
• ✅ Docker & Docker Compose for local deployment
• 🚧 Kubernetes & Helm (future work)

• 🔑 core-service → manages users, wallets, and permissions
• 💰 crypto-service → handles crypto orders, real-time prices via websockets, margin, futures, and crypto portfolios
• 📈 stock-service → manages stock orders, real-time stock prices, buy/sell operations, and stock portfolios
• 🔔 notification-service → push notifications, fetch by user or id
• 🌐 gateway-service → REST gateway using grpc-gateway for routing

• Language: Go 1.25.0
• Service Communication: gRPC + gRPC Gateway
• Messaging: Kafka
• CDC: Debezium → Kafka
• Databases:
  • Postgres (write DB)
  • EventStoreDB (event sourcing)
  • MongoDB (read DB)
  • ElasticSearch (search)
• Config: Viper
• Logging: Zap
• Testing: testify, mockery, testcontainers-go
• Deployment: Docker & Docker Compose

Here’s a list of key libraries and tools used across services:

• gRPC — RPC communication between services
• grpc-gateway — REST ↔ gRPC mapping
• protobuf — schema definitions
• Viper — configuration management
• Zap — structured logging
• Mockery — generating mocks for tests
• testify — unit testing assertions
• testcontainers-go — integration testing with real containers

• Postgres — relational DB for writes
• EventStoreDB — event sourcing store
• MongoDB — read DB (NoSQL)
• ElasticSearch — search engine
• Kafka — event streaming
• Debezium — change data capture

• Docker — containerization
• Docker Compose — local orchestration
• Air — live reload for Go
• Make — build automation

• Domain: aggregates, entities, domain events
• Application: commands, queries, handlers
• Adapters: persistence (Postgres, EventStoreDB), messaging (Kafka), transport (gRPC, HTTP)

• Commands mutate state, events are persisted in EventStoreDB
• Events are published to Kafka for other services
• Read models built asynchronously in MongoDB / ElasticSearch

• Debezium streams Postgres changes into Kafka
• Enables reliable read-model updates & audit logs

go test ./... -v

Mocks generated with mockery.

make test-integration

Uses testcontainers-go to spin up real dependencies.

• Logging: Zap (structured, leveled)
• Tracing/Metrics: OpenTelemetry (Jaeger, Prometheus, Grafana)

• Dockerfiles per service (multi-stage builds)
• docker-compose for local development
• Future: Kubernetes + Helm

1. Follow Conventional Commits
2. Run make format && make lint before commits
3. Add tests for new features
4. Open issues for large changes

MIT License — see LICENSE