Example: User logs into an e-commerce website

1. User Action: Enters email/password and clicks "Login"
2. Frontend: JavaScript captures form data, validates input, sends POST request to /api/login with JSON credentials
3. DNS Resolution: Browser resolves domain to IP address
4. Web Server (Nginx/Apache):
   • Accepts TCP connection on port 80/443
   • Terminates SSL/TLS if HTTPS
   • Parses HTTP request headers
   • Routes to appropriate handler (PHP-FPM, Node.js, etc.)
5. Application Server:
   • Routes to login controller
   • Extracts credentials from request body
   • Hashes password for comparison
6. Database Query:
   • SELECT * FROM users WHERE email = ?
   • Database executes query, returns user record
   • Application compares password hash
7. Session Management:
   • Creates session record in database or Redis
   • Generates session ID or JWT token
   • Sets cookie in response headers
8. Response Formation:
   • Application creates JSON response with user data
   • Sets appropriate HTTP status code (200 OK)
9. Web Server Response: Sends HTTP response back to client
10. Frontend Handling: JavaScript receives response, updates UI, redirects to dashboard

Example Frameworks: Laravel, Django, Ruby on Rails, Spring MVC

Components communicate through events:

• Event Producers: Generate events (user registered, order placed)
• Event Consumers: React to events (send email, update inventory)
• Message Broker: RabbitMQ, Kafka, AWS SQS

Benefits: Loose coupling, scalability, asynchronous processing

Use Cases: Notification systems, data pipelines, microservices

Core business logic isolated from external concerns:

• Core Domain: Business logic, entities, use cases
• Ports: Interfaces for input/output
• Adapters: Implementations (web, database, external APIs)

Benefits: Testability, framework independence, maintainability

Best For:

Web applications, CMS, E-commerce, SaaS products

Companies Using:

Facebook (Hack), Wikipedia, Slack (parts), Etsy

Best For:

Web applications, Data science APIs, ML services, Automation

Companies Using:

Instagram, YouTube, Spotify, Dropbox, Reddit

Best For:

Enterprise applications, Banking systems, Large-scale web apps

Companies Using:

Netflix, Amazon, LinkedIn, Twitter (originally), eBay

Best For:

Real-time applications, APIs, Streaming services, Microservices

Companies Using:

Netflix, Uber, LinkedIn, PayPal, Walmart

Best For:

Microservices, Cloud services, DevOps tools, Network applications

Companies Using:

Google, Uber, Twitch, Dropbox, Docker, Kubernetes

Best For:

Startups, MVPs, Web applications, E-commerce

Companies Using:

GitHub, Shopify, Airbnb (initially), Basecamp

Best For:

High-performance systems, WebAssembly, Embedded, Game engines

Companies Using:

Mozilla, Dropbox, Figma, Discord, Cloudflare

Best For:

Enterprise applications, Windows apps, Game development (Unity)

Companies Using:

Microsoft, Stack Overflow, GoDaddy, Intel, Dell

Laravel is the most popular PHP framework, known for its elegant syntax, expressive code, and powerful features. Created by Taylor Otwell in 2011, it has revolutionized PHP development by bringing modern programming practices to the PHP ecosystem.

Models in Laravel represent database tables and provide an elegant interface for interacting with your data.

Model Structure and Configuration:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Notifications\Notifiable;

class Post extends Model
{
    use SoftDeletes, Notifiable;
    
    // Table name (optional - Laravel uses plural of class name)
    protected $table = 'blog_posts';
    
    // Primary key (default: 'id')
    protected $primaryKey = 'post_id';
    
    // Incrementing (default: true)
    public $incrementing = true;
    
    // Key type (default: 'int')
    protected $keyType = 'int';
    
    // Timestamps (default: true)
    public $timestamps = true;
    
    // Date format for serialization
    protected $dateFormat = 'Y-m-d H:i:s';
    
    // Connection name for multiple databases
    protected $connection = 'mysql';
    
    // Fillable attributes (mass assignment allowed)
    protected $fillable = [
        'title', 'content', 'slug', 'user_id', 'published_at'
    ];
    
    // Guarded attributes (mass assignment protected)
    protected $guarded = ['id', 'created_at', 'updated_at'];
    
    // Hidden attributes (excluded from JSON)
    protected $hidden = ['deleted_at'];
    
    // Casts - attribute type conversion
    protected $casts = [
        'published_at' => 'datetime',
        'metadata' => 'array',
        'is_published' => 'boolean',
        'view_count' => 'integer'
    ];
    
    // Date attributes
    protected $dates = [
        'deleted_at',
        'published_at',
        'created_at',
        'updated_at'
    ];
    
    // Relationships
    public function author()
    {
        return $this->belongsTo(User::class, 'user_id');
    }
    
    public function comments()
    {
        return $this->hasMany(Comment::class);
    }
    
    public function tags()
    {
        return $this->belongsToMany(Tag::class)
                    ->withTimestamps()
                    ->withPivot('order');
    }
    
    // Accessors
    public function getExcerptAttribute()
    {
        return substr(strip_tags($this->content), 0, 200) . '...';
    }
    
    public function getUrlAttribute()
    {
        return route('posts.show', $this->slug);
    }
    
    // Mutators
    public function setTitleAttribute($value)
    {
        $this->attributes['title'] = $value;
        $this->attributes['slug'] = Str::slug($value);
    }
    
    // Query Scopes
    public function scopePublished($query)
    {
        return $query->whereNotNull('published_at')
                     ->where('published_at', '<=', now());
    }
    
    public function scopeByAuthor($query, $userId)
    {
        return $query->where('user_id', $userId);
    }
    
    public function scopePopular($query)
    {
        return $query->orderBy('view_count', 'desc');
    }
    
    // Custom methods
    public function publish()
    {
        $this->update(['published_at' => now()]);
    }
    
    public function unpublish()
    {
        $this->update(['published_at' => null]);
    }
    
    public function incrementViews()
    {
        $this->increment('view_count');
    }
}

Advanced Model Features:

• Global Scopes: Apply constraints to all queries for a model
• Local Scopes: Reusable query constraints
• Observers: Group model event listeners
• Events: Fired during model lifecycle (retrieved, creating, created, updating, updated, saving, saved, deleting, deleted, restoring, restored)
• Polymorphic Relations: Model can belong to multiple other models
• Has-One-Through / Has-Many-Through: Distant relations
• Eloquent Collections: Enhanced collections with model-specific methods
• Serialization: toArray(), toJson(), API resources

Blade is Laravel's powerful templating engine that compiles views into plain PHP code for optimal performance.

Blade Directives Reference:

Blade Components (Modern Approach):

<!-- Create component -->
php artisan make:component Alert

<!-- app/View/Components/Alert.php -->
namespace App\View\Components;

use Illuminate\View\Component;

class Alert extends Component
{
    public $type;
    public $message;
    
    public function __construct($type = 'info', $message)
    {
        $this->type = $type;
        $this->message = $message;
    }
    
    public function render()
    {
        return view('components.alert');
    }
}

<!-- resources/views/components/alert.blade.php -->
<div class="alert alert-{{ $type }}" role="alert">
    {{ $message }}
    {{ $slot }}
</div>

<!-- Usage -->
<x-alert type="success" message="Operation successful" />

<!-- With slot -->
<x-alert type="warning">
    <strong>Warning!</strong> Please check your input.
</x-alert>

Blade Stacks and Pushes:

<!-- Layout -->
<head>
    @stack('styles')
</head>
<body>
    @yield('content')
    @stack('scripts')
</body>

<!-- Child view -->
@push('styles')
    <link href="/css/page.css" rel="stylesheet">
@endpush

@push('scripts')
    <script src="/js/page.js"></script>
@endpush

@prepend('scripts')
    <script>window.pageData = @json($data);</script>
@endprepend

Controllers group related request handling logic into a single class.

Types of Controllers:

• Basic Controllers: Simple class with methods for routes
• Resource Controllers: Pre-defined CRUD methods
• API Resource Controllers: Resource controllers without create/edit views
• Single Action Controllers: Controllers with single __invoke method

Complete Resource Controller Example:

<?php

namespace App\Http\Controllers;

use App\Models\Post;
use Illuminate\Http\Request;
use App\Http\Requests\PostRequest;
use App\Http\Resources\PostResource;

class PostController extends Controller
{
    public function __construct()
    {
        $this->middleware('auth')->except(['index', 'show']);
        $this->authorizeResource(Post::class, 'post');
    }
    
    /**
     * Display a listing of the resource.
     */
    public function index()
    {
        $posts = Post::with('author')
                    ->published()
                    ->latest()
                    ->paginate(15);
        
        return view('posts.index', compact('posts'));
    }
    
    /**
     * Show the form for creating a new resource.
     */
    public function create()
    {
        return view('posts.create');
    }
    
    /**
     * Store a newly created resource in storage.
     */
    public function store(PostRequest $request)
    {
        $validated = $request->validated();
        
        $post = $request->user()->posts()->create($validated);
        
        if ($request->has('tags')) {
            $post->tags()->sync($request->tags);
        }
        
        return redirect()->route('posts.show', $post)
                        ->with('success', 'Post created successfully!');
    }
    
    /**
     * Display the specified resource.
     */
    public function show(Post $post)
    {
        $this->authorize('view', $post);
        
        $post->load('author', 'comments.user', 'tags');
        $post->incrementViews();
        
        return view('posts.show', compact('post'));
    }
    
    /**
     * Show the form for editing the specified resource.
     */
    public function edit(Post $post)
    {
        $this->authorize('update', $post);
        
        return view('posts.edit', compact('post'));
    }
    
    /**
     * Update the specified resource in storage.
     */
    public function update(PostRequest $request, Post $post)
    {
        $this->authorize('update', $post);
        
        $validated = $request->validated();
        
        $post->update($validated);
        
        if ($request->has('tags')) {
            $post->tags()->sync($request->tags);
        }
        
        return redirect()->route('posts.show', $post)
                        ->with('success', 'Post updated successfully!');
    }
    
    /**
     * Remove the specified resource from storage.
     */
    public function destroy(Post $post)
    {
        $this->authorize('delete', $post);
        
        $post->delete();
        
        return redirect()->route('posts.index')
                        ->with('success', 'Post deleted successfully!');
    }
    
    /**
     * API endpoint for posts.
     */
    public function apiIndex()
    {
        return PostResource::collection(Post::paginate());
    }
}

Route Definitions:

<!-- routes/web.php -->
// Resource routes (all CRUD routes)
Route::resource('posts', PostController::class);

// Only specific actions
Route::resource('posts', PostController::class)->only(['index', 'show']);

// Except specific actions
Route::resource('posts', PostController::class)->except(['destroy']);

// API routes (no create/edit forms)
Route::apiResource('posts', PostController::class);

// Nested resources
Route::resource('users.posts', PostController::class);

// Custom routes with resource
Route::resource('posts', PostController::class)->names([
    'index' => 'posts.all',
    'show' => 'posts.view'
]);

Laravel's routing system maps URLs to controller actions or closures.

Route Files:

• web.php: Routes with session, CSRF, cookies (for browser requests)
• api.php: Stateless routes, API authentication, rate limiting
• console.php: Artisan commands
• channels.php: Broadcasting channels

Route Definition Examples:

<!-- Basic Routes -->
Route::get('/', function () {
    return view('welcome');
});

Route::post('/login', [AuthController::class, 'login']);

<!-- Route Parameters -->
Route::get('/posts/{id}', function ($id) {
    return Post::find($id);
});

Route::get('/posts/{post}', function (Post $post) {
    return $post; // Route model binding
});

<!-- Optional Parameters -->
Route::get('/user/{name?}', function ($name = 'Guest') {
    return "Hello $name";
});

<!-- Regular Expression Constraints -->
Route::get('/user/{id}', function ($id) {
    //
})->where('id', '[0-9]+');

Route::get('/category/{category}', function ($category) {
    //
})->whereIn('category', ['tech', 'sports', 'news']);

<!-- Named Routes -->
Route::get('/profile', [ProfileController::class, 'show'])->name('profile');

// Generate URL
$url = route('profile');

// Redirect
return redirect()->route('profile');

<!-- Route Groups -->
Route::prefix('admin')->group(function () {
    Route::get('/dashboard', [AdminController::class, 'dashboard']);
    Route::get('/users', [AdminController::class, 'users']);
});

Route::middleware(['auth', 'verified'])->group(function () {
    Route::get('/dashboard', [DashboardController::class, 'index']);
    Route::resource('posts', PostController::class);
});

Route::namespace('Admin')->group(function () {
    // Controllers assumed in "App\Http\Controllers\Admin"
    Route::get('/users', 'UserController@index');
});

<!-- Route Model Binding -->
Route::get('/posts/{post:slug}', function (Post $post) {
    // Uses slug instead of id
    return $post;
});

<!-- Fallback Route -->
Route::fallback(function () {
    return response()->view('errors.404', [], 404);
});

<!-- Rate Limiting -->
Route::middleware('throttle:10,1')->group(function () {
    Route::get('/api/data', [ApiController::class, 'data']);
});

<!-- View Routes (directly return view) -->
Route::view('/about', 'pages.about');

Route Caching:

// Cache routes (production only)
php artisan route:cache

// Clear route cache
php artisan route:clear

// List all routes
php artisan route:list

// List routes with details
php artisan route:list --columns=method,uri,name,action,middleware

Laravel provides a complete, secure authentication system out of the box.

Authentication Features:

• Multiple Guards: Session-based, API tokens, JWT, Sanctum
• Password Hashing: Bcrypt, Argon2 with automatic hashing
• Password Reset: Built-in password reset flows
• Email Verification: Verify email addresses before access
• Rate Limiting: Protect against brute force attacks
• Two-Factor Authentication: Additional security layer

Quick Setup:

// Install Laravel Breeze (minimal)
composer require laravel/breeze --dev
php artisan breeze:install

// Install Laravel Jetstream (feature-rich)
composer require laravel/jetstream
php artisan jetstream:install livewire
// or
php artisan jetstream:install inertia

// Run migrations
php artisan migrate

// Install NPM dependencies
npm install && npm run dev

Custom Authentication:

<?php
// config/auth.php - Configuration
'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],
    'api' => [
        'driver' => 'sanctum',
        'provider' => 'users',
    ],
],

// Manual authentication
if (Auth::attempt(['email' => $email, 'password' => $password])) {
    return redirect()->intended('dashboard');
}

// Authentication middleware
Route::get('/dashboard', function () {
    // Only authenticated users
})->middleware('auth');

// Check authentication in views
@auth
    Welcome, {{ Auth::user()->name }}
@endauth

Laravel provides two ways to authorize actions: Gates (closures) and Policies (classes).

Gates Example:

<?php
// App\Providers\AuthServiceProvider
public function boot()
{
    Gate::define('edit-post', function (User $user, Post $post) {
        return $user->id === $post->user_id;
    });
    
    Gate::define('delete-post', function (User $user, Post $post) {
        return $user->id === $post->user_id || $user->isAdmin();
    });
}

// Usage
if (Gate::allows('edit-post', $post)) {
    // User can edit
}

if (Gate::denies('delete-post', $post)) {
    abort(403);
}

// In views
@can('edit-post', $post)
    <button>Edit</button>
@endcan

Policies Example:

<?php
// Create policy
php artisan make:policy PostPolicy --model=Post

// app/Policies/PostPolicy.php
class PostPolicy
{
    use HandlesAuthorization;
    
    public function viewAny(User $user)
    {
        return true;
    }
    
    public function view(User $user, Post $post)
    {
        return true; // Public posts
    }
    
    public function create(User $user)
    {
        return $user->hasVerifiedEmail();
    }
    
    public function update(User $user, Post $post)
    {
        return $user->id === $post->user_id;
    }
    
    public function delete(User $user, Post $post)
    {
        return $user->id === $post->user_id || $user->isAdmin();
    }
    
    public function restore(User $user, Post $post)
    {
        return $user->isAdmin();
    }
    
    public function forceDelete(User $user, Post $post)
    {
        return $user->isAdmin();
    }
}

// Usage in controller
public function update(Request $request, Post $post)
{
    $this->authorize('update', $post);
    // Update post
}

// In views
@can('update', $post)
    <a href="{{ route('posts.edit', $post) }}">Edit</a>
@endcan

Laravel queues allow you to defer time-consuming tasks for better response times.

Queue Drivers:

• Sync: Process immediately (development)
• Database: Store in database table
• Redis: Fast, persistent queue
• Beanstalkd: Simple work queue
• Amazon SQS: Cloud-based queue service
• RabbitMQ: Advanced message broker

Creating and Dispatching Jobs:

<?php
// Create job
php artisan make:job ProcessPodcast

// app/Jobs/ProcessPodcast.php
class ProcessPodcast implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
    
    protected $podcast;
    
    public function __construct(Podcast $podcast)
    {
        $this->podcast = $podcast;
    }
    
    public function handle(AudioProcessor $processor)
    {
        // Process podcast
        $processor->process($this->podcast);
        
        // Dispatch another job
        SendPodcastNotification::dispatch($this->podcast->user);
    }
    
    public function failed(\Throwable $exception)
    {
        // Handle failure
        Log::error('Podcast processing failed', ['podcast' => $this->podcast->id]);
    }
}

// Dispatch job
ProcessPodcast::dispatch($podcast);

// Delayed dispatch
ProcessPodcast::dispatch($podcast)->delay(now()->addMinutes(10));

// Dispatch after response (synchronous but after response)
ProcessPodcast::dispatchAfterResponse($podcast);

// Job middleware
public function middleware()
{
    return [new RateLimited];
}

Running Queues:

// Process queue
php artisan queue:work

// Process specific queue
php artisan queue:work --queue=high,default

// Run as daemon (production)
php artisan queue:work --daemon

// Supervisor configuration (for production)
[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /home/forge/app.com/artisan queue:work --sleep=3 --tries=3 --max-time=3600
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
user=forge
numprocs=8
redirect_stderr=true
stdout_logfile=/home/forge/app.com/worker.log
stopwaitsecs=3600

Job Batching:

// Create batch
$batch = Bus::batch([
    new ProcessPodcast($podcast1),
    new ProcessPodcast($podcast2),
    new ProcessPodcast($podcast3),
])->then(function (Batch $batch) {
    // All jobs completed
})->catch(function (Batch $batch, Throwable $e) {
    // First job failure
})->finally(function (Batch $batch) {
    // Batch finished
})->dispatch();

// Check batch status
$batch = Bus::findBatch($batchId);
$batch->progress(); // Percentage

Laravel's events provide a simple observer implementation for decoupled code.

Events and Listeners:

<?php
// Generate event and listener
php artisan make:event OrderShipped
php artisan make:listener SendShipmentNotification --event=OrderShipped

// Event class
class OrderShipped
{
    use Dispatchable, InteractsWithSockets, SerializesModels;
    
    public $order;
    
    public function __construct(Order $order)
    {
        $this->order = $order;
    }
}

// Listener class
class SendShipmentNotification
{
    public function handle(OrderShipped $event)
    {
        // Send notification
        Mail::to($event->order->user)->send(new OrderShippedMail($event->order));
    }
}

// Register in EventServiceProvider
protected $listen = [
    OrderShipped::class => [
        SendShipmentNotification::class,
        UpdateOrderStatus::class,
        LogOrderActivity::class,
    ],
];

// Dispatch event
event(new OrderShipped($order));

Event Subscribers:

<?php
class UserEventSubscriber
{
    public function handleUserLogin($event) {}
    public function handleUserLogout($event) {}
    
    public function subscribe($events)
    {
        $events->listen(
            'Illuminate\Auth\Events\Login',
            [UserEventSubscriber::class, 'handleUserLogin']
        );
        
        $events->listen(
            'Illuminate\Auth\Events\Logout',
            [UserEventSubscriber::class, 'handleUserLogout']
        );
    }
}

Laravel is built with testing in mind, providing helpers for PHPUnit and Pest.

Feature Tests:

<?php
namespace Tests\Feature;

use Tests\TestCase;
use App\Models\Post;
use App\Models\User;

class PostTest extends TestCase
{
    public function test_authenticated_user_can_create_post()
    {
        $user = User::factory()->create();
        
        $response = $this->actingAs($user)
                         ->post('/posts', [
                             'title' => 'Test Post',
                             'content' => 'Test content',
                         ]);
        
        $response->assertStatus(302);
        $this->assertDatabaseHas('posts', [
            'title' => 'Test Post',
            'user_id' => $user->id,
        ]);
    }
    
    public function test_guest_cannot_create_post()
    {
        $response = $this->post('/posts', [
            'title' => 'Test Post',
            'content' => 'Test content',
        ]);
        
        $response->assertRedirect('/login');
    }
    
    public function test_post_listing_is_paginated()
    {
        Post::factory()->count(20)->create();
        
        $response = $this->get('/posts');
        
        $response->assertStatus(200);
        $response->assertSee('pagination');
        $response->assertViewHas('posts', function ($posts) {
            return $posts->count() === 15; // Default pagination
        });
    }
}

HTTP Test Helpers:

<?php
// JSON API tests
$response = $this->json('POST', '/api/user', ['name' => 'Sally']);

$response
    ->assertStatus(201)
    ->assertJson([
        'created' => true,
    ]);

// Assert exact JSON
$response->assertExactJson([
    'name' => 'Sally',
    'email' => 'sally@example.com',
]);

// Assert JSON structure
$response->assertJsonStructure([
    'id',
    'name',
    'email',
    'created_at',
]);

// Session assertions
$response->assertSessionHas('status', 'success');
$response->assertSessionHasErrors(['email']);

Database Testing:

<?php
use Database\RefreshDatabase;

class ExampleTest extends TestCase
{
    use RefreshDatabase; // Reset database between tests
    
    public function test_database()
    {
        // Create 10 users
        User::factory()->count(10)->create();
        
        // Assert count
        $this->assertDatabaseCount('users', 10);
        
        // Assert record exists
        $this->assertDatabaseHas('users', [
            'email' => 'sally@example.com',
        ]);
        
        // Assert missing
        $this->assertDatabaseMissing('users', [
            'email' => 'missing@example.com',
        ]);
    }
}

1. Team Expertise: Does your team know PHP? Laravel's learning curve is moderate
2. Project Timeline: Laravel excels at rapid development – great for tight deadlines
3. Scalability Requirements: Laravel scales well vertically, but microservices might need different tools
4. Budget: Laravel is free, but Forge/Vapor add costs for convenience
5. Hosting Environment: Laravel runs anywhere PHP runs – shared hosting to AWS
6. Community Support: Need quick answers? Laravel has the largest PHP community
7. Long-term Maintenance: Laravel's clear conventions make maintenance easier
8. Integration Needs: Laravel has packages for almost everything
9. Security Requirements: Laravel has excellent built-in security features
10. Team Size: Laravel's conventions help large teams stay consistent

Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. Created in 2005 by Adrian Holovaty and Simon Willison while working at a newspaper, Django was built to handle the intense demands of newsroom deadlines while maintaining code quality and security.

Basic CRUD Operations:

# Create
book = Book.objects.create(
    title="Django for Beginners",
    author=author,
    price=29.99
)

# Read
book = Book.objects.get(id=1)
books = Book.objects.filter(price__lt=50)
recent = Book.objects.filter(published_date__year=2024)

# Update
book.price = 34.99
book.save()
# or
Book.objects.filter(author=author).update(price=19.99)

# Delete
book.delete()
# or
Book.objects.filter(price__lt=10).delete()

Complex Queries:

# Chaining filters
books = Book.objects.filter(
    author__name__icontains="smith"
).exclude(
    price__gte=100
).order_by('-published_date')[:10]

# Aggregations
from django.db.models import Count, Avg, Sum

stats = Book.objects.aggregate(
    total_books=Count('id'),
    avg_price=Avg('price'),
    total_value=Sum('price')
)

# Annotations
authors = Author.objects.annotate(
    book_count=Count('book'),
    avg_price=Avg('book__price')
)

# Complex lookups
from django.db.models import Q
books = Book.objects.filter(
    Q(price__lte=20) | Q(published_date__year=2024)
)

Relationships and Prefetching:

# Select related (JOIN) for foreign keys
books = Book.objects.select_related('author').all()

# Prefetch related for many-to-many
authors = Author.objects.prefetch_related('books').all()

# Custom querysets
class BookQuerySet(models.QuerySet):
    def available(self):
        return self.filter(stock__gt=0)
    
    def by_price_range(self, min_price, max_price):
        return self.filter(price__range=(min_price, max_price))

class Book(models.Model):
    # ...
    objects = BookQuerySet.as_manager()

# Usage
books = Book.objects.available().by_price_range(10, 50)

# admin.py
from django.contrib import admin
from .models import Author, Book

@admin.register(Author)
class AuthorAdmin(admin.ModelAdmin):
    list_display = ['name', 'email', 'book_count']
    list_filter = ['name']
    search_fields = ['name', 'email']
    ordering = ['name']
    
    def book_count(self, obj):
        return obj.book_set.count()
    book_count.short_description = 'Number of Books'

@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
    list_display = ['title', 'author', 'price', 'published_date']
    list_filter = ['published_date', 'author']
    search_fields = ['title', 'author__name']
    autocomplete_fields = ['author']
    date_hierarchy = 'published_date'
    fieldsets = (
        ('Book Information', {
            'fields': ('title', 'author', 'description')
        }),
        ('Pricing & Availability', {
            'fields': ('price', 'stock', 'available'),
            'classes': ('collapse',)
        }),
    )
    
    actions = ['apply_discount']
    
    def apply_discount(self, request, queryset):
        queryset.update(price=models.F('price') * 0.9)
    apply_discount.short_description = "Apply 10% discount"

The admin provides:

• Authentication and permissions
• CRUD interfaces for all models
• Search, filtering, and pagination
• Inline editing of related models
• History tracking
• Custom actions and widgets

Built-in Features:

• User model: Username, password, email, first/last name
• Permissions: Per-model add/change/delete/view permissions
• Groups: Assign permissions to groups of users
• Sessions: Anonymous and authenticated session management
• Password hashing: PBKDF2, Argon2, bcrypt support
• Email/password reset: Built-in flows with tokens

Custom User Model Example:

# models.py
from django.contrib.auth.models import AbstractUser
from django.db import models

class User(AbstractUser):
    bio = models.TextField(max_length=500, blank=True)
    birth_date = models.DateField(null=True, blank=True)
    avatar = models.ImageField(upload_to='avatars/', null=True)
    
    def __str__(self):
        return self.email

# settings.py
AUTH_USER_MODEL = 'myapp.User'

# views.py
from django.contrib.auth.decorators import login_required
from django.contrib.auth.mixins import LoginRequiredMixin

@login_required
def profile(request):
    return render(request, 'profile.html')

class DashboardView(LoginRequiredMixin, View):
    def get(self, request):
        return render(request, 'dashboard.html')

# serializers.py
from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.ModelSerializer):
    author_name = serializers.CharField(source='author.name')
    
    class Meta:
        model = Book
        fields = ['id', 'title', 'author_name', 'price', 'published_date']

# views.py
from rest_framework import viewsets
from .models import Book
from .serializers import BookSerializer

class BookViewSet(viewsets.ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    permission_classes = [IsAuthenticated]
    
    def get_queryset(self):
        return self.queryset.filter(author=self.request.user)

# urls.py
from rest_framework.routers import DefaultRouter
router = DefaultRouter()
router.register(r'books', BookViewSet)

urlpatterns = router.urls

DRF Features:

• Serialization with validation
• Authentication (Token, Session, JWT)
• Permissions and throttling
• Browsable API interface
• Viewsets and routers
• Filtering, pagination, ordering

Flask is a lightweight WSGI web application framework designed to make getting started quick and easy, with the ability to scale up to complex applications. Created by Armin Ronacher in 2010 as an April Fool's joke that became real, Flask has grown into one of the most popular Python frameworks.

# app.py - Single file application
from flask import Flask, render_template, request, jsonify

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key'

@app.route('/')
def home():
    return 'Hello, World!'

@app.route('/user/<string:username>')
def profile(username):
    return f'Hello, {username}!'

@app.route('/api/data', methods=['POST'])
def api_data():
    data = request.get_json()
    return jsonify({'received': data, 'status': 'success'})

if __name__ == '__main__':
    app.run(debug=True)

myapp/
├── run.py
├── config.py
├── requirements.txt
├── app/
│   ├── __init__.py
│   ├── models.py
│   ├── forms.py
│   ├── views/
│   │   ├── __init__.py
│   │   ├── main.py
│   │   └── auth.py
│   ├── templates/
│   │   ├── base.html
│   │   ├── index.html
│   │   └── auth/
│   │       ├── login.html
│   │       └── register.html
│   ├── static/
│   │   ├── css/
│   │   ├── js/
│   │   └── images/
│   └── extensions.py
└── tests/
    ├── __init__.py
    └── test_app.py

# app/__init__.py - Application factory pattern
from flask import Flask
from config import Config
from .extensions import db, login_manager, migrate

def create_app(config_class=Config):
    app = Flask(__name__)
    app.config.from_object(config_class)
    
    # Initialize extensions
    db.init_app(app)
    login_manager.init_app(app)
    migrate.init_app(app, db)
    
    # Register blueprints
    from .views.main import main_bp
    from .views.auth import auth_bp
    
    app.register_blueprint(main_bp)
    app.register_blueprint(auth_bp, url_prefix='/auth')
    
    return app

# app/views/main.py - Blueprint example
from flask import Blueprint, render_template

main_bp = Blueprint('main', __name__)

@main_bp.route('/')
def index():
    return render_template('index.html')

@main_bp.route('/about')
def about():
    return render_template('about.html')

# tests/test_app.py
import pytest
from app import create_app
from app.extensions import db

@pytest.fixture
def app():
    app = create_app('testing')
    with app.app_context():
        db.create_all()
        yield app
        db.drop_all()

@pytest.fixture
def client(app):
    return app.test_client()

def test_home_page(client):
    response = client.get('/')
    assert response.status_code == 200
    assert b'Welcome' in response.data

def test_user_registration(client):
    response = client.post('/auth/register', data={
        'username': 'testuser',
        'email': 'test@example.com',
        'password': 'password123',
        'confirm_password': 'password123'
    }, follow_redirects=True)
    
    assert response.status_code == 200
    assert b'Registration successful' in response.data

FastAPI is a modern, fast (high-performance) web framework for building APIs with Python 3.7+ based on standard Python type hints. Created by Sebastián Ramírez in 2018, FastAPI has quickly become one of the most popular Python frameworks due to its incredible performance, automatic documentation, and developer-friendly design.

# main.py
from fastapi import FastAPI
from typing import Optional

app = FastAPI(title="My API", version="1.0.0")

@app.get("/")
async def root():
    return {"message": "Hello World"}

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: Optional[str] = None):
    return {"item_id": item_id, "q": q}

# Run with: uvicorn main:app --reload
# Docs at: http://localhost:8000/docs

from fastapi import FastAPI
from pydantic import BaseModel, Field, EmailStr
from typing import List, Optional
from datetime import datetime

app = FastAPI()

