An easy-to-use, instant API engine

Create and manage GraphQL APIs for all your SQL databases.
Watch Demo
Watch Demo
cloud icon
Broad DB Compatibility
Devii is compatible with 98% of all SQL databases out-of-the-box.
no code icon
Easy API Management
Configure & manage GraphQL APIs for all your databases in one place.
security engine icon
Built-in Security
A Policy-Based Access Control system is our default security model.
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
Devii portal dashboard screenshot.
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 1000 hours or more on API dev time per software development 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.
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 introspect and generate both a GraphQL schema and API for any SQL database. In seconds, you'll be able to safely access and interact with your database online.

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

Manage all your Devii-generated GraphQL APIs in one, convenient location. Link as many SQL databases, hosted from anywhere and everywhere, to your Devii account.

Manage your API effectively.

With a simple interface, you can manage roles, policy rules, and GraphQL schemas & APIs without writing a line of code. Even Dave from accounting could do it (but that is not his responsibility...it is only an expression).

animated gif of devii portal in action

Simply manage your security.

Configure your GraphQL API policy to seamlessly align with your security requirements by building a few simple rules. Devii offers a policy-based access control system that scales with your users' permission requirements.

Devii portal policy settings screenshot

Pare down your schema.

With Devii, you can choose exactly what tables are exposed in your GraphQL schemas and APIs. Your end users will only ever see what API functionality you authorize them to see.

Devii portal dashboard screenshot
3 step process to signup for Devii
Our mission is to provide the same experience for every SQL database in use
PostgreSQL logo
SQL server logo
Microsoft SQL Azure logo
MySQL logo
Oracle Logo
Aurora logo
yugabyteDB logo
MariaDB 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 dev; blaze through the API build.

Speed icon

Speed

Devii eliminates manual API development, saving API development time of up to 1000 hours or more per project.
database icon

Flexibility

Add new features and update databases without having to spend days or weeks on API regression testing.  Automatic introspection forms your API into the shape your database requires.
Auto resolvers icon

Automation

Reduce the time it takes to deploy a fully functioning, production-ready, enterprise-grade API from months to minutes.

Built for developers,
by developers.



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 simply 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 can shift focus from maintaining complex API policies to building their application's features right now.

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

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. Use these powerful capabilities as a part of your account experience.
Read more
Check mark

Alerts

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

Geoimaging

Geospatial raster and vector 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 your own payment gateways.
Check mark

Geospatial

Geospatial (GIS) 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
Principal Engineer