# Add Client Logins. Connect Your Domain. Ship a Real Product in 2026

> Turn a cloned app into a product clients pay for. Add email sign-in on every plan including Free, point your domain at it with one CNAME on Pro, and get visitor analytics as soon as you publish.

- Source: https://www.taskade.com/blog/client-logins-custom-domains
- Published: 2026-08-28
- Author: John Xie

Two things separate a demo from a product someone pays for: your clients can sign in, and it lives on your web address. Both are built into every app you publish with [Taskade Genesis](https://www.taskade.com/create) — sign-in is a single component you ask for in plain English and works on every plan including Free, and your own domain is one DNS record on Pro. This is the step after building, and it takes an afternoon, not a sprint.

> **TL;DR:**
>
> **Add email sign-in to any published app on every plan including Free.** Each visitor who signs in becomes an App User you can tag, scope, or revoke — no Taskade account on their side, no seat consumed on yours. Point your own domain at it with one CNAME on **Pro, $10/mo billed annually**. [Clone a live client portal →](https://www.taskade.com/app/client-portal-nexus-1s4lv2y3jb9z7zpf)

## Your app already has logins — you just have to ask for them

Every published Taskade Genesis app can hand out its own accounts. The feature is called GenesisAuth, and you add it by opening your app and telling [Taskade EVE](https://www.taskade.com/learn/agents/eve-assistant): *"Add GenesisAuth to the homepage."* A sign-in panel appears in the builder, you publish, and the next visitor to a gated page gets an email sign-in on your app's own URL. New people sign up, returning people go straight through. You never run an auth server, never rotate a signing key, and never store a credential.

The part that surprises most people is the billing math. Everyone who signs in to your app is an **App User**, a completely separate population from your Taskade workspace members. Your teammates sign in at `app.taskade.com` and build the thing; your clients sign in at your address and only ever touch the screens you published. App Users do not need a Taskade account and do not consume a seat — so a two-person agency on [Pro at $10/mo billed annually](https://www.taskade.com/pricing) can serve a few hundred signed-in clients without the seat count moving.

| | Workspace members | App Users |
|---|---|---|
| Who they are | You and your team | The clients of your published app |
| What they touch | Projects, agents, automations, settings | Only the screens you published |
| Where they sign in | `app.taskade.com` | Your app's URL or custom domain |
| Costs a seat? | Yes | No, counted separately |
| Managed from | Workspace settings | **App Users** panel inside each app |

Full mechanics live in [GenesisAuth](https://www.taskade.com/learn/genesis/genesis-auth) and [App Users](https://www.taskade.com/learn/genesis/app-users).

## Start with a live kit instead of a blank prompt

The fastest route to a signed-in product is to clone something already running and swap in your own data. Each of these is live right now — open it, click through it, then clone it into your workspace and add sign-in.

| Live kit | What you hand a client on day one | Clone it |
|---|---|---|
| **Client Portal** | Each client signs in, and you match their files, project status, and invoices to that login | [Open →](https://www.taskade.com/app/client-portal-nexus-1s4lv2y3jb9z7zpf) |
| **Onboarding Portal** | New customers walk a checklist that updates your workspace as they complete it | [Open →](https://www.taskade.com/app/onboarding-guide-portal-cjom1t44r0lf9diu) |
| **Appointment Booking System** | Clients book, reschedule, and see their own history behind a login | [Open →](https://www.taskade.com/app/appointment-booking-system-te01cx15e4tv558x) |
| **Class Booking Portal** | Students sign in, reserve a seat, and see the roster you match to them | [Open →](https://www.taskade.com/app/class-booking-portal-cpl9dz85yx75foxo) |
| **Event Portal** | Attendees get a signed-in agenda, ticket, and live updates on your event domain | [Open →](https://www.taskade.com/app/event-management-portal-scv62ou1yocu3sno) |

The Appointment Booking System alone runs about 1,647 sessions a month across everyone who cloned it, which is a useful signal about what people actually put behind a login. More of these live in the [Taskade App Factory](https://www.taskade.com/apps). For a category-shaped starting point rather than a specific app, browse [client portal generators](https://www.taskade.com/generate/client-portals) or [client onboarding templates](https://www.taskade.com/templates/client-onboarding).

## Four steps take a draft to a product clients pay for

The whole sequence fits in one sitting. Publish first, add sign-in second, invite people third, connect the domain last — each step needs the one before it to exist.

```mermaid
graph TD
  A[Clone a live kit] --> B[Publish the app]
  B --> C[Add GenesisAuth sign-in]
  C --> D[Invite App Users]
  D --> E[Connect your domain]
  E --> F[Watch App Analytics]
  F --> G[Refine with Taskade EVE]
  G --> B
```

1. **Publish.** Click **Publish** and the app gets a live web address, a secure connection, and instant updates for everyone holding the link. [Publishing and cloning](https://www.taskade.com/learn/genesis/publishing) covers the sharing options, including letting other people copy your app into their own workspace.
2. **Add GenesisAuth.** Ask Taskade EVE to add it to the page you want gated, adjust the panel on the right, and publish again.
3. **Invite App Users.** Open **Settings → App Users**, paste a list of email addresses one per line, add a tag like `client` or `beta`, and send. Each invitee gets a sign-in link and appears in the Active list as they arrive.
4. **Connect your domain.** Covered next. This is the step that changes how the thing reads to a paying customer.

## Connecting your domain takes one DNS record

Already own the domain? This is a two-record job. Open your published app, go to **App Settings → Domain**, click **Connect existing domain**, and type the address you want — say `portal.yourbrand.com`. Taskade shows you exactly what to paste at your registrar.

For a subdomain, you add a single CNAME:

```text
Type     CNAME
Host     portal            (just the subdomain part)
Value    external.taskade.com
TTL      Automatic / 3600
```

Then you add the short TXT record Taskade hands you, which is what lets the SSL certificate be issued for your name. The Domain panel reads **Pending** while both records resolve, usually a couple of minutes, then flips to **Active** and serves your app over HTTPS. Taskade renews that certificate on a rolling cycle before it expires, so once it is Active you never touch it again.

Want the root — `yourbrand.com` with no subdomain? Most registrars refuse a plain CNAME at the apex, so Taskade detects it and offers two paths: an **ALIAS or ANAME** record pointing `@` at `external.taskade.com`, which Cloudflare, Namecheap, and DNSimple all support, or moving your nameservers to Cloudflare, which flattens the root automatically. The full record-by-record walkthrough with troubleshooting is in [Custom Domains](https://www.taskade.com/learn/genesis/custom-domains).

**No domain yet?** Skip DNS entirely. From your published app open the **Publish** menu → **Domains** → **Buy Domain**, search a few keywords, pick a name, and click **Buy and Publish**. Taskade registers it, writes the records for both the root and `www`, and provisions SSL, with nothing for you to configure. [Buying a domain inside Taskade](https://www.taskade.com/learn/genesis/buy-domain) has the full flow.

**What this costs.** Custom domains for Taskade Genesis apps are on **Pro and up** — $10/mo billed annually ($120/yr), with Business at $25/mo billed annually, Max at $100/mo billed annually and Enterprise at $250/mo billed annually. Sign-in is not gated, so the honest sequence is: build and gate on Free, prove someone wants it, then upgrade for the address. Worth keeping straight: this is app-facing sign-in, not company single sign-on for your own staff. Workspace SSO and SAML are included from **Business** up, and SCIM user provisioning is **Enterprise only**. Most people shipping a client-facing product need GenesisAuth and never touch either.

## Every client sees only their own records

A login is only useful if the app behaves differently for each person behind it. In Taskade Genesis you describe that rule instead of coding it. Tell Taskade EVE *"show this person only the invoices tied to their email"* or *"only show the Billing page to people tagged `client`"* and it wires the check in.

This works because the records live in your Taskade Projects, not in a separate copy inside the app. The portal your client sees and the board your team works from read the same rows — this is [Workspace DNA](https://www.taskade.com/learn/genesis/workspace-dna) doing its job: Projects are the Memory, agents are the Intelligence, automations are the Execution, and the app is a view onto all three. Change a status internally and the client's screen reflects it without a sync step. [Self-updating client portals](https://www.taskade.com/blog/self-updating-client-portals) goes deeper on that loop, and [building a customer portal](https://www.taskade.com/learn/genesis/build-customer-portal) is the step-by-step build.

Access control on your side of the wall stays separate and unchanged. Taskade's role tiers run Owner through Viewer and govern your workspace; App User tags govern your app. The two never collide.

## Analytics arrive the moment you publish

You do not install anything. Every published Taskade Genesis app has a real-time dashboard at **App Settings → Analytics** with total visits, pageviews, average bounce rate, average session duration, visitors online right now, trends over your chosen date range, top pages by unique visitor, geographic distribution, traffic sources, and a device and browser breakdown.

Traffic sources earn their keep fastest: they tell you whether clients arrive from your invoice email or from a bookmark, which tells you where to put the next nudge. Top pages tell you which screen your customers actually live on — almost never the one you designed first. Details in [App Analytics](https://www.taskade.com/learn/genesis/app-analytics).

## What to automate once clients are logging in

A signed-in app generates events, and events are what automations run on. A new App User signing up can open a Project in their name, post to your Slack channel, and send a welcome email. A form submission behind the login can create a ticket and assign it. Because Taskade ships [100+ bidirectional integrations](https://www.taskade.com/integrations), triggers pull events in and actions push data out to the tools you already run.

Payments belong in the same loop. A signed-in client can settle an invoice through [Stripe](https://www.taskade.com/automate/stripe) without leaving your app, and the payment event runs whatever you defined next — receipt, Slack ping, status change on their Project. Automations run as a bounded loop over the items a trigger hands them, so the work you described happens once per item and stops. Nothing recurses off into the weekend. Start from the [automation hub](https://www.taskade.com/automate), and give the app an [embedded agent](https://www.taskade.com/agents) so routine client questions get answered without reaching your inbox.

## Who this is for

Agencies get the clearest payoff, because "log in at `clients.youragency.com`" is a different product than "here's a link." [Agency client portal templates](https://www.taskade.com/blog/agency-client-portal-templates) and [building a client portal without code](https://www.taskade.com/blog/build-client-portal) cover the shape; [ten AI client portal examples](https://www.taskade.com/blog/ai-client-portal-examples), and [the best customer portal software](https://www.taskade.com/blog/best-customer-portal-software) show finished ones. Service businesses that schedule are next — see [booking apps you can clone](https://www.taskade.com/blog/vibe-booking-apps) and [the best AI booking systems](https://www.taskade.com/blog/best-ai-booking-systems). Solo operators running a company from one workspace are third: [business in a box](https://www.taskade.com/blog/business-in-a-box-genesis) and [the vibe-coded business](https://www.taskade.com/blog/vibe-coded-business) both end where this post begins, and [Taskade versus Notion](https://www.taskade.com/compare/free-notion-alternative) or [Taskade versus Lovable](https://www.taskade.com/compare/free-lovable-alternative) settle the tool question.

New accounts earn free AI credits with referrals and invites, and can upgrade any time. [Start building →](https://www.taskade.com/create) or browse [AI apps](https://www.taskade.com/ai/apps) for a starting point.

## Frequently asked questions

### How do clients log in to an app I built with Taskade Genesis?

They sign in with their email address on your app's own web address. Taskade Genesis apps ship with GenesisAuth, a built-in sign-in you add by asking Taskade EVE to put it on a page, then publishing. No auth server to run, nothing for you to store. Every person who signs in becomes an App User you can tag, scope, or revoke, on every plan including Free.

### Do my clients need their own Taskade account to sign in?

No. App Users are completely separate from your Taskade workspace members. Someone signing in to your published app does not need a Taskade account and does not consume a seat on your plan. Workspace members sign in at `app.taskade.com` and build the app; App Users sign in on your app's URL and only ever see the screens you published.

### What plan do I need for a custom domain on a Taskade Genesis app?

Custom domains for Taskade Genesis apps are available on Pro and up. Pro is $10/mo billed annually ($120/yr), and Business is $25/mo billed annually ($300/yr). Max is $100/mo billed annually and Enterprise is $250/mo billed annually. Sign-in itself is not gated, so you can add GenesisAuth and invite App Users on Free, then upgrade when you want the app on your own web address.

### How do I connect a domain I already own?

Open your published app, go to **App Settings → Domain**, and click **Connect existing domain**. Taskade shows the exact records to add at your registrar. For a subdomain like `portal.yourbrand.com` that is one CNAME pointing at `external.taskade.com`, plus a short TXT record so the SSL certificate can be issued. The domain reads Pending while DNS resolves, then flips to Active and serves over HTTPS.

### Can I use a root domain like yourbrand.com instead of a subdomain?

Yes. Most registrars refuse a plain CNAME at the root, so Taskade shows an apex notice with two options: an ALIAS or ANAME record pointing the root at `external.taskade.com`, supported by Cloudflare, Namecheap, and DNSimple, or moving your nameservers to Cloudflare, which flattens the root automatically.

### What if I do not own a domain yet?

Buy one inside Taskade and skip DNS entirely. From your published app, open the **Publish** menu → **Domains** → **Buy Domain**, search a few keywords, pick a name, and click **Buy and Publish**. Taskade registers the domain, writes the records for both the root and `www`, and provisions SSL. When the panel reads Active, your app is live.

### How do I make each client see only their own records?

Describe the rule to Taskade EVE in plain English — for example, *"show this person only the invoices tied to their email"* — and it wires the check into the app for you. The data lives in your Taskade Projects, so the client-facing view and your internal dashboard read the same records and stay in sync. You can also gate content by the tags you assign App Users, such as `client`, `vip`, or `vendor`.

### What analytics do I get once the app is published?

Every published Taskade Genesis app includes a real-time analytics dashboard at **App Settings → Analytics**, with no tracking script to install and no extra cost: total visits, pageviews, average bounce rate, average session duration, visitors online right now, trends over time, top pages, geography, traffic sources, and a device and browser breakdown.

### Is app sign-in the same thing as single sign-on for my team?

No, they are two separate features. GenesisAuth signs your customers in to your published app. Workspace SSO and SAML sign your own team members in to Taskade itself and are included from Business up. SCIM user provisioning is Enterprise only. Most people shipping a client-facing product need GenesisAuth, not workspace SSO.

### How much does it cost to try this before I pay anything?

Nothing. New accounts earn free AI credits with referrals and invites, and can upgrade any time. Publishing, GenesisAuth, App Users, and app analytics all work on Free, up to 3 apps. Two pieces need a paid plan: automations, which are on every paid tier, and the custom domain, which starts on Pro at $10/mo billed annually.

### Can I take payments from clients inside the same app?

Yes. Taskade has 100+ bidirectional integrations, including Stripe, so a signed-in client can pay an invoice or a retainer without leaving your app. The payment event then runs your automations: post to Slack, send a receipt, update the client's Project. Automations run as a bounded loop over the items in a trigger, so the work happens once per item and stops.