# Request/Response Models
class Item(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    price: float = Field(..., gt=0, le=10000)
    description: Optional[str] = None
    tags: List[str] = []
    created_at: datetime = Field(default_factory=datetime.now)

class User(BaseModel):
    username: str = Field(..., min_length=3, max_length=50)
    email: EmailStr
    age: int = Field(..., ge=0, le=150)

class Order(BaseModel):
    user: User
    items: List[Item]
    total: float

@app.post("/items/")
async def create_item(item: Item):
    # Item is automatically validated
    return {"item": item, "message": "Item created"}

@app.post("/orders/")
async def create_order(order: Order):
    # Complex nested validation
    return {"order_id": 123, "total": order.total}

# Query parameters with validation
@app.get("/search/")
async def search(
    q: str = Query(..., min_length=3, max_length=50),
    page: int = Query(1, ge=1),
    limit: int = Query(10, ge=1, le=100)
):
    return {"results": [], "page": page, "limit": limit}

from fastapi import FastAPI, Depends, HTTPException
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker
from sqlalchemy import select
import databases
import sqlalchemy

# Async SQLAlchemy
DATABASE_URL = "postgresql+asyncpg://user:pass@localhost/db"

engine = create_async_engine(DATABASE_URL)
async_session = sessionmaker(engine, class_=AsyncSession)

async def get_db():
    async with async_session() as session:
        yield session

@app.get("/users/{user_id}")
async def get_user(user_id: int, db: AsyncSession = Depends(get_db)):
    result = await db.execute(
        select(User).where(User.id == user_id)
    )
    user = result.scalar_one_or_none()
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    return user

# Concurrent requests
@app.get("/items/batch/")
async def get_batch(items: List[int]):
    # Run multiple async operations concurrently
    tasks = [fetch_item(item_id) for item_id in items]
    results = await asyncio.gather(*tasks)
    return results

from fastapi import FastAPI, Depends, HTTPException, Header
from typing import Optional

app = FastAPI()

# Simple dependency
async def common_parameters(
    q: Optional[str] = None,
    skip: int = 0,
    limit: int = 100
):
    return {"q": q, "skip": skip, "limit": limit}

# Class dependency
class Pagination:
    def __init__(self, skip: int = 0, limit: int = 100):
        self.skip = skip
        self.limit = limit

# Authentication dependency
async def get_current_user(authorization: Optional[str] = Header(None)):
    if not authorization:
        raise HTTPException(status_code=401, detail="Not authenticated")
    # Validate token
    user = verify_token(authorization)
    return user

# Database session dependency
async def get_db():
    db = DatabaseSession()
    try:
        yield db
    finally:
        db.close()

# Using dependencies
@app.get("/items/")
async def list_items(
    commons: dict = Depends(common_parameters),
    user: User = Depends(get_current_user),
    db: Database = Depends(get_db)
):
    items = db.query(Item).offset(commons["skip"]).limit(commons["limit"]).all()
    return items

@app.get("/users/")
async def list_users(
    pagination: Pagination = Depends(),
    db: Database = Depends(get_db)
):
    users = db.query(User).offset(pagination.skip).limit(pagination.limit).all()
    return users

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from typing import List

app = FastAPI()

class ConnectionManager:
    def __init__(self):
        self.active_connections: List[WebSocket] = []
    
    async def connect(self, websocket: WebSocket):
        await websocket.accept()
        self.active_connections.append(websocket)
    
    def disconnect(self, websocket: WebSocket):
        self.active_connections.remove(websocket)
    
    async def send_personal_message(self, message: str, websocket: WebSocket):
        await websocket.send_text(message)
    
    async def broadcast(self, message: str):
        for connection in self.active_connections:
            await connection.send_text(message)

manager = ConnectionManager()

@app.websocket("/ws/{client_id}")
async def websocket_endpoint(websocket: WebSocket, client_id: int):
    await manager.connect(websocket)
    try:
        while True:
            data = await websocket.receive_text()
            await manager.send_personal_message(f"You wrote: {data}", websocket)
            await manager.broadcast(f"Client #{client_id} says: {data}")
    except WebSocketDisconnect:
        manager.disconnect(websocket)
        await manager.broadcast(f"Client #{client_id} left the chat")

from fastapi import FastAPI, BackgroundTasks
from typing import Dict

app = FastAPI()

def write_log(message: str):
    with open("log.txt", "a") as log:
        log.write(f"{message}\n")

def send_email(email: str, subject: str, body: str):
    # Simulate email sending
    import time
    time.sleep(5)
    print(f"Email sent to {email}")

@app.post("/send-notification/{email}")
async def send_notification(
    email: str, 
    background_tasks: BackgroundTasks
):
    background_tasks.add_task(write_log, f"Notification sent to {email}")
    background_tasks.add_task(send_email, email, "Hello", "Welcome!")
    return {"message": "Notification sent in background"}

# Heavy background tasks with Celery
from celery import Celery

celery = Celery("tasks", broker="redis://localhost:6379")

@celery.task
def process_video(video_path: str):
    # Long running task
    time.sleep(300)
    return {"status": "completed"}

@app.post("/process-video/")
async def start_processing(video_path: str):
    task = process_video.delay(video_path)
    return {"task_id": task.id, "status": "processing"}

1. Do you need an admin interface? → Django (built-in) vs Flask/FastAPI (build yourself)
2. Is it primarily an API? → FastAPI (best performance) vs Django REST Framework
3. Team size? → Large team: Django (conventions) vs Small team: Flask (flexibility)
4. Database complexity? → Complex: Django ORM vs Simple: SQLAlchemy with Flask
5. Real-time requirements? → FastAPI (async/WebSocket) vs Django Channels
6. Time to market? → Django (batteries included) vs Flask (choose components)
7. Microservices architecture? → Flask/FastAPI (lightweight) vs Django (heavy)
8. Machine learning integration? → Any Python framework works well
9. Scalability needs? → FastAPI (async) vs Django (with async in 4.0+)
10. Team's Python experience? → Beginners: Django vs Experienced: Flask/FastAPI

Express.js is the most popular Node.js framework, providing a robust set of features for web and mobile applications. Created by TJ Holowaychuk in 2010, Express has become the de facto standard for Node.js web development, serving as the foundation for countless applications and other frameworks.

Application-level Middleware:

const express = require('express');
const app = express();

// Logger middleware - runs for every request
app.use((req, res, next) => {
    console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`);
    next(); // Pass control to next middleware
});

// Parse JSON bodies - built-in middleware
app.use(express.json());

// Parse URL-encoded bodies
app.use(express.urlencoded({ extended: true }));

// Serve static files
app.use('/static', express.static('public'));

// Route-specific middleware
app.use('/api', (req, res, next) => {
    req.apiRequest = true;
    next();
});

Router-level Middleware:

const router = express.Router();

// Authentication middleware for specific routes
const authenticate = (req, res, next) => {
    const token = req.headers['authorization'];
    if (!token) {
        return res.status(401).json({ error: 'No token provided' });
    }
    
    jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => {
        if (err) {
            return res.status(403).json({ error: 'Invalid token' });
        }
        req.user = decoded;
        next();
    });
};

// Apply authentication to all routes in this router
router.use('/protected', authenticate);

// Route handlers
router.get('/protected/profile', (req, res) => {
    res.json({ user: req.user });
});

Error-handling Middleware:

// Error-handling middleware (must have 4 parameters)
app.use((err, req, res, next) => {
    console.error(err.stack);
    
    // Log to error tracking service
    errorTracker.captureException(err);
    
    res.status(err.status || 500).json({
        error: {
            message: err.message || 'Internal Server Error',
            ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
        }
    });
});

// 404 handler - must be after all routes
app.use((req, res) => {
    res.status(404).json({ error: 'Route not found' });
});

Third-party Middleware Examples:

const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');
const compression = require('compression');
const rateLimit = require('express-rate-limit');
const session = require('express-session');
const RedisStore = require('connect-redis')(session);

const app = express();

// Security middleware
app.use(helmet()); // Sets various HTTP headers for security

// CORS middleware
app.use(cors({
    origin: ['https://example.com', 'https://api.example.com'],
    credentials: true
}));

// Logging middleware
app.use(morgan('combined')); // Apache combined log format

// Compression middleware
app.use(compression()); // Gzip compression for responses

// Rate limiting
const limiter = rateLimit({
    windowMs: 15 * 60 * 1000, // 15 minutes
    max: 100, // Limit each IP to 100 requests per windowMs
    message: 'Too many requests from this IP'
});
app.use('/api', limiter);

// Session middleware with Redis
app.use(session({
    store: new RedisStore({ client: redisClient }),
    secret: process.env.SESSION_SECRET,
    resave: false,
    saveUninitialized: false,
    cookie: {
        secure: process.env.NODE_ENV === 'production',
        httpOnly: true,
        maxAge: 1000 * 60 * 60 * 24 // 24 hours
    }
}));

Basic Routing:

const express = require('express');
const app = express();

// Route methods
app.get('/users', getUsers);
app.post('/users', createUser);
app.put('/users/:id', updateUser);
app.delete('/users/:id', deleteUser);
app.patch('/users/:id', partialUpdate);
app.options('/users/:id', cors); // Preflight requests
app.all('/webhook', verifySignature); // All HTTP methods

// Route parameters
app.get('/users/:userId/posts/:postId', (req, res) => {
    const { userId, postId } = req.params;
    // Access userId and postId
});

// Query parameters
app.get('/search', (req, res) => {
    const { q, page = 1, limit = 10 } = req.query;
    // Search with query string ?q=javascript&page=2&limit=20
});

Route Patterns and Regular Expressions:

// Route patterns with ?
app.get('/users?', (req, res) => {
    // Matches '/user' and '/users'
});

// Route patterns with +
app.get('/ab+cd', (req, res) => {
    // Matches abcd, abbcd, abbbcd, etc.
});

// Route patterns with *
app.get('/ab*cd', (req, res) => {
    // Matches abcd, abxcd, abRANDOMcd, etc.
});

// Route with regex
app.get(/.*fly$/, (req, res) => {
    // Matches butterfly, dragonfly, but not butterflyman
});

// Route with validation
app.get('/users/:userId(\\d+)', (req, res) => {
    // Only matches if userId is numeric
});

Route Chaining and Grouping:

// Route chaining
app.route('/users')
    .get(getUsers)
    .post(createUser)
    .put(updateAllUsers);

// Route groups with Router
const userRouter = express.Router();

userRouter.param('userId', (req, res, next, id) => {
    // Load user for all routes with userId parameter
    User.findById(id, (err, user) => {
        if (err) return next(err);
        if (!user) return next(new Error('User not found'));
        req.user = user;
        next();
    });
});

userRouter.get('/', getAllUsers);
userRouter.get('/:userId', getUser);
userRouter.put('/:userId', updateUser);
userRouter.delete('/:userId', deleteUser);

// Mount the router
app.use('/api/users', userRouter);

// Nested routes
const postRouter = express.Router({ mergeParams: true });
postRouter.get('/', getPostsByUser);
postRouter.post('/', createPost);

userRouter.use('/:userId/posts', postRouter);

EJS Example:

// Setup
app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'views'));

// Route
app.get('/profile/:username', async (req, res) => {
    const user = await User.findOne({ username: req.params.username });
    res.render('profile', { 
        user,
        title: `${user.username}'s Profile`,
        isAuthenticated: req.isAuthenticated()
    });
});

<!-- views/profile.ejs -->
<!DOCTYPE html>
<html>
<head>
    <title><%= title %></title>
</head>
<body>
    <h1><%= user.name %></h1>
    <p>Email: <%= user.email %></p>
    
    <% if (isAuthenticated && user.id === currentUser.id) { %>
        <a href="/profile/edit">Edit Profile</a>
    <% } %>
    
    <ul>
        <% user.posts.forEach(post => { %>
            <li><%= post.title %> - <%= post.date %></li>
        <% }); %>
    </ul>
</body>
</html>

Pug Example:

// Setup
app.set('view engine', 'pug');
app.set('views', path.join(__dirname, 'views'));

// Route
app.get('/dashboard', ensureAuthenticated, async (req, res) => {
    const stats = await getDashboardStats(req.user.id);
    res.render('dashboard', { 
        user: req.user,
        stats,
        layout: 'layouts/main'
    });
});

//- views/dashboard.pug
extends layouts/main

block content
    h1 Welcome back, #{user.name}!
    
    .stats-grid
        .stat-card
            h3 Total Posts
            p= stats.postCount
        
        .stat-card
            h3 Total Views
            p= stats.viewCount
        
        .stat-card
            h3 Comments
            p= stats.commentCount
    
    if stats.recentPosts.length
        h2 Recent Posts
        each post in stats.recentPosts
            .post-card
                h3: a(href=`/posts/${post.slug}`)= post.title
                p= post.excerpt
                small Posted on #{post.createdAt.toLocaleDateString()}

Cluster Mode for Multi-core Systems:

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
    const numCPUs = os.cpus().length;
    console.log(`Master ${process.pid} is running`);
    
    // Fork workers
    for (let i = 0; i < numCPUs; i++) {
        cluster.fork();
    }
    
    cluster.on('exit', (worker, code, signal) => {
        console.log(`Worker ${worker.process.pid} died`);
        // Replace dead worker
        cluster.fork();
    });
} else {
    // Worker processes share the same server
    const app = require('./app');
    const server = app.listen(3000);
    console.log(`Worker ${process.pid} started`);
}

Caching Strategies:

const NodeCache = require('node-cache');
const cache = new NodeCache({ stdTTL: 600 }); // 10 minutes

// Cache middleware
function cacheMiddleware(duration = 600) {
    return (req, res, next) => {
        const key = `__express__${req.originalUrl}`;
        const cachedResponse = cache.get(key);
        
        if (cachedResponse) {
            res.send(cachedResponse);
            return;
        }
        
        // Override res.send to cache the response
        const originalSend = res.send;
        res.send = function(body) {
            cache.set(key, body, duration);
            originalSend.call(this, body);
        };
        
        next();
    };
}

// Redis caching example
const redis = require('redis');
const client = redis.createClient();

async function getOrSetCache(key, cb) {
    return new Promise(async (resolve, reject) => {
        const cached = await client.get(key);
        
        if (cached !== null) {
            return resolve(JSON.parse(cached));
        }
        
        const freshData = await cb();
        client.setex(key, 3600, JSON.stringify(freshData));
        resolve(freshData);
    });
}

// Usage in route
app.get('/api/posts', async (req, res) => {
    try {
        const posts = await getOrSetCache('posts:all', async () => {
            return await Post.find().populate('author').lean();
        });
        res.json(posts);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

NestJS is a progressive framework for building efficient, reliable, and scalable server-side applications. Created by Kamil Mysliwiec in 2017, NestJS brings a modular architecture inspired by Angular to the Node.js ecosystem, providing structure and maintainability for large-scale applications.

NestJS has a sophisticated dependency injection system that manages object creation and lifecycle.

Constructor-based Injection:

@Injectable()
export class AuthService {
    constructor(
        private userService: UserService,
        private jwtService: JwtService,
        @Inject('CONFIG') private config: ConfigType
    ) {}
    
    async validateUser(username: string, password: string) {
        const user = await this.userService.findByUsername(username);
        if (user && user.password === password) {
            const { password, ...result } = user;
            return result;
        }
        return null;
    }
    
    async login(user: any) {
        const payload = { username: user.username, sub: user.userId };
        return {
            access_token: this.jwtService.sign(payload, {
                secret: this.config.jwtSecret
            })
        };
    }
}

Custom Providers:

// Value provider
const configProvider = {
    provide: 'CONFIG',
    useValue: {
        apiUrl: process.env.API_URL,
        jwtSecret: process.env.JWT_SECRET
    }
};

// Factory provider
const databaseProvider = {
    provide: 'DATABASE_CONNECTION',
    useFactory: async (config: ConfigService) => {
        const connection = await createConnection(config.get('database'));
        return connection;
    },
    inject: [ConfigService]
};

// Class provider
const customLoggerProvider = {
    provide: Logger,
    useClass: CustomLogger
};

@Module({
    providers: [configProvider, databaseProvider, customLoggerProvider]
})
export class AppModule {}

// Entity definition
@Entity('users')
export class User {
    @PrimaryGeneratedColumn('uuid')
    id: string;
    
    @Column({ unique: true })
    email: string;
    
    @Column()
    @Exclude() // Exclude from serialization
    password: string;
    
    @Column({ nullable: true })
    firstName: string;
    
    @Column({ nullable: true })
    lastName: string;
    
    @CreateDateColumn()
    createdAt: Date;
    
    @UpdateDateColumn()
    updatedAt: Date;
    
    @OneToMany(() => Post, post => post.author)
    posts: Post[];
    
    @ManyToMany(() => Role)
    @JoinTable()
    roles: Role[];
}

// Repository pattern
@Module({
    imports: [TypeOrmModule.forFeature([User])],
    controllers: [UserController],
    providers: [UserService],
    exports: [UserService]
})
export class UserModule {}

@Injectable()
export class UserService {
    constructor(
        @InjectRepository(User)
        private userRepository: Repository<User>
    ) {}
    
    async create(createUserDto: CreateUserDto): Promise<User> {
        const user = this.userRepository.create(createUserDto);
        return this.userRepository.save(user);
    }
    
    async findWithPosts(id: string): Promise<User> {
        return this.userRepository.findOne({
            where: { id },
            relations: ['posts', 'posts.comments', 'roles'],
            order: {
                posts: {
                    createdAt: 'DESC'
                }
            }
        });
    }
    
    async updateLastLogin(id: string): Promise<void> {
        await this.userRepository.update(id, {
            lastLoginAt: new Date()
        });
    }
    
    async deleteUser(id: string): Promise<void> {
        await this.userRepository.softDelete(id);
    }
}

// server.js - Main application file
const express = require('express');
const mongoose = require('mongoose');
const helmet = require('helmet');
const compression = require('compression');
const rateLimit = require('express-rate-limit');
const { body, validationResult } = require('express-validator');

const app = express();

// Middleware
app.use(helmet());
app.use(compression());
app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true, limit: '10mb' }));

// Rate limiting
const limiter = rateLimit({
    windowMs: 15 * 60 * 1000, // 15 minutes
    max: 100, // limit each IP to 100 requests per windowMs
    message: 'Too many requests from this IP'
});
app.use('/api/', limiter);

// Database connection
mongoose.connect(process.env.MONGODB_URI, {
    useNewUrlParser: true,
    useUnifiedTopology: true
}).then(() => {
    console.log('Connected to MongoDB');
}).catch(err => {
    console.error('MongoDB connection error:', err);
    process.exit(1);
});

// Models
const userSchema = new mongoose.Schema({
    email: { type: String, required: true, unique: true, lowercase: true },
    password: { type: String, required: true, select: false },
    name: { type: String, required: true },
    role: { type: String, enum: ['user', 'admin'], default: 'user' },
    createdAt: { type: Date, default: Date.now },
    updatedAt: { type: Date, default: Date.now }
});

const User = mongoose.model('User', userSchema);

// Validation middleware
const validate = (validations) => {
    return async (req, res, next) => {
        await Promise.all(validations.map(validation => validation.run(req)));
        
        const errors = validationResult(req);
        if (errors.isEmpty()) {
            return next();
        }
        
        res.status(400).json({ errors: errors.array() });
    };
};

// Routes
const userRoutes = express.Router();

// GET /api/users - List users with pagination
userRoutes.get('/', async (req, res) => {
    try {
        const page = parseInt(req.query.page) || 1;
        const limit = parseInt(req.query.limit) || 10;
        const skip = (page - 1) * limit;
        
        const query = {};
        
        // Filtering
        if (req.query.role) {
            query.role = req.query.role;
        }
        
        if (req.query.search) {
            query.$or = [
                { name: { $regex: req.query.search, $options: 'i' } },
                { email: { $regex: req.query.search, $options: 'i' } }
            ];
        }
        
        // Sorting
        const sort = {};
        if (req.query.sortBy) {
            const parts = req.query.sortBy.split(':');
            sort[parts[0]] = parts[1] === 'desc' ? -1 : 1;
        } else {
            sort.createdAt = -1;
        }
        
        const users = await User.find(query)
            .select('-__v')
            .sort(sort)
            .skip(skip)
            .limit(limit)
            .lean();
        
        const total = await User.countDocuments(query);
        
        res.json({
            data: users,
            pagination: {
                page,
                limit,
                total,
                pages: Math.ceil(total / limit),
                hasNext: page < Math.ceil(total / limit),
                hasPrev: page > 1
            }
        });
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

// GET /api/users/:id - Get single user
userRoutes.get('/:id', async (req, res) => {
    try {
        const user = await User.findById(req.params.id).select('-__v').lean();
        
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        res.json(user);
    } catch (error) {
        if (error.kind === 'ObjectId') {
            return res.status(400).json({ error: 'Invalid user ID' });
        }
        res.status(500).json({ error: error.message });
    }
});

// POST /api/users - Create user
userRoutes.post('/', validate([
    body('email').isEmail().normalizeEmail().withMessage('Valid email required'),
    body('password').isLength({ min: 6 }).withMessage('Password must be at least 6 characters'),
    body('name').notEmpty().trim().withMessage('Name required')
]), async (req, res) => {
    try {
        // Check if user exists
        const existingUser = await User.findOne({ email: req.body.email });
        if (existingUser) {
            return res.status(400).json({ error: 'Email already registered' });
        }
        
        // Hash password
        const hashedPassword = await bcrypt.hash(req.body.password, 10);
        
        // Create user
        const user = new User({
            email: req.body.email,
            password: hashedPassword,
            name: req.body.name
        });
        
        await user.save();
        
        // Remove password from response
        const userObject = user.toObject();
        delete userObject.password;
        delete userObject.__v;
        
        res.status(201).json(userObject);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

// PUT /api/users/:id - Update user
userRoutes.put('/:id', validate([
    body('email').optional().isEmail().normalizeEmail(),
    body('name').optional().notEmpty().trim()
]), async (req, res) => {
    try {
        const updates = req.body;
        updates.updatedAt = new Date();
        
        const user = await User.findByIdAndUpdate(
            req.params.id,
            updates,
            { new: true, runValidators: true }
        ).select('-__v');
        
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        res.json(user);
    } catch (error) {
        if (error.kind === 'ObjectId') {
            return res.status(400).json({ error: 'Invalid user ID' });
        }
        res.status(500).json({ error: error.message });
    }
});

// DELETE /api/users/:id - Delete user
userRoutes.delete('/:id', async (req, res) => {
    try {
        const user = await User.findByIdAndDelete(req.params.id);
        
        if (!user) {
            return res.status(404).json({ error: 'User not found' });
        }
        
        res.json({ message: 'User deleted successfully' });
    } catch (error) {
        if (error.kind === 'ObjectId') {
            return res.status(400).json({ error: 'Invalid user ID' });
        }
        res.status(500).json({ error: error.message });
    }
});

// Mount routes
app.use('/api/users', userRoutes);

// Error handling middleware
app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).json({ error: 'Something went wrong!' });
});

// 404 handler
app.use('*', (req, res) => {
    res.status(404).json({ error: 'Route not found' });
});

// Start server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
});

// schema.graphql
type User {
    id: ID!
    email: String!
    name: String!
    posts: [Post!]!
    createdAt: String!
}

type Post {
    id: ID!
    title: String!
    content: String!
    author: User!
    comments: [Comment!]!
    createdAt: String!
}

type Comment {
    id: ID!
    content: String!
    author: User!
    post: Post!
    createdAt: String!
}

type Query {
    users(limit: Int = 10, offset: Int = 0): [User!]!
    user(id: ID!): User
    posts(limit: Int = 10, offset: Int = 0): [Post!]!
    post(id: ID!): Post
    search(query: String!): [SearchResult!]!
}

type Mutation {
    createUser(input: CreateUserInput!): User!
    updateUser(id: ID!, input: UpdateUserInput!): User!
    deleteUser(id: ID!): Boolean!
    createPost(input: CreatePostInput!): Post!
    createComment(input: CreateCommentInput!): Comment!
}

input CreateUserInput {
    email: String!
    password: String!
    name: String!
}

input UpdateUserInput {
    email: String
    name: String
}

input CreatePostInput {
    title: String!
    content: String!
    authorId: ID!
}

input CreateCommentInput {
    content: String!
    authorId: ID!
    postId: ID!
}

union SearchResult = User | Post

// resolvers.ts
import { AuthenticationError, UserInputError } from 'apollo-server-express';

export const resolvers = {
    Query: {
        users: async (_, { limit, offset }, { dataSources }) => {
            return dataSources.userAPI.getUsers(limit, offset);
        },
        
        user: async (_, { id }, { dataSources }) => {
            const user = await dataSources.userAPI.getUserById(id);
            if (!user) {
                throw new UserInputError('User not found');
            }
            return user;
        },
        
        posts: async (_, { limit, offset }, { dataSources }) => {
            return dataSources.postAPI.getPosts(limit, offset);
        },
        
        post: async (_, { id }, { dataSources }) => {
            const post = await dataSources.postAPI.getPostById(id);
            if (!post) {
                throw new UserInputError('Post not found');
            }
            return post;
        },
        
        search: async (_, { query }, { dataSources }) => {
            const [users, posts] = await Promise.all([
                dataSources.userAPI.searchUsers(query),
                dataSources.postAPI.searchPosts(query)
            ]);
            
            return [...users, ...posts];
        }
    },
    
    Mutation: {
        createUser: async (_, { input }, { dataSources }) => {
            // Validate input
            if (!input.email || !input.password || !input.name) {
                throw new UserInputError('Missing required fields');
            }
            
            // Check if user exists
            const existingUser = await dataSources.userAPI.findByEmail(input.email);
            if (existingUser) {
                throw new UserInputError('Email already registered');
            }
            
            // Hash password
            const hashedPassword = await bcrypt.hash(input.password, 10);
            
            // Create user
            return dataSources.userAPI.createUser({
                ...input,
                password: hashedPassword
            });
        },
        
        updateUser: async (_, { id, input }, { dataSources, user }) => {
            // Check authentication
            if (!user || user.id !== id) {
                throw new AuthenticationError('Not authorized');
            }
            
            return dataSources.userAPI.updateUser(id, input);
        },
        
        deleteUser: async (_, { id }, { dataSources, user }) => {
            // Check authentication
            if (!user || user.id !== id) {
                throw new AuthenticationError('Not authorized');
            }
            
            return dataSources.userAPI.deleteUser(id);
        },
        
        createPost: async (_, { input }, { dataSources, user }) => {
            // Check authentication
            if (!user) {
                throw new AuthenticationError('Not authenticated');
            }
            
            return dataSources.postAPI.createPost({
                ...input,
                authorId: user.id
            });
        },
        
        createComment: async (_, { input }, { dataSources, user }) => {
            if (!user) {
                throw new AuthenticationError('Not authenticated');
            }
            
            return dataSources.commentAPI.createComment({
                ...input,
                authorId: user.id
            });
        }
    },
    
    User: {
        posts: async (parent, _, { dataSources }) => {
            return dataSources.postAPI.getPostsByAuthor(parent.id);
        }
    },
    
    Post: {
        author: async (parent, _, { dataSources }) => {
            return dataSources.userAPI.getUserById(parent.authorId);
        },
        
        comments: async (parent, _, { dataSources }) => {
            return dataSources.commentAPI.getCommentsByPost(parent.id);
        }
    },
    
    Comment: {
        author: async (parent, _, { dataSources }) => {
            return dataSources.userAPI.getUserById(parent.authorId);
        },
        
        post: async (parent, _, { dataSources }) => {
            return dataSources.postAPI.getPostById(parent.postId);
        }
    },
    
    SearchResult: {
        __resolveType(obj) {
            if (obj.email) {
                return 'User';
            }
            if (obj.title) {
                return 'Post';
            }
            return null;
        }
    }
};

// server.ts
import { ApolloServer } from 'apollo-server-express';
import { typeDefs } from './schema';
import { resolvers } from './resolvers';
import { dataSources } from './datasources';
import { authMiddleware } from './auth';

const server = new ApolloServer({
    typeDefs,
    resolvers,
    dataSources,
    context: ({ req }) => ({
        user: req.user
    }),
    formatError: (err) => {
        // Log errors
        console.error(err);
        
        // Don't expose internal errors
        if (err.extensions?.code === 'INTERNAL_SERVER_ERROR') {
            return new Error('Internal server error');
        }
        
        return err;
    },
    introspection: process.env.NODE_ENV !== 'production',
    playground: process.env.NODE_ENV !== 'production'
});

app.use('/graphql', authMiddleware);
server.applyMiddleware({ app });

// server.js - Socket.io setup
const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const jwt = require('jsonwebtoken');
const redis = require('redis');

const app = express();
const server = http.createServer(app);
const io = socketIo(server, {
    cors: {
        origin: process.env.CLIENT_URL,
        methods: ['GET', 'POST'],
        credentials: true
    },
    pingTimeout: 60000,
    pingInterval: 25000
});

// Redis adapter for multi-server support
const { createAdapter } = require('@socket.io/redis-adapter');
const pubClient = redis.createClient({ host: 'localhost', port: 6379 });
const subClient = pubClient.duplicate();
io.adapter(createAdapter(pubClient, subClient));

// Authentication middleware
io.use(async (socket, next) => {
    try {
        const token = socket.handshake.auth.token;
        if (!token) {
            return next(new Error('Authentication required'));
        }
        
        const decoded = jwt.verify(token, process.env.JWT_SECRET);
        socket.userId = decoded.userId;
        socket.user = await User.findById(decoded.userId);
        
        next();
    } catch (err) {
        next(new Error('Invalid token'));
    }
});

// Connection handling
io.on('connection', (socket) => {
    console.log(`User ${socket.userId} connected`);
    
    // Join user to their own room
    socket.join(`user:${socket.userId}`);
    
    // Join rooms based on user's groups
    socket.user.groups.forEach(group => {
        socket.join(`group:${group.id}`);
    });
    
    // Handle joining a chat room
    socket.on('join-room', (roomId) => {
        socket.join(roomId);
        socket.to(roomId).emit('user-joined', {
            userId: socket.userId,
            username: socket.user.username
        });
    });
    
    // Handle leaving a room
    socket.on('leave-room', (roomId) => {
        socket.leave(roomId);
        socket.to(roomId).emit('user-left', {
            userId: socket.userId,
            username: socket.user.username
        });
    });
    
    // Handle messages
    socket.on('send-message', async (data) => {
        try {
            const { roomId, content, type = 'text' } = data;
            
            // Save message to database
            const message = await Message.create({
                roomId,
                userId: socket.userId,
                content,
                type,
                timestamp: new Date()
            });
            
            // Emit to room
            io.to(roomId).emit('new-message', {
                id: message.id,
                userId: socket.userId,
                username: socket.user.username,
                content,
                type,
                timestamp: message.timestamp
            });
            
            // Send notification to offline users
            const roomUsers = await getRoomUsers(roomId);
            roomUsers.forEach(user => {
                if (user.id !== socket.userId && !io.sockets.adapter.rooms.get(`user:${user.id}`)) {
                    notifyUser(user.id, {
                        type: 'new-message',
                        roomId,
                        message: message.id
                    });
                }
            });
        } catch (err) {
            socket.emit('error', { message: 'Failed to send message' });
        }
    });
    
    // Handle typing indicators
    socket.on('typing', ({ roomId, isTyping }) => {
        socket.to(roomId).emit('user-typing', {
            userId: socket.userId,
            username: socket.user.username,
            isTyping
        });
    });
    
    // Handle read receipts
    socket.on('mark-read', async ({ roomId, messageIds }) => {
        await Message.updateMany(
            { _id: { $in: messageIds } },
            { $addToSet: { readBy: socket.userId } }
        );
        
        socket.to(`user:${socket.userId}`).emit('messages-read', {
            roomId,
            messageIds
        });
    });
    
    // Handle file upload progress
    socket.on('file-upload-progress', ({ roomId, fileId, progress }) => {
        socket.to(roomId).emit('file-progress', {
            fileId,
            progress,
            userId: socket.userId
        });
    });
    
    // Handle reactions
    socket.on('add-reaction', async ({ messageId, reaction }) => {
        const message = await Message.findByIdAndUpdate(
            messageId,
            { $addToSet: { reactions: { userId: socket.userId, reaction } } },
            { new: true }
        );
        
        if (message) {
            io.to(`room:${message.roomId}`).emit('reaction-added', {
                messageId,
                userId: socket.userId,
                reaction
            });
        }
    });
    
    // Disconnect handling
    socket.on('disconnect', () => {
        console.log(`User ${socket.userId} disconnected`);
        io.emit('user-offline', {
            userId: socket.userId,
            username: socket.user.username
        });
    });
});

// Client-side example
<script>
const socket = io('http://localhost:3000', {
    auth: {
        token: 'jwt-token-here'
    }
});

socket.on('connect', () => {
    console.log('Connected to server');
    
    // Join room
    socket.emit('join-room', 'room-123');
});

socket.on('new-message', (message) => {
    console.log('New message:', message);
    displayMessage(message);
});

socket.on('user-typing', ({ username, isTyping }) => {
    if (isTyping) {
        showTypingIndicator(username);
    } else {
        hideTypingIndicator(username);
    }
});

function sendMessage(content) {
    socket.emit('send-message', {
        roomId: currentRoom,
        content
    });
}

function startTyping() {
    socket.emit('typing', {
        roomId: currentRoom,
        isTyping: true
    });
}

function stopTyping() {
    socket.emit('typing', {
        roomId: currentRoom,
        isTyping: false
    });
}
</script>

1. Team Skills: Does your team already know JavaScript? Full-stack JavaScript enables shared code and knowledge.
2. I/O vs CPU: Node.js excels at I/O operations but struggles with CPU-intensive tasks. Consider your workload.
3. Real-time Requirements: Need WebSockets, live updates, or streaming? Node.js is unmatched here.
4. Scalability Needs: Node.js handles thousands of concurrent connections with minimal resources.
5. Development Speed: Node.js has one of the fastest development cycles due to npm ecosystem.
6. Microservices Architecture: Node.js is perfect for building lightweight, independent services.
7. Type Safety Requirements: Consider TypeScript if you need static typing.
8. Community Support: npm is the largest package ecosystem in the world.
9. Budget Constraints: Node.js runs efficiently on smaller servers, reducing infrastructure costs.
10. Future Maintenance: JavaScript's popularity ensures long-term support and talent availability.

Spring Boot makes it easy to create stand-alone, production-grade Spring-based applications. Released in 2014 by the Pivotal team, Spring Boot revolutionized Java development by providing opinionated defaults and auto-configuration, dramatically reducing the boilerplate code required for enterprise applications.

Spring Boot starters are curated dependency descriptors that simplify Maven/Gradle configuration.

Maven Example:

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

Gradle Example:

plugins {
    id 'org.springframework.boot' version '3.2.0'
    id 'io.spring.dependency-management' version '1.1.0'
    id 'java'
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'org.postgresql:postgresql'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

Spring Boot's auto-configuration uses @Conditional annotations to apply configuration conditionally.

@Configuration
@ConditionalOnClass(DataSource.class)
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnProperty(name = "spring.datasource.type")
    public DataSource dataSource(DataSourceProperties properties) {
        return properties.initializeDataSourceBuilder()
                .build();
    }
    
    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnBean(DataSource.class)
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

Common Conditional Annotations:

• @ConditionalOnClass: Configuration applies if class is on classpath
• @ConditionalOnMissingBean: Applies if bean doesn't exist
• @ConditionalOnProperty: Applies based on property value
• @ConditionalOnWebApplication: For web-specific configuration
• @ConditionalOnExpression: Based on SpEL expression

Disabling Specific Auto-Configuration:

@SpringBootApplication(exclude = {
    DataSourceAutoConfiguration.class,
    HibernateJpaAutoConfiguration.class
})
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

Embedded Servlet Containers:

# application.properties
# Tomcat configuration
server.port=8080
server.servlet.context-path=/api
server.tomcat.max-threads=200
server.tomcat.max-connections=10000
server.tomcat.accept-count=100

# SSL Configuration
server.ssl.key-store=classpath:keystore.p12
server.ssl.key-store-password=secret
server.ssl.key-store-type=PKCS12
server.ssl.key-alias=tomcat

# Compression
server.compression.enabled=true
server.compression.mime-types=application/json,application/xml,text/html
server.compression.min-response-size=2048

Programmatic Server Configuration:

@Configuration
public class ServerConfig {
    
    @Bean
    public TomcatServletWebServerFactory tomcatFactory() {
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
        factory.addConnectorCustomizers(connector -> {
            connector.setProperty("compression", "on");
            connector.setProperty("compressionMinSize", "2048");
            connector.setProperty("compressableMimeType", 
                "application/json,application/xml,text/html");
        });
        return factory;
    }
    
    @Bean
    public WebServerFactoryCustomizer<TomcatServletWebServerFactory> 
            tomcatCustomizer() {
        return factory -> {
            factory.addContextCustomizers(context -> {
                context.setSessionTimeout(30, TimeUnit.MINUTES);
                context.setCookieProcessor(new LegacyCookieProcessor());
            });
        };
    }
}

Spring Boot Actuator – Production Monitoring:

# application.properties
# Enable all endpoints
management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always

# Custom info endpoint
info.application.name=@project.name@
info.application.version=@project.version@
info.java.version=@java.version@

# Metrics configuration
management.metrics.export.prometheus.enabled=true
management.metrics.tags.application=myapp

# Custom health indicator
@Component
public class DatabaseHealthIndicator implements HealthIndicator {
    
    @Autowired
    private DataSource dataSource;
    
    @Override
    public Health health() {
        try (Connection conn = dataSource.getConnection()) {
            boolean valid = conn.isValid(1000);
            if (valid) {
                return Health.up()
                    .withDetail("database", "PostgreSQL")
                    .withDetail("version", conn.getMetaData().getDatabaseProductVersion())
                    .build();
            } else {
                return Health.down()
                    .withDetail("error", "Connection validation failed")
                    .build();
            }
        } catch (SQLException e) {
            return Health.down(e).build();
        }
    }
}

Spring Boot provides rich support for externalized configuration across different environments.

Type-Safe Configuration Properties:

@ConfigurationProperties(prefix = "app")
@Component
public class AppProperties {
    
    private String name;
    private String description;
    private String version;
    private Security security = new Security();
    private Database database = new Database();
    private List<String> servers = new ArrayList<>();
    private Map<String, String> mappings = new HashMap<>();
    
    // Getters and setters
    
    public static class Security {
        private boolean enabled = true;
        private List<String> allowedOrigins = new ArrayList<>();
        private Jwt jwt = new Jwt();
        
        // Getters and setters
    }
    
    public static class Jwt {
        private String secret;
        private long expiration = 3600000; // 1 hour
        private String issuer = "myapp";
        
        // Getters and setters
    }
}

// Enable configuration properties
@Configuration
@EnableConfigurationProperties(AppProperties.class)
public class AppConfig {
    
    @Autowired
    private AppProperties properties;
    
    @Bean
    public JwtTokenProvider jwtTokenProvider() {
        return new JwtTokenProvider(
            properties.getSecurity().getJwt().getSecret(),
            properties.getSecurity().getJwt().getExpiration()
        );
    }
}

application.yml with Profile Support:

# application.yml
spring:
  application:
    name: myapp
  profiles:
    active: ${SPRING_PROFILES_ACTIVE:dev}
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: ${DB_USER:appuser}
    password: ${DB_PASSWORD:}
    hikari:
      maximum-pool-size: 10
      minimum-idle: 5
      connection-timeout: 30000
  jpa:
    hibernate:
      ddl-auto: validate
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
        format_sql: true
    show-sql: ${SHOW_SQL:false}

server:
  port: ${PORT:8080}
  error:
    include-message: always
    include-binding-errors: always

app:
  name: My Enterprise Application
  description: Production-ready Spring Boot application
  version: 1.0.0
  security:
    jwt:
      secret: ${JWT_SECRET:mySecretKey}
      expiration: 86400000
    allowed-origins:
      - https://example.com
      - https://app.example.com
  servers:
    - https://api1.example.com
    - https://api2.example.com

---
spring:
  config:
    activate:
      on-profile: dev

app:
  security:
    jwt:
      secret: devSecretKey
  servers:
    - http://localhost:3000

---
spring:
  config:
    activate:
      on-profile: prod

server:
  port: 8080
  
app:
  security:
    jwt:
      secret: ${JWT_SECRET}
  servers:
    - https://api.prod.example.com

Command Line and Environment Variable Overrides:

# Command line
java -jar myapp.jar --server.port=9090 --app.security.jwt.secret=strongSecret

# Environment variables
export SPRING_DATASOURCE_URL=jdbc:postgresql://prod-db:5432/proddb
export SPRING_PROFILES_ACTIVE=prod
export APP_SECURITY_JWT_SECRET=veryStrongSecret

# Docker environment
docker run -e SPRING_PROFILES_ACTIVE=prod -e DB_PASSWORD=secret myapp

Spring's IoC container manages object lifecycle and dependencies, promoting loose coupling and testability.

Types of Dependency Injection:

@Service
public class UserService {
    
    // Constructor injection (recommended)
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;
    private final EmailService emailService;
    
    public UserService(UserRepository userRepository, 
                      PasswordEncoder passwordEncoder,
                      EmailService emailService) {
        this.userRepository = userRepository;
        this.passwordEncoder = passwordEncoder;
        this.emailService = emailService;
    }
    
    // Setter injection (optional dependencies)
    @Autowired(required = false)
    public void setAuditService(AuditService auditService) {
        this.auditService = auditService;
    }
    
    // Field injection (not recommended for testing)
    @Autowired
    private NotificationService notificationService;
    
    public User createUser(UserDto userDto) {
        User user = new User();
        user.setEmail(userDto.getEmail());
        user.setPassword(passwordEncoder.encode(userDto.getPassword()));
        
        User savedUser = userRepository.save(user);
        emailService.sendWelcomeEmail(savedUser);
        
        if (auditService != null) {
            auditService.log("User created: " + savedUser.getId());
        }
        
        return savedUser;
    }
}

// Java configuration
@Configuration
public class AppConfig {
    
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(12);
    }
    
    @Bean
    @Scope("prototype")
    public EmailService emailService() {
        return new SmtpEmailService(
            mailHost(),
            mailPort(),
            mailUsername(),
            mailPassword()
        );
    }
    
    @Bean
    @ConditionalOnProperty(name = "audit.enabled", havingValue = "true")
    public AuditService auditService() {
        return new DatabaseAuditService();
    }
}

Bean Scopes:

Spring provides consistent transaction management across different APIs (JPA, JDBC, JTA).

@Service
@Transactional
public class OrderService {
    
    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private InventoryService inventoryService;
    
    @Autowired
    private PaymentService paymentService;
    
    @Autowired
    private NotificationService notificationService;
    
    @Transactional(rollbackFor = {PaymentException.class, InventoryException.class})
    public Order placeOrder(OrderRequest request) {
        // Create order
        Order order = new Order();
        order.setCustomerId(request.getCustomerId());
        order.setItems(request.getItems());
        order.setTotalAmount(calculateTotal(request.getItems()));
        
        Order savedOrder = orderRepository.save(order);
        
        try {
            // Reserve inventory
            inventoryService.reserveItems(request.getItems());
            
            // Process payment
            Payment payment = paymentService.processPayment(
                request.getPaymentDetails(),
                savedOrder.getTotalAmount()
            );
            
            savedOrder.setPaymentId(payment.getId());
            savedOrder.setStatus(OrderStatus.PAID);
            
            // Send confirmation
            notificationService.sendOrderConfirmation(savedOrder);
            
            return orderRepository.save(savedOrder);
            
        } catch (Exception e) {
            savedOrder.setStatus(OrderStatus.FAILED);
            orderRepository.save(savedOrder);
            throw e; // Will trigger rollback
        }
    }
    
    @Transactional(readOnly = true)
    public Order getOrder(Long id) {
        return orderRepository.findById(id)
            .orElseThrow(() -> new OrderNotFoundException(id));
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void auditOrder(Long orderId, String action) {
        // This runs in a new transaction
        auditRepository.save(new AuditEntry(orderId, action));
    }
    
    @Transactional(timeout = 30)
    public void processBatchOrders(List<Long> orderIds) {
        // Must complete within 30 seconds
        orderIds.forEach(this::processOrder);
    }
}

Transaction Propagation Levels:

• REQUIRED: Join existing transaction or create new (default)
• REQUIRES_NEW: Always create new transaction, suspend existing
• NESTED: Execute within nested transaction if supported
• MANDATORY: Must run in existing transaction, throw exception if none
• SUPPORTS: Run within transaction if exists, otherwise non-transactional
• NOT_SUPPORTED: Suspend transaction, run non-transactional
• NEVER: Throw exception if transaction exists

Isolation Levels:

• DEFAULT: Use database default
• READ_UNCOMMITTED: May see uncommitted changes (dirty reads)
• READ_COMMITTED: Only see committed changes (prevents dirty reads)
• REPEATABLE_READ: Same read returns same data (prevents non-repeatable reads)
• SERIALIZABLE: Complete isolation, slowest (prevents phantom reads)

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class SecurityConfig {
    
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable()) // For stateless APIs
            .sessionManagement(session -> 
                session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**").permitAll()
                .requestMatchers("/api/public/**").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .requestMatchers("/api/user/**").hasAnyRole("USER", "ADMIN")
                .anyRequest().authenticated()
            )
            .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt)
            .addFilterBefore(jwtAuthenticationFilter(), 
                UsernamePasswordAuthenticationFilter.class);
        
        return http.build();
    }
    
    @Bean
    public JwtDecoder jwtDecoder() {
        return NimbusJwtDecoder.withJwkSetUri("https://auth.example.com/jwks").build();
    }
    
    @Bean
    public AuthenticationManager authenticationManager(
            AuthenticationConfiguration config) throws Exception {
        return config.getAuthenticationManager();
    }
}

