Notion Page-Level Access: How to Lock Down Client Portals Without Exposing Your Database
🔒

Notion Page-Level Access: How to Lock Down Client Portals Without Exposing Your Database

View Details
Unsplash Cover
Unsplash Cover
Video
Prompt status
Draft ready
Short video prompt
You are creating a short-form vertical video (9:16) for TikTok + IG Reels for Connex Digital.

Goal
- Teach what “Notion page-level access” means and how it locks down a client portal so guests only see their own records.
- Drive viewers to book a call.

Source article
- Use this blog post as the single source of truth: https://connex.digital/blog/notion-page-level-access-how-to-lock-down-client-portals-without-exposing-your-database

Video requirements
- Duration: 20 to 35 seconds.
- Structure: hook in first 2 seconds, then 3 to 5 quick points, then CTA.
- Pacing: fast cuts, quick b-roll, screen captures, simple motion graphics.
- Captions: burned-in captions for every spoken line.
- On-screen text: high-contrast, short phrases, large readable type.
- Branding: include “Connex Digital” in on-screen text and keep a subtle Connex Digital logo in-frame.

Tone + voice
- Warm US confident, energetic and clear.
- Voiceover: conversational expert.
- Music: upbeat, trendy, low under VO.

Storyboard (quick cut list)
1) Hook (0 to 2s)
- On-screen text: “Building a Notion client portal?”
- On-screen text (beat 2): “Don’t share your master database.”

2) Point 1 (2 to 8s): Portal page first
- VO: “Share a portal page per client, not your master database.”
- Visual: Notion page called “Client Portal” with a few sections.
- On-screen text: “Share a portal page per client”

3) Point 2 (8 to 14s): Linked database views
- VO: “Inside that portal, embed linked database views so clients only see what you allow.”
- Visual: Linked database view embedded in a page.
- On-screen text: “Use linked database views”

4) Point 3 (14 to 22s): Database rule (page-level access)
- VO: “Then add a database permission rule: only show records where the Person property contains the current user.”
- Visual: Permission rule UI + a database with a Person column.
- On-screen text: “Rule: Person contains current user”

5) Point 4 (22 to 28s): Avoid the big mistake
- VO: “Big mistake: sharing a database view is not the same as sharing one page. Clients can click back if they have broad access.”
- Visual: Cursor clicking “Back” to a database (with a red X overlay).
- On-screen text: “Avoid ‘click back’ exposure”

6) CTA (28 to 35s)
- VO: “Want this set up securely? Book a call with Connex Digital.”
- On-screen text: “Book a call: connex.digital/book/short”
- End frame: Connex Digital logo + URL.

Include these links
- Primary CTA: https://connex.digital/book/short
- Related mention (quick pop-up lower third, 2 seconds): https://connex.digital/blog/how-to-share-notion-databases-with-guests-without-paying-for-member-seats

Assumptions
- Use generic Notion UI screen captures if the exact permission-rule screen is not available.
- Show the concept clearly rather than matching every pixel of the Notion UI.
Long video prompt
You are creating a YouTube video (16:9) for Connex Digital based on this published blog post.

Primary source article (include on-screen once early)
- https://connex.digital/blog/notion-page-level-access-how-to-lock-down-client-portals-without-exposing-your-database

Video goal
- Teach a safe, repeatable pattern for building a Notion client portal using page-level access (database permission rules) so each guest only sees records assigned to them.
- Prevent the common “client can click back and see everything” failure mode.
- Drive viewers to book a call.

Length + format
- Duration: 6 to 10 minutes.
- 16:9.
- Structure: hook, intro, sections aligned to article headings, recap checklist, CTA.

Presenter + voice
- Use an avatar talking head.
- Presenter: Paul (founder).
- Voiceover tone: warm US confident, conversational expert.

Music + style
- Music: upbeat, trendy, low volume under VO.
- Visuals: a mix of talking-head, Notion screen recordings, b-roll of “client portal / security / folders / locks”, and simple motion graphics.
- On-screen text: section headings and key takeaways. Use Connex Digital branding and keep a subtle Connex Digital logo watermark.

Outline (match these sections to the article)

1) Hook (0:00 to 0:20)
- Show a Notion client portal mockup.
- On-screen text: “Notion client portal mistake: sharing the database.”
- VO: Tease the fix: portal page + linked views + page-level access rules.

2) Intro (0:20 to 0:50)
- Who Connex Digital is and what viewers will learn.
- On-screen: blog URL + a quick “save this checklist” tease.

3) What “page-level access” means in Notion (0:50 to 2:10)
- Explain in plain English: database rule that limits visible pages based on a Person property containing the current user.
- Visual: simple animation: database → filter per user.
- Key takeaway on-screen: “Rule = Person contains current user”.

4) The key misconception to avoid (2:10 to 2:50)
- “Sharing a database view is not the same as sharing one page.”
- Demonstrate “click back” risk if a guest has broad access.
- Visual: screen capture showing navigation back path (blur any sensitive info).

5) The safest client portal setup (2:50 to 6:40)
5.1) Keep a single master database
- Explain why the master database stays internal.
- Visual: master database labeled “Internal only”.

