The type safe
serverless platform for
modern full-stack developers

Everything you need to build apps that scale up to millions of users.

her0-3-terminals
hero-3-terminals-mobile
hostingIncludedIcon

Hosting included

for all plans


USED AND TRUSTED AT

multiversx-logo google-logo splunk-logo uipath-logo
howGenezioWork

Your app, your code, your data.

If you are a full-stack developer who needs to build, deploy and maintain web, mobile or enterprise apps that scale automatically, and use type safe frontend-backend communication, then Genezio is for you. There are many solutions that are easy to use, but hide their magic and trap you in. With Genezio, you own all the code and the databases that we help you set up.

CAPABILITIES

Genezio in a nutshell

genezio-logo-icon-black

Type safe RPC backend breaks less often

  • Full static type safety with auto-completion in your favorite editor. Dynamic type safety at runtime.
  • Tested and production ready for TypeScript BE/FE. Beta support for Kotlin and DART. Under development: GoLang and Swift.
  • Export the resulting SDK using dependency managers such as NPM Registry - private to your team or public for anybody to use.
Learn more ->
genezio-logo-icon-black

Easy to use databases, queues, crons, auth...

  • Databases - provisioned by us or you can bring your own. Table creation and CRUD boilerplate functions generated through LLM.
  • Cron jobs - scheduled to be executed up to a minute granularity.
  • User authentication module - works on any database.
  • Email service - use it in your code to send emails to your users securely.
Learn more ->
genezio-logo-icon-black

Host your app for free with auto-scaling

  • Framework agnostic, works with React, Vue, Angular, Svelte, ExpressJS, Fastify, etc.
  • Developer experience enhanced bundling - minimal package generated automatically.
  • Deploy the backend on managed AWS or Genezio.Cloud. Frontend deployment with CDN.
  • Multiple staging environments supported, production deployment as well as local development environment.
Learn more ->

Dashboard with test-interface

Collaborate with your teammates

Automatic scaling

View and search live logs

Framework agnostic - React, Vue, Svelte, etc

Open source community

Show me the code

A more natural paradigm in software design, leading to less error prone parameter passing than REST APIs and auto completion in your favorite IDE. Here we define the "bye" method in the HelloWorldService backend class, and we call it from the frontend using the auto-generated SDK.

genezio server
type Person = {
  firstName: string;
  lastName: string;
}

@GenezioDeploy()
class HelloWorldService {
  hello(name: string): string {
    return `Hello ${name}!`;
  }

  bye(person: Person): string {
    return `Bye, ${person.firstName} ${person.lastName}!`;
  }
}
client
import { HelloworldService, Person } from '@genezio-sdk/helloworld-app';

const hi = await HelloworldService.hello('John');
const person: Person = {firstName: 'John', lastName: 'Ronald'};
const bye = await HelloworldService.bye(person);

We parse the backend code you write and store the AST in a database. From there we generate client side stubs in any language. It's like tRPC but for any backend language to any frontend language.

Now supporting JavaSript/TypeScript, with support for DART/Flutter, Kotlin, Swift, GO, Python and others coming soon.

client.ts (TypeScript)
import { HelloworldService, Person } from '@genezio-sdk/helloworld-app';

async function main() {
  const hi = await HelloworldService.hello('John');
  const person: Person = {firstName: 'John', lastName: 'Ronald'};
  const bye = await HelloworldService.bye(person);
}
client.dart (Flutter)
import 'package:hello_world/sdk/hello_world_service.dart';

void main() async {
  final hi = await HelloWorldService.hello('John');
  final person = Person(firstName: 'John', lastName: 'Ronald');
  final bye = await HelloWorldService.bye(person);
}
client.kt (Kotlin)
import sdk.HelloWorldService
import sdk.Person

suspend fun sayHi() {
  val hi = HelloWorldService().hello("John")
  val person = Person(firstName = "John", lastName = "Ronald")
  val bye = HelloWorldService().bye(person)
}

Authenticate users securely with multiple login methods, such as Email/Password, Google, and more coming soon. Use PostgreSQL or MongoDB provisioned from the Genezio Dashboard, or bring your own database. No vendor lock-in; take control of your code at any time.

client
import { AuthService } from '@genezio/auth';

  AuthService.get().setTokenAndRegion("1-xyz", "us-east-1")
  
  const Signup = () => {
    // rest of the code
  
    const handleSignupSubmit = async (e) => {
      // Use the auto generated EmailAuthService to register the user
      const response = await AuthService.get().register(user.email, user.password, user.username)
      if (response.success) { ... }
    }
  
    const handleLoginSubmit = async (e) => {
      // Use the auto generated EmailAuthService to register the user
      const response = await AuthService.get().login(user.email, user.password)
      if (response.success) { ... }
    }
  
    const getUserInfo = async (e) => {
      // Use the auto generated EmailAuthService to register the user
      const userInfo = await AuthService.get().getUserInfo()
      ...
    }
    
    // rest of the code
  }