@Configuration
public class UserDetailsServiceImpl implements UserDetailsService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Override
    @Transactional
    public UserDetails loadUserByUsername(String username) 
            throws UsernameNotFoundException {
        User user = userRepository.findByEmail(username)
            .orElseThrow(() -> new UsernameNotFoundException("User not found"));
        
        return org.springframework.security.core.userdetails.User.builder()
            .username(user.getEmail())
            .password(user.getPassword())
            .roles(user.getRoles().stream()
                .map(Role::getName)
                .toArray(String[]::new))
            .accountLocked(user.isLocked())
            .disabled(!user.isEnabled())
            .build();
    }
}

@RestController
@RequestMapping("/api/users")
@PreAuthorize("isAuthenticated()")
public class UserController {
    
    @GetMapping("/profile")
    @PreAuthorize("#userId == authentication.principal.id")
    public UserProfile getProfile(@PathVariable Long userId) {
        return userService.getProfile(userId);
    }
    
    @PostMapping
    @PreAuthorize("hasRole('ADMIN')")
    public User createUser(@Valid @RequestBody CreateUserRequest request) {
        return userService.createUser(request);
    }
    
    @DeleteMapping("/{userId}")
    @Secured("ROLE_ADMIN")
    public void deleteUser(@PathVariable Long userId) {
        userService.deleteUser(userId);
    }
    
    @GetMapping("/search")
    @PostAuthorize("returnObject.createdBy == authentication.principal.id")
    public User searchUsers(@RequestParam String email) {
        return userService.findByEmail(email);
    }
    
    @GetMapping("/all")
    @PostFilter("filterObject.createdBy == authentication.principal.id")
    public List<User> getAllUsers() {
        return userService.findAll();
    }
}

Method-Level Security Annotations:

• @PreAuthorize: Check authorization before method execution
• @PostAuthorize: Check after execution (access result)
• @PreFilter: Filter collection arguments
• @PostFilter: Filter returned collection
• @Secured: Simple role-based authorization
• @RolesAllowed: JSR-250 annotation

@Entity
@Table(name = "users")
@EntityListeners(AuditingEntityListener.class)
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    private String id;
    
    @Column(nullable = false, unique = true)
    private String email;
    
    @Column(nullable = false)
    @JsonIgnore
    private String password;
    
    @Column(nullable = false)
    private String firstName;
    
    @Column(nullable = false)
    private String lastName;
    
    @Column(nullable = false)
    @Enumerated(EnumType.STRING)
    private UserStatus status = UserStatus.ACTIVE;
    
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(
        name = "user_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private Set<Role> roles = new HashSet<>();
    
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    @OrderBy("createdAt DESC")
    private List<Order> orders = new ArrayList<>();
    
    @OneToOne(mappedBy = "user", cascade = CascadeType.ALL)
    private Profile profile;
    
    @CreatedDate
    private LocalDateTime createdAt;
    
    @LastModifiedDate
    private LocalDateTime updatedAt;
    
    @Version
    private Long version;
    
    // Getters, setters, equals, hashCode
}

@Repository
public interface UserRepository extends JpaRepository<User, String>, 
                                        UserRepositoryCustom {
    
    Optional<User> findByEmail(String email);
    
    @Query("SELECT u FROM User u WHERE u.status = :status")
    Page<User> findByStatus(@Param("status") UserStatus status, Pageable pageable);
    
    @Query(value = "SELECT * FROM users u WHERE u.last_name LIKE %:search% " +
           "OR u.first_name LIKE %:search%", nativeQuery = true)
    List<User> searchByName(@Param("search") String search);
    
    @EntityGraph(attributePaths = {"roles", "profile"})
    @Query("SELECT u FROM User u WHERE u.id IN :ids")
    List<User> findByIdsWithDetails(@Param("ids") List<String> ids);
    
    long countByStatus(UserStatus status);
    
    boolean existsByEmail(String email);
    
    @Modifying
    @Transactional
    @Query("UPDATE User u SET u.status = :status WHERE u.lastLoginAt < :date")
    int deactivateInactiveUsers(@Param("date") LocalDateTime date, 
                                @Param("status") UserStatus status);
}

public interface UserRepositoryCustom {
    Page<User> findUsersByCriteria(UserSearchCriteria criteria, Pageable pageable);
}

@Repository
public class UserRepositoryImpl implements UserRepositoryCustom {
    
    @PersistenceContext
    private EntityManager entityManager;
    
    @Override
    public Page<User> findUsersByCriteria(UserSearchCriteria criteria, 
                                          Pageable pageable) {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<User> query = cb.createQuery(User.class);
        Root<User> root = query.from(User.class);
        
        List<Predicate> predicates = new ArrayList<>();
        
        if (criteria.getEmail() != null) {
            predicates.add(cb.like(root.get("email"), 
                "%" + criteria.getEmail() + "%"));
        }
        
        if (criteria.getStatus() != null) {
            predicates.add(cb.equal(root.get("status"), criteria.getStatus()));
        }
        
        if (criteria.getRole() != null) {
            Join<User, Role> roles = root.join("roles");
            predicates.add(cb.equal(roles.get("name"), criteria.getRole()));
        }
        
        if (criteria.getCreatedAfter() != null) {
            predicates.add(cb.greaterThan(root.get("createdAt"), 
                criteria.getCreatedAfter()));
        }
        
        query.where(predicates.toArray(new Predicate[0]));
        query.orderBy(cb.desc(root.get("createdAt")));
        
        TypedQuery<User> typedQuery = entityManager.createQuery(query);
        typedQuery.setFirstResult((int) pageable.getOffset());
        typedQuery.setMaxResults(pageable.getPageSize());
        
        List<User> users = typedQuery.getResultList();
        
        // Count query
        CriteriaQuery<Long> countQuery = cb.createQuery(Long.class);
        countQuery.select(cb.count(countQuery.from(User.class)))
                  .where(predicates.toArray(new Predicate[0]));
        Long total = entityManager.createQuery(countQuery).getSingleResult();
        
        return new PageImpl<>(users, pageable, total);
    }
}

JPA Performance Optimizations:

• N+1 Problem Prevention: Use @EntityGraph or JOIN FETCH
• Batch Fetching: @BatchSize for collections
• Second-Level Cache: Ehcache, Redis for frequently accessed entities
• Read-Only Transactions: @Transactional(readOnly = true)
• Projections: Interface-based projections for specific fields
• Pagination: Always use Pageable for large result sets

@RestController
@RequestMapping("/api/v1/orders")
@Slf4j
public class OrderController {
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private OrderMapper orderMapper;
    
    @GetMapping
    @ResponseStatus(HttpStatus.OK)
    public Page<OrderDto> getAllOrders(
            @PageableDefault(size = 20, sort = "createdAt", direction = Sort.Direction.DESC)
            Pageable pageable,
            @RequestParam(required = false) OrderStatus status,
            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
            LocalDate fromDate) {
        
        OrderCriteria criteria = OrderCriteria.builder()
            .status(status)
            .fromDate(fromDate)
            .build();
        
        return orderService.findOrders(criteria, pageable)
            .map(orderMapper::toDto);
    }
    
    @GetMapping("/{id}")
    @ResponseStatus(HttpStatus.OK)
    public OrderDto getOrder(@PathVariable Long id) {
        return orderMapper.toDto(orderService.findById(id));
    }
    
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    @PreAuthorize("hasRole('CUSTOMER')")
    public OrderDto createOrder(@Valid @RequestBody CreateOrderRequest request) {
        Order order = orderService.createOrder(request);
        return orderMapper.toDto(order);
    }
    
    @PutMapping("/{id}")
    @ResponseStatus(HttpStatus.OK)
    public OrderDto updateOrder(@PathVariable Long id, 
                                @Valid @RequestBody UpdateOrderRequest request) {
        Order order = orderService.updateOrder(id, request);
        return orderMapper.toDto(order);
    }
    
    @PatchMapping("/{id}/status")
    @ResponseStatus(HttpStatus.OK)
    public OrderDto updateOrderStatus(@PathVariable Long id,
                                      @RequestParam OrderStatus status) {
        Order order = orderService.updateStatus(id, status);
        return orderMapper.toDto(order);
    }
    
    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    @PreAuthorize("hasRole('ADMIN')")
    public void deleteOrder(@PathVariable Long id) {
        orderService.deleteOrder(id);
    }
    
    @PostMapping("/{id}/cancel")
    @ResponseStatus(HttpStatus.OK)
    public OrderDto cancelOrder(@PathVariable Long id,
                                @RequestParam String reason) {
        Order order = orderService.cancelOrder(id, reason);
        return orderMapper.toDto(order);
    }
    
    @ExceptionHandler(OrderNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public ErrorResponse handleOrderNotFound(OrderNotFoundException ex) {
        return ErrorResponse.builder()
            .code("ORDER_NOT_FOUND")
            .message(ex.getMessage())
            .timestamp(LocalDateTime.now())
            .build();
    }
    
    @ExceptionHandler(ValidationException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public ErrorResponse handleValidation(ValidationException ex) {
        return ErrorResponse.builder()
            .code("VALIDATION_ERROR")
            .message(ex.getMessage())
            .details(ex.getErrors())
            .timestamp(LocalDateTime.now())
            .build();
    }
}

Request/Response DTOs with Validation:

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CreateOrderRequest {
    
    @NotNull(message = "Customer ID is required")
    private Long customerId;
    
    @NotEmpty(message = "Order must have at least one item")
    @Valid
    private List<OrderItemDto> items;
    
    @Pattern(regexp = "CREDIT_CARD|PAYPAL|BANK_TRANSFER", 
             message = "Invalid payment method")
    private String paymentMethod;
    
    @Future(message = "Delivery date must be in the future")
    private LocalDateTime deliveryDate;
    
    @Size(max = 500, message = "Notes cannot exceed 500 characters")
    private String notes;
}

@Data
public class OrderItemDto {
    
    @NotNull(message = "Product ID is required")
    private Long productId;
    
    @Min(value = 1, message = "Quantity must be at least 1")
    @Max(value = 100, message = "Quantity cannot exceed 100")
    private Integer quantity;
    
    @DecimalMin(value = "0.01", message = "Price must be positive")
    private BigDecimal price;
}

@Data
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ErrorResponse {
    
    private String code;
    private String message;
    private List<String> details;
    private LocalDateTime timestamp;
    private String path;
}

@SpringBootTest
@AutoConfigureMockMvc
@Transactional
@ActiveProfiles("test")
class OrderControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @MockBean
    private OrderService orderService;
    
    @Test
    void shouldCreateOrder() throws Exception {
        // Given
        CreateOrderRequest request = CreateOrderRequest.builder()
            .customerId(1L)
            .items(List.of(new OrderItemDto(1L, 2, BigDecimal.valueOf(29.99))))
            .paymentMethod("CREDIT_CARD")
            .build();
        
        Order order = Order.builder()
            .id(1L)
            .customerId(1L)
            .status(OrderStatus.PENDING)
            .totalAmount(BigDecimal.valueOf(59.98))
            .build();
        
        given(orderService.createOrder(any(CreateOrderRequest.class)))
            .willReturn(order);
        
        // When & Then
        mockMvc.perform(post("/api/v1/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(request)))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.id").value(1))
            .andExpect(jsonPath("$.status").value("PENDING"))
            .andExpect(jsonPath("$.totalAmount").value(59.98));
    }
    
    @Test
    void shouldReturnValidationError() throws Exception {
        // Given
        CreateOrderRequest request = CreateOrderRequest.builder()
            .items(List.of())
            .build();
        
        // When & Then
        mockMvc.perform(post("/api/v1/orders")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(request)))
            .andExpect(status().isBadRequest())
            .andExpect(jsonPath("$.code").value("VALIDATION_ERROR"))
            .andExpect(jsonPath("$.details").isArray());
    }
}

@DataJpaTest
class UserRepositoryTest {
    
    @Autowired
    private TestEntityManager entityManager;
    
    @Autowired
    private UserRepository userRepository;
    
    @Test
    void shouldFindUserByEmail() {
        // Given
        User user = User.builder()
            .email("test@example.com")
            .password("password")
            .firstName("John")
            .lastName("Doe")
            .build();
        entityManager.persist(user);
        entityManager.flush();
        
        // When
        Optional<User> found = userRepository.findByEmail("test@example.com");
        
        // Then
        assertThat(found).isPresent();
        assertThat(found.get().getEmail()).isEqualTo("test@example.com");
    }
    
    @Test
    void shouldReturnEmptyWhenEmailNotFound() {
        Optional<User> found = userRepository.findByEmail("nonexistent@example.com");
        assertThat(found).isEmpty();
    }
}

@WebMvcTest(OrderController.class)
class OrderControllerUnitTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private OrderService orderService;
    
    @Test
    void shouldReturnNotFound() throws Exception {
        given(orderService.findById(999L))
            .willThrow(new OrderNotFoundException(999L));
        
        mockMvc.perform(get("/api/v1/orders/999"))
            .andExpect(status().isNotFound())
            .andExpect(jsonPath("$.code").value("ORDER_NOT_FOUND"));
    }
}

Spring Cloud provides tools for building common patterns in distributed systems.

// Eureka Server
@SpringBootApplication
@EnableEurekaServer
public class ServiceRegistryApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceRegistryApplication.class, args);
    }
}

# application.yml for Eureka Server
server:
  port: 8761

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

// Eureka Client (Microservice)
@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

# application.yml for User Service
spring:
  application:
    name: user-service

server:
  port: 8081

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
  instance:
    instance-id: ${spring.application.name}:${random.uuid}
    prefer-ip-address: true

// Using Discovery Client
@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @Autowired
    private DiscoveryClient discoveryClient;
    
    @GetMapping("/services")
    public List<String> getServices() {
        return discoveryClient.getServices();
    }
    
    @GetMapping("/instances")
    public List<ServiceInstance> getInstances() {
        return discoveryClient.getInstances("order-service");
    }
}

@SpringBootApplication
@EnableDiscoveryClient
public class ApiGatewayApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(ApiGatewayApplication.class, args);
    }
    
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("user-service", r -> r
                .path("/api/users/**")
                .filters(f -> f
                    .stripPrefix(1)
                    .addRequestHeader("X-Gateway-Request", "true")
                    .addResponseHeader("X-Gateway-Response", "true")
                    .circuitBreaker(config -> config
                        .setName("userServiceCB")
                        .setFallbackUri("forward:/fallback/users")))
                .uri("lb://USER-SERVICE"))
            
            .route("order-service", r -> r
                .path("/api/orders/**")
                .filters(f -> f
                    .stripPrefix(1)
                    .retry(config -> config
                        .setRetries(3)
                        .setStatuses(HttpStatus.SERVICE_UNAVAILABLE))
                    .requestRateLimiter(config -> config
                        .setRateLimiter(redisRateLimiter())))
                .uri("lb://ORDER-SERVICE"))
            
            .route("product-service", r -> r
                .path("/api/products/**")
                .filters(f -> f
                    .stripPrefix(1)
                    .cache(RequestCachingConfig.DEFAULT_CACHE_SPEC))
                .uri("lb://PRODUCT-SERVICE"))
            .build();
    }
    
    @Bean
    public RedisRateLimiter redisRateLimiter() {
        return new RedisRateLimiter(10, 20, 1);
    }
}

// Custom Global Filter
@Component
public class GatewayLoggingFilter implements GlobalFilter, Ordered {
    
    private static final Logger log = LoggerFactory.getLogger(GatewayLoggingFilter.class);
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        
        log.info("Incoming request: {} {}", request.getMethod(), request.getURI());
        
        return chain.filter(exchange)
            .doOnSuccess(v -> {
                ServerHttpResponse response = exchange.getResponse();
                log.info("Response status: {}", response.getStatusCode());
            });
    }
    
    @Override
    public int getOrder() {
        return -1;
    }
}

// Config Server
@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}

# application.yml for Config Server
server:
  port: 8888

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/company/config-repo
          search-paths: '{application}'
          default-label: main
          clone-on-start: true
          force-pull: true

# Config Repository Structure
config-repo/
├── user-service.yml
├── user-service-dev.yml
├── user-service-prod.yml
├── order-service.yml
├── order-service-dev.yml
├── application.yml
└── application-dev.yml

# user-service.yml
server:
  port: 8081

spring:
  datasource:
    url: ${DB_URL:jdbc:postgresql://localhost:5432/userdb}
    username: ${DB_USER:user}
    password: ${DB_PASSWORD:}
  jpa:
    hibernate:
      ddl-auto: validate

app:
  features:
    email-verification: true
    social-login: false
  max-users-per-page: 100

# Client Configuration
@SpringBootApplication
@EnableDiscoveryClient
@RefreshScope
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

# bootstrap.yml for client
spring:
  application:
    name: user-service
  cloud:
    config:
      uri: http://localhost:8888
      fail-fast: true
      retry:
        max-attempts: 6
        initial-interval: 1000
        max-interval: 2000
        multiplier: 1.1

@RestController
@RequestMapping("/api/config")
@RefreshScope
public class ConfigController {
    
    @Value("${app.features.email-verification}")
    private boolean emailVerificationEnabled;
    
    @Value("${app.max-users-per-page:50}")
    private int maxUsersPerPage;
    
    @Autowired
    private Environment env;
    
    @GetMapping("/features")
    public Map<String, Object> getFeatures() {
        Map<String, Object> features = new HashMap<>();
        features.put("emailVerification", emailVerificationEnabled);
        features.put("maxUsersPerPage", maxUsersPerPage);
        features.put("activeProfiles", Arrays.asList(env.getActiveProfiles()));
        return features;
    }
}

@Service
public class OrderServiceClient {
    
    private static final Logger log = LoggerFactory.getLogger(OrderServiceClient.class);
    
    @Autowired
    private RestTemplate restTemplate;
    
    @CircuitBreaker(name = "orderService", fallbackMethod = "getOrdersFallback")
    @TimeLimiter(name = "orderService")
    @Bulkhead(name = "orderService", type = Bulkhead.Type.THREADPOOL)
    @Retry(name = "orderService", fallbackMethod = "getOrdersRetryFallback")
    public CompletableFuture<List<OrderDto>> getUserOrders(Long userId) {
        return CompletableFuture.supplyAsync(() -> {
            String url = "http://order-service/api/orders?userId=" + userId;
            ResponseEntity<List<OrderDto>> response = restTemplate.exchange(
                url,
                HttpMethod.GET,
                null,
                new ParameterizedTypeReference<List<OrderDto>>() {}
            );
            return response.getBody();
        });
    }
    
    private CompletableFuture<List<OrderDto>> getOrdersFallback(Long userId, 
            Exception ex) {
        log.warn("Fallback for user {}: {}", userId, ex.getMessage());
        return CompletableFuture.completedFuture(Collections.emptyList());
    }
    
    private CompletableFuture<List<OrderDto>> getOrdersRetryFallback(Long userId,
            Exception ex) {
        log.error("All retries failed for user {}: {}", userId, ex.getMessage());
        return CompletableFuture.completedFuture(
            List.of(OrderDto.builder()
                .id(-1L)
                .status("UNAVAILABLE")
                .build())
        );
    }
}

# application.yml for Resilience4j
resilience4j:
  circuitbreaker:
    instances:
      orderService:
        register-health-indicator: true
        sliding-window-size: 10
        minimum-number-of-calls: 5
        permitted-number-of-calls-in-half-open-state: 3
        automatic-transition-from-open-to-half-open-enabled: true
        wait-duration-in-open-state: 10s
        failure-rate-threshold: 50
        event-consumer-buffer-size: 10
        record-exceptions:
          - org.springframework.web.client.HttpServerErrorException
          - java.io.IOException
          - java.util.concurrent.TimeoutException
  
  timelimiter:
    instances:
      orderService:
        timeout-duration: 3s
        cancel-running-future: true
  
  bulkhead:
    instances:
      orderService:
        max-thread-pool-size: 4
        core-thread-pool-size: 2
        queue-capacity: 2
        keep-alive-duration: 20ms
  
  retry:
    instances:
      orderService:
        max-attempts: 3
        wait-duration: 500ms
        retry-exceptions:
          - org.springframework.web.client.HttpServerErrorException
          - java.util.concurrent.TimeoutException

@Configuration
public class TracingConfig {
    
    @Bean
    public AlwaysSampler defaultSampler() {
        return new AlwaysSampler();
    }
    
    @Bean
    public RestTemplate restTemplate(RestTemplateBuilder builder) {
        return builder.build();
    }
    
    @Bean
    public WebClient webClient() {
        return WebClient.builder()
            .filter(WebClientTracingFilter.create())
            .build();
    }
}

@RestController
@Slf4j
public class OrderController {
    
    @Autowired
    private Tracer tracer;
    
    @Autowired
    private OrderService orderService;
    
    @GetMapping("/api/orders/{id}")
    public OrderDto getOrder(@PathVariable Long id) {
        Span currentSpan = tracer.currentSpan();
        if (currentSpan != null) {
            currentSpan.tag("order.id", String.valueOf(id));
            currentSpan.annotate("Fetching order from database");
        }
        
        log.info("Fetching order with id: {}", id);
        
        return orderService.findById(id);
    }
    
    @GetMapping("/api/orders/trace")
    public String getTraceInfo() {
        Span span = tracer.currentSpan();
        if (span != null) {
            TraceContext context = span.context();
            return String.format("TraceId: %s, SpanId: %s",
                context.traceId(), context.spanId());
        }
        return "No tracing context";
    }
}

@Configuration
public class MessagingConfig {
    
    @Bean
    public Supplier<OrderEvent> orderSupplier() {
        return () -> {
            OrderEvent event = new OrderEvent();
            event.setOrderId(System.currentTimeMillis());
            event.setStatus("CREATED");
            return event;
        };
    }
    
    @Bean
    public Function<OrderEvent, PaymentEvent> processPayment() {
        return orderEvent -> {
            PaymentEvent payment = new PaymentEvent();
            payment.setOrderId(orderEvent.getOrderId());
            payment.setStatus("PROCESSING");
            payment.setAmount(new BigDecimal("100.00"));
            return payment;
        };
    }
    
    @Bean
    public Consumer<PaymentEvent> handlePaymentResult() {
        return paymentEvent -> {
            log.info("Received payment result: {}", paymentEvent);
            if ("SUCCESS".equals(paymentEvent.getStatus())) {
                // Update order status
                orderService.confirmOrder(paymentEvent.getOrderId());
            } else {
                // Handle failure
                orderService.cancelOrder(paymentEvent.getOrderId(), 
                    "Payment failed");
            }
        };
    }
}

@SpringBootApplication
@EnableBinding(OrderProcessor.class)
public class OrderServiceApplication {
    
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

public interface OrderProcessor {
    
    String INPUT = "order-input";
    String OUTPUT = "order-output";
    
    @Input(INPUT)
    SubscribableChannel input();
    
    @Output(OUTPUT)
    MessageChannel output();
}

@Service
public class OrderMessageHandler {
    
    @Autowired
    private OrderProcessor processor;
    
    @StreamListener(OrderProcessor.INPUT)
    public void handleOrder(OrderEvent event) {
        log.info("Received order: {}", event);
        
        // Process order
        Order order = orderService.processOrder(event);
        
        // Send response
        processor.output().send(MessageBuilder
            .withPayload(order)
            .setHeader("status", "PROCESSED")
            .build());
    }
}

# Dockerfile for Spring Boot application
FROM eclipse-temurin:17-jre-alpine
VOLUME /tmp
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

# Multi-stage build for smaller images
FROM maven:3.8-eclipse-temurin-17 AS builder
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn package -DskipTests

FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
COPY --from=builder /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

# docker-compose.yml for local development
version: '3.8'
services:
  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: userdb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7
    ports:
      - "6379:6379"

  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "5672:5672"
      - "15672:15672"

  eureka-server:
    build: ./eureka-server
    ports:
      - "8761:8761"
    environment:
      - SPRING_PROFILES_ACTIVE=docker

  config-server:
    build: ./config-server
    ports:
      - "8888:8888"
    depends_on:
      - eureka-server
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - EUREKA_URI=http://eureka-server:8761/eureka

  user-service:
    build: ./user-service
    ports:
      - "8081:8081"
    depends_on:
      - postgres
      - eureka-server
      - config-server
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - EUREKA_URI=http://eureka-server:8761/eureka
      - CONFIG_URI=http://config-server:8888
      - DB_URL=jdbc:postgresql://postgres:5432/userdb

  order-service:
    build: ./order-service
    ports:
      - "8082:8082"
    depends_on:
      - postgres
      - rabbitmq
      - eureka-server
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - EUREKA_URI=http://eureka-server:8761/eureka
      - RABBIT_HOST=rabbitmq

  api-gateway:
    build: ./api-gateway
    ports:
      - "8080:8080"
    depends_on:
      - eureka-server
      - user-service
      - order-service
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - EUREKA_URI=http://eureka-server:8761/eureka

volumes:
  postgres_data:

# Kubernetes deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: myregistry/user-service:latest
        ports:
        - containerPort: 8080
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "k8s"
        - name: DB_URL
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: url
        - name: DB_USERNAME
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: username
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: password
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /actuator/health/readiness
            port: 8080
          initialDelaySeconds: 20
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
  - port: 80
    targetPort: 8080
  type: ClusterIP

ASP.NET Core is a cross-platform, high-performance framework for building modern, cloud-based, internet-connected applications. Released in 2016 as a complete rewrite of the original ASP.NET, it represents a fundamental shift in Microsoft's web development strategy, embracing open-source development, cross-platform support, and modern architectural patterns.

Kestrel is the cross-platform web server for ASP.NET Core, designed for high performance.

Kestrel Features:

• Performance: One of the fastest web servers (TechEmpower benchmarks)
• Cross-platform: Runs on Windows, Linux, macOS
• HTTP/2 support: Multiplexing, server push
• HTTPS: Built-in SSL/TLS support
• WebSockets: Real-time communication
• Unix sockets: High-performance inter-process communication

Configuration Example:

var builder = WebApplication.CreateBuilder(args);

// Configure Kestrel
builder.WebHost.ConfigureKestrel(options =>
{
    // Listen on port 5000
    options.Listen(IPAddress.Any, 5000);
    
    // Listen on port 5001 with HTTPS
    options.Listen(IPAddress.Any, 5001, listenOptions =>
    {
        listenOptions.UseHttps("certificate.pfx", "password");
    });
    
    // Configure limits
    options.Limits.MaxConcurrentConnections = 100;
    options.Limits.MaxConcurrentUpgradedConnections = 100;
    options.Limits.MaxRequestBodySize = 10 * 1024 * 1024; // 10 MB
    options.Limits.MinRequestBodyDataRate = new MinDataRate(
        bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
    options.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(2);
    options.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(30);
});

var app = builder.Build();
app.Run();

Middleware components form the request pipeline, handling requests and responses.

var app = builder.Build();

// Custom middleware
app.Use(async (context, next) =>
{
    // Before next middleware
    context.Items["StartTime"] = DateTime.UtcNow;
    
    await next.Invoke();
    
    // After next middleware
    var duration = DateTime.UtcNow - (DateTime)context.Items["StartTime"];
    Console.WriteLine($"Request took {duration.TotalMilliseconds}ms");
});

// Built-in middleware
app.UseHttpsRedirection();      // Redirect HTTP to HTTPS
app.UseStaticFiles();           // Serve static files
app.UseRouting();               // Route matching
app.UseAuthentication();        // Authentication
app.UseAuthorization();         // Authorization
app.UseCors();                  // CORS policy

// Terminal middleware (ends pipeline)
app.MapGet("/api/health", () => Results.Ok(new { status = "Healthy" }));

// Conditional middleware
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}
else
{
    app.UseExceptionHandler("/error");
    app.UseHsts();
}

app.Run();

Custom Middleware Class:

public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;
    
    public RequestLoggingMiddleware(RequestDelegate next, ILogger<RequestLoggingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        // Log request
        _logger.LogInformation("Request: {Method} {Path} from {IP}", 
            context.Request.Method, 
            context.Request.Path,
            context.Connection.RemoteIpAddress);
        
        // Capture response
        var originalBodyStream = context.Response.Body;
        using var responseBody = new MemoryStream();
        context.Response.Body = responseBody;
        
        await _next(context);
        
        // Log response
        context.Response.Body.Seek(0, SeekOrigin.Begin);
        var responseText = await new StreamReader(context.Response.Body).ReadToEndAsync();
        context.Response.Body.Seek(0, SeekOrigin.Begin);
        
        _logger.LogInformation("Response: {StatusCode} - {Body}", 
            context.Response.StatusCode,
            responseText);
        
        await responseBody.CopyToAsync(originalBodyStream);
    }
}

// Extension method for easy registration
public static class RequestLoggingMiddlewareExtensions
{
    public static IApplicationBuilder UseRequestLogging(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<RequestLoggingMiddleware>();
    }
}

ASP.NET Core includes a built-in dependency injection container with three service lifetimes.

var builder = WebApplication.CreateBuilder(args);

// Register services with different lifetimes
builder.Services.AddScoped<IUserRepository, UserRepository>();      // Per request
builder.Services.AddTransient<IEmailService, EmailService>();       // Per usage
builder.Services.AddSingleton<ICacheService, RedisCacheService>();  // Single instance

// Register with factory
builder.Services.AddScoped<IUserService>(provider => 
{
    var repo = provider.GetRequiredService<IUserRepository>();
    var logger = provider.GetRequiredService<ILogger<UserService>>();
    return new UserService(repo, logger, "custom-config");
});

// Register multiple implementations
builder.Services.AddScoped<IPaymentProcessor, StripePaymentProcessor>();
builder.Services.AddScoped<IPaymentProcessor, PayPalPaymentProcessor>();

// Service example
public class UserService : IUserService
{
    private readonly IUserRepository _userRepository;
    private readonly IEmailService _emailService;
    private readonly ICacheService _cacheService;
    private readonly ILogger<UserService> _logger;
    
    public UserService(
        IUserRepository userRepository,
        IEmailService emailService,
        ICacheService cacheService,
        ILogger<UserService> logger)
    {
        _userRepository = userRepository;
        _emailService = emailService;
        _cacheService = cacheService;
        _logger = logger;
    }
    
    public async Task<User> CreateUserAsync(CreateUserDto dto)
    {
        _logger.LogInformation("Creating user with email: {Email}", dto.Email);
        
        var user = new User
        {
            Email = dto.Email,
            Name = dto.Name,
            CreatedAt = DateTime.UtcNow
        };
        
        await _userRepository.AddAsync(user);
        await _emailService.SendWelcomeEmailAsync(user.Email, user.Name);
        await _cacheService.RemoveAsync("users:all");
        
        return user;
    }
}

ASP.NET Core supports configuration from multiple sources with a unified API.

Configuration Sources:

• appsettings.json: Environment-specific settings
• Environment variables: For sensitive data and container environments
• Command-line arguments: Override at runtime
• Azure Key Vault: For production secrets
• User secrets: For development secrets

var builder = WebApplication.CreateBuilder(args);

// Configuration is already set up by default
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");

// Strongly-typed configuration
public class EmailSettings
{
    public string SmtpServer { get; set; }
    public int Port { get; set; }
    public string Username { get; set; }
    public string Password { get; set; }
    public bool EnableSsl { get; set; }
}

// Bind to class
var emailSettings = builder.Configuration
    .GetSection("Email")
    .Get<EmailSettings>();

// Register for DI
builder.Services.Configure<EmailSettings>(builder.Configuration.GetSection("Email"));

// appsettings.json
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=mydb;User Id=sa;Password=Your_password123;"
  },
  "Email": {
    "SmtpServer": "smtp.gmail.com",
    "Port": 587,
    "Username": "user@gmail.com",
    "Password": "password",
    "EnableSsl": true
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

// Using in service
public class EmailService : IEmailService
{
    private readonly EmailSettings _settings;
    
    public EmailService(IOptions<EmailSettings> options)
    {
        _settings = options.Value;
    }
    
    public async Task SendEmailAsync(string to, string subject, string body)
    {
        using var client = new SmtpClient(_settings.SmtpServer, _settings.Port);
        client.EnableSsl = _settings.EnableSsl;
        client.Credentials = new NetworkCredential(_settings.Username, _settings.Password);
        
        var message = new MailMessage(_settings.Username, to, subject, body);
        await client.SendMailAsync(message);
    }
}

// Record declaration
public record User(
    string Id,
    string Email,
    string Name,
    DateTime CreatedAt
);

// Record with validation
public record CreateUserRequest
{
    public required string Email { get; init; }
    public required string Name { get; init; }
    public string? PhoneNumber { get; init; }
    
    public void Deconstruct(out string email, out string name)
    {
        email = Email;
        name = Name;
    }
}

// Record with methods
public record Order
{
    public string Id { get; }
    public List<OrderItem> Items { get; }
    public decimal Total { get; }
    
    public Order(List<OrderItem> items)
    {
        Id = Guid.NewGuid().ToString();
        Items = items;
        Total = items.Sum(i => i.Price * i.Quantity);
    }
    
    public Order WithDiscount(decimal percentage)
    {
        return this with { Total = Total * (1 - percentage / 100) };
    }
}

// Usage
var user1 = new User("1", "john@example.com", "John", DateTime.UtcNow);
var user2 = user1 with { Name = "John Doe" }; // Non-destructive mutation

// Value-based equality
Console.WriteLine(user1 == user2); // False (different names)

// Deconstruction
var (id, email, name, createdAt) = user1;

public static decimal CalculateDiscount(Order order) => order switch
{
    // Type pattern
    { Total: > 1000 } => order.Total * 0.1m,
    
    // Property pattern with nested
    { Customer: { IsPremium: true }, Total: > 500 } => order.Total * 0.15m,
    
    // Relational pattern
    { Items.Count: > 5 } => order.Total * 0.2m,
    
    // Logical patterns
    { Total: > 100 and < 500 } => order.Total * 0.05m,
    
    // List pattern (C# 11)
    { Items: [var first, ..] } when first.Price > 100 => order.Total * 0.12m,
    
    // Discard
    _ => 0
};

// Switch expression with multiple inputs
public static string GetShippingMethod(Order order, Address address) => 
    (order.Total, address.Country) switch
    {
        (> 1000, "USA") => "Express",
        (> 500, "USA") => "Standard",
        (_, "Canada") => "International",
        (_, _) => "Economy"
    };

// Type pattern matching
public static string ProcessPayment(IPayment payment) => payment switch
{
    CreditCardPayment { CardType: "Visa" } cc => ProcessVisaPayment(cc),
    PayPalPayment pp => ProcessPayPalPayment(pp),
    CryptoPayment crypto => ProcessCryptoPayment(crypto),
    null => throw new ArgumentNullException(nameof(payment)),
    _ => throw new NotSupportedException($"Payment type {payment.GetType()} not supported")
};

public class OrderService
{
    private readonly IOrderRepository _orderRepository;
    private readonly IPaymentService _paymentService;
    private readonly IInventoryService _inventoryService;
    private readonly IEmailService _emailService;
    
    public async Task<Order> PlaceOrderAsync(OrderRequest request, CancellationToken cancellationToken = default)
    {
        // Validate
        if (!await ValidateOrderAsync(request, cancellationToken))
        {
            throw new ValidationException("Invalid order");
        }
        
        // Reserve inventory (parallel operations)
        var reservationTasks = request.Items.Select(item => 
            _inventoryService.ReserveAsync(item.ProductId, item.Quantity, cancellationToken));
        
        var reservations = await Task.WhenAll(reservationTasks);
        
        if (reservations.Any(r => !r.Success))
        {
            throw new InventoryException("Some items are out of stock");
        }
        
        // Create order
        var order = new Order
        {
            Id = Guid.NewGuid().ToString(),
            CustomerId = request.CustomerId,
            Items = request.Items,
            Total = request.Items.Sum(i => i.Price * i.Quantity),
            CreatedAt = DateTime.UtcNow
        };
        
        // Process payment and save order concurrently
        var (payment, savedOrder) = await (
            _paymentService.ProcessPaymentAsync(request.PaymentDetails, order.Total, cancellationToken),
            _orderRepository.CreateAsync(order, cancellationToken)
        );
        
        // Update order with payment info
        savedOrder.PaymentId = payment.Id;
        savedOrder.Status = OrderStatus.Paid;
        await _orderRepository.UpdateAsync(savedOrder, cancellationToken);
        
        // Send confirmation (fire and forget with error handling)
        _ = SendConfirmationEmailAsync(savedOrder, cancellationToken)
            .ContinueWith(t =>
            {
                if (t.IsFaulted)
                {
                    _logger.LogError(t.Exception, "Failed to send confirmation email");
                }
            }, cancellationToken);
        
        return savedOrder;
    }
    
    // Async streams with IAsyncEnumerable
    public async IAsyncEnumerable<Order> StreamOrdersAsync(DateTime from, [EnumeratorCancellation] CancellationToken cancellationToken)
    {
        var page = 0;
        const int pageSize = 100;
        
        while (!cancellationToken.IsCancellationRequested)
        {
            var orders = await _orderRepository.GetOrdersPageAsync(from, page++, pageSize, cancellationToken);
            
            if (!orders.Any())
            {
                yield break;
            }
            
            foreach (var order in orders)
            {
                yield return order;
            }
        }
    }
    
    // Async disposal
    public class DatabaseConnection : IAsyncDisposable
    {
        public async ValueTask DisposeAsync()
        {
            await CleanupAsync();
        }
    }
}

// Entity configuration
public class User
{
    public string Id { get; set; }
    public string Email { get; set; }
    public string Name { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? LastLoginAt { get; set; }
    
    // Navigation properties
    public ICollection<Order> Orders { get; set; }
    public Profile Profile { get; set; }
}

public class Order
{
    public string Id { get; set; }
    public string UserId { get; set; }
    public User User { get; set; }
    public decimal Total { get; set; }
    public OrderStatus Status { get; set; }
    public ICollection<OrderItem> Items { get; set; }
    public DateTime CreatedAt { get; set; }
}

// DbContext configuration
public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }
    
    public DbSet<User> Users { get; set; }
    public DbSet<Order> Orders { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // User configuration
        modelBuilder.Entity<User>(entity =>
        {
            entity.HasKey(e => e.Id);
            entity.HasIndex(e => e.Email).IsUnique();
            
            entity.Property(e => e.Name)
                .IsRequired()
                .HasMaxLength(100);
            
            entity.Property(e => e.CreatedAt)
                .HasDefaultValueSql("GETUTCDATE()");
            
            // Value conversion
            entity.Property(e => e.Email)
                .HasConversion(
                    v => v.ToLowerInvariant(),
                    v => v
                );
            
            // Owned entity
            entity.OwnsOne(e => e.Profile, profile =>
            {
                profile.Property(p => p.Bio).HasMaxLength(500);
                profile.Property(p => p.AvatarUrl);
            });
            
            // Query filter
            entity.HasQueryFilter(e => e.CreatedAt > DateTime.UtcNow.AddYears(-1));
        });
        
        // Order configuration
        modelBuilder.Entity<Order>(entity =>
        {
            entity.HasKey(e => e.Id);
            
            entity.Property(e => e.Total)
                .HasPrecision(18, 2);
            
            entity.Property(e => e.Status)
                .HasConversion<string>();
            
            entity.HasOne(e => e.User)
                .WithMany(u => u.Orders)
                .HasForeignKey(e => e.UserId)
                .OnDelete(DeleteBehavior.Restrict);
            
            // Shadow property
            entity.Property<DateTime>("LastUpdated");
        });
    }
}

