Why Gati?

"Let developers write business logic. Let Gati handle everything else."

The Problem

Modern backend development is powerful, but painful. Developers spend more time:

• 🔧 Fighting infrastructure than building features
• 🐛 Debugging version conflicts than shipping code
• 📝 Rewriting old APIs for backward compatibility
• 🔗 Stitching services together than innovating
• 🚀 Wrestling with DevOps than solving business problems

The result? Backend development is slow, fragile, and frustrating.

The Gati Solution

Gati ends this era of backend suffering by transforming backend development from a complex, error-prone process into an automated, intelligent, and developer-first experience.

Zero-Ops, Infinite Evolution

Gati is a next-generation backend engine that analyzes your code as you write it and automatically generates:

• ✅ Optimized runtime — Containerized, distributed, version-aware execution
• ✅ Deployment configs — Docker, K8s manifests, scaling policies
• ✅ Type validators — Runtime validation from TypeScript types
• ✅ API documentation — OpenAPI specs, client SDKs
• ✅ Version management — Schema diffing, automatic transformers
• ✅ Observability — Logging, metrics, tracing, debugging tools

No manual configuration. No YAML hell. No CI pipeline complexity.

Just write code.

What Makes Gati Different?

1. A Backend That Understands Your Code

Traditional frameworks are passive. They execute your code but don't understand it.

Gati analyzes your backend as you build it:

// You write this
type CreateUser = {
  email: EmailString;
  password: string & MinLen<8>;
  age?: number & Min<18> & Max<100>;
};

export const createUserHandler: Handler = async (req, res, gctx, lctx) => {
  const { email, password, age } = req.body; // Auto-validated!
  const user = await gctx.modules['database']?.createUser({ email, password, age });
  res.json({ user });
};

Gati automatically generates:

• ✅ Runtime validator (Ajv-level performance)
• ✅ OpenAPI specification
• ✅ TypeScript/Python/Go SDKs
• ✅ Timescape version metadata
• ✅ Playground request template
• ✅ Test fixtures and mocks

2. APIs That Never Break (Timescape)

Every backend eventually becomes unmaintainable:

• New versions break old clients
• Migrations are dangerous
• Legacy routes accumulate
• Outdated code is hard to delete
• API evolution slows to a crawl
• Developers fear making changes

Gati introduces Timescape — a revolutionary version management system:

// Version 1 (2024-11-01)
type User = {
  name: string;
  email: EmailString;
};

// Version 2 (2024-11-15) - Breaking change detected automatically
type User = {
  firstName: string;  // name split into two fields
  lastName: string;
  email: EmailString;
};

// Gati auto-generates transformer stub (AI-assisted completion)
export const transformV1toV2 = (v1: UserV1): UserV2 => ({
  firstName: v1.name.split(' ')[0],
  lastName: v1.name.split(' ')[1] || '',
  email: v1.email,
});

Timescape features:

• ✔ Automatic version creation when handlers change
• ✔ Parallel version execution (v1 and v2 run simultaneously)
• ✔ Automatic schema diffing and breaking change detection
• ✔ Auto-generated transformer stubs (AI-assisted)
• ✔ Backward and forward compatibility
• ✔ Zero-downtime version rollouts
• ✔ Safe, gradual deprecation

3. Modular Architecture That Scales

Gati treats everything as a module:

• Databases (PostgreSQL, MongoDB, etc.)
• Caches (Redis, Dragonfly)
• Queues (SQS, Pub/Sub, RabbitMQ)
• Auth providers (OAuth, JWT, WebAuthn)
• Storage (S3, GCS, Azure Blob)
• AI models (OpenAI, Anthropic, local LLMs)
• Custom business logic

Modules are installed like NPM packages:

# Install database module
pnpm add @gati-modules/postgresql

# Configure in gati.config.ts
export default {
  modules: {
    database: {
      type: '@gati-modules/postgresql',
      config: { url: process.env.DATABASE_URL }
    }
  }
}

Modules run in isolated processes with their own:

• Manifests and contracts
• Scaling policies (independent autoscaling)
• Health checks and lifecycle hooks
• Version compatibility metadata

4. TypeScript-Native Type System

Other frameworks:

// ❌ Duplicate definitions (Zod example)
const UserSchema = z.object({
  email: z.string().email(),
  password: z.string().min(8),
  age: z.number().min(18).max(100).optional(),
});

type User = z.infer<typeof UserSchema>; // Must keep in sync

Gati approach:

// ✅ Single definition with branded types
type User = {
  email: EmailString;
  password: string & MinLen<8>;
  age?: number & Min<18> & Max<100>;
};

