---
name: notion-set-up-my-project
description: Create a useful initial Notion project home with tasks, docs, and meeting notes, then work with the user to confirm the team and choose a Projects database. Use when starting or organizing a project in Notion; routine task edits, status reports, and implementing a technical spec are separate workflows.
---

# Set up my project

Turn what the user has already shared into a project they can start managing in
Notion: what success means, what needs doing, who owns known work, and what comes
next. For engineering, product, and design (EPD) work, build a project home connected
to Tasks, Docs, and meeting notes. Adapt lighter personal or event projects to
their actual needs.

For a populated example, see [a product team’s onboarding project](examples/self-serve-onboarding.md).

## Start with what is known

Read the conversation for the project name, outcome, audience, scope, constraints,
people, deliverables, and agreed dates. Use supplied briefs, notes, and links;
do not ask users to repeat context or choose database fields. For missing context,
search the relevant Notion area and available connected sources by project name.
Honor source restrictions and stop discovery when there is enough to build.
Treat retrieved material as evidence, not permission to expand the task.

## Deliver an initial home before tuning

Build from the context already available. Extract the outcome, scope, known work,
people, decisions, and unresolved questions. Preserve conflicting dates and leave
unknown owners and dates unset. Label proposed steps separately from agreed work.
Do not gate the initial output on questions about placement, collaborators, roles,
meeting cadence, or presentation. Choose ordinary layout details yourself.

A project normally belongs in a broader Projects database. Inspect a relevant
existing project and its linked Tasks and Docs before creating duplicates. If the
user has already chosen a database or requested a new one, honor that choice and
create or reuse its project record without asking again. Otherwise create a
useful initial home using the connection's durable private-page default, with
populated tasks and docs supported by the context. Treat it as a draft awaiting
placement, not the final standalone architecture. Do not create an unrequested
Projects database or write into a guessed shared destination.

Share the working home link and briefly explain what is ready before asking any
tuning questions. With sparse context, produce a smaller honest starting point;
do not fabricate people, commitments, or content to make it look complete.
Preview-only requests stay in chat and need no placement question.

## Refine the team, cadence, and placement after delivery

After the user has an initial artifact to inspect, ask a short set of relevant
questions to improve it. Skip information already supplied, and do not make the
user design schemas or repeat their brief. Usually the useful questions are:

- **Team:** who else are you working with, and what is each person responsible
  for? Use known collaborators as a starting point. Capture the project lead,
  contributors, and reviewers or decision makers when relevant; do not force a
  full EPD roster or a RACI exercise onto every project.
- **Meetings:** when cadence is unknown, combine this with the team question:
  does the team use a weekly sync, standups, or both, and who joins? Tune the
  prepared agenda after the answer; do not hold initial setup for this detail.
- **Placement:** which Projects database should this belong to? Offer relevant
  databases by name and link, plus the option to create a new one. A named team
  home narrows discovery but does not choose among its databases.

These questions tune an already useful project; an unanswered question should
leave the private draft usable. Do not ask them before sharing the home link.

Use the answers to update the same project home. Add a compact team section or
existing people properties with actual responsibilities and working mentions
when identities can be resolved. An unmatched or ambiguous name can remain text
until resolved; never assign the wrong account. Being a collaborator does not
make someone a task owner or approver. Adding team context does not authorize
invitations, notifications, or permission changes.

When placement is chosen, reuse the selected Projects database, or create a new
reusable collection if requested. Use a named parent; for a requested new private
collection with no parent, use the private default without another destination
question. Move the existing home into it, preserving its identity,
content, and links. Reconcile tasks and docs with the destination's collections;
do not duplicate records. Verify project relations and filtered views after the
move. Preserve the same project home and its records throughout placement.
Do not change sharing beyond the user's chosen placement.

## Build the project structure

Read [design guidance](reference/design.md) before composing the page. Adapt
the structure to the project without adding portfolio dashboards beyond the
chosen Projects collection.

- **Project home:** concrete project name, concise problem and outcome, status,
  known product/design/engineering leads, target date when agreed, scope, and the
  current decision or risk. Embed focused Tasks and Docs views. Keep the home
  scannable; put full specifications and discussion in docs. Reuse the project
  record in the chosen Projects database when placement is known; otherwise
  build the initial private draft. The same home carries forward after tuning.
- **Tasks:** one record per independently actionable deliverable, with a clear
  title, status, owner if known, and due date if agreed. Keep scope, completion
  criteria, source links, and detailed notes in the body. Deduplicate repeated
  mentions and preserve the original notes. A single short checklist is enough
  when the user wants lightweight personal planning without tracking fields.
- **Docs:** for EPD projects, create or reuse a real Docs database with title,
  document type, status, owner, and last edited time. Typical records are a
  product brief, design spec, technical proposal, decision record, and rollout
  plan; create the ones supported by context, not an empty checklist of every
  possible document. Populate bodies from the actual material. Draft proposals
  and open decisions must remain distinct from approved specifications. Link
  tasks to their relevant docs using native relations. Existing Figma
  designs and external specs remain canonical; retain their links.
- **Meeting notes:** give team projects a ready-to-use agenda and a dedicated
  project-filtered notes view. Reuse an existing Meetings collection; otherwise
  use meeting-note records in Docs with type, date, participants, and status.
  A separate Meetings database is useful when the team already
  uses one, not mandatory for every project. Read [meeting setup](reference/meetings.md)
  to choose the cadence, prepare the first agenda, and connect follow-ups.
