Show HN: Build TypeScript backends and SDKs with up to 90% less code

1 day ago 1

Read as "JavaScript 2.0"

The missing standard for full-stack TypeScript apps.

Build TypeScript backends and SDKs with up to less code. Faster, cheaper & easier to maintain.

Backend code

// Auth, ACL, Validation, Sanitation, // ORM & more out of the box app.addEndpoint({ path: '/car', method: 'POST', inputSchema: sCar, outputSchema: Schema.withInstance(sCar), isLoggedIn: true, run: async (system, input) => { return system.models.car.create(input); } });

Frontend code

// Talk to API using generated async // functions (100% type-safe) const newCar = await createCar({ isLeased: false, registrationNumber: 'ABC123' }); console.log(newCar.id);

Reduce code by up to • Generate the frontend SDK • Save time & cost on dev

Most backends contain repetitive code

With JS20 you can eliminate boilerplate code and focus on business logic. This means faster development, less testing and easier maintenance.

Everything you need, built in

JS20 offers a solid framework that takes care of most of the heavy-lifting when building a backend app, designed to scale from prototype to millions of users. Start building your next app now.

Specify instead of code

Focus more on specifying what you need, less on how to implement it. This paves the way for automations & code generation.

Heavy-lifting done for you

Built-in authentication, authorization, validation & security. Deploy with confidence from day one.

Rigid, yet flexible

JS20 is strict & rigid, but still offers full flexibility. Replace & modify any component. Use your own database, auth, or validation. Run on any cloud or web server.

Security & Validation

Schema-driven validation, sanitation, and conversion with type-safe APIs that prevent injection and data corruption.

Auto-Generated Frontend SDK

Define backend endpoints once to get versioned, typed frontend APIs automatically—no client code or docs required.

Optimized for AI

Writing less code makes it easier for AI to build your backend, cutting token costs and boosting quality.

Ready for the AI era

Modular, high-level code with minimal boilerplate is optimal for generative AI to interpret and build upon. Less code leads to higher quality, lower costs, and greater efficiency.

AI coding becomes more powerful by:

Reduce code base by up to

Shorter queries, means lowered token costs

Increased quality - let AI focus on business logic, not implementation details

Easier to do high-level system changes, perfect for prompt instructions

Less environmental impact - less tokens means less energy usage

Made for critical systems

Achieve greater readability through repeatable, validated chained actions that streamline business logic. With step-by-step validation, you can build critical systems with confidence.

async function transferCarOwnership({ run }, input) { const taxDebt = await run(getTaxes, input); await run(verifyNoUnpaidTaxes, taxDebt); const oldOwner = await run(getOwner, input); await run(verifyTransferApproved, { ...input, oldOwner }); const updated = await run(updateOwner, input); return await run(getTransferCertificate, updated); }

Input & output validated at every step • Automatic roll-back on error

Ready for a frontend integration?

Because of JS20 ability to specify code, we can easily generate docs & versioned SDK for your frontend integration. No need to keep client SDK in sync with backend changes - generate it

// Generate frontend SDK await app.generate(options);

Use app.generate() to automatically create an SDK based on your schemas, models & endpoints.

Console output showing generate output

Build your first application.

Note: JS20 is currently in beta. See status here.

Read Entire Article