An instant API for your app.

Build, test, and deploy GraphQL APIs in under an hour.
Sign up for free access to the pilot program.
help icon
Watch Demo
Watch Demo
cloud icon
Cloud Hosted
Host your databases inside Devii or connect to external ones
no code icon
No-code Management
Configure & manage all your APIs in one place
security engine icon
Built-in Security
Policy-Based Access Control with default deny
Auto resolvers icon
Auto Resolvers
Near-instant access to table and view types
process rules icon
Process Rules
Added flexibility beyond simple database triggers
security engine icon
Advanced Security
Policy Based Access Control for scalable security
API engine icon
security engine icon
Speed icon
green gradient
blue gradient

Stop spending time on API development.

Your API should be a time saver, not a time suck.

yellow gradient
blue gradient
Check mark

Fewer hours

Save up to 27% API development time per project.
Check mark

Fewer developers

Cut API management from full-time to "Yeah, Jerry, I updated it this morning."
Check mark

Focus on features

Focus on the features and enhancements rather than backend configuration and infrastructure.

Turn every developer into a backend engineer.

Get Early Access
Initial query & schema

type Query { #schema definition
  Aggregates: Aggregates   # Aggregates are: avg, count, min, max, sum
  people(filter: String, ordering: [String], limit: Int, offset: Int): [people]
}

type people { #schema returned
  personid: ID!
  name: String!
  createtime: DateTime
}
After adding the places and things table and the relationships:

type Query { #schema definition
  Aggregates: Aggregates   # Aggregates are: avg, count, min, max, sum
  people(filter: String, ordering: [String], limit: Int, offset: Int): [people]
  places(filter: String, ordering: [String], limit: Int, offset: Int): [places] #new
  things(filter: Text, limit: Int, offset: Int): [things] #new
}

type people { #schema returned
  personid: ID!
  name: String!
  createtime: DateTime
  placeid: Float  #new
  place: places  #new
  things_collection: [things] #new 
}

Reflect any SQL database...in seconds.

No more shall we toil away, updating the API manually. There must be a better way!

With just a few clicks, you can reflect any GraphQL database. In seconds, you'll be able to view and query your data.

One handwritten resolver

class Person(graphene.ObjectType):
    personid = graphene.ID()
    name = graphene.String()
    createtime = graphene.DateTime()
class Query(graphene.ObjectType):
    person = graphene.String(personid=graphene.ID())
    place_person = graphene.Int(placeid=graphene.ID())
    person_things_list = graphene.String(personid=graphene.ID())

    def resolve_person(self, info, personid):
        person = session.query(base.classes.people).get(personid)
        return f"{person.name} created on: {person.createtime}"
    def resolve_place_person(root, info, placeid):
        return session.query(base.classes.people).filter(
            base.classes.people.placeid == placeid).count()
    def resolve_person_things_list(root, info, personid):
        person = session.query(base.classes.people).get(personid)
        thingslist = ', '.join([t.name for t in person.things_collection])
        return f"{person.name} has the following things: {thingslist}."
Devii Auto Resolvers

Introspection complete...resolvers generated.

No need to hand roll resolvers anymore.
You can thank us later.

Resolvers are generated automatically with each introspection. You can now spend your time on more important things.

Flexibility that goes way beyond automation.

Admin schema

schema {
  query: Query
  mutation: Mutation
}

