Build Friction-Free SaaS Trials with Kinde in 9 Steps

SaaS products thrive on free trials, but most implementations create more friction than value. A scattered approach—database timestamps, unreliable cron jobs, and misfiring upgrade prompts—often leaves teams scrambling to fix sync issues and edge cases. Kinde’s modern billing infrastructure offers a cleaner alternative: a fully managed free trial system built on a $0.00 plan, custom user properties, and real-time token claims.

This guide walks you through a production-ready trial setup that avoids database lookups, eliminates cron jobs, and keeps trial state perfectly in sync with your application. By leveraging Kinde Workflows and feature flags, you’ll deploy a trial experience that feels native to your product—no matter how complex your pricing tier becomes.

Why Most Free Trial Systems Fail (And How to Fix It)

Most SaaS teams treat free trials as a simple date calculation: store a trial_expires_at field, run a nightly cron job, and call it a day. But this brittle approach breaks down quickly. Cron jobs run at 3 AM while users are active in different time zones. Middleware checks miss WebSocket connections or edge cases. Upgrade prompts fire too early, too late, or for users who already converted. The root problem? Trial state lives in too many places—your database, Stripe, middleware—and never stays perfectly synchronized.

The smarter solution centralizes trial logic in a single source: the Kinde access token. Every request carries the user’s trial_start timestamp and their current plan, allowing your app to compute trial status instantly without querying a database. This eliminates sync lag, removes cron jobs, and ensures trial state is always accurate. When Kinde eventually introduces native trial support, this architecture will adapt seamlessly—your feature-gating logic remains unchanged.

Kinde’s Billing Model Today: Workarounds for Native Trial Gaps

As of mid-2026, Kinde Billing does not include built-in free trial support, despite documentation listing it as a planned feature. This gap doesn’t require a workaround—it invites innovation. Instead of waiting for native support, teams can build a production-grade trial system using existing Kinde primitives: a $0.00 Free plan, custom user properties, Kinde Workflows, and feature flags. The result is a flexible system that gives you full control over trial logic, from duration to feature access.

Important: everything in this guide uses Kinde’s non-production environment and Stripe test mode. Do not apply these changes to your live environment until you’ve validated the full flow in testing. Once Kinde adds native trial support, migrating to it will be straightforward—your existing logic will remain intact.

The Four-Part Architecture of a Friction-Free Trial

A high-performance trial system in Kinde relies on four core components working in harmony:

• A Free plan ($0.00) configured in Kinde Billing with credit card collection disabled and trial feature flags attached. This is the default plan for new users.

• A Kinde Workflow that triggers after user authentication and stamps a Unix timestamp (trial_start) onto the user’s custom property the first time they log in.

• Token customization that embeds the trial_start property and current plan flags directly into the access token. Your app reads these claims in real time, eliminating database queries.

• A `useTrialStatus` hook in your Next.js frontend that processes token claims to determine trial state—active, expired, or converted—driving UI decisions like upgrade prompts, countdown banners, and feature lockouts.

Step-by-Step: Configuring Your SaaS Free Trial in Kinde

Let’s build your trial system in nine clear steps. Each step adds a layer of reliability, from plan setup to real-time UI feedback.

Step 1: Create the Free Plan in Kinde Billing

Start by logging into your Kinde dashboard and navigating to Billing → Plans → Add plan.

Fill in the following details:

• Name: Free Trial (this appears on your pricing page to users)

• Description: 14 days of full Pro access, no credit card required

• Key: free_trial (this identifier is permanent and used in code)

• Plan type: Choose Users for B2C apps or Organizations for B2B platforms

After saving the basics, add a charge—even a $0.00 plan requires one to sync with Stripe.

Select Add charge and configure:

• Name: Base subscription fee

• Amount: 0.00

• Interval: Monthly

Save the charge. Next, disable credit card collection in the Payment collection section. This ensures users can sign up without friction. Note: Kinde only allows disabling card collection for $0.00 plans—upgrade to paid tiers will require card details later.

Finally, attach the feature flags that represent your Pro tier capabilities. Navigate to the Features tab and enable flags like advanced_analytics, api_access, and export_data. These will activate automatically for users on the Free Trial plan.

Step 2: Set Up a Kinde Workflow to Track Trial Start

Now automate trial state by creating a workflow triggered when users authenticate.

In Kinde, go to Workflows → Add workflow. Name it set_trial_start and set the trigger to User signed in.

Add an action to Set custom property on the user:

{
  "property_name": "trial_start",
  "value": "{{workflow.now.unix}}"
}

This command writes a Unix timestamp to the user’s trial_start property the first time they log in. No database maintenance. No manual updates.

Step 3: Customize the Access Token to Include Trial Data

Next, configure your Kinde app to include trial state in every access token. In Settings → Tokens, add the following custom claims:

• trial_start (from the custom property)
• current_plan (the user’s active plan key, e.g., free_trial)
• feature_flags (all enabled flags for their plan)

Save the token configuration. Now, every API call carries this context—your backend reads trial status directly from the token, not a database.

Step 4: Build a useTrialStatus React Hook for Real-Time UI

In your Next.js app, create a custom hook to process token claims and determine trial state.

import { useKindeAuth } from "@kinde-oss/kinde-auth-nextjs";

export function useTrialStatus() {
  const { accessToken } = useKindeAuth();

  const claims = accessToken?.decodedToken?.["
  const trialStart = claims?.trial_start;
  const plan = claims?.current_plan;

  const isTrialActive = trialStart && plan === "free_trial";
  const daysLeft = isTrialActive ? Math.max(0, 14 - ((Date.now() / 1000 - trialStart) / 86400)) : 0;
  const hasConverted = plan !== "free_trial";

  return { isTrialActive, daysLeft, hasConverted };
}

This hook powers every trial-aware UI element—countdown banners, upgrade prompts, and feature gating—all derived from a single source of truth.

Step 5: Deploy Dynamic Upgrade Prompts Based on Trial Days

Use the useTrialStatus hook to show upgrade prompts at precise moments. For example:

• Day 7: A subtle nudge with a discount offer
• Day 13: A warning that the trial ends tomorrow
• Day 14+: A paywall blocking Pro features

import { useTrialStatus } from "./useTrialStatus";

export function UpgradePrompt() {
  const { isTrialActive, daysLeft, hasConverted } = useTrialStatus();

  if (hasConverted) return null;
  if (!isTrialActive) return <Paywall />;
  if (daysLeft === 7) return <DiscountBanner />;
  if (daysLeft === 1) return <FinalWarning />;

  return null;
}

No middleware. No stale data. Just real-time decisions driven by the token.

Step 6: Test the Full Trial Lifecycle Without Waiting 14 Days

Validate your system quickly using Kinde’s test environment. Simulate trial expiration by manually adjusting the trial_start property in the Kinde dashboard or triggering the workflow with a past timestamp. Confirm that upgrade prompts fire correctly and users are properly downgraded when the trial ends. Once all flows work in test mode, replicate them in production with confidence.

The Future of Trials in Kinde

When Kinde introduces native free trial support, your system won’t need a rewrite. The trial_start workflow can be replaced with a plan configuration, and feature flags will remain the same. This forward-looking architecture ensures your trial logic stays maintainable—and scalable—as your product grows.

Deploying a friction-free trial isn’t about adding another feature—it’s about removing friction from the entire user journey. With Kinde’s tools, you can build a trial experience that feels effortless, predictable, and fully under your control.