Since GusLift is a ride-sharing platform, payments are an important part of the user experience. Riders need a simple and secure way to complete payment, while the backend needs a reliable way to track payment status for each ride. To begin this process, we integrated Stripe Checkout into the project.

Implementing Stripe Checkout

One of the biggest goals so far was to create a payment flow that could be tested safely during development.
To do this, we added a backend route that creates a Stripe Checkout Session. When the mobile app requests a payment, the backend communicates with Stripe and receives a hosted checkout URL.
The user can then open that Stripe-hosted page and complete the payment using a test card.
This approach is useful because Stripe handles the secure payment form, card validation, and checkout experience. GusLift does not need to directly collect or store sensitive card information, which makes the implementation safer and easier to maintain.

Connecting Payments to Rides

Another important part of the payment system was making sure payments could be connected back to a specific ride.
When a checkout session is created, GusLift can include ride information such as:
-Ride ID
-Rider ID
-Ride label
-Customer email
-Payment amount

This information allows the backend to keep track of which payment belongs to which ride.
We also added support for storing payment records in a RidePayments table. This table keeps track of information such as the Stripe checkout session ID, payment intent ID, amount, currency, checkout URL, and payment status.
This gives the app a clearer record of what happened during the payment process.

Handling Payment Status

After a user finishes checkout, Stripe redirects them to a success page. GusLift then retrieves the checkout session details from Stripe and updates the payment record.
If the payment was completed successfully, the record can be marked as paid. If checkout is canceled, the payment can be marked as canceled instead.
Tracking these states is important because ride status and payment status are separate things.
For example, a ride could be accepted, but the payment may still be pending. Keeping those states separate makes the system easier to reason about as the app grows.
Building the Mobile Checkout Screen
On the mobile side, we added a Stripe Demo Checkout screen.
This screen checks whether the backend payment configuration is ready before allowing the user to continue. If Stripe is configured correctly, the user can tap a button to launch checkout.
For the current development version, the checkout uses a fixed demo amount of $5.00.
The mobile screen also supports passing ride-related information into the checkout flow, which helps prepare the app for real ride payments later.

Why Stripe Matters

Stripe is useful for GusLift because it allows us to build payment processing without needing to manage sensitive payment details ourselves.
Instead of building a custom card form from scratch, we can use Stripe’s hosted checkout flow. This improves security, reduces complexity, and lets the team focus more on the ride-sharing experience.
It also gives us a strong foundation for future payment features, such as authorizing payment when a rider confirms a driver and capturing payment after the ride is completed.

Some of the next milestones include:

Connecting payment more directly to confirmed rides
Improving success and cancel handling in the mobile app
Adding webhook support for more reliable payment updates
Moving from simple checkout payments toward authorization and capture
Testing the full ride flow from request to completed payment

By integrating Stripe Checkout, adding backend payment routes, and storing payment records, the app now has a basic but functional payment flow. While there is still more work to do before payments are production-ready, this is an important step toward making GusLift feel like a complete ride-sharing platform.