Skip to main content
Goal templates let you save the structure of a goal so you can reuse it later. Templates are perfect for recurring projects, standardized workflows, or common goal patterns you use frequently.

​
What are templates

A template is a saved goal structure that you can instantiate into a new goal: 
interface GoalTemplate {
  id: string
  user_id: string
  name: string
  structure: Partial<Goal>    // The goal fields to reuse
  created_at: string
}
Templates store:
  • Title and description
  • Status (usually “not_started”)
  • Priority and color tag
  • Any other goal properties you want to reuse
Templates do NOT store:
  • Sub-goals (only the parent goal structure)
  • Dates (start and end dates are set when creating from template)
  • Collaborators or share links
  • Progress or completion data
Templates are per-user. You cannot share templates with other users (though you could share a goal created from a template).

​
Starter templates

Goalst includes three built-in starter templates to get you going:

Fitness Plan

Title: “Fitness Plan”
Description: “Get fit and healthy”
Use for: Health and wellness goals

Book a Trip

Title: “Book a Trip”
Description: “Plan and book your next trip”
Use for: Travel planning

Launch a Project

Title: “Launch a Project”
Description: “Take a project from idea to launch”
Use for: Product launches or initiatives
const STARTER_TEMPLATES = [
  {
    id: 'starter-fitness',
    name: 'Fitness Plan',
    structure: {
      title: 'Fitness Plan',
      description: 'Get fit and healthy',
      status: 'not_started',
    } as Partial<Goal>,
  },
  // ...
]
Starter templates are always available and cannot be deleted.

​
Creating a template

You can save a new template from the Templates page:
1

Navigate to Templates

Click “Templates” in your app navigation to open the templates screen.
2

Click 'Save template'

Click the “Save template” button in the top-right corner.
3

Enter template details

Provide a name for your template (e.g., “My workout plan”, “Quarterly review”).
export function useSaveTemplate() {
  const qc = useQueryClient()
  return useMutation({
    mutationFn: async ({ name, goal }: { name: string; goal: Partial<Goal> }) => {
      const { data: { user } } = await supabase.auth.getUser()
      const { data, error } = await supabase
        .from('goalst_templates')
        .insert({ name, structure: goal, user_id: user!.id })
        .select()
        .single()
      if (error) throw error
      return data as GoalTemplate
    },
  })
}
4

Save

Click “Save” to create the template. It appears in your “My templates” section.
Currently, templates are created with just a name. Future versions may allow saving an existing goal as a template to preserve all its properties.

​
Using a template

To create a goal from a template:
1

Find the template

Browse your saved templates or starter templates on the Templates page.
2

Click 'Use template'

Click the “Use template” button on the template card.
3

Goal is created

A new goal is created with the template’s structure. The app navigates you to the new goal’s detail page.
async function useTemplate(structure: Partial<Goal>) {
  const { data: { user } } = await supabase.auth.getUser()
  const goal = await createGoal.mutateAsync({
    ...structure,
    user_id: user!.id,
    parent_goal_id: null,
    start_date: structure.start_date ?? new Date().toISOString().split('T')[0],
    manual_progress: 0,
    is_recurring: false,
    recurrence_cadence: null,
  })
  navigate(goalDetailPath(goal.id))
}
4

Customize the new goal

Edit the goal to add dates, sub-goals, or any other details specific to this instance.
Creating a goal from a template does not create a link between them. Editing the goal doesn’t affect the template, and vice versa.

​
Template structure

The structure field is a Partial<Goal> that contains the fields you want to reuse: 
interface GoalTemplate {
  structure: Partial<Goal>
}

// Example structure
{
  title: "Launch a Project",
  description: "Take a project from idea to launch",
  status: "not_started",
  priority: 10,
  color_tag: "#0284c7"
}
When creating from a template, these fields are copied to the new goal. Fields not in the structure get default values:
  • start_date: Today’s date
  • end_date: null
  • manual_progress: 0
  • is_recurring: false
  • priority: Copied from template or defaults to 1

​
Managing templates

You can manage your saved templates from the Templates page:

​
Viewing templates

Templates are organized into two sections:
  1. Starter templates - Built-in templates, always visible
  2. My templates - Your saved templates, sorted by creation date (newest first)
export function useTemplates() {
  return useQuery({
    queryKey: ['templates'],
    queryFn: async () => {
      const { data, error } = await supabase
        .from('goalst_templates')
        .select('*')
        .order('created_at', { ascending: false })
      if (error) throw error
      return data as GoalTemplate[]
    },
  })
}

​
Deleting templates

To delete a template:
  1. Find the template in your “My templates” section
  2. Click the trash icon in the top-right corner of the template card
  3. The template is deleted immediately (no confirmation)
export function useDeleteTemplate() {
  const qc = useQueryClient()
  return useMutation({
    mutationFn: async (templateId: string) => {
      const { error } = await supabase
        .from('goalst_templates')
        .delete()
        .eq('id', templateId)
      if (error) throw error
    },
    onSuccess: () => {
      qc.invalidateQueries({ queryKey: ['templates'] })
    },
  })
}
Deleting a template does not affect goals created from it. They remain unchanged.

​
Empty state

If you haven’t created any templates yet, you’ll see an empty state: 
<EmptyState
  icon={<BookTemplate size={40} />}
  title="No saved templates"
  description="Save a goal structure as a template to reuse it later."
/>
Starter templates are always visible, so the empty state only applies to the “My templates” section.

​
Use cases for templates

Recurring projects

Save structures for quarterly reviews, monthly reports, or annual planning cycles.

Standardized workflows

Create templates for onboarding new team members, product launches, or event planning.

Personal routines

Template your weekly workout plan, meal prep checklist, or study schedule.

Client work

Save goal structures you use for every client project to ensure consistency.

​
Best practices

Use descriptive names

Name templates clearly so you can identify them later (e.g., “Q1 Product Launch” not “Template 1”).

Keep templates generic

Don’t include instance-specific details. Templates should work for multiple use cases.

Set reasonable priorities

Choose a default priority that makes sense for most instances of the template.

Use color tags

Color-code templates by category to make them easier to scan visually.

​
Future enhancements

Templates currently have basic functionality. Potential future features:
  • Save existing goals as templates - Right-click a goal to save it as a template
  • Template sub-goal structures - Save the entire goal hierarchy, not just the parent
  • Template sharing - Share templates with other users or make them public
  • Template variables - Placeholder fields like {{project_name}} that get filled in when using the template
  • Template categories - Organize templates into folders or categories
Want to see a feature? Reach out to the Goalst team with your use case and feedback.

Goals

Learn about creating and managing goals

Nested goals

Build goal hierarchies with sub-goals

Build docs developers (and LLMs) love

Get started for freeTalk to us