Performance

Performance

NestForge Web leverages Rust’s performance characteristics for blazing-fast response times and minimal resource usage.

Benchmarks

Cold Start Time

Framework	Cold Start
Next.js (Node.js)	100-500ms
NestForge Web	< 50ms
Improvement	5-10x faster

Memory Usage

Framework	Baseline Memory
Next.js	50-200MB
NestForge Web	< 20MB
Improvement	3-10x lower

Throughput

Framework	Requests/second
Next.js (Node.js)	~10,000-30,000
NestForge Web	~100,000+
Improvement	3-10x higher

Time to First Byte (TTFB)

Framework	TTFB
Next.js SSR	50-150ms
NestForge Web SSR	< 10ms
Improvement	5-15x faster

Why So Fast?

Native Binary

# Next.js requires Node.js runtime (~100MB)
# NestForge Web is a compiled native binary
file my-app
# my-app: ELF 64-bit LSB executable... (no runtime needed)

tokio Runtime

use tokio::runtime::Runtime;

// Single-threaded runtime for I/O-bound tasks
let rt = Runtime::new().unwrap();

// Multi-threaded for CPU-bound work
let rt = Runtime::new().multi_thread().build().unwrap();

Axum HTTP Server

use axum::{Router, routing::get};

let app = Router::new()
    .route("/", get(handler))
    .layer(cors())
    .layer(compress());

// Zero-copy routing
async fn handler() -> &'static str {
    "Hello, World!"
}

Memory Optimization

Connection Pooling

// Reuse database connections
#[nestforge::service]
pub struct DatabaseService {
    pool: Pool<Postgres>,
}

// Pool manages connections efficiently
pool.get_read().await?;
pool.get_write().await?;

Zero-Copy Parsing

// Deserialize without allocation
use serde_json::Value;

fn process_json(data: &[u8]) -> Value {
    // No intermediate allocations
    serde_json::from_slice(data).unwrap()
}

Arena Allocators

use bumpalo::Bump;

fn process<'a>(&self, arena: &'a Bump) -> &'a str {
    // Allocate from arena (faster than heap)
    arena.alloc_str("hello")
}

Benchmarking Your App

Load Testing with wrk

# Install wrk
brew install wrk

# Run benchmark
wrk -t12 -c400 -d30s http://localhost:3000/api/users

Artillery for Complex Tests

test.yml

config:
  target: "http://localhost:3000"
  phases:
    - duration: 60
      arrivalRate: 100
scenarios:
  - name: "User API"
    flow:
      - get:
          url: "/api/users"
      - post:
          url: "/api/users"
          json:
            name: "Test"
            email: "test@example.com"

artillery run test.yml

Rust Profiling

# CPU profile with perf
perf record -g ./target/release/my-app
perf report

# Memory with valgrind
valgrind --tool=massif ./target/release/my-app

Optimization Tips

Enable LTO

Cargo.toml

[profile.release]
lto = true
codegen-units = 1
opt-level = 3

Use Release Profile

cargo build --release

Enable Parallel Compilation

~/.cargo/config.toml

[build]
jobs = 8

Resource Limits

Memory Usage by Feature

Feature	Memory
Base server	~5MB
+ Routing	~8MB
+ Database pool	~15MB
+ Full app	< 20MB

Scaling Characteristics

Instance Size	Concurrent Users
256MB RAM	~10,000
512MB RAM	~50,000
1GB RAM	~100,000+

Deployment Benefits

Cost Savings

Provider	Next.js	NestForge Web
AWS Lambda	~$0.02/1M req	~$0.002/1M req
Cloudflare Workers	Not available	$0.50/1M req
VPS	Full Node.js	1/10 resources

Carbon Footprint

Lower resource usage means:

• Less energy consumption
• Smaller data center footprint
• Reduced CO2 emissions

Related Pages

• Architecture - Internal design
• Rendering Modes - SSR/SSG/ISR performance