The UI is the easy part these days. Logins, users, permissions, forms, workflows… that's where the weeks go. Oblax gives you that part, ready to use, behind one API.
You can generate a UI in minutes now. Cool. Someone still has to handle the logins, the permissions, the file uploads, and the database that shouldn't fall over when real traffic shows up.
AI-assisted UI generation, component libraries, and no-code tools have compressed frontend development from weeks to hours. The bar for shipping a polished interface is lower than ever.
Every new app still needs the same auth system, the same file handling, the same CRM logic. None of that disappears just because the frontend was generated in an afternoon.
Consistent workflows underneath, no matter how the UI was built.
Oblax is a modular Backend-as-a-Service that provides complete business workflows like Authentication, CRM, Forms, Storage, Inventory, and much more through a single API. Enable modules, configure workflows, and start building immediately.
A pre-built, pre-hosted mesh of small backend services. Each one handles a single business domain (auth, identity, forms…), and the whole platform sits behind one secure, standardized, and well-documented API.
Every service is built to scale, so more users don't have to mean a slower app. Each application also gets its own database, guarded by a fine-grained access control list. Your data doesn't mix with anyone else's.
No infrastructure to provision. No boilerplate to write. Just pick what you need and start calling APIs.
Sign up and create your workspace. That's the whole step, really.
Create a project and turn on the modules you need. Auth? Forms? Both? Flip the switch.
Grab the SDK (or plain HTTP, we don't judge) and start calling the API.
You've built a login system before. Probably more than once. These are the parts every app needs, built once and ready to use from day one.
authSign-up, login, and sessions for web, mobile, desktop, or backend apps. The part every app needs and nobody wants to build again.
identityManage people, organizations, and their relationships in one place, with structured identity data ready to use across your application.
formsContact forms, applications, sign-ups… Define the fields, and Oblax stores the submissions. No new table and endpoint for every form.
bookmarksLet users save anything in your app and come back to it later. One bookmarking service for the whole app, not one per feature.
fluxExtend your backend with event-driven JavaScript that connects services, automates business logic, and adapts application behavior to your needs.
mailerGenerate dynamic content from reusable templates, making it easy to produce consistent emails, documents, invoices, and other application outputs.
business workflowsBuild CRM, project management, delivery management, and other business applications on a shared backend for managing work, tracking progress, and coordinating processes.
ecommerceBuild your online store on a backend designed to bring product catalogs, order management, and commerce workflows together.
cmsManage structured content independently of your frontend, with a dedicated backend for organizing entries and delivering content to your applications.
AI makes writing code faster, but speed means little if every feature introduces more complexity.
AI can write you a login system in ten seconds. Then you get to review it, test it, secure it, and maintain it… forever. Or you call an API that already does all of that, and spend your time on what makes your app unique. Less code to own means less code to break.
See it in codeOne consistent experience across the entire platform. Learn it once, work with any module, through the SDK, API, or CLI.
const oblax = new Oblax({
endpoint: 'https://api.oblax.io',
clientId: 'my-service',
modules: [PlatformServer(), Auth({ realm: 'webapp' }), Forms(), Templates(), FileManager()],
})
await oblax.auth.session.create({ email: 'you@example.com', password: 'supersecret' })
// 1. Forms — create a contact form
await oblax.forms.create({ name: 'contact', fields: [
{ name: 'email', dataType: 'email', required: true },
{ name: 'message', dataType: 'string', required: true },
]})
// 2. Templates — the "thanks" email
await oblax.templates.create({ displayName: 'Contact reply', format: 'html',
content: '<p>Hi {{.Name}}, thanks for reaching out!</p>', fields: ['Name'] })
// 3. Files — upload the logo
const logo = new Blob([await readFile('logo.png')], { type: 'image/png' })
await oblax.filemanager.upload({ file: logo, filename: 'logo.png',
contentType: 'image/png', directory: 'images', public: true })
// Every module lists the same way
await oblax.forms.list()
await oblax.templates.list()
await oblax.filemanager.list()API=https://api.oblax.io/api/v1
CLIENT='oblax-client-id: my-service'
# Sign in (service clients get the token back as JSON)
TOKEN=$(curl -s $API/auth/session/webapp -H "$CLIENT" \
--json '{"email":"you@example.com","password":"supersecret"}' | jq -r .oblax_access_token)
AUTH="Authorization: Bearer $TOKEN"
# 1. Forms — create a contact form
curl $API/forms -H "$CLIENT" -H "$AUTH" --json '{"name":"contact","fields":[
{"name":"email","data_type":"email","required":true},
{"name":"message","data_type":"string","required":true}]}'
# 2. Templates — the "thanks" email
curl $API/templates -H "$CLIENT" -H "$AUTH" --json '{"display_name":"Contact reply","format":"html",
"content":"<p>Hi {{.Name}}, thanks for reaching out!</p>","fields":["Name"]}'
# 3. Files — upload the logo
curl $API/filemanager -H "$CLIENT" -H "$AUTH" -F file=@logo.png -F directory=images -F public=true
# Every module lists the same way
curl $API/forms -H "$CLIENT" -H "$AUTH"
curl $API/templates -H "$CLIENT" -H "$AUTH"
curl $API/filemanager -H "$CLIENT" -H "$AUTH"obx login
obx project link brave-otter-d8k2m4p6r1t3v5q7s9b0
# 1. Forms — create a contact form
obx app forms init
cat > app/dev/forms/init.json <<'EOF'
{ "name": "contact", "fields": [
{ "name": "email", "data_type": "email", "required": true },
{ "name": "message", "data_type": "string", "required": true } ] }
EOF
obx app forms push init
# 2. Templates — the "thanks" email
obx app templates init "Contact reply" --format html
echo '<p>Hi {{.Name}}, thanks for reaching out!</p>' > app/dev/templates/contact_reply_html.html
cat > app/dev/templates/contact_reply_html.json <<'EOF'
{ "key": "contact_reply_html", "display_name": "Contact reply", "format": "html", "fields": ["Name"] }
EOF
obx app templates push contact_reply_html
# 3. Files — upload the logo
obx app files init
cat > app/dev/files/init.json <<'EOF'
{ "file_path": "logo.png", "directory": "images", "is_public": true }
EOF
obx app files push
# Every module lists the same way
obx app forms ls
obx app templates ls
obx app files lsNo adapters. No custom integrations. One REST API or SDK from any language, any framework, any runtime.
Works with any HTTP client in any environment.
Saving a row is easy. Knowing who's allowed to save it, what has to happen next, and who needs to hear about it… that's the real work. Oblax handles that part.
Build your frontend with whatever you like and talk to Oblax through the API or the SDK. We handle the backend. How you build the rest is your call.
Need only auth today? Use only auth. Add the rest when (and if) you need it. No all-in-one monster to adopt on day one.
Identity, data, business logic, and workflows on one platform. Not five different services duct-taped together and held up by hope.
A predictable API, a practical SDK, and a CLI for the terminal people. Whether you write the code yourself or your AI agent does, it works the same way.
Prototypes are easy. Production is where it hurts: traffic spikes, crashes at 2am, someone poking at your API. Oblax is built for that part, so you don't have to rebuild your backend once the app takes off.
Services don't depend on local session state, making it easier to run multiple instances and recover from failures.
Scale your infrastructure as demand grows, without redesigning your application around a new backend.
Centralized identity and access control, so security isn't something you bolt on the week before launch.
Every capability is accessible through a consistent API, with SDKs and CLI tools that fit into your existing development workflow.
Partner with Oblax to extend the platform and reach developers who need exactly what you make.
We are really close to opening Oblax to the public. So, as it usually goes with these things, we're starting with limited access.
This form helps us gradually roll out the platform while we monitor its performance. Everyone who signs up joins the pre-registration list and gets early access to Oblax. Access will open in stages, not all at once, but everyone will get in eventually.
We'll notify you by email when your access is ready. Your information stays private and is only used for early access updates.