type Aggregates {
  avg(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
  count(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
  max(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
  min(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
  sum(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
}

scalar DateTime

scalar GenericScalar

type Mutation {
  create_people(input: peopleInput): people
  update_people(input: peopleInput, personid: ID!): people
  delete_people(personid: ID!): people
  create_places(input: placesInput): places
  update_places(input: placesInput, placeid: ID!): places
  delete_places(placeid: ID!): places
  create_things(input: thingsInput): things
  update_things(input: thingsInput, thingid: ID!): things
  delete_things(thingid: ID!): things
}

type Query {
  Aggregates: Aggregates
  people(filter: String, ordering: [String], limit: Int, offset: Int): [people]
  places(filter: String, ordering: [String], limit: Int, offset: Int): [places]
  things(filter: String, ordering: [String], limit: Int, offset: Int): [things]
}

type people {
  personid: ID!
  name: String!
  createtime: DateTime
  placeid: Float
  place: places
  things_collection: [things]
  people_secrets_collection: [people_secrets]
}

input peopleInput {
  name: String!
  placeid: Float
  things_collection: [ID]
}

type places {
  placeid: ID!
  name: String!
  createtime: DateTime
  people_collection: [people]
}

input placesInput {
  name: String!
}

type things {
  thingid: ID!
  name: String!
  createtime: DateTime
  people_collection: [people]
}

input thingsInput {
  name: String!
  people_collection: [ID]
}
Restricted schema

schema {
  query: Query
}

type Aggregates {
  avg(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
  count(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
  max(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
  min(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
  sum(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar
}

scalar DateTime

scalar GenericScalar

type Query {
  Aggregates: Aggregates
  people(filter: String, ordering: [String], limit: Int, offset: Int): [people]
  things(filter: String, ordering: [String], limit: Int, offset: Int): [things]
}

type people {
  personid: ID!
  name: String!
  createtime: DateTime
  placeid: Float
  things_collection: [things]
}

type things {
  thingid: ID!
  name: String!
  createtime: DateTime
  people_collection: [people]
}

User Access Control without role-based security threats.

APIs that are both secure and scalable from built-in policy-based security that helps to minimize user configuration complexity, no matter the scale.

You can ensure that only the people who need access to your data will be able to get it, and that everyone else is securely distanced from your information.
Read more

Add server-side functionality to any app

You can't just add server-side functionality to any old app...oh wait...yes you can.

Start from our free library of rules:
Send emails, Generate PDFs, Image & Video Processing, Payment Gateway Actions , and more...
blue gradient
green gradient
Initial GraphQL schema:
schema {  
query: Query  
mutation: Mutation
}

type Aggregates {  
avg(subquery: String, filter: String, having: String, ordering: [String], limit: Int, offset: Int, distincton: [String]): GenericScalar  count(subquery: String, filter: String, having: String, ordering: [String], limit: Int, ion {  create_people(input: peopleInput): people  update_people(input: peopleInput, personid: ID!): people  delete_people(personid: ID!): people}type Query {  Aggregates: Aggregates  people(filter: String, ordering: [String], limit: Int, offset: Int): [people]}type people {  personid: ID!  name: String!  createtime: DateTime}input peopleInput {  name: String!}
After adding the places table and the relationship:
schema {  
query: Query  
mutation: Mutation
}


green gradient

Turn every developer into a backend engineer.

Schedule a demo
API engine icon
Instant API Engine
Reflect any GraphQL database...in seconds.
Flexibility that goes way beyond automation.
read more
process rules icon
Process Rules
Add server-side functionality to any app:
Send emails, Generate PDFs, Image & Video Processing, Payment Gateway Actions , and more...
read more
security engine icon
Authorization Engine
Policy Based Access Control allows user access without role-based security threats.
read more

All the APIs you need in one platform.

Schedule a demo

Host your API and databases in the cloud on one platform. So whether you need to power a web app or a mobile app, we've got you covered.

Manage

With our easy to use interface, you can manage roles, rules, and databases without writing a line of code. Even Dave from accounting could do it.

Configure

Configure your database and API to work together seamlessly with a few clicks. Reduce development time and simplify your stack.

Test

With Devii, you can test your APIs to ensure they're functioning properly and identify any issues before your customers encounter them.

From signup to API in minutes.

Sign up for free access to the pilot program.
3 step process to signup for Devii
Support for 9 Databases and counting...
PostgreSQL logo
SQL server logo
MySQL logo
Oracle Logo
Aurora logo
SQLite logo
green gradient
yellow gradient

Advaced Security (PBAC)
User access control without role-based security threats.

Policy Based Access Control (PBAC)

Policy-base access control diagram

Role Based Access Control (RBAC)

role-base access control diagram

Role-based Access Control (RBAC) is a static form of authorization that exponentially grows in complexity as user management grows.

In contrast, Policy-based Access Control (PBAC) enables you to quickly make user-wide changes to match new policies or regulations without the need to audit each role throughout the user base.

Gain peace of mind that assets cannot be compromised and regulations are met. Using PBAC to govern authorization empowers you to know that your data is securely used and controlled.

blue gradient
Devii Screenshot

The API you want in one platform

Speed icon

Build

Devii reduces API development time from368 hours to 30 seconds per project.
Check mark

Host

Add new features and update database sets in days instead of weeks by automatic reflection and API updates.
Check mark

Manage

Reduce the time it takes to go from architecture to front end from months to minutes.

Focus on software development
& blaze through the API build.

Speed icon

Speed

Devii eliminates manual API development, making API development time up to 27% faster per project..
database icon

Flexibility

Add new features and update databases in days instead of weeks by automatic reflection and API updates.
Auto resolvers icon

Automation

Reduce the time it takes to go from architecture to front-end from months to minutes.

Built for developers,
by developers.

Devii is an instant API engine that significantly reduces the time and cost for software developers to build and maintain GraphQL APIs.  

API management is a critical piece of every software development project, and Devii makes it easy to create, publish, and secure APIs. Using Devii, developers quickly create APIs that are both secure and scalable with built-in policy-based security that helps to minimize user configuration complexity, no matter the scale.

The Devii platform also offers instant API access to popular databases like MySQL, Oracle, and PostgreSQL. This means that developers now focus on building their applications rather than worrying about API management. In addition, Devii offers a cost-effective solution for hosting databases in the cloud.

By using Devii, developers save time and money on every API developed.

yellow gradient
blue gradient
green gradient
blue gradient
green gradient
Process packages icon

Out-of-the-box power
A massive jumpstart with Packages.

Devii comes with powerful tools built directly into your API without writing a single line of code. Enable any number of capabilities with the press of a button.
Read more
Check mark

Alerts

Automatic generation of alert messages based on database mutations.
Check mark

Geoimaging

Geospatial raster processing capabilities.
Check mark

Multimedia

Multimedia file storage & streaming.
Check mark

Secrets

Added security with off-server token storage.
Check mark

Financial

Processing of payments and subscriptions via payment gateways.
Check mark

Geospatial

Geospatial capabilities.
Check mark

Reporting

Generation of PDF reports based on queries with Javascript templates.
quotes icon

It is magical. So easy to plug into the endpoint for my databases. And treating each database as the microservices they are is an obvious choice with Devii.

Jase Kraft
Web Developer
LulzBot