genezio server
import { GenezioDeploy, GnzContext, GnzAuth } from '@genezio/types';

@GenezioDeploy()
export class UserInfoService {

  @GnzAuth
  async getUserInfo(context: GnzContext): Promise<void> {
    const userInfo = await UserModel.getUserInfo(context.user.id)

    return userInfo
  }
}

We offer Redis or Postgres through our partners. Or bring your own database and connect it to your backend like you normally would.

genezio server with Neon Postgres
import { GenezioDeploy } from "@genezio/types";
import pg from 'pg'
const { Pool } = pg

@GenezioDeploy()
export class PostgresService {
  pool = new Pool({
    connectionString: process.env.NEON_POSTGRES_URL,
    ssl: true,
  });

  async insertUser(name: string): Promise<string> {
    await this.pool.query(
      "CREATE TABLE IF NOT EXISTS users (id serial PRIMARY KEY,name VARCHAR(255))"
    );

    await this.pool.query("INSERT INTO users (name) VALUES ($1)", [name]);
    const result = await this.pool.query("select * from users");

    return JSON.stringify(result.rows);
  }
}
genezio server with Upstash Redis
import { GenezioDeploy } from '@genezio/types';
import { Redis } from '@upstash/redis'

@GenezioDeploy()
export class RedisService{
  client = new Redis({
    url: process.env.UPSTASH_REDIS_URL,
    token: process.env.UPSTASH_REDIS_TOKEN,
  })

  async insertUser(name: string): Promise<string> {
    await this.client.set('user', name);
    const result = await this.client.get('user');
    return JSON.stringify(result);
  }
}

Manage and process large volumes of tasks and requests with ease and reliability. Extremely helpful when you need to do something asynchronously.

genezio server
import { GenezioDeploy, GenezioMethod,
  GenezioHttpRequest, GenezioHttpResponse } from "@genezio/types";
import axios from 'axios';

@GenezioDeploy()
export class QstashService{

  async chatbot(): Promise<boolean> {
    const url = `https://qstash.upstash.io/v2/publish/${process.env.QUEUE_WEBHOOK_URL}`;
    const payload = {
      "message": "I am your trusty chatbot! I'll help you process your tasks.",
    };

    const headers = {
      Authorization: `Bearer ${process.env.QSTASH_TOKEN}`,
      'Content-Type': 'application/json',
    };

    await axios.post(url, payload, { headers: headers })

    return true
  }

  @GenezioMethod({ type: 'http' })
  async sendReplyToChatApp(request: GenezioHttpRequest): Promise<GenezioHttpResponse> {
    const message: string = request.body.message;

    await this.#sendReplyToChatApp(message);

    const response: GenezioHttpResponse = {
      body: {"status":"ok"},
      headers: { 'content-type': 'application/json' },
      statusCode: '200',
    };
    return response;
  }
}

Support for configurable cron jobs to automate your application.

genezio server
import { GenezioDeploy } from '@genezio/types';

@GenezioDeploy()
export class OrderService {

  // this method will run every day at midnight
  @GenezioMethod({ type: "cron", cronString: '0 0 * * *' })
  async checkForUnfinishedOrders() {
    const unfinishedOrders = await this.orders.find({
      where: {
        status: 'unfinished'
      }
    });

    await this.sendReminderEmails(orders);
  }
}

Store and retrieve user-generated content, application settings or multimedia files.

We will support long running servers through genezio.deploy on AWS and we will provide real-time communication between the backend and the frontend.

Genezio offers multi-cloud support, including AWS and the new Genezio.Cloud that's still being tested. We're using AWS Lambda right now, and we're working to add long running servers. Plus, we provide support to deploy on your own AWS account.

genezio deploy

% ls
client/      server/      genezio.yaml

% genezio deploy
Bundling your code...
Deploying your server...

The server was deployed and the SDK was successfully generated!
You can test it at https://app.genez.io/project/a1b2c3d4-e5f6-7890-g1h2-i3j4k5l6m7n8/a1b2c3d4-e5f6-7890-g1h2-i3j4k5l6m7n9

Deploying your frontend...
Frontend successfully deployed at https://happy-purple-capybara.app.genez.io
                
testing locally

% ls
client/      server/      genezio.yaml

% genezio local
Bundling your code...
Starting your local server...

Your local server is running, and the SDK was successfully generated!
Test your code at https://dev.app.genez.io/test-interface/local?port=8083
                

Deploy to local, stage or production with one command.

genezio deploy

% ls
client/      server/      genezio.yaml

% genezio deploy --stage dev
Bundling your code...
Deploying your server...

The server was deployed, and the SDK was successfully generated!
You can test it at https://app.genez.io/project/a1b2c3d4-e5f6-7890-g1h2-i3j4k5l6m7n8/a1b2c3d4-e5f6-7890-g1h2-i3j4
                
