July 01, 2021

How Prisma Allowed Pearly to Scale Quickly with an Ultra-Lean Team

Pearly provides a platform for dentists to create better and reliable revenue streams and affordable care plans for their patients. Learn how Prisma has helped them scale quickly with an ultra-lean team.

Pearly is a dental financial engagement platform for dentists enabling them to create better and reliable revenue streams. Pearly offers two products — Pearly Pay and Pearly Plan. Patients can access care plans from their dentists at affordable rates with Pearly Plan. In addition, Pearly Pay enables dental practices to automate their customer payments.

Pearly's financial platform provides a smooth user experience for dentists and their patients while still being HIPAA-compliant ensuring the information is secure.

While Pearly is currently expanding its engineering team, the first version of both products have been built by a single developer. Prisma's tooling enabled Pearly to iterate on products quickly without worrying about database queries and migrations.

A head start with Prisma

A common trend in many startups is adopting the lean software development methodology. The strategy focuses on addressing risks as quickly and cheaply as possible. Lean also focuses on the team being waste averse and iterative. The process and product are incrementally improved through the cycles of development and learning.

In particular, Sean Emmer's (CTO at Pearly) vision for his team is to iterate and adapt the product specifications quickly based on market feedback, without sacrificing the ability to scale the product after launch. Prisma gave him the ability to balance this, allowing him to to build a highly flexible GraphQL API against a robust SQL database, all according to best practice and with minimal boilerplate.

Sean picked Prisma as his go-to database client from day one. Prisma abstracted managing databases, enabling him to focus on delivering mission-critical features. Prisma Client provided a clean API for database access and Prisma Migrate to manage schema changes.

"This is the fastest I've ever developed in my life, by far. The tooling has dramatically cut down on the amount of time I've had to spend working on things. Not only, that but I've also been able to say yes to a lot of new incremental features, that used to be a 1-2 day thing and that are now a half-day thing."

Sean EmmerSean Emmer, CTO & Co-Founder at Pearly Plan

Pearly's stack is simple and modern that has enabled them to scale. The backend is built with the following libraries and third-party services:

  • GraphQL with Apollo
  • GraphQL Nexus
  • Serverless on Google Cloud Platform
  • PostgreSQL
  • Stripe
  • Firebase

Pearly ArchitecturePearly Architecture

Under the hood, Pearly communicates with multiple third-party services that are abstracted by GraphQL. This means that the frontend application queries data from the API without worrying about where the data is fetched. The GraphQL schema is uploaded to the Apollo Schema registry. The frontend applications use the uploaded schema to generate types that provide auto-completion.

Pearly's applications are written entirely in TypeScript — both the frontend and backend, enabling them to have end-to-end type-safe applications.

End-to-end type-safety, starting with the Prisma data model, has and continues to pay dividends for Pearly in terms of reduced compile-time bugs and easier refactoring or feature extension.The cumulative result has been a massive increase in developer productivity, developer experience, and ultimately a more robust and adaptable product.

For adding new fields and relationships, prisma db push enables Sean to quickly prototype a new schema without creating and editing database migrations.

"…we've been really happy with our decision to use Prisma — we've been iterating very fast...."

Sean EmmerSean Emmer, CTO & Co-Founder at Pearly Plan

Schema prototyping with db push

Building prototypes quickly is vital for validating ideas. Prototypes allow teams to iterate on products until they reach their desired state.

Prisma allows you to prototype your database schema using the prisma db push command. It is handy when you do not need to version the schema changes and prioritize reaching the desired end-state without previewing changes.

The Prisma schema makes defining data models human-readable and the intuitive.

generator client {
provider = "prisma-client-js"
}
datasource db {
provider = "postgresql"
url = env("DATABASE_URL")
}
model User {
id Int @id @default(autoincrement())
name String
posts Post[]
}
model Post {
id Int @id @default(autoincrement())
title String
published Boolean @default(true)
content String @db.VarChar(500)
authorId Int
author User @relation(fields: [authorId], references: [id])
}

Prisma allows you to quickly prototype and iterates on your schema without generating migrations with the db push command:

npx prisma db push

The above command also generates the Prisma Client that provides a type-safe database client that can be used as follows:

import { PrismaClient } from '@prisma/client'
const prisma = new PrismaClient()
async function createPost() {
return await prisma.post.create({
data: {
title: 'Database Type-Safety with Prisma',
content: 'Database type-safety',
},
})
}

Conclusion

Prisma has played a significant role for Pearly as an early-stage startup. As a result, Sean moves faster and focuses on rolling out new features currently as a solo developer.

To find out more about how Prisma can help your teams boost productivity, join the Prisma Slack community.

Join the discussion

Follow @prisma on Twitter

Don’t miss the next post!

Sign up for the Prisma newsletter