goplt/docs/content/index.md

Go Platform Documentation

Welcome to the Go Platform documentation! This is a plugin-friendly SaaS/Enterprise platform built with Go.

What is Go Platform?

Go Platform is a microservices platform designed to support multiple business domains through independent, deployable services. It provides:

• Core Kernel: Infrastructure only (configuration, logging, DI, health, metrics, observability) - no business logic
• Core Services: Independent microservices (Auth, Identity, Authz, Audit) with their own entry points and databases
• API Gateway: Single entry point for all external traffic, handles routing, authentication, and rate limiting
• Service Discovery: Consul-based service registry for dynamic service discovery
• Module Framework: Feature services (Blog, Billing, etc.) as independent services
• Infrastructure Adapters: Support for databases, caching, event buses, and job scheduling
• Security-by-Design: Built-in JWT authentication, RBAC/ABAC authorization, and audit logging
• Observability: OpenTelemetry integration for distributed tracing, metrics, and logging across services

Documentation Structure

Overview

• Requirements: High-level architectural principles and requirements
• Implementation Plan: Epic-based implementation plan with timelines
• Playbook: Detailed implementation guide and best practices

Architecture

• Architecture Overview: System architecture with diagrams
• Module Architecture: Module system design and integration
• Module Requirements: Detailed requirements for each module
• Component Relationships: Component interactions and dependencies
• System Specifications
  • System Behavior Overview: How the system behaves end-to-end
  • Service Orchestration: How services work together
  • Module Integration Patterns: How modules integrate with the platform
  • Operational Scenarios: Common operational flows and use cases
  • Data Flow Patterns: How data flows through the system

Architecture Decision Records (ADRs)

All architectural decisions are documented in ADR records, organized by implementation epic:

• Epic 0: Project Setup & Foundation
• Epic 1: Core Kernel & Infrastructure
• Epic 2: Authentication & Authorization
• Epic 3: Module Framework
• Epic 5: Infrastructure Adapters
• Epic 6: Observability & Production Readiness
• Epic 7: Testing, Documentation & CI/CD

Implementation Tasks

Detailed task definitions for each epic are available in the Stories section:

• Epic 0: Project Setup & Foundation - Implementation Summary
• Epic 1: Core Kernel & Infrastructure - Implementation Summary
• Epic 2: Authentication & Authorization
• Epic 3: Module Framework
• Epic 4: Sample Feature Module (Blog)
• Epic 5: Infrastructure Adapters
• Epic 6: Observability & Production Readiness
• Epic 7: Testing, Documentation & CI/CD
• Epic 8: Advanced Features & Polish (Optional)

Quick Start

1. Review the Requirements to understand the platform goals
2. Check the Implementation Plan for the epic-based approach
3. Follow the Playbook for implementation details
4. Refer to ADRs when making architectural decisions
5. Use the Task Stories as a checklist for implementation

Key Principles

• microMicroservices Architecture: Each service is independently deployable from day one
  • Core Kernel: Infrastructure only (config, logger, DI, health, metrics)
  • Core Services: Auth, Identity, Authz, Audit as separate services
  • Feature Services: Blog, Billing, etc. as independent services
• API Gateway: Single entry point for all external traffic
• Service Discovery: Consul-based service registry for dynamic service location
• Service Clients: All inter-service communication via gRPC/HTTP through service clients
• Database Isolation: Each service has its own database connection pool and schema
• Hexagonal Architecture: Clear separation between interfaces and implementations
• Security-by-Design: Built-in authentication, authorization, and audit capabilities
• Observability: Comprehensive distributed tracing, metrics, and logging across services
• API-First: OpenAPI/GraphQL schema generation

Contributing

When contributing to the platform:

1. Review relevant ADRs before making architectural decisions
2. Follow the task structure defined in the Stories
3. Update documentation as you implement features
4. Ensure all tests pass before submitting changes