Before I entered the world of computer programming, the terms API or CRUD didn’t mean very much to me. Little did I know that CRUD APIs were a huge part of my digital life working under the hood.

How does your banking app use your phone’s face recognition feature to log you into your account? How does Twitter allow only your followers to see your posts? An API (application programming interface) is responsible for handling these permissions and exchanges at a high level. And what about a CRUD API? Well, APIs act as both the referee and gatekeeper of information, and CRUD functions allow specific interactions between the client and the database.

I’m going to explain what a CRUD API is and how to apply it in different use cases to protect and interact with data in very specific ways. This post will introduce and explain CRUD and authentication to programmers and curious dilettantes.

What Is a CRUD API?

CRUD stands for create, read, update, and delete. These functions are the four pillars of a complete CRUD API (and full-stack application, for that matter). 

Let’s look at a sample healthcare company, Shmealth, which needs to store, access, and update its patients’ health records accurately and securely. Follow along to see how each of the CRUD functions operate in Shmealth’s API built in Ruby on Rails.

CRUD: Create

The C in CRUD stands for create, which has many nuances. We need to add a new patient to Shmealth’s database before a physician is able to view their vitals or update their prescriptions. Let’s discuss this action first. 

Your CRUD API should first be architected to relate various resources to one another. Then, you can start creating those resources either as seeds directly into the back end or through an HTTP POST request from a front end.

For those of you who need a quick refresher on what it means to seed your database, when you create a new record, you’re generating an instance of that resource’s class. Capitalization and pluralization matter when talking about instances and classes.

Use Cases

In this scenario, Sadie Baker will be a new Shmealth patient and, therefore, an instance of the Patient class. Before we can view or interact with any data, it must first exist in the database. Other use cases include:

  • Adding a new doctor to Shmealth’s system,
  • Creating an appointment, and
  • Adding a new medication.

In relational databases, some resources may need to be created before others (e.g., an instance of the Appointments class cannot be created for Sadie until she’s in the system). 

When new seeds are created, some APIs automatically assign an identification number to those instances (e.g., a health record number or an appointment confirmation number). It’s important that this ID number remains unique. If you’re just starting out, don’t touch or change these numbers. We’ll go over how they can be used in other CRUD API actions later.


You would use different conventions for the create function depending on whether you’re working in the front end or back end. For the front end, the REST and HTTP method is “POST”. For the back end, the SQL operation is “INSERT”.


Inaccurate or falsified information can have colossal consequences. In healthcare, it’s extremely important that patients’ health data (such as prescriptions and blood test results) are protected.

As such, you need to safeguard against user errors. When generating a new record in a database (e.g., adding a new patient), each property of the record (the patient’s information) has to be entered as the same data type defined in the migration file (i.e., string, date, boolean, float, etc.).

class CreatePatients < ActiveRecord::Migration[6.1]

  def change

    create_table :patients do |t|

      t.string :firstname

      t.string :lastname

      t.date :birthday

      t.boolean :is_active

      t.float :monthly_premium

      t.string :username

      t.string :password_digest





Don’t forget to use validations in your Models, as well as strong_params and status codes in your Controllers. 

Here, I use the #create method:

class PatientsController < ApplicationController

  def create

    @new_patient = Patient.new patient_params

    if @new_patient # if new instance of @new_patient from line 4 returns truthy with no errors

      @new_patient.save # then save

      render json: @new_patient, status: :created


      render json:

        { error: “Oops! Something went wrong. Please check patient’s information and try again” },

        status: :unprocessable_entity




  def patient_params

    params.require(:patient).permit(:firstname, :lastname, :birthday, :is_active, :monthly_premium, :username,:password)



Notice that I use Patient.new to check the validity of a @new_patient instance before saving the record. 


As with many databases, Shmealth’s health records need to be accurate and protected. This is why developers have created and utilized secure accounts that require encrypted credentials (i.e., signup and login). Sadie shouldn’t be able to log in to her patient portal and create a new prescription for herself.

