Build with Taubyte: Online Marketplace Part 1

In this tutorial, we’ll go step by step through building a fully functional online marketplace using Taubyte. The focus is on a smooth “vibe coding” experience - local development first, then pushing to production.

Step 1: Setting Up Locally and Creating a Universe

We start by creating a local environment using the Dream Desktop program.

1. Open Dream Desktop and create a Universe.

2. Connect to it via the console at console.taubyte.com.

3. Choose the universe, enter your email, and connect with GitHub.

4. Create a project in the console.

Step 2: Understanding Frontend and Backend

Our marketplace has two main parts: frontend and backend.

We’ll start with the backend. The backend is made of multiple services, each responsible for a single function. Our first service is Auth Service.

Create an application for the Auth Service.

Step 3: Pushing from Dream Desktop

Once the application is ready:

• Push all changes from Dream Desktop.
• Normally, builds are triggered automatically via a webhook from GitHub.
• Locally, simulate this webhook with a push button on Dream Desktop.
• This creates a local test cloud instead of deploying to a production node.

Step 4: Creating Serverless Functions

We won’t use inline code for serverless functions - it’s messy to maintain. Instead:

• Use Taubyte libraries (distinct Git repos) as the code source.
• Each serverless function takes its code from the library.

Steps:

1. Push the config from the console.

2. Push again from Dream Desktop.
3. Clone the backend library from GitHub.

Step 5: Auth Service API

We’ll use agents.doc as documentation. Prompt your AI to generate code:

The AI generates:

• Handlers & exported logic → serverless functions.

Serverless function endpoints:

Step 6: Push and Configure Serverless Functions

1. Push to GitHub, then create serverless functions in the console:

   • Set timeout and path.
   • Pick the domain.
   • Source code = backend library.
   • Entry point = exported function from Go library.

2. Push console config, then push build from Dream Desktop.

Step 7: Database Setup

• Create a database from the console called data.
• Push again from the console after creation.

Step 8: Testing Endpoints with Curl (Using JWT)

Use the following curl commands to test your Auth Service:

Register User

curl -X POST <BASE_URL>/api/auth/register \
-H "Content-Type: application/json" \
-d '{"username":"testuser","email":"test@example.com","password":"password"}'

Login User (Get JWT Token)

curl -X POST <BASE_URL>/api/auth/login \
-H "Content-Type: application/json" \
-d '{"email":"test@example.com","password":"password"}'

The response will return a JSON containing the token. Use this token for the next requests.

Get User

curl -X GET <BASE_URL>/api/auth/getuser \
-H "Content-Type: application/json" \
-H "Authorization: Bearer <JWT_TOKEN>" \
-d '{"id":"<USER_ID>"}'

Update User

curl -X PUT <BASE_URL>/api/auth/updateuser \
-H "Content-Type: application/json" \
-H "Authorization: Bearer <JWT_TOKEN>" \
-d '{"id":"<USER_ID>", "username":"updatedName"}'

Delete User

curl -X DELETE <BASE_URL>/api/auth/deleteuser \
-H "Content-Type: application/json" \
-H "Authorization: Bearer <JWT_TOKEN>" \
-d '{"id":"<USER_ID>"}'

Backend library example: tb_library_auth_service

Step 9: Frontend Setup

1. Create a global website empty repo.

2. Push to GitHub, then open it in Dream Desktop.

3. Use Vite + VueJS + Tailwind to create a frontend project.

   • Keep the .taubyte folder created by Taubyte (essential for build).

4. Prompt AI:

5. Include the curl commands above for reference.
6. Test locally, make tweaks, then push to GitHub to trigger a build via Dream Desktop.

Step 10: Final Config Tweaks

• Add build.sh and config.yaml in .taubyte folder for Vite projects.

• Update serverless function domains if needed.
• Push console config and trigger build.
• Visit your website via the lightning button in the console.

Important: Ensure the library domain and website domain match. Otherwise, window.location.origin won’t work correctly.

Conclusion

Following these steps, you now have a fully functioning online marketplace built on Taubyte, complete with backend services, JWT-secured serverless functions, a database, and a minimal VueJS + Tailwind frontend.

This approach keeps everything modular, maintainable, and ready for production while allowing you to vibe code locally.