// Gati analyzer automatically generates:
// - Runtime validator
// - GType schema (manifest)
// - OpenAPI spec
// - Client SDKs
// - Timescape metadata
// - Transformer hints

Zero boilerplate. Write once, use everywhere.

5. Zero-Ops Deployment

Traditional deployment:

# 1. Write Dockerfile
# 2. Create K8s manifests (Deployment, Service, ConfigMap, Ingress)
# 3. Set up CI/CD pipeline
# 4. Configure load balancer
# 5. Set up SSL certificates
# 6. Configure auto-scaling
# 7. Set up monitoring/alerting
# 8. Deploy and pray

Gati deployment:

gati deploy production --provider aws

Gati handles:

• ✅ Container registry
• ✅ K8s cluster provisioning (or uses existing)
• ✅ Load balancer setup
• ✅ SSL/TLS certificates (auto-renewal)
• ✅ DNS configuration
• ✅ Secrets management
• ✅ Auto-scaling policies (HPA/VPA)
• ✅ Monitoring and alerting
• ✅ Health checks and rollouts

6. Visual Debugging Playground

Traditional API testing:

• Postman/Insomnia for manual testing
• Separate load testing tools (k6, Artillery)
• Log aggregation systems (ELK, Splunk)
• Distributed tracing (Jaeger, Zipkin)
• Custom monitoring dashboards

Gati Playground (built-in):

• 🟦 API Mode — Postman on steroids (stress testing, mock datasets, version switching)
• 🟧 Network Mode — 2D visualization of distributed backend (real-time particle flow, component health)
• 🟪 Tracking Mode — 3D request lifecycle visualization (debug gates, data inspection, time-travel replay)

All in one tool. No external dependencies.

Comparison with Other Frameworks

Feature	Gati	Express/Fastify	NestJS	Serverless (AWS Lambda)
Learning Curve	Low	Low	Medium	Medium
Infrastructure	✅ Fully Automated	❌ Manual	⚠️ Partial	✅ Automated
Type Safety	✅ TypeScript-Native	⚠️ Manual	✅ Full	⚠️ Partial
Auto-Scaling	✅ Built-in (HPA/VPA)	❌ Manual	❌ Manual	✅ Built-in
API Versioning	✅ Timescape (M2+)	❌ Manual	⚠️ Partial	❌ Manual
SDK Generation	✅ Auto (M5)	❌ None	⚠️ Via Tools	❌ None
Vendor Lock-in	❌ None	❌ None	❌ None	✅ High (AWS)
Multi-Cloud	✅ Yes (M2+)	⚠️ Manual	⚠️ Manual	❌ Single Cloud
Visual Debugging	✅ Playground	❌ None	❌ None	⚠️ CloudWatch
Module System	✅ Isolated Processes	⚠️ Shared Runtime	✅ Dependency Injection	❌ Per-Function Only

Who Should Use Gati?

✅ Perfect For

• Startups — Ship MVPs faster without infrastructure headaches
• Scale-ups — Grow from 10 to 10M users without rewrites
• Backend-for-Frontend — Type-safe API layer for web/mobile apps
• Microservices — Deploy independent, scalable services easily
• Internal Tools — Rapidly build internal APIs and admin panels
• API-First Products — Build public APIs with auto-generated SDKs

⚠️ Not Ideal For (Yet)

• Static Websites — Use Next.js, Gatsby, Astro instead
• Real-time Games — Use dedicated game servers (Unity, Unreal)
• Heavy Data Processing — Use Spark, Airflow, Dagster
• Existing Large Apps — Migration tools coming in M8 (Q1 2026)

The Gati Promise

For Individual Developers

• Write less boilerplate — Focus on business logic, not infrastructure
• Ship faster — MVP to production in days, not months
• Sleep better — Automatic scaling, monitoring, rollback
• Learn less — No need to master DevOps, K8s, Terraform

For Teams

• Faster onboarding — New developers productive in hours
• Consistent architecture — Gati enforces best practices
• Reduced ops burden — Less time firefighting infrastructure
• Better collaboration — Auto-generated SDKs sync frontend/backend

For Businesses

• Lower costs — Smaller teams, less infrastructure complexity
• Faster time-to-market — Ship features, not YAML configs
• Better reliability — Battle-tested patterns, automatic scaling
• Future-proof — Timescape ensures APIs never break

Next Steps

Ready to experience the future of backend development?

• 📖 Quick Start — Build your first Gati app in 5 minutes
• 🎯 Core Philosophy — Understand Gati's design principles
• 🚀 Feature Registry — See all planned capabilities
• 📚 Architecture Overview — Deep dive into internals

---

"The best code is the code you don't have to write."
— Gati embodies this philosophy by automating everything that isn't your core business logic.

---

Last Updated: November 18, 2025