Through the use of authorization and authentication in the API, only authorized users have access to creating certain records. Every time an HTTP request is made from the patient’s portal, an authentication method in the API filters patient-specific actions and information from the database.

When logging in to an account, the wording of error messages is important, too. When Sadie enters her username and password and clicks “Log In,” her account is making a POST request. If the password she enters doesn’t match the hashed password used to create her account, it’s less secure to be more specific in the error message. In this case, we’d want to use something vague like “Username and password do not match” rather than “Incorrect password” or “Incorrect username.”

CRUD: Read  

The R in CRUD stands for read, which simply retrieves data from the database and displays it. From a programmer’s perspective, this is the simplest and safest CRUD action. As database architects, we can decide which routes allow the view of all, some, or only single records.

Use Cases

Some use cases for the read function include:

  • Viewing upcoming appointments,
  • Reviewing a patient’s cholesterol levels over time, and
  • Reading a doctor’s virtual action plan curated for the patient.


Again, you’ll use different methods depending on which side of the application you’re working on. For the front end, the REST and HTTP method is “GET”. For the back end, the SQL operation is “SELECT”.

Let’s Take a Look at the API Configuration

Let’s say Dr. Rebecca Hernandez wants to view of all Sadie’s current prescriptions (starting with the most recently prescribed in descending order). So, she logs in to her physician portal and clicks on “View All Prescriptions.” What’s happening behind the scenes to allow this list to populate on her screen?

The Patient Model has a custom instance method that finds all prescriptions relating to Sadie’s ID number and filters out the inactive medications, which I’ve called sorted_meds.

class Patient < ApplicationRecord


  has_many :appointments

  has_many :prescriptions

  has_one :doctor, through: :appointments

  has_many :vitals, through: :appointments

  validates :username, presence: true, uniqueness: true

  def sorted_meds

    current = self.prescriptions.where(active: true)

    sorted = current.sort_by { |med| [med.start_date]}




The Routes file would also need to specify the action associated with an endpoint for this method. In this case, I’ve used /current_meds. When creating endpoints, we want to design with intent; it’s important that they are specific enough to a particular resource and legible.

Rails.application.routes.draw do

  resources :prescriptions

  resources :members

  resources :doctors

  get ‘/current_meds’, to: ‘patients#current_meds’


Notice how I used the HTTP method GET in the above code.

Lastly, the Patients Controller has a custom method I’ve created, called current_meds. I use the same nomenclature as the endpoint for readability.

class PatientsController < ApplicationController

  def current_meds

    @patient = Patient.find params[:id]

    render json: {patient: @patient}, methods: [:sorted_meds], status: :ok



When Dr. Hernandez clicks that “View Current Prescriptions” button, this sends an HTTP request to Shmealth’s back end (to the /current_meds endpoint we created). The API’s authenticator grants Dr. Hernandez access to all of the sorted_meds related to Sadie’s ID number, pulls the data from the SQL database, and returns that information in JSON to Shmealth’s front end, which parses and reformats to some customized view on Dr. Hernandez’s screen—all within milliseconds. 

secure patient information

To view all medications prescribed to all patients at Shmealth, I use the standard #index method in the Prescriptions Controller:

class PrescriptionsController < ApplicationController

  def index

    @medication = Prescription.all

    render json: @medication, status: :ok



To view information about a single medication, the standard method is #show, which requires the ID number of that specific medication.

Accuracy and Security

In terms of viewing data from an API, security measures pertain mostly to the credentials used to retrieve this data. Sadie shouldn’t be able to see which patients Dr. Hernandez has, just as nonmembers shouldn’t be able to access exclusive Shmealth resources.

Here’s an example of an authentication method in the Application Controller:

