Enterprise-grade modular platform for building scalable applications across healthcare, insurance, finance, and banking sectors. Built with clean architecture principles and Go, Evero provides a robust foundation for domain-specific services with shared infrastructure components.

Evero follows a modular monolith architecture with clear separation of concerns:

• Multi-Domain Support: Access (SSO), Healthcare, Insurance, Finance, and Banking modules
• Clean Architecture: Domain-driven design with layers (Entity, Use Case, Repository, Controller)
• Shared Infrastructure: Reusable components across all modules
• Event-Driven: Kafka integration for asynchronous messaging
• API-First: RESTful APIs with comprehensive validation
• Modular Deployment: Each module can be deployed independently

• Configuration Management: Environment-specific configurations (local, development, staging, production)
• Database Support: PostgreSQL with GORM ORM
• Caching: Redis integration for high-performance caching
• Message Broker: Kafka and RabbitMQ support
• Logging: Structured logging with Logrus and Zap
• Validation: Request validation with go-playground/validator
• Routing: Fiber v2 (primary framework)

Enterprise-grade single sign-on and access control system.

• Authentication

  • User registration and login
  • JWT-based access and refresh tokens
  • Token rotation and refresh
  • Session management with device tracking
  • Email verification workflow

• Authorization

  • Multi-company/tenant support
  • OAuth 2.0 authorization code flow
  • Two-factor authentication (TOTP)
  • Role-based access control (RBAC)
  • Fine-grained permissions

• Security

  • Password reset and verification
  • Account lockout protection
  • Audit logging
  • bcrypt password hashing
  • Secure token management

📖 Documentation: docs/access/IMPLEMENTATION_SUMMARY.md
Migration Guide: docs/SSO_MIGRATION_SUMMARY.md
Quick Start: docs/access/QUICK_REFERENCE.md

Build & Deploy:

make build-access    # Build the module
make deploy-access   # Deploy the module

API: http://localhost:3000 (configurable)

Comprehensive healthcare management system for patient care, appointments, and medical records.

• Patient Management

  • Patient registration and demographics
  • Medical history tracking
  • Insurance information
  • Emergency contacts

• Appointments & Scheduling

  • Appointment booking
  • Provider availability
  • Appointment reminders
  • Waitlist management

• Electronic Medical Records (EMR)

  • Clinical notes
  • Diagnosis recording (ICD-10)
  • Prescription management
  • Lab results integration

• Billing Integration

  • Insurance claim generation
  • Payment processing
  • Finance module integration

📖 Documentation: docs/healthcare/README.md

Build & Deploy:

make build-healthcare    # Build the module
make deploy-healthcare   # Deploy the module

API: http://localhost:3001 (configurable)

Complete insurance management platform for policies, claims, and underwriting.

• Policy Management

  • Policy creation and issuance
  • Premium calculation
  • Renewals and endorsements
  • Coverage management

• Claims Processing

  • Claim submission and intake
  • Assessment and adjudication
  • Payment processing
  • Fraud detection

• Underwriting

  • Risk assessment
  • Quote generation
  • Automated underwriting rules
  • Manual workflow support

• Agent & Commission Management

  • Agent registration
  • Commission calculation
  • Performance analytics

📖 Documentation: docs/insurance/README.md

Build & Deploy:

make build-insurance    # Build the module
make deploy-insurance   # Deploy the module

API: http://localhost:3002 (configurable)

Comprehensive financial management system with general ledger, AR/AP, and budgeting.

• General Ledger

  • Chart of accounts
  • Double-entry bookkeeping
  • Journal entries
  • Period closing
  • Multi-currency support

• Accounts Receivable/Payable

  • Customer invoicing
  • Payment tracking
  • Aging reports
  • Vendor management

• Budgeting & Forecasting

  • Budget creation
  • Variance analysis
  • Cash flow forecasting

• Financial Reporting

  • Balance sheet
  • Income statement
  • Cash flow statement
  • Custom reports

📖 Documentation: docs/finance/README.md

Build & Deploy:

make build-finance    # Build the module
make deploy-finance   # Deploy the module

API: http://localhost:3003 (configurable)

Core banking platform for account management, transactions, and lending (in planning).

📖 Documentation: docs/banking/README.md
Status: 📋 Planning Phase

