Skip to Content
Engineering11 Documentation 🔥
FoundationGetting Started

Getting Started with the Engineering11 Full-Stack Foundation

Overview

This guide will help you understand how to begin working with the Engineering11 Full-Stack Foundation, whether you’re evaluating it for your organization or preparing to build on top of it.

Evaluation Phase

If you’re evaluating the Foundation for your organization, follow one of the guided journeys based on your role:

For Engineering Leaders

Developer Experience Journey

  • See hands-on implementation patterns
  • Understand day-to-day developer workflows
  • Explore code examples and service structure

For Technical Leadership

Technical Architecture Journey

  • Validate architectural soundness
  • Understand scalability and security patterns
  • Review operational maturity

For Product Leadership

Product Velocity Journey

  • Understand time-to-market benefits
  • See what’s built vs. what you still own
  • Learn how this prevents future rewrites

For Executive Leadership

Business Impact Journey

  • Understand ROI and cost efficiency
  • Review risk mitigation strategies
  • See competitive advantages

Onboarding Phase

Once you’ve decided to work with Engineering11, here’s what to expect:

Step 1: Infrastructure Provisioning

Engineering11 will work with your team to:

  1. Define your environments:

    • Development (dev)
    • Continuous Integration (CI)
    • Quality Assurance (QA)
    • Staging (stage)
    • Production (prod)

  2. Provision cloud infrastructure:

    • Google Cloud Project setup
    • Identity and Access Management (IAM)
    • Networking and security
    • Resource allocation

  3. Deploy the foundation:

    • 20+ platform microservices
    • CI/CD pipelines
    • Monitoring and observability
    • Configuration and secrets management

Timeline: Typically 1-2 weeks

Step 2: Repository Access

Your engineering team will receive access to:

  1. Backend repository:

    • Platform microservices
    • Server API packages
    • Shared libraries and utilities
    • Infrastructure as Code

  2. Frontend repositories:

    • Seed applications for each framework
    • Shared component libraries
    • SDK packages
    • Configuration and theming

  3. Documentation repository:

    • Operational runbooks
    • Architecture decision records
    • Development guides
    • Deployment procedures

Step 3: Team Onboarding

Engineering11 provides onboarding sessions covering:

  1. Architecture Overview:

    • System design and patterns
    • Service boundaries and responsibilities
    • Communication patterns (sync vs. async)

  2. Development Workflow:

    • Local development environment setup
    • Building and testing services
    • Deployment process
    • Debugging and observability tools

  3. Platform Services Deep Dive:

    • Available microservices and their capabilities
    • Server API packages and how to use them
    • Integration patterns

  4. Frontend Development:

    • Seed app structure
    • SDK usage and best practices
    • Theming and customization
    • State management patterns

Timeline: 1-2 weeks

Development Phase

Building Your First Custom Service

  1. Choose your domain:

    • Identify a product-specific domain (e.g., “Inventory”, “Scheduling”, “Recommendations”)
    • Define the service boundaries and responsibilities

  2. Scaffold the service:

    • Use the E11 service template
    • Follow the standard microservice anatomy
    • Set up local development environment

  3. Implement core functionality:

    • Define domain models
    • Implement repository pattern for data access
    • Create REST endpoints for clients
    • Add background jobs for async workflows

  4. Integration:

    • Install needed E11 server API packages
    • Call platform services (auth, user, notifications)
    • Publish events for other services to consume

  5. Testing:

    • Write unit tests for business logic
    • Add integration tests for API endpoints
    • Test async workflows end-to-end

  6. Deployment:

    • Push code to repository
    • CI pipeline runs tests and builds container
    • Deploy to dev environment
    • Promote through QA → stage → prod

See Microservice Implementation Guide →

Building Your Frontend Application

  1. Choose a seed app:

    • React, Angular, React Native, or Flutter
    • Based on your target platform (web, mobile)

  2. Customize the foundation:

    • Update branding and theming
    • Configure routing for your workflows
    • Set up authentication flows

  3. Build product features:

    • Create pages and components
    • Integrate with backend APIs using SDKs
    • Handle state management
    • Add error handling and loading states

  4. Testing & Deployment:

    • Write component and integration tests
    • Deploy to dev environment
    • Test across devices and browsers
    • Promote to production

Learn more about Frontend Development →

Development Environment Setup

Prerequisites

  • Node.js 18.x or later
  • Yarn 1.22.x or later
  • Docker and Docker Compose
  • Google Cloud SDK (gcloud CLI)
  • Git

Local Development

  1. Clone repositories:

    git clone [backend-repo-url]
git clone [frontend-repo-url]

  2. Install dependencies:

    cd backend
yarn install
 
cd frontend
yarn install

  3. Configure environment:

    # Copy example environment files
cp .env.example .env
 
# Update with your local configuration
# (Engineering11 will provide values)

  4. Start local services:

    # Start all services with Docker Compose
docker-compose up
 
# Or start individual services
yarn dev:service-user

  5. Verify setup:

    # Check service health
curl http://localhost:8080/health
 
# Run tests
yarn test

Common Development Tasks

Running Tests

# Run all tests
yarn test
 
# Run tests for a specific service
yarn test service-user
 
# Run in watch mode
yarn test:watch
 
# Run with coverage
yarn test:coverage

Building Services

# Build all services
yarn build
 
# Build a specific service
yarn build service-user
 
# Build for production
yarn build:prod

Deploying Changes

# Deploy to dev environment
./deploy-dev.sh
 
# Deploy specific service
./deploy-dev.sh service-user
 
# Deploy to staging
./deploy-stage.sh
 
# Production deployment (requires approval)
./deploy-prod.sh

Viewing Logs

# Stream logs from dev environment
gcloud logs tail --project=your-dev-project
 
# Filter by service
gcloud logs tail --project=your-dev-project --filter="resource.labels.service_name=service-user"
 
# View in Cloud Console
# (Engineering11 will provide dashboard links)

Getting Help

Documentation Resources

Engineering11 Support

  • Slack Channel: Real-time support from the E11 team
  • Weekly Office Hours: Q&A sessions with E11 engineers
  • GitHub Issues: Bug reports and feature requests
  • Pull Request Reviews: Feedback on your contributions

Community

  • Contribution Guidelines: How to submit improvements
  • Architecture Decision Records: Context for design choices
  • Best Practices: Patterns and conventions

Next Steps

  1. Explore the platform:

  2. Plan your first custom service:

    • Define the domain and responsibilities
    • Identify platform services you’ll integrate with
    • Outline your data models and API contracts

  3. Set up your development environment:

    • Follow the local setup guide above
    • Run the test suite to verify everything works
    • Deploy a small change to dev to test the workflow

  4. Join the community:

    • Connect on Slack for real-time support
    • Attend office hours to ask questions
    • Review pull requests to learn from others
Last updated on
ArchitectureOverview