// Repository pattern with EF Core
public interface IOrderRepository
{
    Task<Order> GetByIdAsync(string id, CancellationToken cancellationToken = default);
    Task<IEnumerable<Order>> GetUserOrdersAsync(string userId, CancellationToken cancellationToken = default);
    Task<Order> CreateAsync(Order order, CancellationToken cancellationToken = default);
    Task<Order> UpdateAsync(Order order, CancellationToken cancellationToken = default);
    Task<bool> DeleteAsync(string id, CancellationToken cancellationToken = default);
}

public class OrderRepository : IOrderRepository
{
    private readonly AppDbContext _context;
    
    public OrderRepository(AppDbContext context)
    {
        _context = context;
    }
    
    public async Task<Order> GetByIdAsync(string id, CancellationToken cancellationToken = default)
    {
        return await _context.Orders
            .Include(o => o.User)
            .Include(o => o.Items)
            .FirstOrDefaultAsync(o => o.Id == id, cancellationToken);
    }
    
    public async Task<IEnumerable<Order>> GetUserOrdersAsync(string userId, CancellationToken cancellationToken = default)
    {
        return await _context.Orders
            .Where(o => o.UserId == userId)
            .OrderByDescending(o => o.CreatedAt)
            .Take(50)
            .ToListAsync(cancellationToken);
    }
    
    public async Task<Order> CreateAsync(Order order, CancellationToken cancellationToken = default)
    {
        await _context.Orders.AddAsync(order, cancellationToken);
        await _context.SaveChangesAsync(cancellationToken);
        return order;
    }
    
    public async Task<Order> UpdateAsync(Order order, CancellationToken cancellationToken = default)
    {
        _context.Entry(order).State = EntityState.Modified;
        _context.Entry(order).Property("LastUpdated").CurrentValue = DateTime.UtcNow;
        await _context.SaveChangesAsync(cancellationToken);
        return order;
    }
    
    public async Task<bool> DeleteAsync(string id, CancellationToken cancellationToken = default)
    {
        var order = await _context.Orders.FindAsync(new[] { id }, cancellationToken);
        if (order == null) return false;
        
        _context.Orders.Remove(order);
        await _context.SaveChangesAsync(cancellationToken);
        return true;
    }
}

// Raw SQL queries
var users = await _context.Users
    .FromSqlRaw("SELECT * FROM Users WHERE Email LIKE {0}", "%@example.com")
    .ToListAsync();

// Execute raw SQL
var affected = await _context.Database
    .ExecuteSqlRawAsync("UPDATE Users SET LastLoginAt = GETUTCDATE() WHERE Id = {0}", userId);

var builder = WebApplication.CreateBuilder(args);

// Add services
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

builder.Services.AddScoped<IUserRepository, UserRepository>();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure pipeline
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

// Minimal API endpoints
app.MapGet("/users", async (IUserRepository repo) =>
{
    var users = await repo.GetAllAsync();
    return Results.Ok(users);
})
.WithName("GetUsers")
.WithOpenApi();

app.MapGet("/users/{id}", async (string id, IUserRepository repo) =>
{
    var user = await repo.GetByIdAsync(id);
    return user is not null ? Results.Ok(user) : Results.NotFound();
})
.WithName("GetUserById");

app.MapPost("/users", async (CreateUserRequest request, IUserRepository repo) =>
{
    var user = new User
    {
        Id = Guid.NewGuid().ToString(),
        Email = request.Email,
        Name = request.Name,
        CreatedAt = DateTime.UtcNow
    };
    
    await repo.CreateAsync(user);
    return Results.Created($"/users/{user.Id}", user);
})
.WithName("CreateUser")
.WithValidation();

app.MapPut("/users/{id}", async (string id, UpdateUserRequest request, IUserRepository repo) =>
{
    var user = await repo.GetByIdAsync(id);
    if (user is null) return Results.NotFound();
    
    user.Name = request.Name;
    await repo.UpdateAsync(user);
    
    return Results.Ok(user);
});

app.MapDelete("/users/{id}", async (string id, IUserRepository repo) =>
{
    var result = await repo.DeleteAsync(id);
    return result ? Results.NoContent() : Results.NotFound();
});

// Grouped endpoints
var ordersApi = app.MapGroup("/orders")
    .WithTags("Orders")
    .RequireAuthorization();

ordersApi.MapGet("/", async (IOrderRepository repo) =>
    await repo.GetAllAsync());

ordersApi.MapGet("/{id}", async (string id, IOrderRepository repo) =>
    await repo.GetByIdAsync(id) is Order order ? Results.Ok(order) : Results.NotFound());

ordersApi.MapPost("/", async (CreateOrderRequest request, IOrderRepository repo) =>
{
    var order = new Order
    {
        Id = Guid.NewGuid().ToString(),
        UserId = request.UserId,
        Items = request.Items,
        Total = request.Items.Sum(i => i.Price * i.Quantity),
        Status = OrderStatus.Pending,
        CreatedAt = DateTime.UtcNow
    };
    
    await repo.CreateAsync(order);
    return Results.Created($"/orders/{order.Id}", order);
});

// Custom endpoint filters
public class ValidationFilter<T> : IEndpointFilter
{
    public async ValueTask<object?> InvokeAsync(EndpointFilterInvocationContext context, EndpointFilterDelegate next)
    {
        var request = context.Arguments.OfType<T>().FirstOrDefault();
        if (request is null)
        {
            return Results.BadRequest("Invalid request");
        }
        
        // Validate
        var validator = context.HttpContext.RequestServices.GetRequiredService<IValidator<T>>();
        var result = await validator.ValidateAsync(request);
        
        if (!result.IsValid)
        {
            return Results.ValidationProblem(result.ToDictionary());
        }
        
        return await next(context);
    }
}

// Apply filter
app.MapPost("/users", async (CreateUserRequest request, IUserRepository repo) =>
{
    // Handler
})
.AddEndpointFilter<ValidationFilter<CreateUserRequest>>();

app.Run();

// Hub definition
public class ChatHub : Hub
{
    private static readonly Dictionary<string, string> _connections = new();
    private readonly ILogger<ChatHub> _logger;
    
    public ChatHub(ILogger<ChatHub> logger)
    {
        _logger = logger;
    }
    
    public override async Task OnConnectedAsync()
    {
        var userId = Context.UserIdentifier;
        var connectionId = Context.ConnectionId;
        
        lock (_connections)
        {
            _connections[userId] = connectionId;
        }
        
        _logger.LogInformation("User {UserId} connected with connection {ConnectionId}", userId, connectionId);
        
        await Groups.AddToGroupAsync(connectionId, "All");
        await Clients.Caller.SendAsync("Connected", "Welcome to chat!");
        await Clients.Others.SendAsync("UserJoined", userId);
        
        await base.OnConnectedAsync();
    }
    
    public override async Task OnDisconnectedAsync(Exception? exception)
    {
        var userId = Context.UserIdentifier;
        
        lock (_connections)
        {
            _connections.Remove(userId);
        }
        
        await Groups.RemoveFromGroupAsync(Context.ConnectionId, "All");
        await Clients.Others.SendAsync("UserLeft", userId);
        
        await base.OnDisconnectedAsync(exception);
    }
    
    public async Task SendMessage(string user, string message)
    {
        _logger.LogInformation("Message from {User}: {Message}", user, message);
        
        var chatMessage = new ChatMessage
        {
            Id = Guid.NewGuid().ToString(),
            User = user,
            Message = message,
            Timestamp = DateTime.UtcNow
        };
        
        await Clients.All.SendAsync("ReceiveMessage", chatMessage);
    }
    
    public async Task SendPrivateMessage(string targetUser, string message)
    {
        var sender = Context.UserIdentifier;
        
        if (_connections.TryGetValue(targetUser, out var connectionId))
        {
            await Clients.Client(connectionId).SendAsync("ReceivePrivateMessage", sender, message);
            await Clients.Caller.SendAsync("MessageDelivered", targetUser);
        }
        else
        {
            await Clients.Caller.SendAsync("UserOffline", targetUser);
        }
    }
    
    public async Task JoinRoom(string roomName)
    {
        await Groups.AddToGroupAsync(Context.ConnectionId, roomName);
        await Clients.Group(roomName).SendAsync("UserJoinedRoom", Context.UserIdentifier, roomName);
    }
    
    public async Task LeaveRoom(string roomName)
    {
        await Groups.RemoveFromGroupAsync(Context.ConnectionId, roomName);
        await Clients.Group(roomName).SendAsync("UserLeftRoom", Context.UserIdentifier, roomName);
    }
    
    public async Task SendToRoom(string roomName, string message)
    {
        await Clients.Group(roomName).SendAsync("RoomMessage", Context.UserIdentifier, message, DateTime.UtcNow);
    }
    
    public async Task<IEnumerable<string>> GetOnlineUsers()
    {
        lock (_connections)
        {
            return _connections.Keys.ToList();
        }
    }
}

// Program.cs - SignalR setup
builder.Services.AddSignalR(options =>
{
    options.EnableDetailedErrors = true;
    options.MaximumReceiveMessageSize = 102400; // 100 KB
    options.StreamBufferCapacity = 10;
});

builder.Services.AddSingleton<IUserIdProvider, CustomUserIdProvider>();

// Authentication for SignalR
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.Events = new JwtBearerEvents
        {
            OnMessageReceived = context =>
            {
                var accessToken = context.Request.Query["access_token"];
                
                var path = context.HttpContext.Request.Path;
                if (!string.IsNullOrEmpty(accessToken) && path.StartsWithSegments("/chatHub"))
                {
                    context.Token = accessToken;
                }
                
                return Task.CompletedTask;
            }
        };
    });

// Map hub
app.MapHub<ChatHub>("/chatHub", options =>
{
    options.CloseOnAuthenticationExpiration = true;
    options.ApplicationMaxConcurrentConnections = 1000;
});

// Client-side JavaScript
const connection = new signalR.HubConnectionBuilder()
    .withUrl("/chatHub", {
        accessTokenFactory: () => localStorage.getItem("accessToken")
    })
    .withAutomaticReconnect([0, 2000, 5000, 10000, 30000])
    .configureLogging(signalR.LogLevel.Information)
    .build();

connection.on("ReceiveMessage", (message) => {
    console.log("New message:", message);
    displayMessage(message);
});

connection.on("UserJoined", (userId) => {
    showNotification(`${userId} joined the chat`);
});

connection.on("UserLeft", (userId) => {
    showNotification(`${userId} left the chat`);
});

connection.onreconnecting(error => {
    console.log("Reconnecting...", error);
    showReconnectingIndicator();
});

connection.onreconnected(connectionId => {
    console.log("Reconnected with ID:", connectionId);
    hideReconnectingIndicator();
});

connection.onclose(error => {
    console.log("Connection closed", error);
    showOfflineIndicator();
});

async function start() {
    try {
        await connection.start();
        console.log("Connected!");
    } catch (err) {
        console.log(err);
        setTimeout(start, 5000);
    }
}

start();

Load Balancing with YARP (Yet Another Reverse Proxy)

// YARP reverse proxy configuration
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddReverseProxy()
    .LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"));

var app = builder.Build();
app.MapReverseProxy();
app.Run();

// appsettings.json
{
  "ReverseProxy": {
    "Routes": {
      "user-route": {
        "ClusterId": "user-cluster",
        "Match": {
          "Path": "/api/users/{**catch-all}"
        },
        "Transforms": [
          { "PathPattern": "/{**catch-all}" }
        ]
      },
      "order-route": {
        "ClusterId": "order-cluster",
        "Match": {
          "Path": "/api/orders/{**catch-all}"
        }
      }
    },
    "Clusters": {
      "user-cluster": {
        "Destinations": {
          "user1": {
            "Address": "http://user-service-1:8080/"
          },
          "user2": {
            "Address": "http://user-service-2:8080/"
          }
        },
        "LoadBalancingPolicy": "LeastRequests",
        "HealthCheck": {
          "Active": {
            "Enabled": true,
            "Interval": "10s",
            "Timeout": "5s",
            "Policy": "ConsecutiveFailures",
            "Path": "/health"
          }
        }
      },
      "order-cluster": {
        "Destinations": {
          "order1": {
            "Address": "http://order-service-1:8080/"
          },
          "order2": {
            "Address": "http://order-service-2:8080/"
          }
        }
      }
    }
  }
}

Distributed Caching with Redis

// Redis cache setup
builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = builder.Configuration.GetConnectionString("Redis");
    options.InstanceName = "MyApp";
});

// Cache service
public interface ICacheService
{
    Task<T> GetOrSetAsync<T>(string key, Func<Task<T>> factory, TimeSpan? expiration = null);
    Task RemoveAsync(string key);
    Task RemoveByPrefixAsync(string prefix);
}

public class RedisCacheService : ICacheService
{
    private readonly IDistributedCache _cache;
    private readonly ILogger<RedisCacheService> _logger;
    
    public RedisCacheService(IDistributedCache cache, ILogger<RedisCacheService> logger)
    {
        _cache = cache;
        _logger = logger;
    }
    
    public async Task<T> GetOrSetAsync<T>(string key, Func<Task<T>> factory, TimeSpan? expiration = null)
    {
        var cached = await _cache.GetStringAsync(key);
        
        if (!string.IsNullOrEmpty(cached))
        {
            _logger.LogDebug("Cache hit for key: {Key}", key);
            return JsonSerializer.Deserialize<T>(cached);
        }
        
        _logger.LogDebug("Cache miss for key: {Key}", key);
        
        var value = await factory();
        
        var options = new DistributedCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = expiration ?? TimeSpan.FromMinutes(10),
            SlidingExpiration = TimeSpan.FromMinutes(2)
        };
        
        await _cache.SetStringAsync(key, JsonSerializer.Serialize(value), options);
        
        return value;
    }
    
    public async Task RemoveAsync(string key)
    {
        await _cache.RemoveAsync(key);
    }
    
    public async Task RemoveByPrefixAsync(string prefix)
    {
        // This requires additional Redis client for scanning
        var server = ConnectionMultiplexer.Connect(builder.Configuration.GetConnectionString("Redis"))
            .GetServer(builder.Configuration.GetConnectionString("Redis").Split(',')[0]);
        
        var keys = server.Keys(pattern: $"{prefix}*").ToArray();
        
        foreach (var key in keys)
        {
            await _cache.RemoveAsync(key);
        }
    }
}

// Usage in service
public async Task<User> GetUserAsync(string id)
{
    return await _cacheService.GetOrSetAsync(
        $"user:{id}",
        async () => await _userRepository.GetByIdAsync(id),
        TimeSpan.FromMinutes(30)
    );
}

Data Protection API

// Data protection setup
builder.Services.AddDataProtection()
    .PersistKeysToAzureBlobStorage(connectionString, "keys/keyring.xml")
    .ProtectKeysWithAzureKeyVault(keyVaultUrl, credential)
    .SetDefaultKeyLifetime(TimeSpan.FromDays(90));

// Encryption service
public interface IEncryptionService
{
    string Encrypt(string plaintext);
    string Decrypt(string ciphertext);
}

public class DataProtectionEncryptionService : IEncryptionService
{
    private readonly IDataProtector _protector;
    
    public DataProtectionEncryptionService(IDataProtectionProvider provider)
    {
        _protector = provider.CreateProtector("MyApp.Encryption.v1");
    }
    
    public string Encrypt(string plaintext)
    {
        return _protector.Protect(plaintext);
    }
    
    public string Decrypt(string ciphertext)
    {
        return _protector.Unprotect(ciphertext);
    }
}

JWT Authentication

// JWT setup
builder.Services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
    options.TokenValidationParameters = new TokenValidationParameters
    {
        ValidateIssuer = true,
        ValidateAudience = true,
        ValidateLifetime = true,
        ValidateIssuerSigningKey = true,
        ValidIssuer = builder.Configuration["Jwt:Issuer"],
        ValidAudience = builder.Configuration["Jwt:Audience"],
        IssuerSigningKey = new SymmetricSecurityKey(
            Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"])),
        ClockSkew = TimeSpan.Zero
    };
    
    options.Events = new JwtBearerEvents
    {
        OnAuthenticationFailed = context =>
        {
            if (context.Exception.GetType() == typeof(SecurityTokenExpiredException))
            {
                context.Response.Headers.Add("Token-Expired", "true");
            }
            return Task.CompletedTask;
        }
    };
});

// Token service
public interface ITokenService
{
    string GenerateToken(User user);
    string GenerateRefreshToken();
    ClaimsPrincipal GetPrincipalFromExpiredToken(string token);
}

public class TokenService : ITokenService
{
    private readonly IConfiguration _configuration;
    
    public TokenService(IConfiguration configuration)
    {
        _configuration = configuration;
    }
    
    public string GenerateToken(User user)
    {
        var claims = new[]
        {
            new Claim(JwtRegisteredClaimNames.Sub, user.Id),
            new Claim(JwtRegisteredClaimNames.Email, user.Email),
            new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
            new Claim("name", user.Name),
            new Claim("role", string.Join(",", user.Roles))
        };
        
        var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:Key"]));
        var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
        
        var token = new JwtSecurityToken(
            issuer: _configuration["Jwt:Issuer"],
            audience: _configuration["Jwt:Audience"],
            claims: claims,
            expires: DateTime.UtcNow.AddMinutes(15),
            signingCredentials: creds
        );
        
        return new JwtSecurityTokenHandler().WriteToken(token);
    }
    
    public string GenerateRefreshToken()
    {
        var randomNumber = new byte[32];
        using var rng = RandomNumberGenerator.Create();
        rng.GetBytes(randomNumber);
        return Convert.ToBase64String(randomNumber);
    }
    
    public ClaimsPrincipal GetPrincipalFromExpiredToken(string token)
    {
        var tokenValidationParameters = new TokenValidationParameters
        {
            ValidateAudience = false,
            ValidateIssuer = false,
            ValidateIssuerSigningKey = true,
            IssuerSigningKey = new SymmetricSecurityKey(
                Encoding.UTF8.GetBytes(_configuration["Jwt:Key"])),
            ValidateLifetime = false
        };
        
        var tokenHandler = new JwtSecurityTokenHandler();
        var principal = tokenHandler.ValidateToken(token, tokenValidationParameters, out var securityToken);
        
        if (securityToken is not JwtSecurityToken jwtSecurityToken || 
            !jwtSecurityToken.Header.Alg.Equals(SecurityAlgorithms.HmacSha256, StringComparison.InvariantCultureIgnoreCase))
        {
            throw new SecurityTokenException("Invalid token");
        }
        
        return principal;
    }
}

.NET Aspire – Cloud-Native Stack

// AppHost project (orchestration)
var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache")
    .WithRedisCommander()
    .WithDataVolume();

var database = builder.AddPostgres("postgres")
    .WithPgAdmin()
    .WithDataVolume();

var userDb = database.AddDatabase("userdb");

var messaging = builder.AddRabbitMQ("messaging")
    .WithManagementPlugin();

var userService = builder.AddProject<Projects.UserService>("user-service")
    .WithReference(cache)
    .WithReference(userDb)
    .WithReference(messaging)
    .WithEnvironment("ASPNETCORE_ENVIRONMENT", "Development");

var orderService = builder.AddProject<Projects.OrderService>("order-service")
    .WithReference(cache)
    .WithReference(messaging)
    .WithEnvironment("ServiceUrls__UserService", userService.GetEndpoint("http"));

var apiGateway = builder.AddProject<Projects.ApiGateway>("api-gateway")
    .WithReference(userService)
    .WithReference(orderService)
    .WithExternalHttpEndpoints();

builder.Build().Run();

Dapr Integration

// Dapr setup
builder.Services.AddDaprClient();

// Service invocation
[ApiController]
[Route("api/[controller]")]
public class OrderController : ControllerBase
{
    private readonly DaprClient _daprClient;
    
    public OrderController(DaprClient daprClient)
    {
        _daprClient = daprClient;
    }
    
    [HttpGet("{userId}")]
    public async Task<IActionResult> GetUserOrders(string userId)
    {
        // Invoke user service via Dapr
        var user = await _daprClient.InvokeMethodAsync<User>(
            HttpMethod.Get,
            "user-service",
            $"api/users/{userId}");
        
        if (user == null)
        {
            return NotFound();
        }
        
        // Get orders
        var orders = await _daprClient.InvokeMethodAsync<List<Order>>(
            HttpMethod.Get,
            "order-service",
            $"api/orders?userId={userId}");
        
        return Ok(new { User = user, Orders = orders });
    }
    
    [HttpPost]
    public async Task<IActionResult> CreateOrder([FromBody] CreateOrderRequest request)
    {
        // Publish event
        await _daprClient.PublishEventAsync("pubsub", "order-created", request);
        
        // Save state
        var order = new Order
        {
            Id = Guid.NewGuid().ToString(),
            UserId = request.UserId,
            Items = request.Items,
            CreatedAt = DateTime.UtcNow
        };
        
        await _daprClient.SaveStateAsync("statestore", order.Id, order);
        
        return Ok(order);
    }
    
    [HttpGet("state/{id}")]
    public async Task<IActionResult> GetOrderState(string id)
    {
        var order = await _daprClient.GetStateAsync<Order>("statestore", id);
        return order != null ? Ok(order) : NotFound();
    }
}

// Dapr configuration in appsettings.json
{
  "Dapr": {
    "Sidecar": {
      "AppId": "order-service",
      "AppPort": 5000,
      "DaprHttpPort": 3500,
      "DaprGrpcPort": 50001
    }
  }
}

• Response Caching: Use ResponseCache attribute for static content
• Output Caching: Cache entire responses with OutputCache middleware
• Compression: Enable response compression for text-based responses
• Connection Pooling: Use HttpClientFactory for efficient HTTP connections
• Database Optimization: Use AsNoTracking for read-only queries
• Compiled Queries: Use EF Core compiled queries for repeated queries
• Array Pools: Use ArrayPool<T> for temporary buffers
• Span<T> and Memory<T>: For high-performance string processing
• ValueTask: Use for async methods that often complete synchronously
• Native AOT: Compile to native code for faster startup (with limitations)

// Performance optimization examples
[ResponseCache(Duration = 60, Location = ResponseCacheLocation.Any)]
[HttpGet("products")]
public IActionResult GetProducts()
{
    var products = _db.Products
        .AsNoTracking()  // Read-only optimization
        .ToList();
    return Ok(products);
}

// ArrayPool example
public void ProcessData(byte[] data)
{
    var buffer = ArrayPool<byte>.Shared.Rent(1024);
    try
    {
        // Use buffer
        Array.Copy(data, buffer, data.Length);
    }
    finally
    {
        ArrayPool<byte>.Shared.Return(buffer);
    }
}

// Span example
public static int Sum(Span<int> numbers)
{
    var sum = 0;
    foreach (var n in numbers)
    {
        sum += n;
    }
    return sum;
}

// ValueTask example
public ValueTask<User> GetUserAsync(int id)
{
    if (_cache.TryGetValue(id, out User cached))
    {
        return new ValueTask<User>(cached); // Synchronous completion
    }
    return new ValueTask<User>(FetchUserAsync(id));
}

Ruby on Rails (Rails) is a server-side web application framework written in Ruby. Created by David Heinemeier Hansson (DHH) while building Basecamp in 2004 and released as open source in 2005, Rails introduced revolutionary concepts that fundamentally changed web development. Its emphasis on convention over configuration, don't repeat yourself (DRY), and developer happiness created a paradigm shift that influenced frameworks across all programming languages.