class ApplicationController < ActionController::API

  before_action :authenticate

  def authenticate

    auth_header = request.headers[:Authorization]

    if !auth_header

      render json: {error: ‘Auth bearer token header is required’}, status: :forbidden


      token = auth_header.split(‘ ‘)[1]

      secret = ‘XXXXXXX’


        decoded_token = JWT.decode token, secret

        payload = decoded_token.first

        @user = User.find payload[‘user_id’] #instance variable that can be carried across methods


        render json: {error: ‘Unrecognized auth bearer token’}, status: :forbidden





 def login

    @user = Patient.find_by username: params[:patient][:username]

    if !@user

      render json: {error: ‘Invalid username or password’}, status: :unauthorized


      if !@user.authenticate params[:patient][:password]

        render json: {error: ‘Invalid username or password’}, status: :unauthorized


        payload = {patient_id: @user.id}

        secret = ‘XXXXXXX’

        @token = JWT.encode payload, secret

        render json: {token: @token, patient: @user}, status: :ok




Other security measures should be taken on the front end, such as timed logout after two minutes of inactivity, etc.

CRUD: Update

The U stands for update. This means changing existing data to a new value of the same data type and overwriting the old value in the database. 

Depending on how databases and APIs are set up, a user may not be able to see previously edited versions of data easily. Updating data, especially in healthcare, must be set up with a robust authentication so patients can’t update the dosage of their medications or values of their blood test, etc. Similarly, physicians shouldn’t be able to update a patient’s username or password. This could cause legal issues on top of a multitude of other consequences.

secure medical technology

Use Cases

Some use cases for the update function include:

  • Changing the patient’s mailing address,
  • Switching primary doctors,
  • Rescheduling an appointment time, and
  • Increasing the patient’s monthly premium.

Remember when I said identification numbers would be useful? These come into play any time we are targeting a specific instance or record. Below, I use the #update method to find an existing appointment by ID (or confirmation number). Then, I take in the new date and time parameters for that appointment and update the key-value properties accordingly in the database. Without being able to locate this appointment by ID, the database would have no idea which appointment we wanted to update.

class AppointmentsController < ApplicationController

 def update

    @appointment = Appointment.find params[:id]

    @appointment.udpate date: params[:date], time: params[:time]

    render json: @appointment, status: :updated




The REST and HTTP method when working in the front end is “PATCH”, “PUT”. The back-end SQL operation is “UPDATE”.


Similar to the create function, updating a record requires protection against users entering a mismatched data type. Status codes should be more specific than just “200” or “500,” as this will help you and other developers debug more easily. You can create your own error messages or utilize 400’s status codes to indicate client errors:

  • 401 Unauthorized: the requested page needs a username and a password
  • 403 Forbidden: access is forbidden to the requested page
  • 409 Conflict: the request could not be completed because of a conflict

CRUD: Delete

Lastly, the D stands for delete. This action is quite simple to set up and use. However, deleting resources in a relational database can bear indirect consequences. When removing a record from a database, it’s a best practice to consider this action permanent and, therefore, to use this operation with caution. SQL doesn’t have a command to retrieve deleted records without a backup.

Here, I use the #destroy method to find the appointment by its identification number and then remove it from the database. I chose the no_content status code to indicate that there isn’t a payload body for this appointment anymore.

class AppointmentsController < ApplicationController

  def destroy

    @appointment = Appointment.find params[:id]


    render json: { appointment: @appointment, message: ‘Successfully deleted’ }, status: :no_content




For the delete function, you would use the same command for both front end and back end: “DELETE.”


As I mentioned previously, consider the delete function a permanent action. Authentication and authorization are critical to protecting resources, so use these security measures generously. Deleting a medication from Shmealth’s database would also affect the records of patients to whom that medication was prescribed. Make sure to update related resources as well, especially if the resource being deleted belongs_to another resource.

Conclusion to CRUD API

The term API is so much more than an acronym. APIs allow two or more applications to interact with each other and exchange data. Each of the four CRUD actions has a very specific role, and CRUD APIs wouldn’t be complete without all of them.

Thank you for reading! Now you know what a CRUD API is and how to apply each operation to a company’s back end in order to protect and interact with records securely.

This post was written by Anika Bernstein. Anika is a full-stack software engineer with a background in environmental studies and data analytics. She specializes in Javascript’s React framework, writing clean, readable, and reusable code to help companies improve their website’s SEO.