Where we're going with this...

Our goal is to enable you to build any backend architecture you like, without the operational overhead. Here are some of the features we think would help - we're really keen to hear your feedback!

Managed databases

No backend is complete without a database, but they can be time consuming to manage. You need to think about the resources you require and how those requirements evolve, manage migrations and credentials, and make data available for testing.

Zero configuration

Simply by requesting a database connection the fold runtime will infer your infrastructure requirements and provision them for you.

Integrated with your development workflow

Locally, the runtime will create a test database for you, making the path from development to deployment completely seamless.

Managed migrations

Fold will manage running your migrations for you, no need to think about it as part of your deployment process or application start up.
1
2
3
4
5
6
7
8
9
10
~
import fold, { postgres } from "@foldsh/sdk"import { initDB } from "./db"const svc = fold();postgres.getConnection(svc, (config) => { initDB(config);};svc.start();
INSERT
svc/index.js

Event driven backends

Managing the infrastructure for event driven architecture can be difficult. Not only do you need to think about a message bus, but also manage tooling required to operate such a system in production. Tracing and a reliable historic event store are indispensible for diagnosing and fixing issues.

A simple but powerful SDK for event driven architectures

The fold SDK will abstract away all of the infrastructure required to run an event driven backend. Simply subscribe to a channel to have your service handle those events. Publishing events from within a service is as simple as a method call.

Create events through a simple REST interface

Publish new events from outside of fold through a simple HTTP request.

Capture event streams for testing and debugging

Take event streams from your deployed services and save them for use in testing. Alternatively, replay events from production to replicate bugs.

Tracing out of the box

View traces of events between your services without the need to set up and maintain the infrastructure to do so.
1
2
3
4
5
6
7
8
9
10
~
import fold, { publish } from "@foldsh/sdk"const svc = fold();svc.subscribe("sign-up", (event) => { sendEmail(event.email); publish("email-sent", event.email);};svc.start();
INSERT
svc/index.js

Integrated development tooling

Developing new services and integrating them with existing ones can be difficult. You need to be able to develop against preexisting services but the tooling that makes this easy is yet another thing you need to manage.

Capture service traffic for testing

Capture traffic to and from your deployed services so that you can mock them locally.

Connect to services from your test environment

Connect to services deployed in your test environment so you can develop new services without a complex local set up.
  • R
    Handled request /read from service: compute
  • E
    Handled "finished" event from service: notify
  • E
    Handled "do-compute" event from service: batch-job
  • R
    Handled request /compute from service: compute
Replay stream
Save stream

Automated resource optimisation

When you truly abstract away infrastructure you no longer need to decide how and where your service are run.

Minimise your costs

Fold can analyse your service usage patterns and deploy it on the most cost effective infrastructure. This would minimise your costs over time.

Infrastructure that evolves with you

As your application evolves your infrastructure needs to change too. Fold can take care of this and change its deployment strategy based on your resource requirements.
Service
search-service
Current backend
Serverless
Proposed action
Move to dedicated VM
Current bill
$100
Projected savings
20%
Your bill next month
$80
Approve
Reject

Service templates and middlewares

We intend to build a collection of services templates and middlewares that save you time on building generic system components. This will be open source so that 3rd parties are able to contribute their own templates and middlewares too.

Service templates

Use pre-made templates from us and from 3rd parties to save time on generic components like authentication.

Middlewares

Inject middlewares to handle things like authorization, compression and monitoring with no effort. No need to deploy and maintain a complex service mesh such as istio.
$ foldctl new service --from auth/js $ foldctl deploy auth/ $ curl -X POST \ https://sub.api.fold.sh/svc/auth \ -d 'client_id=ABCDEFGH' \ -d 'client_secret=abcdefgh123456' \ { "access_token": "ABC987654321", "expires_in": 86400, "token_type": "Bearer" }

Service deployment and versioning

Development teams spend a lot of time developing and maintaining their CI/CD pipelines. These systems enable us to get software to market fast, but they can be complex and difficult to get right.

Simple CI/CD pipelines

Free your team from having to maintain their own CI/CD tooling.

Preview environments

Easily create and deploy preview environments for your PRs.

Service versioning

Fold extracts the version information from your services and would use this to manage your API versions, rollbacks, etc.
ServiceStatusURL
Authv1.0.1Healthysub.api.fold.sh/svc/auth
Searchv2.4.0Healthysub.api.fold.sh/svc/search
Syncv0.1.3Downsub.api.fold.sh/svc/sync
Importv1.2.3Deployingsub.api.fold.sh/svc/import

Sign up for early access

Before launching we can only take on a limited number of customers. Sign up early to take your place in the queue!