Active Record implements the Active Record pattern, providing an intuitive interface for database operations.

Associations and Relationships:

# app/models/user.rb
class User < ApplicationRecord
  # One-to-One
  has_one :profile, dependent: :destroy
  
  # One-to-Many
  has_many :posts, dependent: :destroy
  has_many :comments, dependent: :destroy
  
  # Many-to-Many through join table
  has_many :user_roles
  has_many :roles, through: :user_roles
  
  # Polymorphic associations
  has_many :notifications, as: :notifiable
  
  # Self-referential associations
  has_many :followings, foreign_key: :follower_id, class_name: 'Follow'
  has_many :followers, foreign_key: :followee_id, class_name: 'Follow'
  has_many :followed_users, through: :followings, source: :followee
  
  # Counter cache
  belongs_to :organization, counter_cache: true
end

# app/models/post.rb
class Post < ApplicationRecord
  belongs_to :user, counter_cache: true
  has_many :comments, dependent: :destroy
  has_and_belongs_to_many :tags
  
  # Nested attributes
  accepts_nested_attributes_for :comments, allow_destroy: true
  
  # Delegation
  delegate :username, to: :user, prefix: true
  
  # Enum
  enum status: { draft: 0, published: 1, archived: 2 }
end

Query Interface:

# app/models/post.rb
class Post < ApplicationRecord
  # Named scopes
  scope :published, -> { where(status: :published) }
  scope :recent, -> { order(created_at: :desc).limit(5) }
  scope :by_author, ->(author_id) { where(user_id: author_id) }
  scope :search, ->(query) {
    where("title ILIKE :q OR content ILIKE :q", q: "%#{query}%")
  }
  
  # Class methods for complex queries
  def self.popular_last_week
    published
      .where('created_at > ?', 1.week.ago)
      .joins(:comments)
      .group('posts.id')
      .having('COUNT(comments.id) > 10')
  end
  
  # Custom finders
  def self.find_by_slug_or_id(param)
    find_by(slug: param) || find(param)
  end
end

# Usage examples
@posts = Post.published
             .recent
             .by_author(current_user.id)
             .includes(:user, :tags)
             .page(params[:page])

# Complex joins
@users = User.joins(posts: :comments)
             .where(comments: { created_at: 1.week.ago..Time.current })
             .distinct
             .order('COUNT(comments.id) DESC')
             .group('users.id')
             .limit(10)

Callbacks and Observers:

# app/models/user.rb
class User < ApplicationRecord
  # Available callbacks in order
  before_validation :normalize_email
  after_validation :set_slug
  
  before_create :generate_api_key
  after_create :send_welcome_email
  
  before_update :check_email_changed
  after_update :verify_email, if: :saved_change_to_email?
  
  before_save :encrypt_password
  around_save :log_changes
  
  before_destroy :ensure_no_posts
  after_destroy :cleanup_associated_data
  
  private
  
  def normalize_email
    self.email = email.to_s.downcase.strip
  end
  
  def set_slug
    self.slug = username.parameterize
  end
  
  def generate_api_key
    self.api_key = SecureRandom.hex(32)
  end
  
  def send_welcome_email
    UserMailer.welcome(self).deliver_later
  end
  
  def check_email_changed
    @email_changed = email_changed?
  end
  
  def verify_email
    if @email_changed
      update_column(:email_verified, false)
      EmailVerificationMailer.verify(self).deliver_later
    end
  end
  
  def log_changes
    changes = self.changes.dup
    yield
    Rails.logger.info "User #{id} changed: #{changes}"
  end
  
  def ensure_no_posts
    throw(:abort) if posts.exists?
  end
  
  def cleanup_associated_data
    # Cleanup in background job
    CleanupUserDataJob.perform_later(id)
  end
end

RubyGems is the package manager for Ruby, with over 150,000 gems available. Bundler manages gem dependencies.

Essential Gems:

# Gemfile
source 'https://rubygems.org'
git_source(:github) { |repo| "https://github.com/#{repo}.git" }

ruby '3.2.0'

# Core Rails
gem 'rails', '~> 7.1.0'
gem 'pg', '~> 1.5'
gem 'puma', '~> 6.0'

# Authentication & Authorization
gem 'devise', '~> 4.9'
gem 'pundit', '~> 2.3'

# API
gem 'jbuilder', '~> 2.11'
gem 'rack-cors'

# Background Jobs
gem 'sidekiq', '~> 7.0'
gem 'redis', '~> 5.0'

# Frontend
gem 'sprockets-rails'
gem 'importmap-rails'
gem 'turbo-rails'
gem 'stimulus-rails'

# File Upload
gem 'shrine', '~> 3.5'
gem 'aws-sdk-s3', '~> 1.130'

# Monitoring
gem 'newrelic_rpm'
gem 'sentry-ruby'
gem 'sentry-rails'

# Pagination
gem 'kaminari', '~> 1.2'

# SEO
gem 'friendly_id', '~> 5.5'
gem 'meta-tags', '~> 2.18'

group :development, :test do
  gem 'debug', platforms: %i[ mri mingw x64_mingw ]
  gem 'rspec-rails', '~> 6.0'
  gem 'factory_bot_rails'
  gem 'faker'
end

group :development do
  gem 'web-console'
  gem 'spring'
  gem 'letter_opener'
  gem 'bullet'
end

group :test do
  gem 'capybara'
  gem 'selenium-webdriver'
  gem 'shoulda-matchers'
  gem 'database_cleaner-active_record'
end

Rails uses naming conventions to automatically connect different parts of your application.

myapp/
├── app/                      # Core application code
│   ├── assets/               # CSS, JavaScript, images
│   │   ├── stylesheets/
│   │   ├── javascript/
│   │   └── images/
│   ├── channels/             # Action Cable channels
│   ├── controllers/          # Controllers
│   │   └── concerns/         # Shared controller code
│   ├── helpers/              # View helpers
│   ├── jobs/                 # Background jobs
│   ├── mailers/              # Mailers
│   ├── models/               # Models
│   │   └── concerns/         # Shared model code
│   ├── views/                # View templates
│   │   └── layouts/          # Layout templates
├── bin/                      # Scripts and executables
├── config/                   # Configuration
│   ├── environments/         # Environment configs
│   ├── initializers/         # Initialization code
│   └── locales/              # I18n translations
├── db/                       # Database related
│   ├── migrate/              # Migrations
│   └── seeds.rb              # Seed data
├── lib/                      # Extended modules
│   └── tasks/                # Custom rake tasks
├── log/                      # Application logs
├── public/                   # Static files
├── storage/                  # Active Storage files
├── test/                     # Tests
│   ├── controllers/
│   ├── models/
│   ├── fixtures/
│   └── integration/
├── tmp/                      # Temporary files
└── vendor/                   # Third-party code

This standardized structure means any Rails developer can immediately understand any Rails application, regardless of who built it.

# config/routes.rb
Rails.application.routes.draw do
  # Single resource - generates 7 RESTful routes
  resources :posts
  
  # Nested resources
  resources :users do
    resources :posts, shallow: true
    resources :followers, only: [:index]
    member do
      get :profile
      post :follow
    end
    collection do
      get :active
      get :admins
    end
  end
  
  # Namespaced routes (admin area)
  namespace :admin do
    resources :users
    resources :dashboard, only: [:index]
  end
  
  # API routes with versioning
  namespace :api do
    namespace :v1 do
      resources :posts, only: [:index, :show]
      resources :users, only: [:show] do
        resources :posts, only: [:index]
      end
    end
  end
end

Routes Generated:

Rails generators create complete components with a single command, following all conventions.

# Generate a complete model with migration, tests, and factories
rails generate model User name:string email:string:index age:integer

# This creates:
# - db/migrate/20240101000001_create_users.rb
# - app/models/user.rb
# - test/models/user_test.rb
# - test/fixtures/users.yml

# Generate a controller with actions and views
rails generate controller Users index show new create edit update destroy

# Generate a full scaffold (model, controller, views, tests, routes)
rails generate scaffold Post title:string content:text user:references

# This creates everything needed for a complete CRUD interface

# Generate mailer
rails generate mailer UserMailer welcome notification

# Generate job
rails generate job ProcessImage

# Generate channel for Action Cable
rails generate channel Chat

# Generate custom generator
rails generate generator custom

Scaffold Example:

# One command creates:
rails generate scaffold Product name:string description:text price:decimal category:references

# This generates:
# - Model with validations and associations
# - Migration for products table
# - Controller with full CRUD actions
# - Views for index, show, new, edit, _form
# - Tests for model and controller
# - Routes resource
# - Helpers
# - Factory for testing
# - JSON:API structure

# app/channels/chat_channel.rb
class ChatChannel < ApplicationCable::Channel
  def subscribed
    stream_from "chat_#{params[:room]}"
  end
  
  def unsubscribed
    # Any cleanup needed when channel is unsubscribed
  end
  
  def speak(data)
    message = Message.create!(
      content: data['message'],
      user: current_user,
      room: params[:room]
    )
    
    ActionCable.server.broadcast(
      "chat_#{params[:room]}",
      {
        message: render_message(message),
        user: current_user.username,
        timestamp: Time.current.to_i
      }
    )
  end
  
  private
  
  def render_message(message)
    ApplicationController.render(partial: 'messages/message', locals: { message: message })
  end
end

# app/javascript/channels/chat_channel.js
import consumer from "./consumer"

consumer.subscriptions.create(
  { channel: "ChatChannel", room: "general" },
  {
    connected() {
      console.log("Connected to chat")
    },
    
    disconnected() {
      console.log("Disconnected from chat")
    },
    
    received(data) {
      this.appendMessage(data)
    },
    
    speak(message) {
      this.perform('speak', { message: message })
    },
    
    appendMessage(data) {
      const messages = document.getElementById('messages')
      messages.innerHTML += `
        <div class="message">
          <strong>${data.user}</strong>
          <p>${data.message}</p>
          <small>${new Date(data.timestamp * 1000).toLocaleTimeString()}</small>
        </div>
      `
    }
  }
)

# app/jobs/image_processing_job.rb
class ImageProcessingJob < ApplicationJob
  queue_as :default
  
  # Retry configuration
  retry_on ActiveRecord::Deadlocked, wait: :polynomially_longer, attempts: 3
  discard_on ActiveJob::DeserializationError
  
  def perform(image_id, options = {})
    image = Image.find(image_id)
    
    # Process image
    variants = {
      thumb: { resize: "100x100" },
      medium: { resize: "300x300" },
      large: { resize: "800x800" }
    }
    
    variants.each do |size, opts|
      image.file.variant(opts).processed
    end
    
    # Update record
    image.update!(processed: true, processed_at: Time.current)
    
    # Notify user
    ImageMailer.processing_complete(image.user).deliver_later
  end
end

# app/jobs/notification_job.rb
class NotificationJob < ApplicationJob
  queue_as :notifications
  
  def perform(user_id, message)
    user = User.find(user_id)
    
    # Send push notification
    PushNotificationService.send(user, message)
    
    # Create in-app notification
    user.notifications.create!(
      content: message,
      read: false
    )
    
    # Send email if user is offline
    if user.last_seen_at < 5.minutes.ago
      UserMailer.notification(user, message).deliver_later
    end
  end
end

# Usage
ImageProcessingJob.perform_later(image.id, priority: :high)
NotificationJob.set(wait: 1.minute).perform_later(user.id, "Your order is confirmed")

# app/jobs/order_cleanup_job.rb - Scheduled job
class OrderCleanupJob < ApplicationJob
  queue_as :default
  
  def perform(*args)
    # Delete abandoned carts older than 30 days
    Order.where(status: :abandoned)
         .where('updated_at < ?', 30.days.ago)
         .find_each(&:destroy)
  end
end

# Schedule with cron (config/schedule.yml)
# using gem 'whenever'
every 1.day, at: '2:00 am' do
  runner "OrderCleanupJob.perform_later"
end

# app/mailers/user_mailer.rb
class UserMailer < ApplicationMailer
  default from: 'notifications@example.com'
  
  def welcome_email(user)
    @user = user
    @login_url = login_url
    
    # Attachments
    attachments['welcome-guide.pdf'] = File.read(Rails.root.join('public/guides/welcome.pdf'))
    
    mail(
      to: @user.email,
      subject: 'Welcome to Our Platform',
      template_name: :welcome
    )
  end
  
  def password_reset(user, token)
    @user = user
    @reset_url = edit_password_reset_url(token)
    
    mail(
      to: @user.email,
      subject: 'Password Reset Instructions'
    )
  end
  
  def order_confirmation(order)
    @order = order
    @user = order.user
    
    # Inline images
    attachments.inline['logo.png'] = File.read('app/assets/images/logo.png')
    
    mail(
      to: @user.email,
      subject: "Order Confirmation ##{@order.id}"
    ) do |format|
      format.html { render layout: 'order_mailer' }
      format.text
    end
  end
  
  def digest_email(user, posts)
    @user = user
    @posts = posts
    
    headers['X-Mailer-Count'] = posts.count.to_s
    
    mail(
      to: @user.email,
      subject: 'Your Weekly Digest',
      cc: 'archive@example.com',
      bcc: 'admin@example.com'
    )
  end
end

# app/views/user_mailer/welcome.html.erb
<!DOCTYPE html>
<html>
<head>
  <meta content='text/html; charset=UTF-8' http-equiv='Content-Type' />
</head>
<body>
  <h1>Welcome to our platform, <%= @user.name %>!</h1>
  
  <p>
    You've successfully signed up with: <%= @user.email %>
  </p>
  
  <p>
    To get started, visit: <%= link_to 'Dashboard', @login_url %>
  </p>
  
  <h2>Next steps:</h2>
  <ul>
    <li>Complete your profile</li>
    <li>Connect with other users</li>
    <li>Explore our features</li>
  </ul>
  
  <% if @user.referral_code %>
    <p>
      Share your referral code: <strong><%= @user.referral_code %></strong>
    </p>
  <% end %>
</body>
</html>

# app/views/user_mailer/welcome.text.erb
Welcome to our platform, <%= @user.name %>!
===============================================

You've successfully signed up with: <%= @user.email %>

To get started, visit: <%= @login_url %>

Next steps:
- Complete your profile
- Connect with other users
- Explore our features

<% if @user.referral_code %>
Share your referral code: <%= @user.referral_code %>
<% end %>

Model Tests with RSpec:

# spec/models/user_spec.rb
require 'rails_helper'

RSpec.describe User, type: :model do
  describe 'validations' do
    it { should validate_presence_of(:email) }
    it { should validate_uniqueness_of(:email).case_insensitive }
    it { should validate_presence_of(:username) }
    it { should validate_length_of(:username).is_at_least(3).is_at_most(50) }
  end
  
  describe 'associations' do
    it { should have_many(:posts).dependent(:destroy) }
    it { should have_one(:profile).dependent(:destroy) }
    it { should have_and_belong_to_many(:roles) }
  end
  
  describe 'scopes' do
    let!(:active_user) { create(:user, active: true) }
    let!(:inactive_user) { create(:user, active: false) }
    
    it 'returns active users' do
      expect(User.active).to include(active_user)
      expect(User.active).not_to include(inactive_user)
    end
  end
  
  describe '#full_name' do
    it 'returns combined first and last name' do
      user = build(:user, first_name: 'John', last_name: 'Doe')
      expect(user.full_name).to eq('John Doe')
    end
    
    it 'returns first name when last name is blank' do
      user = build(:user, first_name: 'John', last_name: nil)
      expect(user.full_name).to eq('John')
    end
    
    it 'returns empty string when both names are blank' do
      user = build(:user, first_name: nil, last_name: nil)
      expect(user.full_name).to eq('')
    end
  end
  
  describe '#normalize_email' do
    it 'downcases and strips email before save' do
      user = create(:user, email: '  Test@Example.COM  ')
      expect(user.email).to eq('test@example.com')
    end
  end
  
  describe 'callbacks' do
    it 'creates profile after user creation' do
      user = create(:user)
      expect(user.profile).to be_present
    end
    
    it 'generates API key before creation' do
      user = build(:user)
      expect(user.api_key).to be_nil
      user.save!
      expect(user.api_key).to be_present
    end
  end
end

Controller Tests:

# spec/controllers/users_controller_spec.rb
require 'rails_helper'

RSpec.describe UsersController, type: :controller do
  let(:user) { create(:user) }
  let(:valid_attributes) { attributes_for(:user) }
  let(:invalid_attributes) { attributes_for(:user, email: nil) }
  
  describe 'GET #index' do
    it 'returns a successful response' do
      get :index
      expect(response).to be_successful
    end
    
    it 'assigns @users' do
      user = create(:user)
      get :index
      expect(assigns(:users)).to include(user)
    end
    
    it 'renders the index template' do
      get :index
      expect(response).to render_template(:index)
    end
  end
  
  describe 'GET #show' do
    it 'returns a successful response' do
      get :show, params: { id: user.id }
      expect(response).to be_successful
    end
    
    it 'assigns the requested user' do
      get :show, params: { id: user.id }
      expect(assigns(:user)).to eq(user)
    end
  end
  
  describe 'POST #create' do
    context 'with valid params' do
      it 'creates a new user' do
        expect {
          post :create, params: { user: valid_attributes }
        }.to change(User, :count).by(1)
      end
      
      it 'redirects to the created user' do
        post :create, params: { user: valid_attributes }
        expect(response).to redirect_to(User.last)
      end
    end
    
    context 'with invalid params' do
      it 'does not create a new user' do
        expect {
          post :create, params: { user: invalid_attributes }
        }.not_to change(User, :count)
      end
      
      it 'renders the new template' do
        post :create, params: { user: invalid_attributes }
        expect(response).to render_template(:new)
        expect(response).to have_http_status(:unprocessable_entity)
      end
    end
  end
  
  describe 'DELETE #destroy' do
    it 'destroys the requested user' do
      user_to_delete = create(:user)
      expect {
        delete :destroy, params: { id: user_to_delete.id }
      }.to change(User, :count).by(-1)
    end
    
    it 'redirects to users list' do
      delete :destroy, params: { id: user.id }
      expect(response).to redirect_to(users_path)
    end
  end
end

Integration/Feature Tests:

# spec/features/user_registration_spec.rb
require 'rails_helper'

RSpec.feature 'User Registration', type: :feature do
  scenario 'User successfully registers' do
    visit new_user_registration_path
    
    fill_in 'Email', with: 'test@example.com'
    fill_in 'Username', with: 'testuser'
    fill_in 'Password', with: 'password123'
    fill_in 'Password confirmation', with: 'password123'
    
    click_button 'Sign up'
    
    expect(page).to have_text('Welcome! You have signed up successfully.')
    expect(page).to have_current_path(root_path)
  end
  
  scenario 'User registers with invalid data' do
    visit new_user_registration_path
    
    fill_in 'Email', with: 'invalid-email'
    click_button 'Sign up'
    
    expect(page).to have_text('error')
    expect(page).to have_current_path(user_registration_path)
  end
  
  scenario 'User tries to register with existing email' do
    existing_user = create(:user, email: 'existing@example.com')
    
    visit new_user_registration_path
    
    fill_in 'Email', with: existing_user.email
    fill_in 'Password', with: 'password123'
    fill_in 'Password confirmation', with: 'password123'
    
    click_button 'Sign up'
    
    expect(page).to have_text('Email has already been taken')
  end
end

# Create API-only application
rails new myapi --api

# app/controllers/api/v1/posts_controller.rb
module Api
  module V1
    class PostsController < ApplicationController
      before_action :authenticate_user!
      
      # GET /api/v1/posts
      def index
        @posts = Post.published
                     .includes(:user, :tags)
                     .page(params[:page])
                     .per(params[:per_page] || 20)
        
        render json: {
          data: @posts.map { |post| PostSerializer.new(post) },
          meta: {
            current_page: @posts.current_page,
            total_pages: @posts.total_pages,
            total_count: @posts.total_count
          }
        }
      end
      
      # GET /api/v1/posts/:id
      def show
        @post = Post.find(params[:id])
        render json: PostSerializer.new(@post), include: [:user, :comments]
      end
      
      # POST /api/v1/posts
      def create
        @post = current_user.posts.new(post_params)
        
        if @post.save
          render json: PostSerializer.new(@post), status: :created
        else
          render json: { errors: @post.errors.full_messages }, 
                 status: :unprocessable_entity
        end
      end
      
      private
      
      def post_params
        params.require(:post).permit(:title, :content, tag_ids: [])
      end
    end
  end
end

# app/serializers/post_serializer.rb
class PostSerializer
  include JSONAPI::Serializer
  
  attributes :title, :content, :created_at, :updated_at
  
  belongs_to :user
  has_many :comments
  
  attribute :excerpt do |post|
    post.content.truncate(200)
  end
  
  attribute :comment_count do |post|
    post.comments.count
  end
  
  cache_options store: Rails.cache, namespace: 'jsonapi-serializer', expires_in: 1.hour
end

# config/routes.rb
Rails.application.routes.draw do
  namespace :api do
    namespace :v1 do
      resources :posts
      resources :users, only: [:show] do
        resources :posts, only: [:index]
      end
    end
  end
end

• Caching: Fragment caching, Russian Doll caching, low-level caching
• Background Jobs: Move heavy processing to Sidekiq/Resque
• Database Indexes: Proper indexing for frequent queries
• Eager Loading: Use includes/preload to avoid N+1 queries
• Bullet gem: Detect N+1 queries and unused eager loading
• Pagination: Always paginate large result sets
• Asset Pipeline: Compress and minify assets
• CDN: Serve static assets through CDN
• Database Connection Pool: Optimize pool size for concurrency
• Puma Workers: Scale with multiple workers and threads

# config/puma.rb
workers ENV.fetch("WEB_CONCURRENCY") { 2 }
threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
threads threads_count, threads_count

preload_app!

on_worker_boot do
  ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
end

# Caching example
class ProductsController < ApplicationController
  def index
    @products = Rails.cache.fetch("products/page/#{params[:page]}", expires_in: 1.hour) do
      Product.includes(:category).page(params[:page]).to_a
    end
  end
  
  def show
    @product = Product.find(params[:id])
    fresh_when(@product) # HTTP caching with ETags
  end
end

# Fragment caching in views
<% cache @product do %>
  <div class="product">
    <h2><%= @product.name %></h2>
    <%= render @product.reviews %>
  </div>
<% end %>

Rust is a systems programming language that guarantees memory safety and thread safety without a garbage collector. Originally created by Graydon Hoare at Mozilla Research in 2010, Rust has consistently been voted the "most loved programming language" in Stack Overflow's developer survey. For backend development, Rust offers unprecedented performance while eliminating entire classes of bugs that plague C/C++ applications.

The ownership system is Rust's most distinctive feature and the key to its memory safety guarantees.

// Ownership rules:
// 1. Each value has a single owner
// 2. When owner goes out of scope, value is dropped
// 3. Ownership can be transferred (moved)

fn main() {
    // s1 owns the String
    let s1 = String::from("hello");
    
    // Ownership moves to s2, s1 is no longer valid
    let s2 = s1;
    
    // This would cause a compile error:
    // println!("{}", s1); // ERROR: value borrowed here after move
    
    // Borrowing - temporary access without taking ownership
    let s3 = String::from("world");
    let len = calculate_length(&s3); // &s3 creates a reference (borrow)
    println!("Length of '{}' is {}", s3, len); // s3 still usable
    
    // Mutable borrowing - only one mutable reference allowed at a time
    let mut s4 = String::from("hello");
    append_world(&mut s4);
    println!("{}", s4); // prints "hello world"
}

fn calculate_length(s: &String) -> usize {
    s.len() // s is a reference, can read but not modify
}

fn append_world(s: &mut String) {
    s.push_str(" world"); // Can modify because it's a mutable reference
}

// Lifetimes - ensure references are always valid
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

This ownership system eliminates entire classes of bugs:

• No dangling pointers: References always point to valid data
• No double frees: Each value has exactly one owner
• No iterator invalidation: Can't modify collection while iterating
• Thread safety: Cannot share mutable state across threads accidentally

Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust. Built on the Actix actor framework and Tokio runtime, it consistently ranks at the top of web framework benchmarks, handling millions of requests per second with minimal resource usage.

// Cargo.toml
[package]
name = "actix-api"
version = "0.1.0"
edition = "2021"

[dependencies]
actix-web = "4"
actix-rt = "2"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
sqlx = { version = "0.7", features = ["runtime-tokio-native-tls", "postgres", "uuid"] }
tokio = { version = "1", features = ["full"] }
env_logger = "0.10"
dotenv = "0.15"
uuid = { version = "1", features = ["v4", "serde"] }
chrono = { version = "0.4", features = ["serde"] }
thiserror = "1"
anyhow = "1"
validator = { version = "0.16", features = ["derive"] }
jsonwebtoken = "8"
bcrypt = "0.14"

// src/main.rs
use actix_web::{web, App, HttpServer, HttpResponse, HttpRequest};
use actix_web::middleware::{Logger, Compress, NormalizePath};
use serde::{Deserialize, Serialize};
use sqlx::{PgPool, postgres::PgPoolOptions};
use uuid::Uuid;
use chrono::{DateTime, Utc};
use validator::Validate;
use jsonwebtoken::{encode, decode, Header, Validation, EncodingKey, DecodingKey};
use std::env;

mod models;
mod handlers;
mod middleware;
mod errors;

#[derive(Debug, Serialize, Deserialize)]
struct AppState {
    db: PgPool,
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    dotenv::dotenv().ok();
    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
    
    // Database pool
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let db_pool = PgPoolOptions::new()
        .max_connections(20)
        .connect(&database_url)
        .await
        .expect("Failed to create pool");
    
    // Run migrations
    sqlx::migrate!("./migrations")
        .run(&db_pool)
        .await
        .expect("Failed to run migrations");
    
    let app_state = web::Data::new(AppState { db: db_pool });
    
    println!("Starting server at http://localhost:8080");
    
    HttpServer::new(move || {
        App::new()
            .app_data(app_state.clone())
            .wrap(Logger::default())
            .wrap(Compress::default())
            .wrap(NormalizePath::trim())
            .wrap(middleware::AuthMiddleware)
            .service(
                web::scope("/api/v1")
                    .configure(handlers::user_routes)
                    .configure(handlers::auth_routes)
            )
            .service(
                web::scope("/admin")
                    .wrap(middleware::AdminMiddleware)
                    .configure(handlers::admin_routes)
            )
            .default_service(web::to(handlers::not_found))
    })
    .workers(num_cpus::get())
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Note: This is a simplified version. Full implementation would include all handlers, models, and middleware.

Rocket is a web framework that prioritizes ease of use, type safety, and developer productivity without sacrificing performance. It provides a unique approach to request handling using Rust's type system to guarantee request validity at compile time.

use serde::{Serialize, Deserialize};
use uuid::Uuid;

#[derive(Debug, Serialize, Deserialize)]
pub struct UserResponse {
    pub id: Uuid,
    pub email: String,
    pub username: String,
    pub created_at: chrono::DateTime<chrono::Utc>,
}

use tokio::time::{sleep, Duration};
use tokio::task;

#[tokio::main]
async fn main() {
    let handle = tokio::spawn(async {
        sleep(Duration::from_millis(100)).await;
        "Hello from async task"
    });
    
    let result = handle.await.unwrap();
    println!("{}", result);
}

Optimized Release Build

# Cargo.toml profile for production
[profile.release]
lto = true
codegen-units = 1
opt-level = 3
strip = true

# Build command
cargo build --release

# Result: Single binary, typically 5-15 MB

Dockerfile for Rust Service

FROM rust:1.75-slim as builder
WORKDIR /app
COPY . .
RUN cargo build --release

FROM debian:bookworm-slim
RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY --from=builder /app/target/release/my-service /app/
EXPOSE 8080
CMD ["/app/my-service"]

Go (Golang) was created at Google in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson to address the challenges of building scalable, efficient software at Google's scale. Released as open source in 2009, Go has become the backbone of modern cloud infrastructure, powering tools like Docker, Kubernetes, Terraform, and countless microservices.

package main

import (
    "fmt"
    "time"
    "sync"
)

// Basic goroutine
func sayHello() {
    fmt.Println("Hello from goroutine")
}

func main() {
    go sayHello() // Runs concurrently
    time.Sleep(100 * time.Millisecond) // Give goroutine time to run
}

// Anonymous goroutine
func main() {
    go func() {
        fmt.Println("Hello from anonymous")
    }()
    time.Sleep(100 * time.Millisecond)
}

// Channels for communication
func main() {
    messages := make(chan string)
    
    // Send message
    go func() {
        messages <- "ping"
    }()
    
    // Receive message (blocks until received)
    msg := <-messages
    fmt.Println(msg)
}

// Buffered channels
func main() {
    ch := make(chan int, 3)
    
    ch <- 1
    ch <- 2
    ch <- 3
    
    fmt.Println(<-ch) // 1
    fmt.Println(<-ch) // 2
    fmt.Println(<-ch) // 3
}

// Channel synchronization
func worker(done chan bool) {
    fmt.Print("working...")
    time.Sleep(time.Second)
    fmt.Println("done")
    
    done <- true // Signal completion
}

func main() {
    done := make(chan bool, 1)
    go worker(done)
    
    <-done // Wait for worker
}

// Select statement for multiple channels
func main() {
    c1 := make(chan string)
    c2 := make(chan string)
    
    go func() {
        time.Sleep(1 * time.Second)
        c1 <- "one"
    }()
    
    go func() {
        time.Sleep(2 * time.Second)
        c2 <- "two"
    }()
    
    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-c1:
            fmt.Println("received", msg1)
        case msg2 := <-c2:
            fmt.Println("received", msg2)
        case <-time.After(3 * time.Second):
            fmt.Println("timeout")
        }
    }
}

// Worker pool pattern
func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("worker %d processing job %d\n", id, j)
        time.Sleep(time.Second)
        results <- j * 2
    }
}

func main() {
    const numJobs = 10
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)
    
    // Start 3 workers
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
    
    // Send jobs
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)
    
    // Collect results
    for a := 1; a <= numJobs; a++ {
        <-results
    }
}

// WaitGroup for synchronization
func main() {
    var wg sync.WaitGroup
    
    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            fmt.Printf("Worker %d starting\n", id)
            time.Sleep(time.Second)
            fmt.Printf("Worker %d done\n", id)
        }(i)
    }
    
    wg.Wait() // Wait for all workers
}

// Mutex for shared state
type Counter struct {
    mu    sync.Mutex
    value int
}

func (c *Counter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

func (c *Counter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

func main() {
    var counter Counter
    var wg sync.WaitGroup
    
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Increment()
        }()
    }
    
    wg.Wait()
    fmt.Printf("Counter: %d\n", counter.Value())
}

// Pipeline pattern
func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func sq(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func main() {
    // Set up pipeline
    c := gen(2, 3, 4)
    out := sq(c)
    
    // Consume output
    for n := range out {
        fmt.Println(n) // 4, 9, 16
    }
}

Gin is a high-performance HTTP web framework written in Go. It features a martini-like API but with performance up to 40x faster thanks to httprouter. Gin has become one of the most popular Go frameworks, known for its speed, middleware support, and excellent documentation.

// main.go
package main

import (
    "log"
    "net/http"
    "os"
    "time"
    
    "github.com/gin-gonic/gin"
    "github.com/gin-gonic/gin/binding"
    "github.com/go-playground/validator/v10"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
    "gorm.io/gorm/logger"
    
    "your-project/controllers"
    "your-project/middleware"
    "your-project/models"
    "your-project/services"
)

func main() {
    // Set Gin mode
    if os.Getenv("GIN_MODE") == "release" {
        gin.SetMode(gin.ReleaseMode)
    }
    
    // Initialize database
    dsn := os.Getenv("DATABASE_URL")
    if dsn == "" {
        dsn = "host=localhost user=postgres password=postgres dbname=postgres port=5432 sslmode=disable"
    }
    
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
        Logger: logger.Default.LogMode(logger.Info),
        PrepareStmt: true,
    })
    if err != nil {
        log.Fatal("Failed to connect to database:", err)
    }
    
    // Auto migrate schemas
    err = db.AutoMigrate(
        &models.User{},
        &models.Product{},
        &models.Order{},
    )
    if err != nil {
        log.Fatal("Failed to migrate database:", err)
    }
    
    // Initialize services
    userService := services.NewUserService(db)
    productService := services.NewProductService(db)
    orderService := services.NewOrderService(db)
    
    // Initialize controllers
    userController := controllers.NewUserController(userService)
    productController := controllers.NewProductController(productService)
    orderController := controllers.NewOrderController(orderService)
    
    // Create router
    router := gin.New()
    
    // Global middleware
    router.Use(gin.Logger())
    router.Use(gin.Recovery())
    router.Use(middleware.CORS())
    router.Use(middleware.RateLimiter())
    router.Use(middleware.RequestID())
    
    // Health check
    router.GET("/health", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "status": "healthy",
            "time":   time.Now().Unix(),
        })
    })
    
    // API v1 routes
    v1 := router.Group("/api/v1")
    {
        // Public routes
        auth := v1.Group("/auth")
        {
            auth.POST("/register", userController.Register)
            auth.POST("/login", userController.Login)
            auth.POST("/refresh", userController.RefreshToken)
        }
        
        // Protected routes
        protected := v1.Group("/")
        protected.Use(middleware.AuthRequired())
        {
            // User routes
            users := protected.Group("/users")
            {
                users.GET("/me", userController.GetProfile)
                users.PUT("/me", userController.UpdateProfile)
                users.GET("/:id", userController.GetUser)
            }
            
            // Product routes
            products := protected.Group("/products")
            {
                products.GET("/", productController.ListProducts)
                products.GET("/:id", productController.GetProduct)
                products.POST("/", middleware.AdminRequired(), productController.CreateProduct)
                products.PUT("/:id", middleware.AdminRequired(), productController.UpdateProduct)
                products.DELETE("/:id", middleware.AdminRequired(), productController.DeleteProduct)
            }
            
            // Order routes
            orders := protected.Group("/orders")
            {
                orders.GET("/", orderController.ListOrders)
                orders.POST("/", orderController.CreateOrder)
                orders.GET("/:id", orderController.GetOrder)
                orders.PUT("/:id/cancel", orderController.CancelOrder)
            }
        }
        
        // Admin routes
        admin := v1.Group("/admin")
        admin.Use(middleware.AuthRequired())
        admin.Use(middleware.AdminRequired())
        {
            admin.GET("/stats", adminController.GetStats)
            admin.GET("/users", adminController.ListAllUsers)
        }
    }
    
    // Start server
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }
    
    srv := &http.Server{
        Addr:         ":" + port,
        Handler:      router,
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  120 * time.Second,
    }
    
    log.Printf("Server starting on port %s", port)
    if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
        log.Fatal("Server failed:", err)
    }
}

// models/user.go
package models

import (
    "time"
    
    "gorm.io/gorm"
    "github.com/google/uuid"
)