5.2) Add a Person property used for access
- Give examples: Client user, Portal user, Allowed viewers.
- Visual: database column setup.
- Key takeaway on-screen: “Access property = Person”.

5.3) Create a permission rule on the database
- Walk through the rule conceptually.
- Call out decision point: Can view vs Can edit.
- Visual: permission rule UI + example records assigned to different people.

5.4) Share a portal page, not the database
- Build a sample portal page layout:
- Welcome section
- Requests / Deliverables linked view
- Files / Upload area
- Next steps
- Embed linked database views filtered by the rule.
- Visual: screen recording placing linked database views inside the portal page.

6) Common portal problems (6:40 to 8:20)
- “My client can click back and see everything”
- Fix: remove broad access to parent pages or master DB; rely on portal page + rules.
- “My client cannot upload files”
- Fix: ensure correct permission level and the file block is on an editable page/location.

7) Practical checklist before sending a portal link (8:20 to 9:20)
- Guest, not member.
- Only access to shared portal page.
- Permission rule tested.
- Test file upload + comments from the guest account.
- Visual: checklist motion graphic.

8) Optional: automation layer (9:20 to 9:45)
- Mention you can add notifications via Notion automation, Make, or Zapier.
- Visual: simple icons for Notion, Make, Zapier.

9) CTA (9:45 to 10:00)
- VO: “If you want a secure client portal built the right way, book a call.”
- On-screen text: “Book a call: connex.digital/book/video”

Links to include
- Primary CTA: https://connex.digital/book/video
- Mentioned tools (quick lower thirds when referenced):
- https://connex.digital/apps/notion
- https://connex.digital/apps/make
- https://connex.digital/apps/zapier

Assumptions
- Use a clean demo workspace for screen recordings.
- If exact permission screens differ by plan/UI updates, show the concept and label it clearly.
General
🔑 Keyword Goals
Generate LK
Generate NL
LinkedIn Post Content
🚀 Are you building a Notion client portal? It's crucial to set it up securely! Sharing a portal page rather than your master database ensures that clients only see their assigned records.

Understanding page-level access is key—it allows you to filter visibility based on user properties. This prevents the common pitfall of clients clicking back and seeing everything they shouldn't.

🔑 Here’s a quick recap:
1. Keep your master database internal.
2. Use a Person property for access control.
3. Create specific permission rules.
4. Share only the client portal page.

Want to dive deeper? Read the full guide here: Notion Page-Level Access: How to Lock Down Client Portals Without Exposing Your Database

#Notion #ClientPortal #DataSecurity #ConnexDigital #Productivity
Hidden
Full URL
Unsplash Cover
Unsplash Cover
Prompt last generated
Mar 9, 2026 04:46 PMGMT+00:00
KW AI GEN
Notion client portal, page-level access, secure database
Last edited time
Jul 27, 2026 05:33 PM GMT+0
If you are building a Notion client portal, the safest pattern is to share a portal page with each client and use page-level access (database permissions rules) so clients only see records assigned to them, without ever giving them access to your master databases. This approach pairs well with linked database views (see our related walkthrough: share Notion databases with guests without paying for member seats) and can be extended with automations in Notion, Make, or Zapier.

What “page-level access” actually means in Notion

Notion’s page-level access lets you write a rule on a database that says, “A person can only see database pages where the Person property contains them.” This is how you prevent a guest client from viewing other clients’ records.

The key misconception to avoid

Sharing a database view is not the same as sharing one page. If a client can navigate “back” to your database and they have broad access, they can potentially see more than you intended.

The safest client portal setup (recommended)

1) Keep a single master database

Keep your master database private to your internal team. This is where all client records live.

2) Add a Person property used for access

Add a Person property such as:
  • Client user
  • Portal user
  • Allowed viewers
This property is what the permission rule will reference.

3) Create a permission rule on the database

Create a rule that grants access only when:
  • The Person property contains the current user
Decide whether the client should have:
  • Can view
  • Can edit
notion image

4) Share a portal page, not the database

Create a dedicated portal page per client and place linked views of the master database inside the portal.
Then share only the portal page with the client as a guest.

Common portal problems (and how to fix them)

“My client can click back and see everything”

This usually means the client has access to a higher-level page or the master database. Remove broad access, then rely on the portal page + linked database views.

“My client cannot upload files”

Check both:
  • The client’s permission level (must be able to edit where the file block lives)
  • Whether the file block is inside a database page or page they can edit

Practical checklist before you send a portal link

  • Confirm the client is a guest, not a workspace member.
  • Confirm the client can only access the portal page you shared.
  • Confirm the database permission rule filters records correctly for that client.
  • Test file upload and comments from the client account.

When to use Notion Automation (optional)

If you want a notification when a client adds something (a file, deliverable, or request):
  • Use a database property change trigger where possible.
  • Or add a lightweight workflow in Make or Zapier when you need routing, formatting, or Slack notifications.

CTA

If you want a secure client portal pattern built the right way (so clients only see their own work), book a call here: Book a discovery call