Skip to Content
Engineering11 Documentation 🔥
FoundationArchitecture

Architectural Philosophy

Why This Scales

The Engineering11 Full-Stack Foundation is not a loose collection of services. It is a deliberately designed system with consistent architecture and design patterns applied across the entire platform.

More than a starting point: The Foundation delivers an opinionated foundation and operating model that large enterprises can modernize or replatform onto, preserving speed while enforcing consistency, governance, and architectural cohesion across teams.

Core Architectural Principles

Built for Scale from Day One

  • Clear separation of concerns by domain, rather than a single monolithic application
  • Core capabilities are modeled as independent domains, each with its own backend service and corresponding UI or SDK surface
  • This allows features, ownership, and complexity to scale independently without cross-cutting rewrites

Benefits:

  • Teams can work on different domains without blocking each other
  • Services scale independently based on demand
  • Failures are isolated to specific domains
  • New features don’t require refactoring the entire system

One Architecture, Not Two

  • The same architecture and service patterns used by the E11 platform are used for customer-built services
  • There are no special internal frameworks or exceptions
  • Custom services look, behave, deploy, and scale the same way as the foundation services

Benefits:

  • Reduced cognitive load for engineers
  • Consistent testing and deployment strategies
  • Easier code reviews and onboarding
  • Clear expectations and patterns

Designed for Change (Including AI)

  • AI and automation are incorporated as part of the architecture, not layered on later
  • Eventing, background jobs, and enrichment workflows are first-class patterns
  • This enables AI capabilities to be added incrementally without disrupting core systems or product workflows

Benefits:

  • Add AI features without architectural rewrites
  • Event-driven workflows support async AI processing
  • Natural backpressure and retry mechanisms
  • AI costs and latency don’t block user workflows

Reduced Cognitive Load for Engineers

  • Consistent architecture, naming, and patterns across services significantly reduce mental overhead
  • Engineers do not need to relearn how systems work as they move between domains
  • This leads to faster onboarding, fewer errors, and sustained developer velocity as systems grow

Benefits:

  • New engineers productive faster
  • Fewer bugs from misunderstanding patterns
  • Easier to debug and trace issues
  • Higher engineering satisfaction and retention

Why This Matters

Avoid Rewrites from Architectural Shortcuts

Many platforms hit inflection points where early decisions force expensive rewrites:

  • “We didn’t design for multi-tenancy”
  • “Our monolith can’t scale to the next tier”
  • “We need to rearchitect for AI”
  • “Our initial tech choices don’t support our growth”

The Foundation makes these architectural decisions correctly from day one, eliminating the need for costly rewrites later.

Engineers Focus on Problem-Solving

When engineers don’t have to make foundational infrastructure decisions, they can focus on:

  • Product differentiation
  • Customer workflows
  • Business logic
  • Domain-specific optimizations

Result: Higher velocity, better outcomes, and more satisfied engineers.

Products Evolve Without Accumulating Debt

The Foundation’s consistent patterns and production-grade architecture mean that:

  • New features integrate cleanly with existing systems
  • Technical debt doesn’t compound over time
  • Refactoring is straightforward and localized
  • Long-term maintenance remains manageable

Enterprises Get Alignment and Governance

For large organizations modernizing or replatforming:

  • Consistent patterns align teams around shared practices
  • Clear boundaries enable autonomous team operation
  • Governance is built into the architecture
  • Delivery velocity is sustained across the organization

The Result

A foundation where teams can:

  • Start fast - No months of foundational work
  • Scale confidently - Architecture grows with demand
  • Continue delivering - Sustained velocity over time
  • Adapt to change - AI, new integrations, and pivots are natural

Architectural Patterns

The Foundation implements proven architectural patterns:

Microservices Architecture

  • Domain-driven service boundaries
  • Independent deployment and scaling
  • Clear contracts and versioning
  • Service-to-service communication

Explore Backend Architecture →

Event-Driven Workflows

  • Pub/Sub messaging for async communication
  • Event sourcing for audit and replay
  • Decoupled producers and consumers
  • Natural support for AI enrichment pipelines

Repository Pattern

  • Consistent data access across services
  • Abstraction over storage implementations
  • Testable business logic
  • Easy migration between data stores

Multi-Tenancy

  • Data isolation at every layer
  • Tenant context in all requests
  • White-label provisioning
  • Secure cross-tenant boundaries

API-First Design

  • Well-documented REST APIs
  • Generated TypeScript clients
  • Versioning for backward compatibility
  • Clear contracts between frontend and backend

Technology Stack

Backend Technologies

Runtime & Language:

  • Node.js
  • TypeScript for type safety
  • ES Modules

Framework:

  • NestJS for REST APIs and dependency injection
  • Express as HTTP server
  • CQRS module for event-driven workflows

Data Stores:

  • Firestore for document storage
  • SQL for relational data
  • Redis for caching and sessions
  • Cloud Storage for files

Messaging & Events:

  • Google Pub/Sub for async messaging
  • Cloud Tasks for queued workflows
  • Cloud Scheduler for cron jobs

Authentication & Security:

  • Google Identity Platform
  • JWT tokens
  • Google IAM for service-to-service auth
  • Cloud Secret Manager for secrets

Modern Development Tooling

Engineering11 systems use modern tooling to improve the developer experience:

Monorepo Management:

  • Yarn workspaces for dependency management
  • Nx for build orchestration and caching
  • Release Please for automated versioning and changelogs

Quality & Testing:

  • Jest for unit and integration tests
  • Supertest for API testing
  • gts (Google TypeScript Style) for linting and formatting
  • Husky + lint-staged for pre-commit hooks
  • Commitlint for conventional commits

Development Environment:

  • Docker for containerization
  • Docker Compose for local orchestration
  • Hot reload for rapid iteration

Infrastructure

Cloud Platform:

  • Google Cloud Platform (GCP)
  • Cloud Run for container deployment
  • Kubernetes Engine for advanced orchestration

Deployment:

  • Terraform for Infrastructure as Code
  • Cloud Build for CI/CD pipelines
  • Multi-environment strategy (dev, CI, QA, stage, prod)

Observability:

  • Cloud Logging (structured logs)
  • Cloud Monitoring (metrics and alerting)
  • Cloud Trace (distributed tracing)
  • Error Reporting for exception tracking

Frontend:

  • React, Angular, React Native, Flutter
  • TypeScript
  • Server-side rendering support

Next Steps

Last updated on
OverviewGetting Started