testing locally

% ls
client/      server/      genezio.yaml

% genezio local
Bundling your code...
Starting your local server...

Your local server is running, and the SDK was successfully generated!
Test your code at https://dev.app.genez.io/test-interface/local?port=8083
                

Deploy to AWS CloudFront now. Working to integrate with Netlify.

genezio deploy

% ls
client/      server/      genezio.yaml

% genezio deploy --frontend

Deploying your frontend...
Frontend successfully deployed at https://happy-purple-capybara.app.genez.io
                

Test parameters: Hello World function 30 HTTPS requests for each scenario Cached DNS records for functions domains to prevent additional time caused by DNS

cold-start-chart

Show me the code

EDUCATION

Our latest article


TESTIMONIALS

Don't take our word for it

testimonial-user-2

Daniel M

CEO @DeFiBuilder

Using their SDK, I was able to deploy complex functionalities with an ease that I hadn't experienced before. The integration process is so streamlined and user-friendly that even those with a basic understanding of JavaScript can navigate it with confidence.

testimonial-user-1

Bogdan Ripa

SVP @UiPath

I used the genezio platform for building and deploying my app - I build a node.js module on top of Huawei’s FusionSolar website as their official API does not allow for real-time data, and used Tesla’s unofficial API to change the charging amps in real time. The genezio platform was easy to work with and the fact that I could build and host it (for now it’s free) in such a short time says quite a lot about them.

testimonial-user-3

Laurentiu Ciobanu

CTO @Sessions

It was a pleasant and frictionless experience: from my TypeScript code to the cloud in less than 3 minutes (including creating an account, installing the CLI, and logging in with the CLI).


FAQ

Your questions answered

Genezio is used by our clients to build and host full-stack apps. These include a variety of full-stack Web Apps, Mobile Apps, Enterprise automation apps, and Blockchain enabled apps. Also, some developers use Genezio just to set up scheduled tasks or to keep an API key private in a part of their app that runs in the background. To learn more and see examples, check out our docs.

Your DevOps team is probably pretty busy, so in order to try out a pilot project, it's much easier to use our serverless approach.

tRPC is an amazing library to add type safe calls to TypeScript frontends and backends. Genezio.RPC allows developers to write the backend in, say, Go, and call the exported type safe API from a react frontend.

REST is a flexible standard that is very well suited to open APIs. We have created Genezio.RPC to allow developers to design a backend that doesn't necessarily fit into the REST paradigm. We see more and more developers interested in ensuring type safety and consistent design for the frontend-backend communication. This is the best way to ensure less things break as they change things.

Genezio.Services is similar to a BaaS in the sense that offers a wide variety of out-of-the-box services to help you be more productive. Implementing authentication, setting up cron jobs and working with databases and queues are one click away. They are designed to save you time and effort when developing and maintaining your applications. The differences steam from the fact that Genezio enables you to write your own backend business logic. Also, in Genezio the database is not exposed directly to the frontend, enhancing security and separation of concern.

Genezio.Cloud ensures that you can deploy applications in a serverless fashion, and instantly have a secure, publicly available deployment. After you create, build, and test your application locally, you can deploy it to Genezio Cloud. You can now deploy on production on our managed AWS account. You can also start experimenting on our own serverless cloud that offers zero cold start penalty for backend functions and lower, predictable cost.

You can build your apps using TypeScript for both backend and frontend, which is tested and production-ready. We also offer beta support for Kotlin and DART, and are working towards enabling support for GoLang and Swift.

Genezio is compatible with various frameworks like React, Vue, Angular, Svelte, Flutter, ExpressJS, Fastify, and more, thanks to its framework-agnostic nature.

If all you need is a database exposed to the frontend, then Genezio is not very useful. However, when your business logic becomes more complex, you will need to implement it in a backend, and Genezio is a perfect solution for that.

Yes, you can try out Genezio locally without an account. An account is only required if you wish to deploy a project on our platform. See our docs for how to do this.

If your application requires more than a database, Genezio is the ideal solution. Here are some key benefits:
  1. Flexibility: Genezio supports various programming languages, making it more versatile for developers with different tech stacks.
  2. Type Safety: Genezio provides a type safe interface, reducing errors and enhancing code quality.
  3. Full-Stack Support: You can connect Genezio with any frontend, whether it's for web, mobile, or desktop applications, and still maintain type safety.
  4. Productivity: Genezio offers a range of built-in services like authentication, cron jobs and database integration, making development faster and more efficient.
  5. Scalability: Genezio ensures auto-scalability for your applications, adapting to traffic demands effortlessly.

Yes. Genezio provides the option to integrate your AWS account in place of using our managed AWS for Genezio Cloud. This feature is present in our open source command line tools.

You are fully responsible for the content you host with us. Any type of illegal or offensive content is forbidden. Please refer to our terms of use for further details. We reserve the right to take down your app if it violates our terms of use without any notice.