How to Build a Personalized Cart System in Glide

If you’re building an e-commerce app with Glide and want to go beyond the basics, one of the most powerful features you can implement is a personalized cart system. As someone who’s been working with Glide since 2020, I can confidently say that mastering this aspect opens the door to creating real, scalable applications for serious clients.

In this post, I’ll walk you through the principles and techniques I used to build a multi-cart system for individual users, without writing a single line of code. This is not just another online store example. We’re talking about a dynamic, user-specific experience where each person interacts with their own cart, can add multiple items, manage quantities, and proceed to checkout—all within Glide.


Why Carts Matter in E-Commerce Apps

Most tutorials show you how to display products and maybe even collect a few form responses. But if you want to build a real e-commerce experience, your users need to:

  • Add products to a cart
  • See what’s in their cart
  • Edit quantities before checkout
  • Complete a purchase (or send an order request)

And they need to do this without interfering with anyone else’s data. That’s where personalized logic and Glide’s user-specific features come in.


Step 1: Set Up Your Product Inventory

Start with a simple product table. I used Google Sheets for this, then imported it into Glide. My table includes:

  • Product name
  • Description
  • Image
  • Price

This inventory will later be referenced when building the cart. Keep things tidy: name your table something intuitive like Products or Inventory.


Step 2: Create a Carts Table

Next, create a new table called Carts. Each row here represents a unique shopping cart session. For each cart, include:

  • A unique Row ID
  • User email (who owns this cart)
  • Timestamp
  • Optional: Order number for tracking

Use Glide’s user profiles to tie the current user to their own cart using relations and rollups. You can also store the current cart ID inside the user profile for easy reference throughout the app.


Step 3: Build the Cart Items Table

Create another table, something like Products in Cart. This is your line-item table, where every product added to a cart is logged. You’ll need:

  • Row ID
  • Cart ID
  • Product ID
  • Product Name (optional)
  • Product Image (can be looked up)
  • Price (store a fixed price snapshot)
  • Quantity
  • Timestamp
  • User email (who added it)

Avoid relying too heavily on lookups for key data like price. If a product price changes after someone adds it to their cart, their price should remain unchanged. Store the price at the time it was added.


Step 4: Add Products to the Cart

Here’s where the fun begins. Using Glide’s custom actions, you can create workflows like:

  1. If the user doesn’t have an active cart, create one.
  2. Store the cart ID in the user’s profile.
  3. Add the selected product to the Products in Cart table.

Make sure to use user-specific columns for things like temporary values (current product, quantity input) so multiple users can interact with the same UI at the same time without conflict.


Step 5: Edit Product Quantities

After a product is added, redirect the user to an edit screen where they can set the desired quantity. Use number pickers with a range (e.g. 1–10) and plus/minus buttons for better UX. You can conditionally show the edit button only if the product was added within the same day, or based on other business rules.


Step 6: Display the Cart

Now that you have a functioning cart system, create a new screen that displays all products in the current cart. Use filters to show only items with a Cart ID matching the current cart. Add a rollup to calculate the total price, multiplying quantity by price.

Bonus: You can even add tax, shipping, or discount logic with a few extra columns and math.


Step 7: Admin View (Optional)

If you’re building an app where someone manages orders, like a shop owner or admin, you can set role-based visibility. Admins can:

  • View all users and their carts
  • Change order statuses
  • Edit or delete items manually if needed

Just add a role field in the Users table and use visibility filters across screens and components.


Step 8: Prepare for Checkout

This part depends on your payment system. Whether you’re using Stripe, PayHere, or a custom integration with Make/Zapier, you’ll need a table for Payments where you can log:

  • Cart ID
  • User email
  • Amount paid
  • Timestamp

Once payment is confirmed (manually or via webhook), you can flag the cart as “Paid” and hide or archive it from the active list.


Final Thoughts

What we built here is more than just a shopping cart—it’s a modular, user-driven system that scales. Using Glide’s native features like Big Tables, user-specific columns, and custom actions, you can create experiences that rival traditional web apps—all without writing code.

This setup can be extended in countless ways: stock management, abandoned cart reminders, order history, and even subscription models.

If you’re ready to dive deeper into Glide and want personal guidance, check out my courses, templates, and mentoring options at glide.school. And if you want to see the app we built in action, here’s the link:

👉 https://camera-store.glide.page

See you in the next build!

Recent Posts

Nice to meet you, I'm Gideon And I'm here to build you a customized management system for your business.

Newsletter

×

Want to Build an App for Your Ideas or Business?

With the right guidance, you can turn your vision into a real, working app — no code needed.