evero/
├── Makefile                      # Root orchestration for all modules
├── bin/                          # Compiled binaries (gitignored)
│   ├── access
│   ├── healthcare
│   ├── insurance
│   └── finance
│
├── app/                          # Application entry points
│   ├── healthcare/               # Healthcare application
│   ├── insurance/                # Insurance application
│   └── finance/                  # Finance application
│
├── modules/                      # Domain modules
│   ├── access/                   # Authentication & Authorization module
│   │   ├── cmd/server/           # Entry point
│   │   ├── entities/             # Domain entities
│   │   ├── models/               # Request/Response models
│   │   ├── repositories/         # Data access layer
│   │   ├── usecases/             # Business logic
│   │   ├── controllers/          # HTTP handlers
│   │   └── route.go              # Route definitions
│   └── healthcare/               # Healthcare domain module
│       ├── delivery/             # HTTP handlers/controllers
│       ├── entity/               # Domain entities
│       ├── features/             # Business logic (use cases)
│       ├── gateway/              # External integrations
│       ├── model/                # Request/Response models
│       ├── repository/           # Data access layer
│       └── test/                 # Unit and integration tests
│
├── infrastructure/               # Shared infrastructure components
│   ├── cache/                    # Cache management (Redis, In-memory)
│   ├── config/                   # Configuration management
│   ├── database/                 # Database connections
│   ├── logger/                   # Logging utilities
│   ├── message-broker/           # Kafka/RabbitMQ integration
│   ├── router/                   # HTTP routers (Fiber, Gin, Mux)
│   ├── setup/                    # Infrastructure bootstrapping
│   └── validator/                # Request validation
│
├── config/                       # Configuration files
│   ├── access/                   # Access module configs
│   │   ├── local.json
│   │   ├── development.json
│   │   ├── stage.json
│   │   └── production.json
│   ├── healthcare/               # Healthcare configs
│   ├── insurance/                # Insurance configs
│   └── finance/                  # Finance configs
│
├── database/                     # Database migrations and seeds
│   ├── access/migrations/        # SSO database schemas
│   ├── healthcare/migrations/    # Healthcare schemas
│   ├── insurance/migrations/     # Insurance schemas
│   └── finance/migrations/       # Finance schemas (10 tables)
│
├── deployment/                   # Deployment configurations
│   ├── access/                   # Access module deployment
│   │   ├── Makefile              # Deployment tasks
│   │   ├── setup.sh              # Setup script
│   │   ├── Dockerfile
│   │   └── docker-compose.yml
│   ├── healthcare/               # Healthcare deployment
│   ├── insurance/                # Insurance deployment
│   └── finance/                  # Finance deployment
│
├── packages/                     # External service integrations
│   ├── lib/                      # Shared libraries
│   ├── sendgrid/                 # Email service
│   └── twilio/                   # SMS service
│
└── docs/                         # Documentation
    ├── evero/                    # Platform technical docs
    ├── access/                   # Access module documentation
    ├── healthcare/               # Healthcare module documentation
    ├── insurance/                # Insurance module documentation
    ├── finance/                  # Finance module documentation
    └── banking/                  # Banking module documentation

• Go: 1.24.4
• Web Framework: Fiber v2 (primary), Gin, Gorilla Mux
• ORM: GORM v1.30.3
• Database: PostgreSQL (primary), MySQL support via drivers
• Validation: go-playground/validator v10

• Cache: Redis (go-redis v9)
• Message Broker: Apache Kafka (Sarama v1.46), RabbitMQ
• Logging: Logrus v1.9.3, Zap v1.27.0
• Configuration: Viper v1.20.1
• Database Drivers:
  • PostgreSQL: lib/pq v1.10.9
  • MySQL: gorm.io/driver/mysql v1.6.0
• Security: bcrypt (golang.org/x/crypto v0.41.0)
• UUID: google/uuid v1.6.0

• Go: 1.24.4 or higher
• PostgreSQL: 14 or higher
• Redis: 6 or higher (optional, for caching)
• Kafka: 2.8 or higher (optional, for event streaming)
• Make: For using the Makefile commands

1. Clone the repository

   git clone https://github.com/prayaspoudel/evero.git
   cd evero

2. View available commands

   make help

3. Setup a module (e.g., healthcare)

   make setup-healthcare

4. Build a module

   make build-healthcare

5. Run migrations

   make migrate-healthcare

6. Deploy a module

   make deploy-healthcare

Each module can be set up and deployed independently:

Access Module (SSO):

make setup-access      # Setup access module
make build-access      # Build binary
make deploy-access     # Deploy with migrations

Healthcare Module:

make setup-healthcare
make build-healthcare
make deploy-healthcare

Finance Module:

make setup-finance
make build-finance
make deploy-finance

All Modules:

make setup-all         # Setup all modules
make build-all         # Build all modules
make deploy-all        # Deploy all modules

make status

Output:

📊 Module Status
================================
Access:      ✅ Built
Healthcare:  ✅ Built
Insurance:   ❌ Not built
Finance:     ✅ Built
================================

Evero uses environment-specific JSON configuration files. Each module has its own configuration directory:

config/
├── access/
│   ├── local.json          # Local development
│   ├── development.json    # Development environment
│   ├── stage.json          # Staging environment
│   └── production.json     # Production environment
├── healthcare/
├── insurance/
└── finance/

Each module follows a consistent configuration structure:

{
  "app": {
    "name": "Evero Healthcare API",
    "version": "1.0.0"
  },
  "web": {
    "port": 3000,
    "prefork": false,
    "cors_enabled": true
  },
  "database": {
    "host": "localhost",
    "port": 5432,
    "username": "postgres",
    "password": "postgres",
    "name": "evero_db",
    "sslmode": "disable",
    "pool": {
      "idle": 10,
      "max": 100,
      "lifetime": 300
    }
  },
  "kafka": {
    "bootstrap.servers": "localhost:9092",
    "producer.enabled": false,
    "group.id": "evero-service"
  },
  "redis": {
    "host": "localhost",
    "port": 6379,
    "password": "",
    "db": 0
  },
  "log": {
    "level": "info",
    "format": "json"
  }
}

Set the environment using:

export EVERO_ENV=production  # Options: local, development, stage, production

Or specify when running:

./bin/access --config=config/access/production.json

# Run all tests
go test ./...

# Test specific module
make test-access
make test-healthcare
make test-finance

# All module tests
make test-all

# Run with coverage
go test -cover ./...

Check which modules are built:

make status

Centralized configuration loading with support for:

• Environment-specific files
• Module-specific overrides
• Type-safe access methods
• Hot-reload capability

See infrastructure/config/example_usage.md

Multi-backend caching support:

• Redis
• In-memory cache
• Factory pattern for easy switching

Database connection management:

• PostgreSQL support with GORM
• Connection pooling
• Migration support
• Multi-database support

Event-driven messaging:

• Kafka producer/consumer
• RabbitMQ support
• Async event publishing

HTTP routing with multiple framework support:

• Fiber v2 (primary)
• Gin
• Gorilla Mux

Structured logging:

• Logrus
• Zap
• Configurable log levels
• JSON formatting

See infrastructure/ for detailed documentation.

• Authentication: JWT-based token authentication
• Password Security: bcrypt hashing
• Input Validation: Comprehensive request validation
• SQL Injection: Protected via ORM parameterized queries
• Authorization: User-specific data isolation

Each module can be deployed independently using Docker:

# Build Docker image
make docker-build-access

# Start containers
make docker-up-access

# Stop containers
make docker-down-access

Each module has its own deployment configuration:

deployment/
├── access/
│   ├── Makefile              # Deployment commands
│   ├── setup.sh              # Setup script
│   ├── Dockerfile            # Docker image
│   └── docker-compose.yml    # Orchestration
├── healthcare/
├── insurance/
└── finance/

Set the environment variable:

export EVERO_ENV=production

Configuration files are loaded based on this variable:

• local → config/[module]/local.json
• development → config/[module]/development.json
• stage → config/[module]/stage.json
• production → config/[module]/production.json

1. Build the module:

   make build-access

2. Run migrations:

   make migrate-access

3. Start the service:

   ./bin/access --config=config/access/production.json

Or use the combined deploy command:

make deploy-access  # Builds + migrates

All API responses follow a consistent format:

Success Response:

{
  "code": 200,
  "status": "success",
  "data": { ... }
}

Error Response:

{
  "code": 400,
  "status": "error",
  "message": "Validation failed",
  "errors": ["field: first_name is required"]
}

List endpoints support pagination:

GET /api/v1/[resource]?page=1&size=10

Response includes metadata:

{
  "data": [...],
  "pagination": {
    "page": 1,
    "size": 10,
    "total_items": 50,
    "total_pages": 5
  }
}

• Access Module: Authentication, authorization, OAuth 2.0, 2FA

  • See docs/access/QUICK_REFERENCE.md

• Healthcare Module: Patient management, appointments, EMR

  • See docs/healthcare/README.md

• Insurance Module: Policies, claims, underwriting

  • See docs/insurance/README.md

• Finance Module: General ledger, invoicing, budgeting

  • See docs/finance/README.md

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

• Follow Go standard formatting (gofmt)
• Write meaningful commit messages
• Add tests for new features
• Update documentation as needed
• Use the Makefile for common tasks

1. Create a new module or feature
2. Write tests first (TDD approach)
3. Implement the feature
4. Run tests: make test-[module]
5. Format code: make fmt
6. Run linter: make lint
7. Update documentation
8. Submit PR

• Access Module - Authentication & authorization
• Healthcare Module - Healthcare management
• Insurance Module - Insurance operations
• Finance Module - Financial management
• Banking Module - Banking services (planned)

• Platform Architecture - Platform architecture and design principles
• Deployment Guide - Comprehensive deployment instructions
• Infrastructure Guide - Shared infrastructure components
• Postman Testing Guide - API testing with Postman
• SSO Migration Summary - Access module migration details

• Access Quick Reference
• Makefile Commands - Use make help

This project is private and proprietary.

• Prayas Poudel - @prayaspoudel

• Built with Go and the amazing Go ecosystem
• Inspired by clean architecture principles
• Designed for scalability and maintainability

For questions or issues, please contact the development team or open an issue in the repository.

Note: This is a private repository. Please ensure you have proper authorization before accessing or using this codebase.