type User struct {
    ID           uuid.UUID      `gorm:"type:uuid;primary_key" json:"id"`
    Email        string         `gorm:"uniqueIndex;not null" json:"email" binding:"required,email"`
    Username     string         `gorm:"uniqueIndex;not null" json:"username" binding:"required,min=3,max=50"`
    Password     string         `gorm:"not null" json:"-"` // Exclude from JSON
    FirstName    string         `json:"firstName"`
    LastName     string         `json:"lastName"`
    Role         string         `gorm:"default:user" json:"role"`
    Active       bool           `gorm:"default:true" json:"active"`
    LastLoginAt  *time.Time     `json:"lastLoginAt"`
    CreatedAt    time.Time      `json:"createdAt"`
    UpdatedAt    time.Time      `json:"updatedAt"`
    DeletedAt    gorm.DeletedAt `gorm:"index" json:"-"`
    
    // Relationships
    Orders       []Order        `json:"orders,omitempty"`
}

func (u *User) BeforeCreate(tx *gorm.DB) error {
    u.ID = uuid.New()
    return nil
}

// controllers/user_controller.go
package controllers

import (
    "net/http"
    
    "github.com/gin-gonic/gin"
    "github.com/go-playground/validator/v10"
    "golang.org/x/crypto/bcrypt"
    
    "your-project/models"
    "your-project/services"
)

type UserController struct {
    userService *services.UserService
    validate    *validator.Validate
}

func NewUserController(userService *services.UserService) *UserController {
    return &UserController{
        userService: userService,
        validate:    validator.New(),
    }
}

type RegisterRequest struct {
    Email    string `json:"email" binding:"required,email"`
    Username string `json:"username" binding:"required,min=3,max=50"`
    Password string `json:"password" binding:"required,min=8"`
}

func (ctrl *UserController) Register(c *gin.Context) {
    var req RegisterRequest
    
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "error": "Invalid request",
            "details": err.Error(),
        })
        return
    }
    
    // Hash password
    hashedPassword, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to process password"})
        return
    }
    
    user := &models.User{
        Email:    req.Email,
        Username: req.Username,
        Password: string(hashedPassword),
        Role:     "user",
        Active:   true,
    }
    
    if err := ctrl.userService.Create(user); err != nil {
        c.JSON(http.StatusConflict, gin.H{"error": err.Error()})
        return
    }
    
    // Don't return password
    user.Password = ""
    
    c.JSON(http.StatusCreated, gin.H{
        "message": "User created successfully",
        "user":    user,
    })
}

type LoginRequest struct {
    Email    string `json:"email" binding:"required,email"`
    Password string `json:"password" binding:"required"`
}

func (ctrl *UserController) Login(c *gin.Context) {
    var req LoginRequest
    
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request"})
        return
    }
    
    user, err := ctrl.userService.Authenticate(req.Email, req.Password)
    if err != nil {
        c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid credentials"})
        return
    }
    
    // Generate JWT
    token, err := generateJWT(user)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to generate token"})
        return
    }
    
    c.JSON(http.StatusOK, gin.H{
        "token": token,
        "user":  user,
    })
}

// middleware/auth.go
package middleware

import (
    "net/http"
    "strings"
    
    "github.com/gin-gonic/gin"
    "github.com/golang-jwt/jwt/v5"
)

func AuthRequired() gin.HandlerFunc {
    return func(c *gin.Context) {
        authHeader := c.GetHeader("Authorization")
        if authHeader == "" {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "Authorization header required"})
            c.Abort()
            return
        }
        
        // Extract token
        parts := strings.Split(authHeader, " ")
        if len(parts) != 2 || parts[0] != "Bearer" {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid authorization header"})
            c.Abort()
            return
        }
        
        token := parts[1]
        
        // Validate token
        claims, err := validateJWT(token)
        if err != nil {
            c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid or expired token"})
            c.Abort()
            return
        }
        
        // Set user info in context
        c.Set("userID", claims.UserID)
        c.Set("userRole", claims.Role)
        
        c.Next()
    }
}

func AdminRequired() gin.HandlerFunc {
    return func(c *gin.Context) {
        role, exists := c.Get("userRole")
        if !exists {
            c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
            c.Abort()
            return
        }
        
        if role != "admin" {
            c.JSON(http.StatusForbidden, gin.H{"error": "Admin access required"})
            c.Abort()
            return
        }
        
        c.Next()
    }
}

// middleware/rate_limiter.go
package middleware

import (
    "net/http"
    "sync"
    "time"
    
    "github.com/gin-gonic/gin"
    "golang.org/x/time/rate"
)

type RateLimiter struct {
    visitors map[string]*visitor
    mu       sync.Mutex
    rate     rate.Limit
    burst    int
}

type visitor struct {
    limiter  *rate.Limiter
    lastSeen time.Time
}

func NewRateLimiter(r rate.Limit, b int) *RateLimiter {
    rl := &RateLimiter{
        visitors: make(map[string]*visitor),
        rate:     r,
        burst:    b,
    }
    
    // Cleanup old visitors
    go func() {
        for {
            time.Sleep(time.Minute)
            rl.mu.Lock()
            for ip, v := range rl.visitors {
                if time.Since(v.lastSeen) > 3*time.Minute {
                    delete(rl.visitors, ip)
                }
            }
            rl.mu.Unlock()
        }
    }()
    
    return rl
}

func (rl *RateLimiter) RateLimiter() gin.HandlerFunc {
    return func(c *gin.Context) {
        ip := c.ClientIP()
        
        rl.mu.Lock()
        v, exists := rl.visitors[ip]
        if !exists {
            v = &visitor{
                limiter:  rate.NewLimiter(rl.rate, rl.burst),
                lastSeen: time.Now(),
            }
            rl.visitors[ip] = v
        }
        v.lastSeen = time.Now()
        rl.mu.Unlock()
        
        if !v.limiter.Allow() {
            c.JSON(http.StatusTooManyRequests, gin.H{
                "error": "Rate limit exceeded. Try again later.",
            })
            c.Abort()
            return
        }
        
        c.Next()
    }
}

Fiber is an Express.js-inspired web framework built on top of Fasthttp, the fastest HTTP engine for Go. It's designed for zero memory allocation and maximum performance, making it ideal for high-load microservices and APIs where every microsecond counts.

package main

import (
    "log"
    "time"
    
    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/fiber/v2/middleware/compress"
    "github.com/gofiber/fiber/v2/middleware/cors"
    "github.com/gofiber/fiber/v2/middleware/etag"
    "github.com/gofiber/fiber/v2/middleware/limiter"
    "github.com/gofiber/fiber/v2/middleware/logger"
    "github.com/gofiber/fiber/v2/middleware/monitor"
    "github.com/gofiber/fiber/v2/middleware/recover"
    "github.com/gofiber/fiber/v2/middleware/requestid"
    "github.com/gofiber/fiber/v2/middleware/helmet"
    "github.com/gofiber/fiber/v2/middleware/cache"
    "github.com/gofiber/storage/redis/v3"
    "github.com/gofiber/websocket/v2"
)

func main() {
    // Create Fiber app with custom config
    app := fiber.New(fiber.Config{
        Prefork:       true, // Use all CPU cores
        CaseSensitive: true,
        StrictRouting: true,
        ServerHeader:  "Fiber",
        AppName:       "My API v1.0.0",
        ReadTimeout:   5 * time.Second,
        WriteTimeout:  10 * time.Second,
        IdleTimeout:   120 * time.Second,
        BodyLimit:     10 * 1024 * 1024, // 10MB
    })
    
    // Middleware
    app.Use(helmet.New())                    // Security headers
    app.Use(recover.New())                    // Panic recovery
    app.Use(compress.New(compress.Config{    // Compression
        Level: compress.LevelBestSpeed,
    }))
    app.Use(logger.New(logger.Config{        // Logging
        Format: "[${time}] ${ip} ${status} - ${latency} ${method} ${path}\n",
    }))
    app.Use(requestid.New())                  // Request ID
    app.Use(etag.New())                        // ETag support
    app.Use(cors.New(cors.Config{              // CORS
        AllowOrigins: "*",
        AllowMethods: "GET,POST,PUT,DELETE",
        AllowHeaders: "Origin, Content-Type, Accept, Authorization",
    }))
    
    // Rate limiting with Redis storage
    store := redis.New(redis.Config{
        Host:     "localhost",
        Port:     6379,
        Database: 0,
    })
    
    app.Use(limiter.New(limiter.Config{
        Max:        100,
        Expiration: 30 * time.Second,
        KeyGenerator: func(c *fiber.Ctx) string {
            return c.IP()
        },
        LimitReached: func(c *fiber.Ctx) error {
            return c.Status(fiber.StatusTooManyRequests).JSON(fiber.Map{
                "error": "Rate limit exceeded",
            })
        },
        Storage: store,
    }))
    
    // Cache middleware
    app.Use(cache.New(cache.Config{
        Expiration:   30 * time.Minute,
        CacheControl: true,
    }))
    
    // Static files
    app.Static("/static", "./public", fiber.Static{
        Compress:      true,
        ByteRange:     true,
        Browse:        false,
        MaxAge:        3600,
    })
    
    // Health check
    app.Get("/health", func(c *fiber.Ctx) error {
        return c.JSON(fiber.Map{
            "status":    "ok",
            "timestamp": time.Now().Unix(),
            "uptime":    time.Since(startTime).String(),
        })
    })
    
    // Metrics endpoint
    app.Get("/metrics", monitor.New(monitor.Config{
        Title: "My Service Metrics",
    }))
    
    // API routes
    api := app.Group("/api")
    
    // v1 routes
    v1 := api.Group("/v1")
    
    // User routes
    users := v1.Group("/users")
    users.Get("/", getUsers)
    users.Post("/", createUser)
    users.Get("/:id", getUser)
    users.Put("/:id", updateUser)
    users.Delete("/:id", deleteUser)
    
    // Product routes with caching
    products := v1.Group("/products")
    products.Get("/", getProducts)
    products.Get("/:id", getProduct)
    
    // WebSocket route
    app.Get("/ws", websocket.New(func(c *websocket.Conn) {
        // WebSocket handler
        for {
            msgType, msg, err := c.ReadMessage()
            if err != nil {
                break
            }
            log.Printf("Received: %s", msg)
            c.WriteMessage(msgType, []byte("Echo: "+string(msg)))
        }
    }))
    
    // 404 handler
    app.Use(func(c *fiber.Ctx) error {
        return c.Status(fiber.StatusNotFound).JSON(fiber.Map{
            "error": "Route not found",
        })
    })
    
    // Start server
    log.Fatal(app.Listen(":8080"))
}

// Handlers
func getUsers(c *fiber.Ctx) error {
    page := c.QueryInt("page", 1)
    limit := c.QueryInt("limit", 20)
    
    users := []fiber.Map{
        {"id": 1, "name": "John Doe"},
        {"id": 2, "name": "Jane Smith"},
    }
    
    return c.JSON(fiber.Map{
        "data": users,
        "meta": fiber.Map{
            "page":  page,
            "limit": limit,
            "total": len(users),
        },
    })
}

func getUser(c *fiber.Ctx) error {
    id := c.Params("id")
    
    return c.JSON(fiber.Map{
        "id":   id,
        "name": "John Doe",
        "email": "john@example.com",
    })
}

func createUser(c *fiber.Ctx) error {
    type User struct {
        Name  string `json:"name" validate:"required,min=3"`
        Email string `json:"email" validate:"required,email"`
    }
    
    user := new(User)
    if err := c.BodyParser(user); err != nil {
        return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
            "error": "Invalid request",
        })
    }
    
    // Validate
    if err := validate.Struct(user); err != nil {
        return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
            "error": err.Error(),
        })
    }
    
    return c.Status(fiber.StatusCreated).JSON(fiber.Map{
        "message": "User created",
        "user":    user,
    })
}

package auth

import (
    "time"
    "github.com/golang-jwt/jwt/v5"
    "github.com/casbin/casbin/v2"
    "golang.org/x/crypto/bcrypt"
)

type Claims struct {
    UserID   int    `json:"user_id"`
    Username string `json:"username"`
    Role     string `json:"role"`
    jwt.RegisteredClaims
}

type JWTManager struct {
    secretKey     string
    tokenDuration time.Duration
}

func NewJWTManager(secretKey string, tokenDuration time.Duration) *JWTManager {
    return &JWTManager{secretKey, tokenDuration}
}

func (manager *JWTManager) Generate(userID int, username, role string) (string, error) {
    claims := &Claims{
        UserID:   userID,
        Username: username,
        Role:     role,
        RegisteredClaims: jwt.RegisteredClaims{
            ExpiresAt: jwt.NewNumericDate(time.Now().Add(manager.tokenDuration)),
            IssuedAt:  jwt.NewNumericDate(time.Now()),
        },
    }
    
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString([]byte(manager.secretKey))
}

func (manager *JWTManager) Verify(accessToken string) (*Claims, error) {
    token, err := jwt.ParseWithClaims(
        accessToken,
        &Claims{},
        func(token *jwt.Token) (interface{}, error) {
            _, ok := token.Method.(*jwt.SigningMethodHMAC)
            if !ok {
                return nil, jwt.ErrSignatureInvalid
            }
            return []byte(manager.secretKey), nil
        },
    )
    
    if err != nil {
        return nil, err
    }
    
    claims, ok := token.Claims.(*Claims)
    if !ok || !token.Valid {
        return nil, jwt.ErrTokenInvalidClaims
    }
    
    return claims, nil
}

// Password hashing
func HashPassword(password string) (string, error) {
    bytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
    return string(bytes), err
}

func CheckPasswordHash(password, hash string) bool {
    err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
    return err == nil
}

// Casbin authorization
type Authorizer struct {
    enforcer *casbin.Enforcer
}

func NewAuthorizer(modelPath, policyPath string) (*Authorizer, error) {
    enforcer, err := casbin.NewEnforcer(modelPath, policyPath)
    if err != nil {
        return nil, err
    }
    return &Authorizer{enforcer: enforcer}, nil
}

func (a *Authorizer) Authorize(subject, object, action string) (bool, error) {
    return a.enforcer.Enforce(subject, object, action)
}

// Middleware example
func AuthMiddleware(manager *JWTManager, authorizer *Authorizer) gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        if token == "" {
            c.JSON(401, gin.H{"error": "Unauthorized"})
            c.Abort()
            return
        }
        
        claims, err := manager.Verify(token)
        if err != nil {
            c.JSON(401, gin.H{"error": "Invalid token"})
            c.Abort()
            return
        }
        
        // Check authorization
        allowed, err := authorizer.Authorize(
            claims.Role,
            c.Request.URL.Path,
            c.Request.Method,
        )
        
        if err != nil || !allowed {
            c.JSON(403, gin.H{"error": "Forbidden"})
            c.Abort()
            return
        }
        
        c.Set("user_id", claims.UserID)
        c.Set("username", claims.Username)
        c.Set("role", claims.Role)
        c.Next()
    }
}

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"
    
    "github.com/gin-gonic/gin"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
)

// Unit test example
func TestAdd(t *testing.T) {
    result := Add(2, 3)
    expected := 5
    
    if result != expected {
        t.Errorf("Add(2,3) = %d; want %d", result, expected)
    }
}

// Table-driven tests
func TestDivide(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
        hasError bool
    }{
        {"positive numbers", 10, 2, 5, false},
        {"negative numbers", -10, 2, -5, false},
        {"divide by zero", 10, 0, 0, true},
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result, err := Divide(tt.a, tt.b)
            
            if tt.hasError {
                assert.Error(t, err)
            } else {
                assert.NoError(t, err)
                assert.Equal(t, tt.expected, result)
            }
        })
    }
}

// HTTP handler test
func TestUserHandler(t *testing.T) {
    // Setup
    gin.SetMode(gin.TestMode)
    router := gin.New()
    
    // Mock service
    mockService := new(MockUserService)
    mockService.On("GetUser", 1).Return(&User{ID: 1, Name: "John"}, nil)
    
    handler := NewUserHandler(mockService)
    router.GET("/users/:id", handler.GetUser)
    
    // Create request
    req, _ := http.NewRequest("GET", "/users/1", nil)
    w := httptest.NewRecorder()
    
    // Perform request
    router.ServeHTTP(w, req)
    
    // Assert
    assert.Equal(t, http.StatusOK, w.Code)
    
    var response User
    err := json.Unmarshal(w.Body.Bytes(), &response)
    assert.NoError(t, err)
    assert.Equal(t, "John", response.Name)
    
    mockService.AssertExpectations(t)
}

// Integration test with test database
func TestUserRepository_Integration(t *testing.T) {
    if testing.Short() {
        t.Skip("Skipping integration test")
    }
    
    db, err := setupTestDatabase()
    assert.NoError(t, err)
    defer db.Close()
    
    repo := NewUserRepository(db)
    
    // Test Create
    user := &User{Email: "test@example.com", Name: "Test User"}
    err = repo.Create(user)
    assert.NoError(t, err)
    assert.NotZero(t, user.ID)
    
    // Test Get
    found, err := repo.GetByID(user.ID)
    assert.NoError(t, err)
    assert.Equal(t, user.Email, found.Email)
    
    // Test Update
    user.Name = "Updated Name"
    err = repo.Update(user)
    assert.NoError(t, err)
    
    // Test Delete
    err = repo.Delete(user.ID)
    assert.NoError(t, err)
    
    // Verify deletion
    _, err = repo.GetByID(user.ID)
    assert.Error(t, err)
}

// Benchmark test
func BenchmarkUserHandler(b *testing.B) {
    router := gin.New()
    handler := NewUserHandler(&MockUserService{})
    router.GET("/users/:id", handler.GetUser)
    
    for i := 0; i < b.N; i++ {
        req, _ := http.NewRequest("GET", "/users/1", nil)
        w := httptest.NewRecorder()
        router.ServeHTTP(w, req)
    }
}

// Mock example with testify/mock
type MockUserService struct {
    mock.Mock
}

func (m *MockUserService) GetUser(id int) (*User, error) {
    args := m.Called(id)
    if args.Get(0) != nil {
        return args.Get(0).(*User), args.Error(1)
    }
    return nil, args.Error(1)
}

Multi-stage Docker Build

# Build stage
FROM golang:1.21-alpine AS builder

WORKDIR /app

# Copy go mod files
COPY go.mod go.sum ./
RUN go mod download

# Copy source
COPY . .

# Build with optimizations
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-w -s" -o main .

# Final stage
FROM alpine:latest

RUN apk --no-cache add ca-certificates

WORKDIR /root/

# Copy binary from builder
COPY --from=builder /app/main .

# Copy config files
COPY --from=builder /app/config ./config

EXPOSE 8080

CMD ["./main"]

Docker Compose for Local Development

version: '3.8'

services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=postgres://user:password@db:5432/app?sslmode=disable
      - REDIS_URL=redis://redis:6379
    depends_on:
      - db
      - redis
    volumes:
      - ./logs:/app/logs
  
  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=app
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
  
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
  
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - app

volumes:
  postgres_data:
  redis_data:

Kubernetes Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: go-api
spec:
  replicas: 5
  selector:
    matchLabels:
      app: go-api
  template:
    metadata:
      labels:
        app: go-api
    spec:
      containers:
      - name: api
        image: myregistry/go-api:latest
        ports:
        - containerPort: 8080
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: url
        - name: REDIS_URL
          value: redis://redis-service:6379
        resources:
          requests:
            memory: "64Mi"
            cpu: "100m"
          limits:
            memory: "128Mi"
            cpu: "200m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
        readinessProbe:
          httpGet:
            path: /ready
            port: 8080
          initialDelaySeconds: 3
          periodSeconds: 3
---
apiVersion: v1
kind: Service
metadata:
  name: go-api-service
spec:
  selector:
    app: go-api
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer

Graceful Shutdown

package main

import (
    "context"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
    
    "github.com/gin-gonic/gin"
)

func main() {
    router := gin.Default()
    
    // Setup routes
    router.GET("/health", func(c *gin.Context) {
        c.JSON(200, gin.H{"status": "ok"})
    })
    
    srv := &http.Server{
        Addr:    ":8080",
        Handler: router,
    }
    
    // Start server in goroutine
    go func() {
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("listen: %s\n", err)
        }
    }()
    
    // Wait for interrupt signal
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit
    log.Println("Shutting down server...")
    
    // Graceful shutdown with timeout
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    if err := srv.Shutdown(ctx); err != nil {
        log.Fatal("Server forced to shutdown:", err)
    }
    
    log.Println("Server exiting")
}

Kotlin was created by JetBrains in 2011 and officially released in 2016. It's a statically-typed language that targets the JVM, JavaScript, and native platforms. Google announced first-class support for Kotlin on Android in 2017, and since then, it has exploded in popularity. For backend development, Kotlin offers a perfect balance of modern language features, Java interoperability, and access to the mature JVM ecosystem.

// Kotlin calling Java
import java.util.ArrayList

fun useJavaList() {
    val list = ArrayList()
    list.add("Hello")
    list.add("World")
    
    for (item in list) {
        println(item)
    }
}

// Using Java libraries
import com.fasterxml.jackson.databind.ObjectMapper

val mapper = ObjectMapper()
val json = mapper.writeValueAsString(user)
val userFromJson = mapper.readValue(json)

// Java calling Kotlin (from Java code)
// Kotlin class
data class Product(val id: String, val name: String, val price: Double)

// Java usage
Product product = new Product("1", "Laptop", 999.99);
String name = product.getName(); // Accessors generated automatically

// Kotlin object (singleton)
object Config {
    val apiUrl: String = "https://api.example.com"
    const val timeout = 5000 // Compile-time constant
}

// Java usage
String url = Config.INSTANCE.getApiUrl();
int timeout = Config.timeout;

// Companion objects
class MyClass {
    companion object {
        fun create(): MyClass = MyClass()
    }
}

// Java usage
MyClass obj = MyClass.Companion.create();

// Annotations for Java interoperability
@JvmStatic
@JvmOverloads
@JvmField
@Throws(IOException::class)

Ktor is a framework for building asynchronous servers and clients in Kotlin. Created by JetBrains, it's designed from the ground up to leverage Kotlin coroutines, providing a lightweight, flexible, and opinionated-free approach to building web applications and microservices.

// build.gradle.kts
plugins {
    kotlin("jvm") version "1.9.0"
    kotlin("plugin.serialization") version "1.9.0"
    id("io.ktor.plugin") version "2.3.0"
}

dependencies {
    implementation("io.ktor:ktor-server-core-jvm")
    implementation("io.ktor:ktor-server-netty-jvm")
    implementation("io.ktor:ktor-server-content-negotiation-jvm")
    implementation("io.ktor:ktor-serialization-kotlinx-json-jvm")
    implementation("io.ktor:ktor-server-auth-jvm")
    implementation("io.ktor:ktor-server-auth-jwt-jvm")
    implementation("io.ktor:ktor-server-cors-jvm")
    implementation("io.ktor:ktor-server-caching-headers-jvm")
    implementation("io.ktor:ktor-server-compression-jvm")
    implementation("io.ktor:ktor-server-call-logging-jvm")
    implementation("io.ktor:ktor-server-metrics-micrometer-jvm")
    implementation("io.micrometer:micrometer-registry-prometheus:1.11.0")
    implementation("org.jetbrains.exposed:exposed-core:0.44.0")
    implementation("org.jetbrains.exposed:exposed-dao:0.44.0")
    implementation("org.jetbrains.exposed:exposed-jdbc:0.44.0")
    implementation("org.postgresql:postgresql:42.6.0")
    implementation("com.zaxxer:HikariCP:5.0.1")
    implementation("io.arrow-kt:arrow-core:1.2.0")
    implementation("org.slf4j:slf4j-simple:2.0.7")
}

// Application.kt
package com.example

import io.ktor.server.application.*
import io.ktor.server.engine.*
import io.ktor.server.netty.*
import com.example.plugins.*

fun main() {
    embeddedServer(Netty, port = 8080, host = "0.0.0.0") {
        configureSerialization()
        configureMonitoring()
        configureSecurity()
        configureRouting()
        configureSockets()
    }.start(wait = true)
}

// plugins/Serialization.kt
package com.example.plugins

import io.ktor.serialization.kotlinx.json.*
import io.ktor.server.application.*
import io.ktor.server.plugins.contentnegotiation.*

fun Application.configureSerialization() {
    install(ContentNegotiation) {
        json()
    }
}

// plugins/Monitoring.kt
package com.example.plugins

import io.ktor.server.application.*
import io.ktor.server.metrics.micrometer.*
import io.ktor.server.plugins.callloging.*
import io.ktor.server.request.*
import io.micrometer.core.instrument.binder.jvm.*
import io.micrometer.core.instrument.binder.system.*
import io.micrometer.prometheus.*
import org.slf4j.event.*

fun Application.configureMonitoring() {
    val appMicrometerRegistry = PrometheusMeterRegistry(PrometheusConfig.DEFAULT)
    
    install(MicrometerMetrics) {
        registry = appMicrometerRegistry
        meterBinders = listOf(
            JvmGcMetrics(),
            JvmMemoryMetrics(),
            JvmThreadMetrics(),
            ProcessorMetrics()
        )
    }
    
    install(CallLogging) {
        level = Level.INFO
        filter { call -> call.request.path().startsWith("/api") }
        format { call ->
            val status = call.response.status()?.value ?: 0
            val httpMethod = call.request.httpMethod.value
            val path = call.request.path()
            val elapsed = call.response.processingTimeMillis()
            "$httpMethod $path - $status ($elapsed ms)"
        }
    }
}

// plugins/Security.kt
package com.example.plugins

import io.ktor.server.application.*
import io.ktor.server.auth.*
import io.ktor.server.auth.jwt.*
import com.auth0.jwt.JWT
import com.auth0.jwt.algorithms.Algorithm
import java.util.*

fun Application.configureSecurity() {
    val jwtAudience = environment.config.property("jwt.audience").getString()
    val jwtDomain = environment.config.property("jwt.domain").getString()
    val jwtSecret = environment.config.property("jwt.secret").getString()
    
    install(Authentication) {
        jwt("auth-jwt") {
            realm = "ktor.io"
            verifier(
                JWT
                    .require(Algorithm.HMAC256(jwtSecret))
                    .withAudience(jwtAudience)
                    .withIssuer(jwtDomain)
                    .build()
            )
            
            validate { credential ->
                if (credential.payload.getClaim("email").asString() != null) {
                    JWTPrincipal(credential.payload)
                } else null
            }
        }
    }
}

// models/User.kt
package com.example.models

import kotlinx.serialization.Serializable
import java.time.Instant
import java.util.*

@Serializable
data class User(
    val id: String = UUID.randomUUID().toString(),
    val email: String,
    val username: String,
    val passwordHash: String? = null, // Not sent to client
    val firstName: String? = null,
    val lastName: String? = null,
    val role: Role = Role.USER,
    val active: Boolean = true,
    val createdAt: Instant = Instant.now(),
    val updatedAt: Instant = Instant.now()
)

@Serializable
enum class Role {
    USER, ADMIN, MODERATOR
}

@Serializable
data class UserResponse(
    val id: String,
    val email: String,
    val username: String,
    val fullName: String?,
    val role: Role,
    val createdAt: Instant
)

@Serializable
data class CreateUserRequest(
    val email: String,
    val username: String,
    val password: String,
    val firstName: String? = null,
    val lastName: String? = null
)

@Serializable
data class LoginRequest(
    val email: String,
    val password: String
)

@Serializable
data class AuthResponse(
    val token: String,
    val user: UserResponse
)

// repositories/UserRepository.kt
package com.example.repositories

import com.example.models.User
import com.example.models.Role
import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.transactions.transaction
import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
import java.time.Instant
import java.util.*

object UsersTable : Table("users") {
    val id = varchar("id", 36) // UUID length
    val email = varchar("email", 255).uniqueIndex()
    val username = varchar("username", 50).uniqueIndex()
    val passwordHash = varchar("password_hash", 255)
    val firstName = varchar("first_name", 50).nullable()
    val lastName = varchar("last_name", 50).nullable()
    val role = enumerationByName("role", 20, Role::class)
    val active = bool("active").default(true)
    val createdAt = long("created_at")
    val updatedAt = long("updated_at")
    
    override val primaryKey = PrimaryKey(id)
}

class UserRepository(private val database: Database) {
    init {
        transaction(database) {
            SchemaUtils.create(UsersTable)
        }
    }
    
    fun create(user: User): User = transaction(database) {
        UsersTable.insert {
            it[id] = user.id
            it[email] = user.email
            it[username] = user.username
            it[passwordHash] = user.passwordHash!!
            it[firstName] = user.firstName
            it[lastName] = user.lastName
            it[role] = user.role
            it[active] = user.active
            it[createdAt] = user.createdAt.toEpochMilli()
            it[updatedAt] = user.updatedAt.toEpochMilli()
        }
        user
    }
    
    fun findByEmail(email: String): User? = transaction(database) {
        UsersTable.select { UsersTable.email eq email }
            .map { toUser(it) }
            .singleOrNull()
    }
    
    fun findById(id: String): User? = transaction(database) {
        UsersTable.select { UsersTable.id eq id }
            .map { toUser(it) }
            .singleOrNull()
    }
    
    fun findAll(limit: Int = 100, offset: Int = 0): List = transaction(database) {
        UsersTable.selectAll()
            .limit(limit, offset.toLong())
            .map { toUser(it) }
    }
    
    fun update(id: String, updates: Map): Boolean = transaction(database) {
        UsersTable.update({ UsersTable.id eq id }) {
            updates.forEach { (key, value) ->
                when (key) {
                    "firstName" -> it[firstName] = value as String?
                    "lastName" -> it[lastName] = value as String?
                    "active" -> it[active] = value as Boolean
                    "role" -> it[role] = value as Role
                }
            }
            it[updatedAt] = Instant.now().toEpochMilli()
        } > 0
    }
    
    fun delete(id: String): Boolean = transaction(database) {
        UsersTable.deleteWhere { UsersTable.id eq id } > 0
    }
    
    private fun toUser(row: ResultRow): User = User(
        id = row[UsersTable.id],
        email = row[UsersTable.email],
        username = row[UsersTable.username],
        passwordHash = row[UsersTable.passwordHash],
        firstName = row[UsersTable.firstName],
        lastName = row[UsersTable.lastName],
        role = row[UsersTable.role],
        active = row[UsersTable.active],
        createdAt = Instant.ofEpochMilli(row[UsersTable.createdAt]),
        updatedAt = Instant.ofEpochMilli(row[UsersTable.updatedAt])
    )
}

// services/AuthService.kt
package com.example.services

import com.auth0.jwt.JWT
import com.auth0.jwt.algorithms.Algorithm
import com.example.models.*
import com.example.repositories.UserRepository
import at.favre.lib.crypto.bcrypt.BCrypt
import java.util.*

class AuthService(
    private val userRepository: UserRepository,
    private val jwtSecret: String,
    private val jwtIssuer: String,
    private val jwtAudience: String,
    private val tokenExpirationMs: Long = 86400000 // 24 hours
) {
    
    fun hashPassword(password: String): String = 
        BCrypt.withDefaults().hashToString(12, password.toCharArray())
    
    fun verifyPassword(password: String, hash: String): Boolean =
        BCrypt.verifyer().verify(password.toCharArray(), hash).verified
    
    fun generateToken(user: User): String = JWT.create()
        .withAudience(jwtAudience)
        .withIssuer(jwtIssuer)
        .withSubject(user.id)
        .withClaim("email", user.email)
        .withClaim("username", user.username)
        .withClaim("role", user.role.name)
        .withExpiresAt(Date(System.currentTimeMillis() + tokenExpirationMs))
        .sign(Algorithm.HMAC256(jwtSecret))
    
    suspend fun register(request: CreateUserRequest): Result = try {
        // Check if user exists
        val existing = userRepository.findByEmail(request.email)
        if (existing != null) {
            return Result.failure(IllegalStateException("Email already registered"))
        }
        
        // Create user
        val user = User(
            email = request.email,
            username = request.username,
            passwordHash = hashPassword(request.password),
            firstName = request.firstName,
            lastName = request.lastName
        )
        
        val savedUser = userRepository.create(user)
        val token = generateToken(savedUser)
        
        Result.success(
            AuthResponse(
                token = token,
                user = UserResponse(
                    id = savedUser.id,
                    email = savedUser.email,
                    username = savedUser.username,
                    fullName = listOfNotNull(savedUser.firstName, savedUser.lastName)
                        .joinToString(" ").takeIf { it.isNotBlank() },
                    role = savedUser.role,
                    createdAt = savedUser.createdAt
                )
            )
        )
    } catch (e: Exception) {
        Result.failure(e)
    }
    
    suspend fun login(request: LoginRequest): Result = try {
        val user = userRepository.findByEmail(request.email)
            ?: return Result.failure(IllegalStateException("Invalid credentials"))
        
        if (!verifyPassword(request.password, user.passwordHash!!)) {
            return Result.failure(IllegalStateException("Invalid credentials"))
        }
        
        if (!user.active) {
            return Result.failure(IllegalStateException("Account is deactivated"))
        }
        
        val token = generateToken(user)
        
        Result.success(
            AuthResponse(
                token = token,
                user = UserResponse(
                    id = user.id,
                    email = user.email,
                    username = user.username,
                    fullName = listOfNotNull(user.firstName, user.lastName)
                        .joinToString(" ").takeIf { it.isNotBlank() },
                    role = user.role,
                    createdAt = user.createdAt
                )
            )
        )
    } catch (e: Exception) {
        Result.failure(e)
    }
}

// routes/UserRoutes.kt
package com.example.routes

import io.ktor.server.application.*
import io.ktor.server.auth.*
import io.ktor.server.auth.jwt.*
import io.ktor.server.request.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
import com.example.models.*
import com.example.services.AuthService
import com.example.repositories.UserRepository
import io.ktor.http.*

