Building Tadabase apps with your own custom ChatGPT AI Chatbot

 

Today, we're embarking on an exciting journey where we'll create a complete application harnessing the power of AI tools. Thanks to the recent advancements in OpenAI's Chat GPT, you can now craft your very own AI helpers and chatbots to answer questions based on the knowledge you provide. In this episode, we'll leverage this technology to assist us in designing the data structure and page layout for our database application, essentially building an app from scratch with our personalized AI assistant.

To kick things off, I've already set up my custom AI helper named "Tadabase Helper" using ChatGPT. It can answer questions based on the Tadabase Knowledge Center, making it a valuable resource. Now, let's paste a prompt describing our application's goal: creating an app for my lawn care business. We need guidance on the tables and fields required for a robust connection structure within Tadabase. We'll manage clients, employees, client properties, jobs, and services.

After reviewing the AI's response, I've decided to proceed with two separate tables for clients and employees. While we could store all people in a single users table, separating them makes sense for now. If we want them to log in, we'll create user records and link them to clients or employees. This approach aligns with our AI helper's suggestion.

With our data structure in mind, let's head over to the builder. We'll start by creating the clients and employees tables. The fields recommended by our AI helper, such as client ID, client name, contact information, and notes, are added accordingly. For employees, we include fields like email, phone, address, and employee position. Auto-increment fields for unique identifiers ensure smooth data handling.

Next, we move on to the client properties table. As clients may have multiple properties, we set up a connection field to link each property to a client. Additionally, we add fields for property address, size, and notes to provide detailed information.

The jobs table comes next, with connections to clients, properties, services, and assigned employees. We establish a connection field to assign multiple employees to a single job. Fields for scheduled date and time, job status, and service type ensure we capture essential job details. Notes and comments offer additional flexibility.

Lastly, we create the services table, where we store services with names, descriptions, and prices.

Now that our data tables are set up as guided by our AI helper, it's time to visualize their relationships. The support and table connection graph in the app settings help us understand how each table interacts with others, ensuring a clear and organized structure.

Moving forward, we'll use our Tadabase Helper AI GPT to assist us in designing our app's page structure. This will involve determining layouts, pages, and components per page to create a seamless user experience.

In the upcoming episode, we'll delve deeper into building the front-end of our application using the insights from our AI helper.

Thank you for joining us on this exciting journey of building an application with the help of AI. Stay tuned for next week's episode, and we'll continue to Build It With Tim. Take care, and see you next time!

Features Discussed:

1. GPT-based Helper (Time: 1:30)
   Learn how to use OpenAI’s tools to create a custom GPT-based helper that can assist in designing data structures and page layouts for your application.
2. Data Builder (Time: 3:07)
   Explore how to create and structure data tables for an application, focusing on entities like clients, employees, properties, jobs, and services.
3. Connection Fields (Time: 12:07)
   Detailed explanation of how to connect jobs to clients, properties, and services using connection fields. Learn to manage employee assignments and job statuses effectively.
4. Table Connection Graph (Time: 2:21)
   Use the Table Connection Graph feature to visualize the relationships between tables and ensure that your data structure is properly organized.
5. Page Structures (Time: 17:46)
   Preview how to use the GPT-based helper to design and build page structures for the front-end of your application. The process includes suggestions for layouts, pages, and components to create a user-friendly experience.

 

---

Transcript Summary

Introduction

Hey everybody, this is Build It with Tadabase. On today's episode, we are going to start from scratch and build an entire application using the power of AI tools. If you've been paying attention to recent developments with ChatGPT and OpenAI, OpenAI has released the ability to make your own GPTs. This means you can now create your own AI helpers or chatbots to have conversations and answer questions based on the knowledge you provide.

Creating the AI Helper

We're going to use this AI helper to assist us in designing the structure for both the Data Builder and the Page Builder inside of your Tadabase application. I've already created my GPT inside of ChatGPT, called "Tadabase Helper," which answers questions based on the Tadabase Knowledge Center. I provided it with a URL for reference, and now it can answer questions based on that information.

Planning the Application

We're going to build an app for my lawn care business. I'll paste a simple prompt describing the application we want to build. We want to manage clients, employees, client properties, jobs, and services. After reviewing the answer from my custom AI helper, I noticed some things I’d like to change, especially regarding how we design the tables that contain people.

Users Table vs. Separate Tables

Inside of Tadabase, we have a Users table that can contain every person our application tracks—whether it's an employee or a client—if we intend for them to log in to the application. Alternatively, the AI helper suggested splitting people into two tables: a Clients table and an Employees table. This is totally fine, but if we want these people to log in, we’ll have to create a user record for them and connect them to either a client or an employee. For now, I’ll build it with the two split tables, but I may consider merging them into a single Users table later.

Building the Data Tables

Clients Table

We'll start with the Clients table. I've copied the information off-screen for reference and will begin by adding the suggested fields:

• Client ID (Auto Increment)
• Client Name
• Email Address
• Phone Number
• Address
• Notes and Comments (Rich Text Field)

Employees Table

Next, we’ll build the Employees table, which is similar to the Clients table. The fields include:

• Employee ID (Auto Increment)
• Employee Name
• Email Address
• Phone Number
• Address
• Position (Select Field)

Client Properties Table

We then move on to the Client Properties table, where we manage the properties belonging to clients. This table includes:

• Property ID (Auto Increment)
• Client Connection (One-to-One)
• Property Address
• Property Size (Select Field: Small, Medium, Large)
• Notes (Rich Text Field for gate codes or special instructions)

Jobs Table

Next is the Jobs table, which includes multiple connections to clients, properties, employees, and services. The fields are:

• Job ID (Auto Increment)
• Client Connection
• Property Connection
• Scheduled Date and Time
• Job Status (Select Field: Scheduled, Completed, Cancelled)
• Service Connection
• Assigned Employees (One-to-Many Connection)

Services Table

Before finalizing the Jobs table, we need the Services table. This table includes:

• Service ID (Auto Increment)
• Service Name
• Description (Long Text)
• Price (Currency)

Connecting Data Tables

With the data tables built, we connect them using the following connections:

• Client Properties connect to the Clients table.
• Jobs connect to Clients, Properties, and Services tables.
• Assigned Employees connect to the Employees table within the Jobs table.

Reviewing the Data Structure

After building the data tables, we review the structure using the Table Connection Graph in Tadabase. This graph helps us visualize how each table relates to others and ensures everything is connected correctly before moving on to the Page Builder.

Planning the Page Structure

For the next episode, we’ll use the Tadabase Helper AI GPT again to help us design the page structure, layouts, pages, and components. The AI will suggest how to build the front-end application, including the different pages and components needed.

Conclusion

That's it for this week's episode of Build It with Tadabase. Make sure to tune in next week so we can continue with this build, guided 100% by a custom Tadabase AI helper in ChatGPT. Thanks so much for watching, and we'll see you next time. Take care!