Back I/O is an object-graph-centric backend that elegantly disappears into the semantics of JavaScript. If you know JavaScript, you know Back I/O.
If you're a frontend web/mobile developer, Back I/O makes you full-stack.

▶   Play Intro Video Sign Up Now


var e = new Employee(); var o = new Office(); // Objects now saving // to the backend. = "Bob"; e.salary = 50000; // Properties being // updated on the backend. = $(".file"); // Image now uploading.
o.employees.push(e); // Employee added to // the array on the backend.


Offices .where( .join(Office.employees) .read(offices => { /* offices is an array of offices where no rent is is being paid, with each Office object having a fully populated .employees array. */ });


Employees.login( "", "pass", (e, employee) => { /* employee is a reference to Bob, and now we can do the things Bob has been permitted to do. */ });

What about code that
must run on a server?

Back I/O allows sections of code to be marked as secret. On deployment, these sections of code are relocated to the cloud as a micro-service, and Back I/O automatically deals with the communication between it and your app.

This means that while debugging the frontend, it's possible to step directly into the code that completes payments with Stripe, or sends emails with SendGrid. And in production, all code runs in the right place.

function callService(doneFn) { // Prefix a setTimeout call with // "Back.", and the secret code is // removed at deployment time.
Back.setTimeout(() => { // Secret code
$.ajax({ url: "", password: "my-api-key" }) .done(doneFn); }); }

How is this possible?

Under the covers, Back I/O lightly instruments your domain objects, so that modifying them triggers an optimized network operation, which then compiles to a database operation, which is executed in our massively scalable cloud environment. To get started:

Design the structure of your objects.

Describe your domain objects, and their security constraints in a purely object-oriented model. Think classes, references, and arrays.

Add the generated JavaScript to your app.

When included, instantiating domain objects, assigning values, and pushing items into member arrays generates an IO operation.

Optional: Add the TypeScript typings.

Back I/O generates an accompanying TypeScript definition file, allowing your team to maintain full type safety and code completion against your domain objects.

A Fundamental Shift In Software Development

Gone are the days when the typical "full stack developer" was required to build a successful app. Armed with Back I/O, a front-end development expertise is all that's required to take your project from zero to hero.

Back I/O is a fully managed service that deals exclusively with storing, scaling, and securing a backend and it's data. It makes no assumptions about anything else, so it fits elegantly with any front-end JavaScript framework (AngularJS, React, etc). Fully native mobile apps can be built with ReactNative, NativeScript, or Fuse.

Back I/O is truly object-oriented, not relational (MySQL) or document-oriented (MongoDB, Firebase, Syncano). The data structure of most apps is a complex network of highly interlinked objects. Back I/O is uniquely built to handle this—it transparently maintains the referential integrity of this interlinking, which is in stark contrast to every other BaaS.

Back I/O doesn't have it's own method of operation. Instead, it mirrors the exact semantics of JavaScript, making everything look like frontend code. Apps that use this architecture are simplified dramatically, because there is no leap of translation required to exchange data between the client and the server. And more importantly, it means the code, the user interface, and the stakeholders are all speaking the same language.

“Back I/O's object oriented approach to system design dramatically simplified creating a searchable taxonomy of over 65,000 types of fasteners.”

Mark Krasnohorsky
Consultant for Spaenaur, Inc.

Twitter GitHub Gitter Contact
404 King St. W
Unit 116
Kitchener, ON
N2G 4Z9