Skip to main content

Welcome to Easy AppServer

Easy AppServer is a next-generation application platform that enables teams to build, deploy, and manage modular enterprise applications through a microfrontend architecture. It provides a complete ecosystem for developing composable software where independent applications can be installed, orchestrated, and integrated seamlessly into a unified user experience.

What Problems Does It Solve?​

Modern enterprise software faces several key challenges:

  • Monolithic Complexity: Traditional applications become increasingly difficult to maintain and scale as they grow
  • Team Bottlenecks: Multiple teams working on a single codebase leads to coordination overhead and deployment conflicts
  • Technology Lock-in: Being forced to use the same technology stack across all features limits innovation
  • Deployment Risk: Changes to one feature can break unrelated functionality
  • Integration Complexity: Connecting disparate systems requires custom integration code and maintenance

Easy AppServer addresses these challenges by providing a platform where:

  • Applications are developed, deployed, and versioned independently
  • Teams can choose the best technology for their specific needs
  • New features can be installed and removed without affecting the core system
  • A unified authentication and authorization layer ensures security across all applications
  • Built-in event-driven architecture enables loose coupling between applications

Key Capabilities​

🎯 Microfrontend Platform​

Load and compose frontend applications dynamically using Module Federation, Web Components, or ESM modules. The platform handles asset serving, security, and cross-application communication.

🔌 Intelligent HTTP Proxy​

Applications run as backend services with their own HTTP routes. The AppServer acts as an intelligent reverse proxy that:

  • Routes requests to the correct application backend
  • Verifies permissions BEFORE forwarding requests to apps
  • Enforces rate limiting per route with customizable limits
  • Circuit breaking for failing backends to prevent cascading failures
  • Route metadata (permissions, rate limits) declared in app manifest

🔐 Unified Authentication & Authorization​

Integration with industry-standard auth providers (Ory Kratos, OpenFGA) provides:

  • User authentication with session management (via Kratos)
  • Application-to-AppServer authentication via certificate-based signatures
  • Fine-grained permission control with OpenFGA relation-based access control
  • OAuth2/OIDC support planned (Ory Hydra integration)

🐳 Docker Orchestration (Optional Plugin)​

The standalone orchestrator (cmd/orchestrator/) is an optional component that:

  • Listens for application install/uninstall events via the event bus
  • Automatically deploys containers for applications to Docker infrastructure
  • Manages container lifecycle (start, stop, health monitoring, restarts)
  • Handles network isolation, volume persistence, and environment injection
  • Can be enabled/disabled independently of the core AppServer
  • Container configuration currently via server config (manifest-driven deployment planned)

📡 Event-Driven Architecture​

RabbitMQ-based event bus enables applications to:

  • Publish domain events (app installed, user created, settings changed)
  • Subscribe to events from other applications
  • Maintain eventual consistency
  • Implement cache invalidation strategies
  • Synchronize distributed caches across AppServer instances

📊 GraphQL API​

Real-time API for platform management:

  • Queries for applications, settings, and installation status
  • Mutations for app installation, uninstallation, and configuration
  • Subscriptions for real-time updates (app status changes)
  • Interactive GraphQL Playground (development mode)
  • WebSocket support for live data

⚙️ Application Lifecycle Management​

Complete control over application states:

  • Registration: Apps authenticate and declare capabilities
  • Installation: Dependency resolution, resource allocation, event subscriptions
  • Running: Health monitoring, auto-recovery, automatic restarts
  • Uninstallation: Clean teardown with dependency impact analysis

Architecture Overview​

The Easy AppServer consists of several key components:

  • AppServer Core: Go-based backend with gRPC/HTTP/GraphQL APIs, PostgreSQL persistence, Redis caching
  • Shell: Nuxt 4-based frontend serving as the platform UI and microfrontend host
  • Node.js SDK: Backend SDK for app registration - implements lifecycle hooks, builds frontends (if app has UI), and sends complete AppManifest (dependencies, permissions, routes, settings schemas, etc.) to AppServer
  • Frontend SDK: Browser-side SDK that fetches app information from AppServer and mounts microfrontends into the Shell with Vue integration
  • Orchestrator (Optional): Standalone plugin (cmd/orchestrator/) that listens for install/uninstall events and auto-deploys Docker containers from registry
  • Infrastructure Services: PostgreSQL, Redis, RabbitMQ, Ory Stack (Kratos/Hydra/Oathkeeper), OpenFGA
  • Telemetry Stack: Prometheus metrics, Loki logs, Tempo traces, Grafana dashboards

Horizontal Scalability​

The AppServer is designed for horizontal scaling:

  • Multiple AppServer instances can run concurrently
  • Instances communicate via RabbitMQ event bus to synchronize state
  • State changes (app installations, settings updates, permissions) are propagated across all instances via events
  • Stateless design allows for dynamic scaling based on load

Applications register with the AppServer via the Node.js SDK, providing a complete manifest that declares:

  • Dependencies, permissions, and HTTP routes with metadata
  • Frontend components (if any) to be mounted in the Shell
  • Settings schemas with validation rules and UI hints

Once installed, applications can:

  • Serve HTTP routes (proxied through AppServer with permission checks and rate limiting)
  • Mount microfrontends into the Shell (loaded via Frontend SDK)
  • Store encrypted settings with rich schemas for automated form generation
  • Call APIs of other applications via the AppServer proxy
  • Publish and consume domain events
  • Have their Docker containers automatically managed by the orchestrator plugin

Who Should Use Easy AppServer?​

Easy AppServer is ideal for:

  • Enterprise Development Teams building modular applications that need to scale across multiple teams
  • Platform Engineers creating internal developer platforms with app marketplaces
  • SaaS Providers offering extensible platforms where third-party apps can be integrated
  • Product Teams transitioning from monolithic architectures to microfrontends
  • Organizations managing complex software ecosystems with multiple independent applications

Main Features at a Glance​

FeatureDescription
Application MarketplaceInstall, update, and remove applications dynamically
Dependency ManagementAutomatic resolution with version constraints (HARD/SOFT dependencies)
Microfrontend LoadingModule Federation, Web Components, ESM with asset SRI verification
HTTP ProxyIntelligent routing with permission checks, rate limiting, and circuit breaking
Docker Orchestration (Plugin)Optional orchestrator that auto-deploys containers declared in manifests from registry
Horizontal ScalabilityMultiple AppServer instances synchronized via event bus
GraphQL APIReal-time queries, mutations, and subscriptions
Event BusRabbitMQ-based pub/sub for cross-application events and state synchronization
Settings EncryptionAES-256-GCM encryption for sensitive configuration
Permission SystemOpenFGA relation-based access control with permission declarations
Certificate ManagementX.509 certificate-based app authentication with replay protection
ObservabilityBuilt-in metrics, logs, and traces with OpenTelemetry

Next Steps​

Ready to get started?

Easy AppServer v2 represents a complete rewrite focused on scalability, developer experience, and modern cloud-native patterns. Join us in building the next generation of modular enterprise software.