fun Route.userRoutes(
    userRepository: UserRepository,
    authService: AuthService
) {
    route("/users") {
        // Public routes
        post("/register") {
            val request = call.receive()
            
            authService.register(request).fold(
                onSuccess = { response ->
                    call.respond(HttpStatusCode.Created, response)
                },
                onFailure = { error ->
                    call.respond(HttpStatusCode.BadRequest, mapOf("error" to error.message))
                }
            )
        }
        
        post("/login") {
            val request = call.receive()
            
            authService.login(request).fold(
                onSuccess = { response ->
                    call.respond(response)
                },
                onFailure = { error ->
                    call.respond(HttpStatusCode.Unauthorized, mapOf("error" to error.message))
                }
            )
        }
        
        // Protected routes
        authenticate("auth-jwt") {
            get("/me") {
                val principal = call.principal()
                val userId = principal?.payload?.subject
                
                if (userId == null) {
                    call.respond(HttpStatusCode.Unauthorized, mapOf("error" to "Invalid token"))
                    return@get
                }
                
                val user = userRepository.findById(userId)
                if (user == null) {
                    call.respond(HttpStatusCode.NotFound, mapOf("error" to "User not found"))
                    return@get
                }
                
                call.respond(
                    UserResponse(
                        id = user.id,
                        email = user.email,
                        username = user.username,
                        fullName = listOfNotNull(user.firstName, user.lastName)
                            .joinToString(" ").takeIf { it.isNotBlank() },
                        role = user.role,
                        createdAt = user.createdAt
                    )
                )
            }
            
            put("/me") {
                val principal = call.principal()
                val userId = principal?.payload?.subject
                val updates = call.receive>()
                
                val success = userRepository.update(userId!!, updates)
                if (success) {
                    call.respond(mapOf("message" to "User updated successfully"))
                } else {
                    call.respond(HttpStatusCode.NotFound, mapOf("error" to "User not found"))
                }
            }
            
            // Admin only routes
            get {
                val principal = call.principal()
                val role = principal?.payload?.getClaim("role")?.asString()
                
                if (role != "ADMIN") {
                    call.respond(HttpStatusCode.Forbidden, mapOf("error" to "Admin access required"))
                    return@get
                }
                
                val page = call.request.queryParameters["page"]?.toIntOrNull() ?: 1
                val limit = call.request.queryParameters["limit"]?.toIntOrNull() ?: 20
                val offset = (page - 1) * limit
                
                val users = userRepository.findAll(limit, offset)
                call.respond(users.map { user ->
                    UserResponse(
                        id = user.id,
                        email = user.email,
                        username = user.username,
                        fullName = listOfNotNull(user.firstName, user.lastName)
                            .joinToString(" ").takeIf { it.isNotBlank() },
                        role = user.role,
                        createdAt = user.createdAt
                    )
                })
            }
            
            delete("/{id}") {
                val principal = call.principal()
                val role = principal?.payload?.getClaim("role")?.asString()
                
                if (role != "ADMIN") {
                    call.respond(HttpStatusCode.Forbidden, mapOf("error" to "Admin access required"))
                    return@delete
                }
                
                val id = call.parameters["id"] ?: return@delete
                val deleted = userRepository.delete(id)
                
                if (deleted) {
                    call.respond(mapOf("message" to "User deleted successfully"))
                } else {
                    call.respond(HttpStatusCode.NotFound, mapOf("error" to "User not found"))
                }
            }
        }
    }
}

// plugins/Routing.kt
package com.example.plugins

import io.ktor.server.application.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
import com.example.repositories.UserRepository
import com.example.routes.userRoutes
import com.example.services.AuthService
import org.koin.ktor.ext.inject

fun Application.configureRouting() {
    val userRepository by inject()
    val authService by inject()
    
    routing {
        get("/health") {
            call.respond(mapOf(
                "status" to "healthy",
                "timestamp" to System.currentTimeMillis()
            ))
        }
        
        userRoutes(userRepository, authService)
        
        // Static content
        staticResources("/static", "static")
    }
}

// plugins/Sockets.kt
package com.example.plugins

import io.ktor.server.application.*
import io.ktor.server.websocket.*
import io.ktor.websocket.*
import kotlinx.coroutines.channels.consumeEach
import kotlinx.coroutines.delay
import java.time.Duration

fun Application.configureSockets() {
    install(WebSockets) {
        pingPeriod = Duration.ofSeconds(15)
        timeout = Duration.ofSeconds(15)
        maxFrameSize = Long.MAX_VALUE
        masking = false
    }
    
    routing {
        webSocket("/chat") {
            send("Welcome to chat!")
            
            for (frame in incoming.consumeEach { frame ->
                when (frame) {
                    is Frame.Text -> {
                        val text = frame.readText()
                        send("Echo: $text")
                    }
                }
            })
        }
        
        webSocket("/notifications") {
            while (true) {
                delay(5000)
                send("Notification at ${System.currentTimeMillis()}")
            }
        }
    }
}

Micronaut is a modern, JVM-based framework designed for building microservices and serverless applications. Unlike traditional frameworks that use reflection at runtime, Micronaut performs dependency injection at compile time, resulting in faster startup times and lower memory footprint.

// build.gradle.kts
plugins {
    id("org.jetbrains.kotlin.jvm") version "1.9.0"
    id("org.jetbrains.kotlin.kapt") version "1.9.0"
    id("com.github.johnrengelman.shadow") version "8.1.1"
    id("io.micronaut.application") version "4.0.2"
}

version = "0.1"
group = "com.example"

repositories {
    mavenCentral()
}

dependencies {
    kapt("io.micronaut:micronaut-http-validation")
    implementation("io.micronaut:micronaut-http-client")
    implementation("io.micronaut:micronaut-jackson-databind")
    implementation("io.micronaut.kotlin:micronaut-kotlin-runtime")
    implementation("io.micronaut.sql:micronaut-jdbc-hikari")
    implementation("io.micronaut.data:micronaut-data-jdbc")
    implementation("io.micronaut.validation:micronaut-validation")
    implementation("io.micronaut.reactor:micronaut-reactor")
    implementation("io.micronaut.reactor:micronaut-reactor-http-client")
    implementation("io.micronaut.micrometer:micronaut-micrometer-core")
    implementation("io.micronaut.micrometer:micronaut-micrometer-registry-prometheus")
    implementation("io.micronaut.kafka:micronaut-kafka")
    implementation("org.postgresql:postgresql:42.6.0")
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
    implementation("org.jetbrains.kotlin:kotlin-reflect")
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core")
    runtimeOnly("ch.qos.logback:logback-classic")
    runtimeOnly("com.fasterxml.jackson.module:jackson-module-kotlin")
    
    testImplementation("io.micronaut:micronaut-http-client")
    testImplementation("io.micronaut.test:micronaut-test-kotest")
    testImplementation("io.kotest:kotest-runner-junit5:5.6.2")
    testImplementation("io.kotest:kotest-assertions-core:5.6.2")
    testImplementation("io.mockk:mockk:1.13.5")
}

application {
    mainClass.set("com.example.ApplicationKt")
}

java {
    sourceCompatibility = JavaVersion.toVersion("17")
}

tasks {
    compileKotlin {
        kotlinOptions {
            jvmTarget = "17"
        }
    }
    compileTestKotlin {
        kotlinOptions {
            jvmTarget = "17"
        }
    }
}

micronaut {
    version("4.0.0")
    runtime("netty")
    testRuntime("kotest")
    processing {
        incremental(true)
        annotations("com.example.*")
    }
}

// src/main/kotlin/com/example/Application.kt
package com.example

import io.micronaut.runtime.Micronaut

fun main(args: Array) {
    Micronaut.build()
        .packages("com.example")
        .mainClass(Application::class.java)
        .start()
}

class Application

// src/main/kotlin/com/example/domain/User.kt
package com.example.domain

import java.time.Instant
import java.util.UUID

data class User(
    val id: UUID = UUID.randomUUID(),
    val email: String,
    val username: String,
    val passwordHash: String,
    val firstName: String? = null,
    val lastName: String? = null,
    val role: Role = Role.USER,
    val active: Boolean = true,
    val createdAt: Instant = Instant.now(),
    val updatedAt: Instant = Instant.now()
)

enum class Role {
    USER, ADMIN, MODERATOR
}

// src/main/kotlin/com/example/dto/UserDto.kt
package com.example.dto

import io.micronaut.core.annotation.Introspected
import javax.validation.constraints.Email
import javax.validation.constraints.NotBlank
import javax.validation.constraints.Size

@Introspected
data class CreateUserRequest(
    @field:Email
    @field:NotBlank
    val email: String,
    
    @field:NotBlank
    @field:Size(min = 3, max = 50)
    val username: String,
    
    @field:NotBlank
    @field:Size(min = 8)
    val password: String,
    
    val firstName: String? = null,
    val lastName: String? = null
)

@Introspected
data class LoginRequest(
    @field:Email
    @field:NotBlank
    val email: String,
    
    @field:NotBlank
    val password: String
)

@Introspected
data class AuthResponse(
    val token: String,
    val user: UserResponse
)

@Introspected
data class UserResponse(
    val id: String,
    val email: String,
    val username: String,
    val fullName: String?,
    val role: String,
    val createdAt: Instant
)

// src/main/kotlin/com/example/repository/UserRepository.kt
package com.example.repository

import com.example.domain.User
import com.example.domain.Role
import io.micronaut.data.annotation.Repository
import io.micronaut.data.jdbc.annotation.JdbcRepository
import io.micronaut.data.model.query.builder.sql.Dialect
import io.micronaut.data.repository.CrudRepository
import java.util.*

@Repository
@JdbcRepository(dialect = Dialect.POSTGRES)
interface UserRepository : CrudRepository {
    
    fun findByEmail(email: String): User?
    
    fun findByUsername(username: String): User?
    
    fun findAllByActive(active: Boolean): List
    
    fun countByRole(role: Role): Long
    
    fun existsByEmail(email: String): Boolean
}

// src/main/kotlin/com/example/service/AuthService.kt
package com.example.service

import com.example.domain.User
import com.example.domain.Role
import com.example.dto.*
import com.example.repository.UserRepository
import io.micronaut.security.authentication.Authentication
import io.micronaut.security.token.jwt.generator.JwtTokenGenerator
import jakarta.inject.Singleton
import org.springframework.security.crypto.argon2.Argon2PasswordEncoder
import java.time.Instant

