# Philosophy: The Best of Two Worlds Ignis combines the structured, enterprise-grade development experience of **LoopBack 4** with the speed and simplicity of **Hono**.
Enterprise patterns. Hono performance. Modern simplicity. The framework for developers who want structure without the weight.
## The Framework Landscape When building REST APIs and server applications with Node.js/Bun, developers choose from three categories of frameworks:

Express, Hono, Fastify, Koa

Minimal

Freedom, speed, flexibility

Lightning fast Total control Tiny footprint DIY architecture Manual patterns

Ignis, Ts.ED

Balanced

Structure with lighter footprint

Lighter weight Single file build Fast startup ESM native Modern stack

NestJS, LoopBack 4, AdonisJS

Enterprise

Structure, patterns, conventions

Battle-tested Rich ecosystem Strong typing Heavy footprint Steep learning
## Honest Comparison ### Performance & Runtime
Hono ~10ms startup · ~20MB
~150k req/s
Bun, Node, Deno, CF Workers
Ignis ~30ms startup · ~30MB
~140k req/s
Bun, Node
Fastify ~50ms startup · ~40MB
~80k req/s
Node only
NestJS ~500ms startup · ~100MB
~25k req/s
Node (Bun experimental)
LoopBack 4 ~800ms startup · ~120MB
~20k req/s
Node only
Express ~100ms startup · ~50MB
~15k req/s
Node only

* Benchmarks are approximate and vary by use case

### Developer Experience
Aspect Minimal (Hono/Express) Enterprise (NestJS/LoopBack) Ignis
Setup Time 5 minutes 30+ minutes 10 minutes
Learning Curve Low High Medium
Boilerplate Minimal Heavy Moderate
Type Safety Manual Excellent Excellent
IDE Support Basic Excellent Good
Documentation Good Excellent Growing
Flexibility vs Convention Total Freedom Opinionated Guided Flexibility
### Architecture & Patterns
Feature Minimal Enterprise Ignis
Dependency Injection Manual Built-in (full-featured) Built-in (simpler)
Layered Architecture DIY Enforced Guided
Repository Pattern DIY Built-in Built-in
Validation 3rd party Built-in (class-validator) Zod
OpenAPI/Swagger 3rd party Built-in Built-in
Authentication DIY Passport + Guards Component
### Ecosystem & Maturity
Aspect Hono NestJS Ignis
GitHub Stars ~20k ~70k New
Weekly Downloads ~500k ~3M Starting
First Release 2021 2017 2025
Production Ready Yes Yes Early stage
Corporate Backing Cloudflare Trilon Independent
Official Plugins 20+ 50+ Core only
Community Packages Growing Extensive Few
LTS / Support Active Enterprise LTS Planning
## The Ignis Synthesis

LoopBack 4

+

Hono

=

Ignis

## What Each Approach Excels At

Minimal Frameworks

Hono, Express, Fastify

Strengths

  • Maximum raw performance
  • Complete architectural freedom
  • Fastest time to first endpoint
  • Smallest bundle/memory footprint
  • Perfect for edge/serverless
  • Huge ecosystem (Express has 50k+ packages)

Trade-offs

  • Architecture decisions on your shoulders
  • Patterns must be implemented manually
  • Code structure varies per developer
  • Harder to maintain as project grows

Ignis

The balanced choice

Strengths

  • Enterprise patterns with Hono's performance
  • Lighter weight than NestJS/LoopBack
  • Modern TypeScript-first with Zod validation
  • ESM native, Bun optimized
  • Single file executable build with Bun
  • Built on proven Hono foundation
  • Scales from solo dev to large teams

Considerations

  • Growing community and ecosystem
  • Documentation expanding continuously
  • Early adopter opportunity

Enterprise Frameworks

NestJS, LoopBack, AdonisJS

Strengths

  • Battle-tested at massive scale
  • Comprehensive, mature documentation
  • Huge community & ecosystem (NestJS ~3M weekly downloads)
  • Excellent for large teams & long-term projects
  • Strong conventions prevent architectural chaos
  • Easy to hire developers who know the framework
  • Extensive third-party integrations

Trade-offs

  • Higher resource consumption
  • Steeper learning curve
  • More boilerplate code
  • Slower startup times
## When Should You Use Ignis?
Medium API (10-100 endpoints)
✓ Yes
Structure prevents spaghetti code
Any team size (solo to large)
✓ Yes
Scales from solo dev to enterprise teams
Want DI without NestJS/LoopBack weight
✓ Yes
Lighter alternative, ESM native, enterprise patterns
Coming from NestJS/LoopBack
✓ Yes
Familiar patterns, better performance
Need database + auth + OpenAPI
✓ Yes
All built-in, ready to use
Performance is important
✓ Yes
Hono's speed with structure
Bun-first development
✓ Yes
Native Bun support, single file executable build
Growing from Hono project
✓ Yes
Easy migration, same foundation
3-5 endpoints, solo dev
? Maybe
Start with Hono, migrate later if needed
Quick prototype / MVP
✗ No
Use plain Hono for speed
Simple proxy / webhook
✗ No
Too much structure for simple tasks
## Perfect For

Production APIs

10-100+ endpoints with enterprise patterns. Controllers, services, repositories — all built-in and ready.

Teams of Any Size

Solo developers to large teams. Consistent patterns, DI for testing, scales with your needs.

Performance-Critical Apps

Hono's speed with enterprise structure. ~140k req/s with full DI, validation, and OpenAPI.

Modern Bun Projects

ESM native, Bun optimized. Build to single executable file for easy deployment.

## Choose the Right Tool

Use Hono/Fastify/Express When:

Use NestJS/LoopBack When:

Use Ignis When:

## Why Choose Ignis

What You Get

What's Growing

Summary

Performance: Near Hono speed with enterprise features
Architecture: Clean DI, layered structure, patterns
Features: Validation, OpenAPI, auth built-in
Modern: ESM native, single file build, TypeScript-first
Scalable: Solo dev to enterprise teams
Growing: Active development, expanding ecosystem

IGNIS is ideal for developers who want enterprise patterns with modern performance. Start building today with structure that scales.

## Next Steps
1

Check Prerequisites

Install required tools

→ 2

Complete Installation

Build your first endpoint

→ 3

CRUD Tutorial

Build a complete API

→