Developer Experience Journey

Overview

This journey is designed for engineering professionals who want to understand the hands-on developer experience of building with Engineering11. We'll explore implementation details, coding practices, and the day-to-day workflows that make engineering productive and predictable.

Role: Engineering Lead / Senior Engineer

Focus: “Show me the developer experience and how I'd actually build.”

What You’ll Learn

How microservices are structured and implemented
The patterns and conventions that reduce cognitive load
How custom services integrate with platform services
The development workflow and tooling experience
Real code examples and implementation patterns

Journey Steps

Understanding the Foundation Structure

Engineering11 provides a complete backend foundation with 20+ production microservices covering core platform domains. These aren't black boxes — they follow the exact same patterns you'll use for your custom services.

Key Concepts:

All services (platform and custom) live side by side
Same structure, same patterns, same deployment workflows
No special "internal" frameworks or exceptions

Explore Backend Architecture

Microservice Anatomy

Every Engineering11 microservice follows a consistent structure with a finite set of well-defined parts:

Server APIs - Published packages for service-to-service integration
IPC REST APIs - Internal service communication endpoints
REST APIs - Client-facing endpoints
Background Jobs - Async processing and long-running tasks
Task Handlers - Queue-based workflow processors
Shared Libraries - Full-stack reusable utilities
Migrations - Database evolution scripts

This consistency means:

Reduced cognitive load when moving between services
Predictable testing strategies
Clear ownership boundaries
Faster onboarding for new team members

See Microservice Implementation Guide

Building a Custom Service

Let's look at how you'd build a custom microservice on top of Engineering11.

Your service uses the same building blocks as platform services:

// Example: Your custom service structure
my-service/
├── src/
│   ├── server-api/         // Shared with other services
│   ├── rest/               // Client-facing endpoints
│   ├── ipc-rest/           // Service-to-service endpoints
│   ├── background-jobs/    // Async processing
│   └── migrations/         // Database evolution
├── tests/
└── package.json

Development Workflow:

Define your domain models and repositories
Implement your business logic
Expose REST endpoints for clients
Add background jobs for async workflows
Deploy using the same CI/CD pipeline

Explore Available Platform Services

Frontend Integration

Engineering11 provides frontend SDKs for Angular, React, React Native, and Flutter.

Your frontend applications:

Are built from E11 seed apps with pre-configured auth, routing, and state management
Use generated TypeScript clients for type-safe API calls
Follow established patterns for theming and component architecture
Include built-in observability and error handling

Learn About Frontend Development

Development Tools & Workflow

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

Result: Engineers spend time building features, not fighting tooling.

What Makes This Different

1. One Architecture, Not Two

The same patterns used for platform services are used for your custom services. No framework exceptions or special cases to learn.

2. Reduced Cognitive Load

Consistency across services means less mental overhead. Once you understand one service, you understand them all.

3. AI-Ready from Day One

Event-driven architecture and background job patterns make AI integration natural, not an afterthought.

4. Full Visibility & Control

All code is accessible. You're not locked into black-box abstractions. Fork, modify, and contribute as needed.

Next Steps

Ready to dive deeper?

Explore Backend MicroservicesSee the 20+ platform services available

Review Server APIsUnderstand the building blocks you'll use

Frontend DocumentationLearn about client-side development

Want a different perspective?

Try the Technical Architecture Journey to see how this scales.