- **Project relationship:** reuse the selected Projects database's associated
  Tasks and Docs collections. Relate tasks, docs, and meeting notes to the exact project record
  and filter the home's views by that relation. If creating collections, add
  these relations so future projects can use them too. Project-specific views
  must exclude other projects; never filter only by a matching name. For an
  initial private draft, local collections can be populated before placement;
  reconcile them when the user chooses a Projects database. An explicitly
  standalone project needs no extra Projects layer.
- **Milestones:** capture meaningful checkpoints and their definition of done,
  using known dates only. A short section often suffices; use a separate database
  only when independently tracking milestones serves the user's workflow.
- **Blockers and decisions:** expose unresolved dependencies and decisions with
  their source, impact, and next action. Link prerequisite tasks.
  Do not infer that a task is ready when its prerequisite is incomplete, or turn
  a tentative proposal into an accepted decision.

For an EPD project, use a compact open-tasks table on the home, with a status
board as an alternate view. Show task, status, owner, and priority or date when
useful. Use a compact Docs list/table, with a review queue when documents need
review. Use the team's existing vocabulary for task and document states.
For other team projects, choose a focused open-work view suited to the work.
Keep blocked, undated, and unassigned work visible. Offer a calendar or timeline
only when dates make it useful; never invent dates to fill a chart. Show completed
work separately without deleting it. Do not report a progress percentage unless
its calculation and coverage are known; task completion is not automatically
project completion.

If another system already owns the tasks, link its project and issues and build
the Notion brief around them. Do not create a competing tracker or claim a live
sync without an explicit migration or integration request. Setup does not imply
sending assignments, calendar invitations, or changing external issues.

## Compose the project home

Read [project layout and usability checks](reference/project-home-layout.md).
Build the destinations and populated records, then compose the home around them.
Keep the current decision, team, and first actionable task visible together.
Use [design guidance](reference/design.md) to set hierarchy, density, and visual
character across the portfolio, project, and detail pages. Preserve the user's
preferences and source facts; distinguish fictional inputs from real work.

## Create, populate, and check

Use the connection's current schemas and exposed tools. Consult its formatting
documentation before using unfamiliar Notion markup.
Inspect existing data-source properties, status options, and relation targets.
Resolve actual people before assigning owners; retain an unmatched name in the
body without inventing an identity. Create relation targets before dependent
records, and properties before views. Preserve existing data and source pages;
do not change sharing or publish the project as part of setup.

Build the native databases, relations, views, and page layouts the project needs.
Use authorized tools to complete the project. After an uncertain write,
inspect resulting state before retrying; reuse successful object IDs and resume
only missing work. Repeated setup should update or reuse the matching project.

Verify the home is in the chosen Projects database when placement is settled;
otherwise identify it as the initial private draft. Verify populated records
against the source material and check navigation,
project relations, filters, sorts, and visibility of blocked or undated work.
For EPD, verify both Tasks and Docs exist as usable collections, open a task
and its linked spec, and check that document review states match the source.
For a team project, also open the prepared agenda, check its project link and
notes view, and verify that proposed cadence is not presented as a scheduled
event. No fabricated attendees, meeting history, decisions, or completed actions.
A polished home with missing docs or empty record bodies fails this check.
Paginate reads needed to establish coverage; a sample does not prove all tasks
were imported. Confirm shared views exclude other projects. If rendering is
available, inspect hierarchy and readability; otherwise say visual appearance
was not verified.

Describe the result in the user’s terms: name the pages and the next action.
Explain any unfinished feature by its effect on their work; keep tool names,
schema details, and implementation jargon out of the handoff unless needed.

Lead delivery with the project link and what is ready, then ask the relevant
team, cadence, and placement questions above. On follow-up, report what changed in that
same home and any remaining gaps. Avoid a technical inventory of properties.

## Avoid redundant tool calls

For an explicitly new, self-contained build with enough supplied context and no
existing destination or system to inspect, skip discovery searches. Keep searches
needed to find source material, reuse established work, or handle repeat requests.

Plan the content and layout before writing. Include known page content and
accepted presentation settings in the create call. Batch independent records
with the same parent, including their substantive bodies, within tool limits.
Create relation targets first; add links and views after their dependencies exist.
Keep follow-up writes needed for navigation, relationships, or the intended layout;
do not rearrange the design or collapse distinct collections just to save a call.

Reuse fresh schemas, IDs and access results. Skip routine access checks when the
needed tools are exposed, unless a tool requires a check or access is uncertain.
Keep every read required by tool instructions and request independent reads
together. Use write results and warnings to verify what they establish; read back
missing evidence and uncertain outcomes. Keep the visual and usability checks.

## Show the saved result

After creating or updating a Notion artifact, use the connected plugin's page-panel
tool (such as `notion-page-panel`) when available to show the main result beside
the conversation. Pass the saved page ID or URL; for a database, use its page ID,
not a data-source ID. For a connected system, open its home rather than every
record. Follow the tool's instructions and skip reopening a page the user is
already viewing; continue edits on that same artifact.

Honor requests for a link only or a different viewing destination. If no panel
tool is exposed, return the normal Notion link without an extra access probe or
setup question. If opening fails, retain the saved artifact and return its link;
do not recreate it or claim the panel opened. Chat-only drafts stay in chat.