@Singleton
class AuthService(
    private val userRepository: UserRepository,
    private val tokenGenerator: JwtTokenGenerator,
    private val passwordEncoder: Argon2PasswordEncoder = Argon2PasswordEncoder.defaultsForSpringSecurityV5_8()
) {
    
    suspend fun register(request: CreateUserRequest): Result {
        return try {
            // Check if user exists
            if (userRepository.existsByEmail(request.email)) {
                return Result.failure(IllegalStateException("Email already registered"))
            }
            
            // Create user
            val user = User(
                email = request.email,
                username = request.username,
                passwordHash = passwordEncoder.encode(request.password),
                firstName = request.firstName,
                lastName = request.lastName
            )
            
            val savedUser = userRepository.save(user)
            val token = generateToken(savedUser)
            
            Result.success(
                AuthResponse(
                    token = token,
                    user = savedUser.toResponse()
                )
            )
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
    
    suspend fun login(request: LoginRequest): Result {
        return try {
            val user = userRepository.findByEmail(request.email)
                ?: return Result.failure(IllegalStateException("Invalid credentials"))
            
            if (!passwordEncoder.matches(request.password, user.passwordHash)) {
                return Result.failure(IllegalStateException("Invalid credentials"))
            }
            
            if (!user.active) {
                return Result.failure(IllegalStateException("Account is deactivated"))
            }
            
            val token = generateToken(user)
            
            Result.success(
                AuthResponse(
                    token = token,
                    user = user.toResponse()
                )
            )
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
    
    private fun generateToken(user: User): String {
        val attributes = mapOf(
            "sub" to user.id.toString(),
            "email" to user.email,
            "username" to user.username,
            "role" to user.role.name,
            "active" to user.active
        )
        
        val authentication = Authentication.build(user.id.toString(), attributes)
        
        return tokenGenerator.generateToken(authentication)
            .orElseThrow { IllegalStateException("Failed to generate token") }
    }
    
    private fun User.toResponse(): UserResponse = UserResponse(
        id = id.toString(),
        email = email,
        username = username,
        fullName = listOfNotNull(firstName, lastName)
            .joinToString(" ").takeIf { it.isNotBlank() },
        role = role.name,
        createdAt = createdAt
    )
}

// src/main/kotlin/com/example/controller/AuthController.kt
package com.example.controller

import com.example.dto.*
import com.example.service.AuthService
import io.micronaut.http.HttpResponse
import io.micronaut.http.HttpStatus
import io.micronaut.http.annotation.*
import io.micronaut.security.annotation.Secured
import io.micronaut.security.rules.SecurityRule
import kotlinx.coroutines.*
import org.slf4j.LoggerFactory

@Controller("/api/v1/auth")
@Secured(SecurityRule.IS_ANONYMOUS)
class AuthController(
    private val authService: AuthService
) {
    
    private val log = LoggerFactory.getLogger(javaClass)
    
    @Post("/register")
    suspend fun register(@Body request: CreateUserRequest): HttpResponse {
        return withContext(Dispatchers.IO) {
            authService.register(request).fold(
                onSuccess = { response ->
                    HttpResponse.created(response)
                },
                onFailure = { error ->
                    log.error("Registration failed", error)
                    HttpResponse.badRequest(mapOf("error" to error.message))
                }
            )
        }
    }
    
    @Post("/login")
    suspend fun login(@Body request: LoginRequest): HttpResponse {
        return withContext(Dispatchers.IO) {
            authService.login(request).fold(
                onSuccess = { response ->
                    HttpResponse.ok(response)
                },
                onFailure = { error ->
                    HttpResponse.status>(HttpStatus.UNAUTHORIZED)
                        .body(mapOf("error" to error.message))
                }
            )
        }
    }
    
    @Get("/verify")
    @Secured(SecurityRule.IS_AUTHENTICATED)
    fun verify(): HttpResponse> {
        return HttpResponse.ok(mapOf("status" to "authenticated"))
    }
}

// src/main/kotlin/com/example/controller/UserController.kt
package com.example.controller

import com.example.dto.UserResponse
import com.example.repository.UserRepository
import io.micronaut.http.HttpResponse
import io.micronaut.http.HttpStatus
import io.micronaut.http.annotation.*
import io.micronaut.security.annotation.Secured
import io.micronaut.security.rules.SecurityRule
import io.micronaut.security.authentication.Authentication
import org.slf4j.LoggerFactory
import java.util.*

@Controller("/api/v1/users")
@Secured(SecurityRule.IS_AUTHENTICATED)
class UserController(
    private val userRepository: UserRepository
) {
    
    private val log = LoggerFactory.getLogger(javaClass)
    
    @Get("/me")
    fun getCurrentUser(authentication: Authentication): HttpResponse {
        val userId = authentication.attributes["sub"] as? String
            ?: return HttpResponse.unauthorized()
        
        val user = userRepository.findById(UUID.fromString(userId))
            ?: return HttpResponse.notFound()
        
        return HttpResponse.ok(
            UserResponse(
                id = user.id.toString(),
                email = user.email,
                username = user.username,
                fullName = listOfNotNull(user.firstName, user.lastName)
                    .joinToString(" ").takeIf { it.isNotBlank() },
                role = user.role.name,
                createdAt = user.createdAt
            )
        )
    }
    
    @Get("/{id}")
    @Secured("ADMIN")
    fun getUser(@PathVariable id: UUID): HttpResponse {
        val user = userRepository.findById(id)
            ?: return HttpResponse.notFound()
        
        return HttpResponse.ok(
            UserResponse(
                id = user.id.toString(),
                email = user.email,
                username = user.username,
                fullName = listOfNotNull(user.firstName, user.lastName)
                    .joinToString(" ").takeIf { it.isNotBlank() },
                role = user.role.name,
                createdAt = user.createdAt
            )
        )
    }
    
    @Get
    @Secured("ADMIN")
    fun getAllUsers(): HttpResponse> {
        val users = userRepository.findAll()
        
        val responses = users.map { user ->
            UserResponse(
                id = user.id.toString(),
                email = user.email,
                username = user.username,
                fullName = listOfNotNull(user.firstName, user.lastName)
                    .joinToString(" ").takeIf { it.isNotBlank() },
                role = user.role.name,
                createdAt = user.createdAt
            )
        }
        
        return HttpResponse.ok(responses)
    }
    
    @Delete("/{id}")
    @Secured("ADMIN")
    fun deleteUser(@PathVariable id: UUID): HttpResponse {
        if (!userRepository.existsById(id)) {
            return HttpResponse.notFound()
        }
        
        userRepository.deleteById(id)
        return HttpResponse.noContent()
    }
}

// src/main/kotlin/com/example/client/ProductClient.kt
package com.example.client

import io.micronaut.http.annotation.Get
import io.micronaut.http.client.annotation.Client
import io.micronaut.retry.annotation.Retryable
import org.reactivestreams.Publisher
import java.time.Duration

@Client("product-service")
@Retryable(
    attempts = "3",
    delay = "1s",
    multiplier = "2.0",
    maxDelay = "10s"
)
interface ProductClient {
    
    @Get("/api/v1/products")
    fun getProducts(): Publisher>
    
    @Get("/api/v1/products/{id}")
    fun getProduct(id: String): Publisher
}

data class Product(
    val id: String,
    val name: String,
    val price: Double,
    val stock: Int
)

// src/main/resources/application.yml
micronaut:
  application:
    name: user-service
  server:
    port: 8080
    cors:
      enabled: true
  http:
    client:
      read-timeout: 30s
  security:
    authentication: bearer
    token:
      jwt:
        signatures:
          secret:
            generator:
              secret: ${JWT_SECRET:pleaseChangeThisSecretForProduction}
    endpoints:
      login:
        enabled: true
      oauth:
        enabled: true

datasources:
  default:
    url: ${JDBC_URL:`jdbc:postgresql://localhost:5432/users`}
    username: ${JDBC_USER:postgres}
    password: ${JDBC_PASSWORD:postgres}
    driver-class-name: org.postgresql.Driver

jpa:
  default:
    properties:
      hibernate:
        hbm2ddl:
          auto: update
        show_sql: true

kafka:
  bootstrap:
    servers: ${KAFKA_BOOTSTRAP_SERVERS:localhost:9092}

consul:
  client:
    registration:
      enabled: true
    defaultZone: ${CONSUL_HOST:localhost}:${CONSUL_PORT:8500}

endpoints:
  all:
    port: 8081
    path: /internal
    sensitive: false
  health:
    enabled: true
    sensitive: false
  metrics:
    enabled: true
    sensitive: false
  prometheus:
    enabled: true
    sensitive: false

# src/main/kotlin/com/example/controller/HealthController.kt
package com.example.controller

import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import io.micronaut.http.HttpStatus
import java.time.Instant

@Controller("/health")
class HealthController {
    
    @Get
    fun health(): Map = mapOf(
        "status" to "UP",
        "timestamp" to Instant.now().toEpochMilli(),
        "service" to "user-service",
        "version" to "1.0.0"
    )
    
    @Get("/liveness")
    fun liveness(): Map = mapOf(
        "status" to "UP"
    )
    
    @Get("/readiness")
    fun readiness(): Map = mapOf(
        "status" to "UP"
    )
}

// src/test/kotlin/com/example/controller/AuthControllerTest.kt
package com.example.controller

import com.example.dto.CreateUserRequest
import io.micronaut.http.HttpRequest
import io.micronaut.http.client.HttpClient
import io.micronaut.http.client.annotation.Client
import io.micronaut.test.extensions.kotest.annotation.MicronautTest
import io.kotest.core.spec.style.StringSpec
import io.kotest.matchers.shouldBe
import io.kotest.matchers.shouldNotBe
import io.kotest.matchers.string.shouldContain

@MicronautTest
class AuthControllerTest(
    @Client("/") private val client: HttpClient
) : StringSpec({
    
    "should register new user" {
        val request = CreateUserRequest(
            email = "test@example.com",
            username = "testuser",
            password = "password123",
            firstName = "Test",
            lastName = "User"
        )
        
        val response = client.toBlocking().exchange(
            HttpRequest.POST("/api/v1/auth/register", request)
        )
        
        response.status.code shouldBe 201
    }
    
    "should not register duplicate email" {
        val request = CreateUserRequest(
            email = "duplicate@example.com",
            username = "duplicate",
            password = "password123"
        )
        
        client.toBlocking().exchange(
            HttpRequest.POST("/api/v1/auth/register", request)
        )
        
        val response = client.toBlocking().exchange>(
            HttpRequest.POST("/api/v1/auth/register", request)
        )
        
        response.status.code shouldBe 400
        response.body()?.get("error") shouldContain "Email already registered"
    }
})

// build.gradle.kts - Add native image plugin
plugins {
    id("org.graalvm.buildtools.native") version "0.9.24"
}

graalvmNative {
    binaries {
        named("main") {
            imageName.set("user-service")
            mainClass.set("com.example.ApplicationKt")
            buildArgs.add("-O1")
            buildArgs.add("--enable-url-protocols=http")
            buildArgs.add("--enable-all-security-services")
            buildArgs.add("--trace-class-initialization=org.slf4j.LoggerFactory")
        }
    }
}

// Build native image
./gradlew nativeCompile

// Result: single executable ~50MB
./build/native/nativeCompile/user-service

// Startup time: ~0.05 seconds
// Memory usage: ~20MB

// build.gradle.kts
plugins {
    id("org.springframework.boot") version "3.1.0"
    id("io.spring.dependency-management") version "1.1.0"
    kotlin("jvm") version "1.9.0"
    kotlin("plugin.spring") version "1.9.0"
    kotlin("plugin.jpa") version "1.9.0"
    kotlin("kapt") version "1.9.0"
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    implementation("org.springframework.boot:spring-boot-starter-security")
    implementation("org.springframework.boot:spring-boot-starter-validation")
    implementation("org.springframework.boot:spring-boot-starter-webflux")
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
    implementation("org.jetbrains.kotlin:kotlin-reflect")
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor")
    implementation("io.projectreactor.kotlin:reactor-kotlin-extensions")
    implementation("io.jsonwebtoken:jjwt-api:0.11.5")
    runtimeOnly("io.jsonwebtoken:jjwt-impl:0.11.5")
    runtimeOnly("io.jsonwebtoken:jjwt-jackson:0.11.5")
    runtimeOnly("org.postgresql:postgresql")
    kapt("org.springframework.boot:spring-boot-configuration-processor")
}

// Application.kt
package com.example

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication

@SpringBootApplication
class Application

fun main(args: Array) {
    runApplication(*args)
}

// config/SecurityConfig.kt
package com.example.config

import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.security.config.annotation.web.builders.HttpSecurity
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity
import org.springframework.security.config.http.SessionCreationPolicy
import org.springframework.security.web.SecurityFilterChain
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder
import org.springframework.security.crypto.password.PasswordEncoder

@Configuration
@EnableWebSecurity
class SecurityConfig {
    
    @Bean
    fun filterChain(http: HttpSecurity): SecurityFilterChain {
        http
            .csrf { it.disable() }
            .sessionManagement { it.sessionCreationPolicy(SessionCreationPolicy.STATELESS) }
            .authorizeHttpRequests {
                it
                    .requestMatchers("/api/v1/auth/**").permitAll()
                    .requestMatchers("/api/v1/public/**").permitAll()
                    .requestMatchers("/actuator/**").permitAll()
                    .requestMatchers("/api/v1/admin/**").hasRole("ADMIN")
                    .anyRequest().authenticated()
            }
        
        return http.build()
    }
    
    @Bean
    fun passwordEncoder(): PasswordEncoder = BCryptPasswordEncoder()
}

// controller/UserController.kt
package com.example.controller

import com.example.dto.UserResponse
import com.example.service.UserService
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.*
import org.springframework.security.access.prepost.PreAuthorize
import java.util.*

@RestController
@RequestMapping("/api/v1/users")
class UserController(
    private val userService: UserService
) {
    
    @GetMapping("/me")
    suspend fun getCurrentUser(@RequestAttribute("userId") userId: String): ResponseEntity {
        val user = userService.findById(UUID.fromString(userId))
            ?: return ResponseEntity.notFound().build()
        
        return ResponseEntity.ok(user.toResponse())
    }
    
    @GetMapping("/{id}")
    @PreAuthorize("hasRole('ADMIN')")
    suspend fun getUser(@PathVariable id: UUID): ResponseEntity {
        val user = userService.findById(id)
            ?: return ResponseEntity.notFound().build()
        
        return ResponseEntity.ok(user.toResponse())
    }
    
    @GetMapping
    @PreAuthorize("hasRole('ADMIN')")
    suspend fun getAllUsers(
        @RequestParam(defaultValue = "0") page: Int,
        @RequestParam(defaultValue = "20") size: Int
    ): ResponseEntity> {
        val users = userService.findAll(page, size)
        return ResponseEntity.ok(users.map { it.toResponse() })
    }
}

// service/UserService.kt
package com.example.service

import com.example.domain.User
import com.example.repository.UserRepository
import kotlinx.coroutines.flow.*
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import java.util.*

@Service
class UserService(
    private val userRepository: UserRepository
) {
    
    @Transactional(readOnly = true)
    suspend fun findById(id: UUID): User? = userRepository.findById(id)
    
    @Transactional(readOnly = true)
    suspend fun findByEmail(email: String): User? = userRepository.findByEmail(email)
    
    @Transactional(readOnly = true)
    suspend fun findAll(page: Int, size: Int): List =
        userRepository.findAll(page, size)
    
    @Transactional
    suspend fun create(user: User): User = userRepository.save(user)
    
    @Transactional
    suspend fun update(id: UUID, updates: Map): User? {
        val user = userRepository.findById(id) ?: return null
        return userRepository.save(user.apply { updates.forEach { (k, v) -> set(k, v) } })
    }
    
    @Transactional
    suspend fun delete(id: UUID): Boolean = userRepository.deleteById(id)
}

// repository/UserRepository.kt
package com.example.repository

import com.example.domain.User
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.Query
import org.springframework.data.repository.query.Param
import java.util.*

interface UserRepository : JpaRepository {
    
    fun findByEmail(email: String): User?
    
    @Query("SELECT u FROM User u WHERE u.active = :active")
    fun findAllByActive(@Param("active") active: Boolean): List
    
    @Query(
        value = "SELECT * FROM users WHERE email LIKE %:search% OR username LIKE %:search%",
        nativeQuery = true
    )
    fun search(@Param("search") search: String): List
    
    fun existsByEmail(email: String): Boolean
}

// Project Reactor example
import reactor.core.publisher.Flux
import reactor.core.publisher.Mono
import reactor.kotlin.core.publisher.toMono
import kotlinx.coroutines.reactive.awaitFirst
import kotlinx.coroutines.reactive.awaitFirstOrNull
import kotlinx.coroutines.flow.*

@Service
class ReactiveUserService(
    private val userRepository: ReactiveUserRepository
) {
    
    // Mono (0-1 element)
    fun findById(id: String): Mono = 
        userRepository.findById(id)
            .switchIfEmpty(Mono.error(UserNotFoundException(id)))
            .doOnNext { log.info("Found user: $it") }
            .doOnError { log.error("Error finding user", it) }
    
    // Flux (0-N elements)
    fun findAll(): Flux = 
        userRepository.findAll()
            .delayElements(Duration.ofMillis(100))
            .take(100)
            .cache(Duration.ofMinutes(5))
    
    // Combining reactive streams
    fun getUserWithOrders(userId: String): Mono = 
        Mono.zip(
            findById(userId),
            orderService.findByUserId(userId).collectList()
        ) { user, orders ->
            UserWithOrders(user, orders)
        }
    
    // Error handling
    fun findByEmail(email: String): Mono = 
        userRepository.findByEmail(email)
            .timeout(Duration.ofSeconds(5))
            .retry(3)
            .onErrorResume { Mono.empty() }
    
    // Kotlin Flow example (coroutine-based reactive)
    suspend fun getUsersFlow(): Flow = 
        userRepository.findAll()
            .asFlow()
            .map { it.copy(name = it.name.uppercase()) }
            .filter { it.active }
            .take(50)
    
    // Flow transformations
    suspend fun processUsers() = 
        getUsersFlow()
            .buffer(10)
            .map { processUser(it) }
            .catch { e -> log.error("Error processing user", e) }
            .collect { result -> saveResult(result) }
    
    // ChannelFlow for more complex operations
    fun streamingUsers(): Flow = channelFlow {
        val users = userRepository.findAll()
        users.collect { user ->
            send(user)
            delay(100) // Rate limiting
        }
    }
}

// WebFlux controller
@RestController
@RequestMapping("/api/v2/users")
class ReactiveUserController(
    private val userService: ReactiveUserService
) {
    
    @GetMapping("/{id}")
    fun getUser(@PathVariable id: String): Mono> =
        userService.findById(id)
            .map { ResponseEntity.ok(it) }
            .defaultIfEmpty(ResponseEntity.notFound().build())
    
    @GetMapping
    fun getUsers(@RequestParam page: Int = 1, @RequestParam size: Int = 20): Flux =
        userService.findAll()
            .skip(((page - 1) * size).toLong())
            .take(size.toLong())
    
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    fun createUser(@RequestBody user: User): Mono = userService.save(user)
    
    @GetMapping(value = ["/stream"], produces = [MediaType.TEXT_EVENT_STREAM_VALUE])
    fun streamUsers(): Flux = 
        userService.streamingUsers()
            .delayElements(Duration.ofSeconds(1))
}

Elixir was created by José Valim in 2011 to bring modern language features to the Erlang VM (BEAM). It combines the productivity and expressiveness of Ruby with the battle-tested concurrency and fault-tolerance of Erlang, which has been used in telecommunications systems for over 30 years with 99.999% uptime.

# Spawning a process
pid = spawn(fn -> IO.puts("Hello from process") end)

# Sending messages
send(pid, {:message, "Hello"})

# Receiving messages
defmodule Echo do
  def loop do
    receive do
      {:msg, content} ->
        IO.puts("Received: #{content}")
        loop()
      
      {:stop, from} ->
        send(from, {:ok, "stopped"})
      
      _ ->
        IO.puts("Unknown message")
        loop()
    end
  end
end

pid = spawn(fn -> Echo.loop() end)
send(pid, {:msg, "Hello World"})
send(pid, {:stop, self()})

# Process registration
Process.register(pid, :echo_server)
send(:echo_server, {:msg, "Hello"})

# Stateful processes
defmodule Counter do
  def start(initial_value) do
    spawn(fn -> loop(initial_value) end)
  end
  
  defp loop(value) do
    receive do
      {:increment, caller} ->
        send(caller, {:ok, value + 1})
        loop(value + 1)
      
      {:get, caller} ->
        send(caller, {:value, value})
        loop(value)
      
      :stop ->
        :ok
    end
  end
  
  def increment(counter), do: send(counter, {:increment, self()})
  def get(counter), do: send(counter, {:get, self()})
end

counter = Counter.start(0)
Counter.increment(counter)
Counter.increment(counter)

receive do
  {:ok, value} -> IO.puts("Value: #{value}")
end

# Link processes - if one dies, both die
spawn_link(fn -> raise "Oops" end)  # Will crash parent

# Monitor processes - get notifications without crashing
monitor_ref = Process.monitor(pid)

receive do
  {:DOWN, ^monitor_ref, :process, _pid, reason} ->
    IO.puts("Process died: #{reason}")
end

# Task module for easier async work
task = Task.async(fn -> 
  # Long running work
  :timer.sleep(1000)
  {:result, 42}
end)

result = Task.await(task, 5000)  # Timeout after 5 seconds

# GenServer - generic server behaviour
defmodule BankAccount do
  use GenServer
  
  # Client API
  def start_link(initial_balance) do
    GenServer.start_link(__MODULE__, initial_balance, name: __MODULE__)
  end
  
  def get_balance do
    GenServer.call(__MODULE__, :get_balance)
  end
  
  def deposit(amount) do
    GenServer.cast(__MODULE__, {:deposit, amount})
  end
  
  def withdraw(amount) do
    GenServer.call(__MODULE__, {:withdraw, amount})
  end
  
  # Server Callbacks
  @impl true
  def init(initial_balance) do
    {:ok, initial_balance}
  end
  
  @impl true
  def handle_call(:get_balance, _from, balance) do
    {:reply, balance, balance}
  end
  
  def handle_call({:withdraw, amount}, _from, balance) when amount <= balance do
    {:reply, :ok, balance - amount}
  end
  
  def handle_call({:withdraw, _amount}, _from, balance) do
    {:reply, {:error, :insufficient_funds}, balance}
  end
  
  @impl true
  def handle_cast({:deposit, amount}, balance) do
    {:noreply, balance + amount}
  end
  
  @impl true
  def terminate(reason, _state) do
    IO.puts("Account terminated: #{inspect(reason)}")
    :ok
  end
end

# Usage
{:ok, _pid} = BankAccount.start_link(1000)
BankAccount.deposit(500)
balance = BankAccount.get_balance()  # 1500
BankAccount.withdraw(2000)  # {:error, :insufficient_funds}

# Supervisor - restarts children when they fail
defmodule Bank.Supervisor do
  use Supervisor
  
  def start_link(opts) do
    Supervisor.start_link(__MODULE__, :ok, opts)
  end
  
  @impl true
  def init(:ok) do
    children = [
      {BankAccount, 0},
      {TransactionLogger, []},
      {AuditService, []}
    ]
    
    Supervisor.init(children, strategy: :one_for_one)
  end
end

# Different supervision strategies
# :one_for_one - restart only failed child
# :one_for_all - restart all children
# :rest_for_one - restart failed and subsequent children
# :simple_one_for_one - dynamic children

# Dynamic supervision
defmodule DynamicSupervisor do
  use DynamicSupervisor
  
  def start_link(opts) do
    DynamicSupervisor.start_link(__MODULE__, :ok, opts)
  end
  
  def start_child(sup, child_spec) do
    DynamicSupervisor.start_child(sup, child_spec)
  end
  
  @impl true
  def init(:ok) do
    DynamicSupervisor.init(strategy: :one_for_one)
  end
end

# Application - OTP application
defmodule MyApp do
  use Application
  
  def start(_type, _args) do
    children = [
      MyApp.Repo,
      MyAppWeb.Endpoint,
      {Phoenix.PubSub, name: MyApp.PubSub}
    ]
    
    opts = [strategy: :one_for_one, name: MyApp.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

Phoenix is a web framework for Elixir that brings together the productivity of Ruby on Rails with the performance and fault-tolerance of the BEAM. Created by Chris McCord, Phoenix has become the go-to choice for building high-performance, real-time applications that need to handle millions of concurrent connections.

# mix.exs - Project dependencies
defmodule MyApp.MixProject do
  use Mix.Project

  def project do
    [
      app: :my_app,
      version: "0.1.0",
      elixir: "~> 1.14",
      elixirc_paths: elixirc_paths(Mix.env()),
      start_permanent: Mix.env() == :prod,
      deps: deps()
    ]
  end

  def application do
    [
      mod: {MyApp.Application, []},
      extra_applications: [:logger, :runtime_tools]
    ]
  end

  defp deps do
    [
      {:phoenix, "~> 1.7.0"},
      {:phoenix_ecto, "~> 4.4"},
      {:ecto_sql, "~> 3.10"},
      {:postgrex, ">= 0.0.0"},
      {:phoenix_html, "~> 3.3"},
      {:phoenix_live_reload, "~> 1.2", only: :dev},
      {:phoenix_live_view, "~> 0.18.0"},
      {:phoenix_live_dashboard, "~> 0.7.2"},
      {:esbuild, "~> 0.5", runtime: Mix.env() == :dev},
      {:tailwind, "~> 0.1", runtime: Mix.env() == :dev},
      {:swoosh, "~> 1.3"},
      {:finch, "~> 0.13"},
      {:telemetry_metrics, "~> 0.6"},
      {:telemetry_poller, "~> 1.0"},
      {:gettext, "~> 0.20"},
      {:jason, "~> 1.2"},
      {:dns_cluster, "~> 0.1.1"},
      {:plug_cowboy, "~> 2.5"},
      {:bcrypt_elixir, "~> 3.0"},
      {:guardian, "~> 2.0"},
      {:corsica, "~> 1.3"},
      {:hammer, "~> 6.0"},
      {:ex_machina, "~> 2.7", only: :test}
    ]
  end
end

# lib/my_app/application.ex - OTP Application
defmodule MyApp.Application do
  @moduledoc false
  use Application

  @impl true
  def start(_type, _args) do
    children = [
      MyApp.Repo,
      MyAppWeb.Telemetry,
      {Phoenix.PubSub, name: MyApp.PubSub},
      MyAppWeb.Endpoint,
      MyApp.Cache,  # Custom GenServer
      {Task.Supervisor, name: MyApp.TaskSupervisor},
      {Finch, name: MyApp.Finch}
    ]

    opts = [strategy: :one_for_one, name: MyApp.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

# lib/my_app/repo.ex - Ecto Repository
defmodule MyApp.Repo do
  use Ecto.Repo,
    otp_app: :my_app,
    adapter: Ecto.Adapters.Postgres
end

# lib/my_app/schemas/user.ex - Ecto Schema
defmodule MyApp.User do
  use Ecto.Schema
  import Ecto.Changeset

  schema "users" do
    field :email, :string
    field :username, :string
    field :password_hash, :string
    field :first_name, :string
    field :last_name, :string
    field :role, :string, default: "user"
    field :active, :boolean, default: true
    field :last_login_at, :utc_datetime
    
    # Virtual fields
    field :password, :string, virtual: true
    field :password_confirmation, :string, virtual: true
    
    has_many :posts, MyApp.Post
    has_many :comments, MyApp.Comment
    
    timestamps()
  end

  def changeset(user, attrs) do
    user
    |> cast(attrs, [:email, :username, :first_name, :last_name, :role, :active])
    |> validate_required([:email, :username])
    |> validate_format(:email, ~r/^[^\s]+@[^\s]+$/)
    |> validate_length(:username, min: 3, max: 50)
    |> unique_constraint(:email)
    |> unique_constraint(:username)
  end

  def registration_changeset(user, attrs) do
    user
    |> changeset(attrs)
    |> cast(attrs, [:password, :password_confirmation])
    |> validate_required([:password])
    |> validate_length(:password, min: 8)
    |> validate_confirmation(:password)
    |> put_password_hash()
  end

  defp put_password_hash(changeset) do
    case changeset do
      %Ecto.Changeset{valid?: true, changes: %{password: pass}} ->
        put_change(changeset, :password_hash, Bcrypt.hash_pwd_salt(pass))
      _ ->
        changeset
    end
  end
end

# lib/my_app/schemas/post.ex
defmodule MyApp.Post do
  use Ecto.Schema
  import Ecto.Changeset

  schema "posts" do
    field :title, :string
    field :content, :string
    field :slug, :string
    field :views, :integer, default: 0
    field :published, :boolean, default: false
    field :published_at, :utc_datetime
    
    belongs_to :user, MyApp.User
    has_many :comments, MyApp.Comment
    
    timestamps()
  end

  def changeset(post, attrs) do
    post
    |> cast(attrs, [:title, :content, :slug, :published])
    |> validate_required([:title, :content])
    |> validate_length(:title, min: 3, max: 200)
    |> validate_length(:content, min: 10)
    |> generate_slug()
  end

  defp generate_slug(changeset) do
    case get_change(changeset, :title) do
      nil -> changeset
      title ->
        slug = title
          |> String.downcase()
          |> String.replace(~r/[^\w\s-]/, "")
          |> String.replace(~r/[\s-]+/, "-")
        put_change(changeset, :slug, slug)
    end
  end
end

# lib/my_app/accounts.ex - Context module
defmodule MyApp.Accounts do
  @moduledoc """
  The Accounts context.
  """
  import Ecto.Query, warn: false
  alias MyApp.Repo
  alias MyApp.User

  def list_users(params \\ %{}) do
    User
    |> filter_users(params)
    |> order_by(desc: :inserted_at)
    |> Repo.paginate(params)
  end

  defp filter_users(query, %{"role" => role}) do
    where(query, role: ^role)
  end
  defp filter_users(query, %{"active" => active}) when is_boolean(active) do
    where(query, active: ^active)
  end
  defp filter_users(query, %{"search" => search}) do
    where(query, [u], ilike(u.email, ^"%#{search}%") or ilike(u.username, ^"%#{search}%"))
  end
  defp filter_users(query, _), do: query

  def get_user!(id), do: Repo.get!(User, id)
  
  def get_user_by_email(email) do
    Repo.get_by(User, email: email)
  end

  def create_user(attrs \\ %{}) do
    %User{}
    |> User.registration_changeset(attrs)
    |> Repo.insert()
  end

  def update_user(%User{} = user, attrs) do
    user
    |> User.changeset(attrs)
    |> Repo.update()
  end

  def delete_user(%User{} = user) do
    Repo.delete(user)
  end

  def authenticate_user(email, password) do
    user = get_user_by_email(email)
    
    case user do
      nil -> {:error, :invalid_credentials}
      _ ->
        if Bcrypt.verify_pass(password, user.password_hash) do
          if user.active do
            {:ok, user}
          else
            {:error, :account_inactive}
          end
        else
          {:error, :invalid_credentials}
        end
    end
  end

  def update_last_login(%User{} = user) do
    user
    |> User.changeset(%{last_login_at: DateTime.utc_now()})
    |> Repo.update()
  end
end

# lib/my_app_web/endpoint.ex
defmodule MyAppWeb.Endpoint do
  use Phoenix.Endpoint, otp_app: :my_app

  socket "/live", Phoenix.LiveView.Socket
  socket "/socket", MyAppWeb.UserSocket

  plug Plug.RequestId
  plug Plug.Telemetry, event_prefix: [:phoenix, :endpoint]

  plug Plug.Parsers,
    parsers: [:urlencoded, :multipart, :json],
    pass: ["*/*"],
    json_decoder: Phoenix.json_library()

  plug Plug.MethodOverride
  plug Plug.Head
  plug Plug.Session,
    store: :cookie,
    key: "_my_app_key",
    signing_salt: "secret"

  plug Corsica,
    origins: ["https://example.com", "http://localhost:3000"],
    allow_headers: ["content-type", "authorization"],
    allow_methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]

  plug MyAppWeb.Router
end

# lib/my_app_web/router.ex
defmodule MyAppWeb.Router do
  use MyAppWeb, :router
  use Pow.Phoenix.Router
  use PhoenixLiveSession
  
  pipeline :browser do
    plug :accepts, ["html"]
    plug :fetch_session
    plug :fetch_live_flash
    plug :put_root_layout, {MyAppWeb.LayoutView, :root}
    plug :protect_from_forgery
    plug :put_secure_browser_headers
    plug :fetch_current_user
  end

  pipeline :api do
    plug :accepts, ["json"]
    plug MyAppWeb.APIAuthPlug
  end

  pipeline :api_auth do
    plug Pow.Plug.RequireAuthenticated, error_handler: MyAppWeb.APIAuthErrorHandler
  end

  scope "/", MyAppWeb do
    pipe_through :browser

    get "/", PageController, :index
    resources "/posts", PostController
    live "/dashboard", DashboardLive
  end

  scope "/api", MyAppWeb do
    pipe_through :api

    scope "/v1" do
      post "/auth/login", APIAuthController, :login
      post "/auth/register", APIAuthController, :register
      post "/auth/refresh", APIAuthController, :refresh
      
      scope "/" do
        pipe_through :api_auth
        
        resources "/users", APIUserController, only: [:index, :show, :update, :delete]
        resources "/posts", APIPostController, except: [:new, :edit]
        
        get "/profile", APIProfileController, :show
        put "/profile", APIProfileController, :update
      end
    end
  end

  scope "/live", MyAppWeb do
    pipe_through [:browser, :require_authenticated_user]
    
    live_session :authenticated do
      live "/chat", ChatLive
    end
  end
end

# lib/my_app_web/controllers/api/auth_controller.ex
defmodule MyAppWeb.APIAuthController do
  use MyAppWeb, :controller
  alias MyApp.Accounts
  alias MyApp.Guardian

  def register(conn, %{"user" => user_params}) do
    case Accounts.create_user(user_params) do
      {:ok, user} ->
        {:ok, token, _claims} = Guardian.encode_and_sign(user)
        
        conn
        |> put_status(:created)
        |> render("auth.json", %{
          token: token,
          user: user
        })
      
      {:error, changeset} ->
        conn
        |> put_status(:unprocessable_entity)
        |> render("error.json", changeset: changeset)
    end
  end

  def login(conn, %{"email" => email, "password" => password}) do
    case Accounts.authenticate_user(email, password) do
      {:ok, user} ->
        Accounts.update_last_login(user)
        {:ok, token, _claims} = Guardian.encode_and_sign(user)
        
        conn
        |> put_status(:ok)
        |> render("auth.json", %{
          token: token,
          user: user
        })
      
      {:error, reason} ->
        conn
        |> put_status(:unauthorized)
        |> render("error.json", %{error: reason})
    end
  end

  def refresh(conn, _params) do
    user = Guardian.Plug.current_resource(conn)
    {:ok, token, _claims} = Guardian.encode_and_sign(user)
    
    render(conn, "auth.json", %{token: token, user: user})
  end
end

# lib/my_app_web/controllers/api/user_controller.ex
defmodule MyAppWeb.APIUserController do
  use MyAppWeb, :controller
  alias MyApp.Accounts

  action_fallback MyAppWeb.FallbackController

  def index(conn, params) do
    users = Accounts.list_users(params)
    render(conn, "index.json", users: users)
  end

  def show(conn, %{"id" => id}) do
    user = Accounts.get_user!(id)
    render(conn, "show.json", user: user)
  end

  def update(conn, %{"id" => id, "user" => user_params}) do
    user = Accounts.get_user!(id)
    
    with {:ok, %User{} = user} <- Accounts.update_user(user, user_params) do
      render(conn, "show.json", user: user)
    end
  end

  def delete(conn, %{"id" => id}) do
    user = Accounts.get_user!(id)
    
    with {:ok, %User{}} <- Accounts.delete_user(user) do
      send_resp(conn, :no_content, "")
    end
  end
end

# lib/my_app_web/plugs/api_auth_plug.ex
defmodule MyAppWeb.APIAuthPlug do
  import Plug.Conn
  alias MyApp.Guardian

  def init(opts), do: opts

  def call(conn, _opts) do
    case get_req_header(conn, "authorization") do
      ["Bearer " <> token] ->
        case Guardian.decode_and_verify(token) do
          {:ok, claims} ->
            case Guardian.resource_from_claims(claims) do
              {:ok, user} ->
                conn
                |> assign(:current_user, user)
                |> assign(:claims, claims)
              {:error, _reason} ->
                conn
                |> assign(:current_user, nil)
            end
          {:error, _reason} ->
            conn
            |> assign(:current_user, nil)
        end
      _ ->
        conn
        |> assign(:current_user, nil)
    end
  end
end

# Complex queries with Ecto
defmodule MyApp.Blog do
  import Ecto.Query
  alias MyApp.Repo
  alias MyApp.{Post, Comment, User}

  def list_published_posts_with_authors(params) do
    Post
    |> where([p], p.published == true)
    |> where([p], p.published_at <= ^DateTime.utc_now())
    |> join(:inner, [p], user in assoc(p, :user), as: :author)
    |> join(:left, [p], c in assoc(p, :comments), as: :comments)
    |> preload([p, author: a, comments: c], [user: a, comments: c])
    |> order_by([p], desc: p.published_at)
    |> paginate(params)
  end

  def search_posts(query, search_term) do
    from p in query,
      where: ilike(p.title, ^"%#{search_term}%") or
             ilike(p.content, ^"%#{search_term}%")
  end

  def filter_by_tag(query, tag) do
    from p in query,
      join: t in assoc(p, :tags),
      where: t.name == ^tag
  end

  def with_comment_count(query) do
    from p in query,
      left_join: c in assoc(p, :comments),
      group_by: p.id,
      select: %{
        p |
        comment_count: count(c.id)
      }
  end

  def get_popular_posts(min_views \\ 1000) do
    Post
    |> where([p], p.views > ^min_views)
    |> where([p], p.published == true)
    |> order_by([p], desc: p.views)
    |> limit(10)
    |> Repo.all()
  end

  def get_user_activity(user_id) do
    query = from u in User,
      where: u.id == ^user_id,
      join: p in assoc(u, :posts),
      join: c in assoc(p, :comments),
      group_by: u.id,
      select: %{
        user: u,
        post_count: count(p.id),
        comment_count: count(c.id),
        last_activity: max(p.updated_at)
      }
    
    Repo.one(query)
  end

  # Fragments for raw SQL
  def random_posts(limit) do
    from p in Post,
      order_by: fragment("RANDOM()"),
      limit: ^limit,
      where: p.published == true
  end

  # Upsert
  def create_or_update_post(attrs) do
    %Post{}
    |> Post.changeset(attrs)
    |> Repo.insert(
      on_conflict: [set: [content: attrs.content, updated_at: DateTime.utc_now()]],
      conflict_target: [:slug]
    )
  end

  # Ecto Multi for transactions
  def create_post_with_comments(post_attrs, comments_attrs) do
    Ecto.Multi.new()
    |> Ecto.Multi.insert(:post, Post.changeset(%Post{}, post_attrs))
    |> Ecto.Multi.run(:comments, fn repo, %{post: post} ->
      comments = Enum.map(comments_attrs, fn attrs ->
        %Comment{post_id: post.id}
        |> Comment.changeset(attrs)
      end)
      
      results = repo.insert_all(Comment, comments)
      {:ok, results}
    end)
    |> Repo.transaction()
  end

  # Pagination
  def paginate(query, %{"page" => page, "per_page" => per_page}) do
    offset = (max(1, page) - 1) * per_page
    
    entries = query
      |> limit(^per_page)
      |> offset(^offset)
      |> Repo.all()
    
    total = query |> exclude(:limit) |> exclude(:offset) |> Repo.aggregate(:count, :id)
    
    %{
      entries: entries,
      page: page,
      per_page: per_page,
      total: total,
      total_pages: ceil(total / per_page)
    }
  end
  def paginate(query, _), do: %{entries: Repo.all(query), page: 1, per_page: nil, total: nil}
end

# lib/my_app_web/user_socket.ex
defmodule MyAppWeb.UserSocket do
  use Phoenix.Socket

  channel "room:*", MyAppWeb.RoomChannel
  channel "notifications", MyAppWeb.NotificationChannel
  channel "presence", MyAppWeb.PresenceChannel

  @impl true
  def connect(%{"token" => token}, socket, _connect_info) do
    case MyApp.Guardian.decode_and_verify(token) do
      {:ok, claims} ->
        {:ok, assign(socket, :user_id, claims["sub"])}
      {:error, _} ->
        :error
    end
  end

  @impl true
  def connect(_params, _socket, _connect_info), do: :error

  @impl true
  def id(socket), do: "user_socket:#{socket.assigns.user_id}"
end

# lib/my_app_web/channels/room_channel.ex
defmodule MyAppWeb.RoomChannel do
  use Phoenix.Channel
  alias MyApp.Presence

  def join("room:" <> room_id, _payload, socket) do
    send(self(), :after_join)
    {:ok, assign(socket, :room_id, room_id)}
  end

  def handle_info(:after_join, socket) do
    # Track presence
    Presence.track(socket, socket.assigns.user_id, %{
      online_at: inspect(System.system_time(:second)),
      username: socket.assigns.username
    })
    
    # Push presence update to all clients
    push(socket, "presence_state", Presence.list(socket))
    
    {:noreply, socket}
  end

  def handle_in("new_message", %{"body" => body}, socket) do
    # Save message
    message = %{
      id: Ecto.UUID.generate(),
      user_id: socket.assigns.user_id,
      username: socket.assigns.username,
      body: body,
      timestamp: DateTime.utc_now()
    }
    
    # Broadcast to all clients in room
    broadcast!(socket, "new_message", message)
    
    # Save to database (async)
    Task.start(fn -> 
      MyApp.MessageStore.save(message) 
    end)
    
    {:reply, {:ok, %{message_id: message.id}}, socket}
  end

  def handle_in("typing", %{"is_typing" => is_typing}, socket) do
    broadcast_from!(socket, "typing", %{
      user_id: socket.assigns.user_id,
      username: socket.assigns.username,
      is_typing: is_typing
    })
    {:noreply, socket}
  end

  def handle_in("mark_read", %{"message_ids" => ids}, socket) do
    broadcast_from!(socket, "messages_read", %{
      user_id: socket.assigns.user_id,
      message_ids: ids
    })
    {:noreply, socket}
  end

  def terminate(_reason, socket) do
    # Clean up when user leaves
    broadcast!(socket, "user_left", %{
      user_id: socket.assigns.user_id,
      username: socket.assigns.username
    })
    :ok
  end
end

# lib/my_app_web/channels/notification_channel.ex
defmodule MyAppWeb.NotificationChannel do
  use Phoenix.Channel

  def join("notifications", _payload, socket) do
    {:ok, socket}
  end

  def notify_user(user_id, notification) do
    MyAppWeb.Endpoint.broadcast("notifications", "notification:#{user_id}", notification)
  end

  def handle_in("get_unread", _payload, socket) do
    notifications = MyApp.NotificationStore.get_unread(socket.assigns.user_id)
    {:reply, {:ok, %{notifications: notifications}}, socket}
  end

  def handle_in("mark_read", %{"id" => id}, socket) do
    MyApp.NotificationStore.mark_read(id)
    {:reply, :ok, socket}
  end
end

# lib/my_app/presence.ex
defmodule MyApp.Presence do
  use Phoenix.Presence,
    otp_app: :my_app,
    pubsub_server: MyApp.PubSub

  def fetch(_topic, entries) do
    # Enrich presence data with user info
    user_ids = entries |> Map.keys() |> Enum.map(&String.to_integer/1)
    users = MyApp.Accounts.get_users_by_ids(user_ids)
    
    entries
    |> Enum.map(fn {user_id, presence_data} ->
      user = Enum.find(users, &(&1.id == String.to_integer(user_id)))
      {user_id, Map.put(presence_data, :user_info, %{
        username: user.username,
        avatar: user.avatar
      })}
    end)
    |> Enum.into(%{})
  end
end

# assets/js/socket.js - Client-side
import {Socket} from "phoenix"

let socket = new Socket("/socket", {
  params: {token: localStorage.getItem("token")}
})

socket.connect()

let channel = socket.channel("room:general", {})
channel.join()
  .receive("ok", resp => { console.log("Joined successfully") })
  .receive("error", resp => { console.log("Unable to join") })

channel.on("new_message", payload => {
  console.log("New message:", payload)
  appendMessage(payload)
})

channel.on("typing", payload => {
  if (payload.is_typing) {
    showTypingIndicator(payload.username)
  } else {
    hideTypingIndicator(payload.username)
  }
})

channel.on("presence_state", state => {
  let users = Presence.syncState(state)
  updateUserList(users)
})

channel.on("presence_diff", diff => {
  let users = Presence.syncDiff(diff)
  updateUserList(users)
})

// Send message
document.querySelector("#message-form").addEventListener("submit", e => {
  e.preventDefault()
  let input = document.querySelector("#message-input")
  channel.push("new_message", {body: input.value})
  input.value = ""
})

# lib/my_app_web/live/chat_live.ex
defmodule MyAppWeb.ChatLive do
  use MyAppWeb, :live_view
  alias MyApp.{Accounts, Messages, Presence}

  @impl true
  def mount(_params, %{"user_id" => user_id}, socket) do
    if connected?(socket), do: Messages.subscribe()
    
    user = Accounts.get_user!(user_id)
    
    {:ok, assign(socket,
      user: user,
      messages: [],
      message_body: "",
      users: %{},
      typing_users: MapSet.new()
    )}
  end

  @impl true
  def handle_params(_params, _url, socket) do
    messages = Messages.list_recent_messages(50)
    {:noreply, assign(socket, messages: messages)}
  end

  @impl true
  def handle_event("send_message", %{"body" => body}, socket) when body != "" do
    message = %{
      id: Ecto.UUID.generate(),
      user_id: socket.assigns.user.id,
      username: socket.assigns.user.username,
      body: body,
      timestamp: DateTime.utc_now()
    }
    
    Messages.broadcast_message(message)
    {:noreply, assign(socket, message_body: "")}
  end

  def handle_event("typing", %{"is_typing" => is_typing}, socket) do
    user_id = socket.assigns.user.id
    
    if is_typing do
      Presence.update(self(), "typing", user_id, %{username: socket.assigns.user.username})
    else
      Presence.leave(self(), "typing", user_id)
    end
    
    {:noreply, socket}
  end

  @impl true
  def handle_info({:new_message, message}, socket) do
    {:noreply, update(socket, :messages, &[message | &1])}
  end

  def handle_info({:presence_diff, diff}, socket) do
    typing_users = 
      diff.entries
      |> Map.keys()
      |> MapSet.new()
    
    {:noreply, assign(socket, typing_users: typing_users)}
  end

  def render(assigns) do
    ~H"""
    

      

        
Online Users
        <%= for {user_id, presence} <- @users do %>
          

            
            <%= presence.metas |> List.first() |> Map.get(:username) %>
            <%= if MapSet.member?(@typing_users, user_id) do %>
              typing...
            <% end %>
          
        <% end %>
      
      
      

        <%= for message <- @messages do %>
          

            <%= message.username %>:
            
<%= message.body %>
            <%= format_timestamp(message.timestamp) %>
          
        <% end %>
      
      
      

        
        Send
      
    
    """
  end
  
  defp format_timestamp(datetime) do
    Calendar.strftime(datetime, "%H:%M")
  end
end

# lib/my_app_web/live/dashboard_live.ex
defmodule MyAppWeb.DashboardLive do
  use MyAppWeb, :live_view

  @impl true
  def mount(_params, _session, socket) do
    if connected?(socket) do
      :timer.send_interval(1000, self(), :tick)
    end
    
    {:ok, assign(socket,
      metrics: %{},
      last_updated: DateTime.utc_now(),
      chart_data: []
    )}
  end

  @impl true
  def handle_info(:tick, socket) do
    metrics = %{
      users_online: MyApp.Presence.count_users(),
      requests_per_second: get_rps(),
      memory_usage: :erlang.memory(:total) |> div(1024 * 1024),
      uptime: :erlang.statistics(:wall_clock) |> elem(0) |> div(1000)
    }
    
    chart_data = update_chart(socket.assigns.chart_data, metrics)
    
    {:noreply, assign(socket,
      metrics: metrics,
      last_updated: DateTime.utc_now(),
      chart_data: chart_data
    )}
  end

  def render(assigns) do
    ~H"""
    

      
System Dashboard
      
Last updated: <%= @last_updated %>
      
      

        

          
Users Online
          
<%= @metrics.users_online %>
        
        
        

          
Requests/Second
          
<%= @metrics.requests_per_second %>
        
        
        

          
Memory Usage
          
<%= @metrics.memory_usage %> MB
        
        
        

          
Uptime
          
<%= format_uptime(@metrics.uptime) %>
        
      
      
      

        
      
    
    """
  end
end

# lib/my_app/presence.ex
defmodule MyApp.Presence do
  use Phoenix.Presence,
    otp_app: :my_app,
    pubsub_server: MyApp.PubSub

  def count_users do
    list("room:general")
    |> Enum.count()
  end

  def get_user_rooms(user_id) do
    list()
    |> Enum.filter(fn {_topic, presences} ->
      Map.has_key?(presences, to_string(user_id))
    end)
    |> Enum.map(fn {topic, _} -> topic end)
  end

  def list_user_presences(user_id) do
    list()
    |> Enum.map(fn {topic, presences} ->
      presence = Map.get(presences, to_string(user_id))
      if presence, do: {topic, presence}
    end)
    |> Enum.filter(& &1)
  end
end

# Using Presence in a LiveView
defmodule MyAppWeb.OnlineUsersLive do
  use MyAppWeb, :live_view
  alias MyApp.Presence

  @impl true
  def mount(_params, _session, socket) do
    if connected?(socket) do
      Phoenix.PubSub.subscribe(MyApp.PubSub, "presence")
    end
    
    users = Presence.list("room:general")
    
    {:ok, assign(socket, users: users)}
  end

  @impl true
  def handle_info(%{event: "presence_diff"}, socket) do
    users = Presence.list("room:general")
    {:noreply, assign(socket, users: users)}
  end

  def render(assigns) do
    ~H"""
    

      
Online Users (<%= Enum.count(@users) %>)
      

        <%= for {user_id, presence} <- @users do %>
          

            <%= presence.metas |> List.first() |> Map.get(:username) %>
            joined at <%= presence.metas |> List.first() |> Map.get(:online_at) %>
          
        <% end %>
      
    
    """
  end
end

• Preemptive scheduling: Each process gets ~2,000 reductions (~1ms of work)
• Garbage collection: Per-process GC, no stop-the-world pauses
• Memory management: Each process has its own heap
• SMP support: Scales across multiple CPU cores
• Distribution: Built-in clustering across nodes

# Process limits - can create millions
defmodule ProcessDemo do
  def create_processes(n) when n > 0 do
    pid = spawn(fn -> 
      receive do
        :stop -> :ok
        _ -> create_processes(n - 1)
      end
    end)
    
    IO.puts("Created process #{n}: #{inspect(pid)}")
    pid
  end
  
  def create_processes(0), do: spawn(fn -> Process.sleep(:infinity) end)
end

# Check system limits
IO.puts("Process limit: #{System.schedulers_online()}")
IO.puts("Memory per process: ~2-3 KB")

# Monitor system performance
defmodule SystemMonitor do
  use GenServer

  def start_link(_) do
    GenServer.start_link(__MODULE__, %{})
  end

  @impl true
  def init(state) do
    :timer.send_interval(5000, self(), :collect_metrics)
    {:ok, state}
  end

  @impl true
  def handle_info(:collect_metrics, state) do
    metrics = %{
      processes: :erlang.system_info(:process_count),
      memory: :erlang.memory(:total) |> div(1024 * 1024),
      run_queue: :erlang.statistics(:run_queue),
      reductions: :erlang.statistics(:reductions),
      gc_count: :erlang.statistics(:garbage_collection)
    }
    
    IO.inspect(metrics, label: "System Metrics")
    {:noreply, state}
  end
end

# libcluster configuration for automatic clustering
# config/config.exs
config :libcluster,
  topologies: [
    example: [
      strategy: Cluster.Strategy.Epmd,
      config: [
        hosts: [
          :"node1@192.168.1.100",
          :"node2@192.168.1.101",
          :"node3@192.168.1.102"
        ]
      ]
    ],
    kubernetes: [
      strategy: Cluster.Strategy.Kubernetes,
      config: [
        kubernetes_ip_lookup_mode: :pods,
        kubernetes_node_basename: "myapp",
        kubernetes_selector: "app=myapp",
        kubernetes_namespace: "default"
      ]
    ]
  ]

# Distributed process registry
defmodule MyApp.GlobalRegistry do
  use GenServer
  
  def start_link(_) do
    GenServer.start_link(__MODULE__, :ok, name: {:global, __MODULE__})
  end
  
  def register(pid) do
    :global.register_name({__MODULE__, self()}, pid)
  end
  
  def whereis(name) do
    :global.whereis_name({__MODULE__, name})
  end
  
  def send(name, message) do
    :global.send({__MODULE__, name}, message)
  end
end

# Distributed cache
defmodule MyApp.DistributedCache do
  use GenServer
  
  def start_link(_) do
    GenServer.start_link(__MODULE__, :ok, name: {:global, __MODULE__})
  end
  
  def put(key, value) do
    :global.send(__MODULE__, {:put, key, value})
  end
  
  def get(key) do
    GenServer.call({:global, __MODULE__}, {:get, key})
  end
  
  @impl true
  def init(:ok) do
    {:ok, %{}}
  end
  
  @impl true
  def handle_call({:get, key}, _from, state) do
    {:reply, Map.get(state, key), state}
  end
  
  @impl true
  def handle_cast({:put, key, value}, state) do
    {:noreply, Map.put(state, key, value)}
  end
end

# Distributed task execution
defmodule MyApp.DistributedTask do
  def run_on_all_nodes(module, function, args) do
    Node.list()
    |> Enum.each(fn node ->
      Task.start(fn ->
        result = :rpc.call(node, module, function, args)
        IO.puts("Node #{node} result: #{inspect(result)}")
      end)
    end)
  end
  
  def run_on_least_loaded(module, function, args) do
    node = find_least_loaded_node()
    :rpc.call(node, module, function, args)
  end
  
  defp find_least_loaded_node do
    Node.list()
    |> Enum.map(fn node ->
      {node, :rpc.call(node, :erlang, :system_info, [:process_count])}
    end)
    |> Enum.min_by(fn {_, count} -> count end)
    |> elem(0)
  end
end

# Supervision tree with multiple strategies
defmodule MyApp.Supervisor do
  use Supervisor

  def start_link(opts) do
    Supervisor.start_link(__MODULE__, :ok, opts)
  end

  @impl true
  def init(:ok) do
    children = [
      # Database connection pool
      {MyApp.Repo, []},
      
      # PubSub for the whole app
      {Phoenix.PubSub, name: MyApp.PubSub},
      
      # Business logic workers
      {MyApp.AuthWorker, []},
      {MyApp.EmailWorker, []},
      {MyApp.NotificationWorker, []},
      
      # Dynamic supervisor for runtime processes
      {DynamicSupervisor, name: MyApp.DynamicSupervisor, strategy: :one_for_one},
      
      # Task supervisor for short-lived tasks
      {Task.Supervisor, name: MyApp.TaskSupervisor},
      
      # Custom GenServers
      worker(MyApp.Cache, []),
      worker(MyApp.Metrics, [])
    ]

    Supervisor.init(children, strategy: :one_for_one, max_restarts: 10, max_seconds: 60)
  end
end

# Dynamic child supervision
defmodule MyApp.DynamicManager do
  use GenServer
  
  def start_link(_) do
    GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
  end
  
  def create_child(module, args) do
    GenServer.call(__MODULE__, {:create_child, module, args})
  end
  
  def stop_child(child_id) do
    GenServer.call(__MODULE__, {:stop_child, child_id})
  end
  
  @impl true
  def init(:ok) do
    {:ok, %{children: %{}}}
  end
  
  @impl true
  def handle_call({:create_child, module, args}, _from, state) do
    child_id = String.to_atom("#{module}_#{:erlang.unique_integer()}")
    
    spec = %{
      id: child_id,
      start: {module, :start_link, args},
      restart: :transient,
      shutdown: 5000
    }
    
    case DynamicSupervisor.start_child(MyApp.DynamicSupervisor, spec) do
      {:ok, pid} ->
        new_state = put_in(state.children[child_id], pid)
        {:reply, {:ok, child_id}, new_state}
      error ->
        {:reply, error, state}
    end
  end
  
  def handle_call({:stop_child, child_id}, _from, state) do
    case Map.fetch(state.children, child_id) do
      {:ok, pid} ->
        DynamicSupervisor.terminate_child(MyApp.DynamicSupervisor, pid)
        new_state = update_in(state.children, &Map.delete(&1, child_id))
        {:reply, :ok, new_state}
      :error ->
        {:reply, {:error, :not_found}, state}
    end
  end
end

# Circuit breaker pattern
defmodule MyApp.CircuitBreaker do
  use GenServer
  
  def start_link(name) do
    GenServer.start_link(__MODULE__, :ok, name: name)
  end
  
  def call(breaker, func, fallback \\ nil) do
    case GenServer.call(breaker, :execute) do
      :ok ->
        try do
          func.()
        rescue
          _ -> 
            GenServer.cast(breaker, :failure)
            if fallback, do: fallback.(), else: reraise e, __STACKTRACE__
        end
      :open ->
        fallback && fallback.() || raise "Circuit breaker open"
    end
  end
  
  @impl true
  def init(_) do
    {:ok, %{state: :closed, failures: 0, last_failure: nil}}
  end
  
  @impl true
  def handle_call(:execute, _from, %{state: :closed} = state) do
    {:reply, :ok, state}
  end
  
  def handle_call(:execute, _from, %{state: :open} = state) do
    case should_try?(state) do
      true -> {:reply, :ok, %{state | state: :half_open}}
      false -> {:reply, :open, state}
    end
  end
  
  @impl true
  def handle_cast(:failure, %{failures: failures} = state) do
    new_failures = failures + 1
    
    if new_failures >= 5 do
      {:noreply, %{state | state: :open, failures: 0, last_failure: DateTime.utc_now()}}
    else
      {:noreply, %{state | failures: new_failures}}
    end
  end
  
  defp should_try?(%{last_failure: last}) do
    DateTime.diff(DateTime.utc_now(), last) > 30
  end
end

Performance is measured across multiple dimensions that matter in production:

• Requests per second (RPS): How many requests the framework can handle concurrently
• Memory usage: RAM consumption per request and baseline
• Startup time: Time to first response, critical for auto-scaling and serverless
• Latency: Time to complete a single request (p95, p99)
• CPU efficiency: How well the framework utilizes available CPU cores

Scalability isn't just about handling more users – it's about how your application grows with demand:

• Vertical Scaling (Scale Up): Adding more power to existing servers (CPU, RAM)
• Horizontal Scaling (Scale Out): Adding more servers to distribute load
• Connection Scalability: Handling millions of concurrent connections
• Data Scalability: Managing growing datasets efficiently
• Team Scalability: How well the framework supports multiple developers

A rich ecosystem accelerates development and reduces time-to-market:

• Package managers: npm, Maven, pip, Go modules, etc.
• Package count: Available libraries and their quality
• IDE support: Code completion, debugging, refactoring tools
• Job market: Availability of developers and jobs
• Community activity: Stack Overflow, GitHub, conferences
• Documentation: Quality and completeness of docs
• Enterprise support: Commercial backing and support options

• Language familiarity: Is the syntax similar to languages developers already know?
• Conceptual complexity: Does it introduce new paradigms (functional, actor-based)?
• Framework size: How many concepts must be learned before being productive?
• Documentation quality: How good are the tutorials and API docs?
• Community size: Are there Stack Overflow answers and GitHub examples?
• Tooling: How good are the IDE, debugger, and development tools?

• Developer salary: Availability and cost of developers
• Training costs: Time to onboard new developers
• Infrastructure costs: Server/resources required
• Third-party licenses: Commercial tools and services
• Maintenance: Bug fixes, security updates, refactoring
• Hosting/platform costs: Cloud provider fees

💡 There's no universally "best" framework – only the right tool for your specific context. This systematic framework helps you evaluate options across multiple dimensions.

Create a weighted score for each framework candidate:

Rate each framework from 1-10 for each factor, multiply by weight, sum totals. Choose the highest score.

Startups need to move fast, validate ideas, and pivot quickly. Here's how frameworks compare for startup use cases: