Database Optimization Guide for Notion

The skill Copy

## Overview

Notion databases can grow rapidly and become slow or difficult to manage without proper optimization. This comprehensive guide covers strategies to maximize performance, organization, and functionality of Notion databases using AI resources.

## Table of Contents

1. [Database Structure Optimization](#structure)
2. [Property Management](#properties)
3. [Query Performance](#queries)
4. [Formula Optimization](#formulas)
5. [Relation & Rollup Strategies](#relations)
6. [Database Linking](#linking)
7. [Workspace Organization](#organization)
8. [Performance Monitoring](#monitoring)

## Database Structure Optimization {#structure}

### 1. Primary Key Selection

Choose an appropriate primary key (title field):
- **Simple Text**: For straightforward reference ("Project Name", "Task Title")
- **Auto-ID**: Use formula to generate unique identifiers
- **Composite Keys**: Combine multiple values for complex systems
- **Timestamp**: Useful for chronological tracking

### 2. Table Normalization

Apply database normalization principles:
- **First Normal Form (1NF)**: Each field contains atomic values only
- **Second Normal Form (2NF)**: Remove partial dependencies
- **Third Normal Form (3NF)**: Remove transitive dependencies

```
Bad Structure:
- Project Table has: Name, Owner, Owner Email, Owner Phone

Better Structure:
- Projects Table: Name, Owner (relation to People)
- People Table: Name, Email, Phone
```

### 3. Database Splitting

Divide large databases for better performance:
- Split by status: Active, Archived, Draft
- Split by date: Current Year, Past Years
- Split by category: Different project types
- Split by team: Department-specific databases

## Property Management {#properties}

### 1. Property Types Selection

**Efficient Types**:
- Text (minimal overhead)
- Select (limited options, no duplication)
- Checkbox (boolean values)
- Date (indexed for queries)
- Number (sortable, queryable)

**Heavy Types** (use judiciously):
- Relation (creates bidirectional links)
- Rollup (calculates across relations)
- Files & Media (storage intensive)
- Rich Text (more processing required)

### 2. Property Organization

Arrange properties logically:
```
1. Identity properties (Name, ID, Type)
2. Core data properties (Status, Priority, Category)
3. Timeline properties (Created, Due Date, Completed)
4. Relationship properties (Owner, Project, Team)
5. Metadata properties (Tags, Notes, References)
6. Calculated properties (Formulas, Rollups)
```

### 3. Limiting Empty Properties

Minimize unused properties:
- Archive columns not actively used
- Create template variations for different record types
- Use conditional properties where applicable
- Consolidate similar properties

## Query Performance {#queries}

### 1. Filtering Optimization

**Fast Filters**:
- Single condition on indexed field
- Select/Status filters
- Date range filters
- Checkbox filters

**Slow Filters**:
- Multiple complex AND conditions
- Text contains (case-insensitive search)
- Related property filters
- Formula result filters

**Best Practices**:
```
// Fast: Single indexed field
Status is "In Progress"

// Faster: Combined indexed fields
Status is "In Progress" AND Priority is "High"

// Slower: Text matching
Name contains "Project"

// Slowest: Multiple complex conditions
(Name contains "Project" AND Status is "Active" AND Priority is "High") 
OR (Owner is "John" AND Due Date is within 7 days)
```

### 2. Sorting Strategies

- Sort by indexed fields first (Status, Date, Number)
- Sort by most significant property
- Limit sort operations in views
- Avoid sorting by formula results

### 3. Search Optimization

- Use database search with specific keywords
- Leverage date properties for time-based searches
- Implement status fields for quick filtering
- Use tags/categories for classification

## Formula Optimization {#formulas}

### 1. Formula Complexity

**Simple Formulas** (fast):
```
prop("Priority") == "High"
formatDate(prop("Due Date"), "MMM d")
if(prop("Status") == "Done", "✅", "⏳")
```

**Complex Formulas** (slow):
```
// Multiple nested conditions
if(and(
  prop("Status") == "In Progress",
  prop("Priority") == "High",
  dateBetween(prop("Due Date"), now(), dateAdd(now(), 7, "days")),
  length(prop("Team")) > 0
), "Urgent", if(prop("Status") == "Done", "Complete", "Pending"))
```

### 2. Formula Best Practices

- Break complex formulas into multiple columns
- Avoid recursive formulas
- Use helper formulas for intermediate calculations
- Cache computed values when possible
- Minimize date/time calculations

### 3. Alternative Approaches

Instead of complex formulas:
- Use API for programmatic calculations
- Implement workflows for automation
- Create database templates
- Use rollups instead of aggregating manually

## Relation & Rollup Strategies {#relations}

### 1. Relation Best Practices

```
Bad: Direct person emails in multiple databases
Better: Relation to centralized People database

Bad: Duplicate project info across databases
Better: Relation with rollups for aggregate data
```

### 2. Rollup Calculations

**Efficient Rollups**:
- count() - quick aggregation
- sum() - numeric totals
- unique() - distinct values
- max(), min() - extremes

**Heavy Rollups**:
- every(), any() - boolean logic
- concat() - string combining
- filter() on text matches

### 3. Many-to-Many Patterns

Implement efficient many-to-many relationships:
```
Database A → Junction Database ← Database B

Example:
Projects → Project-Team Assignments ← Team Members

Allows:
- Track which projects team members join
- See which teams work on projects
- Include additional metadata (role, hours spent)
```

## Database Linking {#linking}

### 1. Linking Strategies

**One-to-Many**:
```
Projects (one) → Many Tasks
→ Use relation in Tasks to Project
→ Use rollup in Projects to count tasks
```

**Many-to-Many**:
```
Teams ↔ Projects (through junction database)
→ Track team-project assignments
→ Allows complex access patterns
```

### 2. Synced Blocks vs Relations

**Use Synced Blocks for**:
- Template instances
- Repeating content sections
- Consistent formatting

**Use Relations for**:
- Data relationships
- Bidirectional connections
- Aggregations and calculations

## Workspace Organization {#organization}

### 1. Database Naming Conventions

```
[Type] [Category] [Scope]

Examples:
- DB: Projects (Active)
- DB: Tasks (Engineering)
- DB: Team Members (HR)
- DB: Contacts (Leads)
- Archive: Completed Projects
- Template: Project Setup
```

### 2. Permission Model

- Create database hierarchies by team
- Use shared views for different audiences
- Separate public vs private databases
- Archive completed databases
- Implement access control through workspaces

### 3. Backup Strategy

- Export critical databases periodically
- Maintain archive database of old records
- Use API for programmatic backups
- Document critical database schemas

## Performance Monitoring {#monitoring}

### 1. Metrics to Track

- **Database Size**: Number of records, total properties
- **Query Speed**: Filter and sort performance
- **Relation Count**: How many relations per database
- **Formula Complexity**: Number of heavy formulas

### 2. Performance Issues & Solutions

| Issue | Cause | Solution |
|-------|-------|----------|
| Slow page loads | Large database view | Use filters, pagination, archive old records |
| Relation lag | Too many relations | Normalize, use junction databases |
| Formula delays | Complex calculations | Simplify, break into steps |
| Search slowness | Large text dataset | Add indexed properties, use categories |

### 3. Optimization Checklist

- [ ] Remove unused properties
- [ ] Archive inactive records
- [ ] Simplify complex formulas
- [ ] Review and optimize sorts/filters
- [ ] Split large databases
- [ ] Consolidate redundant databases
- [ ] Update outdated relations
- [ ] Clean up duplicate records
- [ ] Review and optimize relations count
- [ ] Implement proper indexing strategy

## Advanced Optimization Patterns

### 1. Denormalization for Performance

In some cases, duplicate data improves performance:
```
// Instead of always looking up via relation
// Store frequently accessed data in both places

Tasks Table:
- Project Name (text) + Project (relation)
- Project Owner (text) + Owner (relation)

Benefit: Faster display without relation lookups
```

### 2. Archive Pattern

Maintain performance with large datasets:
```
Active Database:
- Current records only
- Full property set
- All filters and sorts

Archive Database:
- Completed/inactive records
- Minimal properties
- Limited filters

API + Automation handles moving between them
```

### 3. Snapshot Pattern

Store historical data efficiently:
```
Current Database:
- Active records
- Full relational links
- Frequent updates

Snapshot Database:
- Point-in-time copies
- Denormalized (reduced relations)
- No updates
```

## API Optimization

When using Notion API:
- Use batch requests where possible
- Filter results server-side, not client-side
- Cache frequently accessed data
- Use pagination for large result sets
- Implement retry logic for rate limits
- Consider workspace vs database scoped tokens

## Conclusion

Database optimization is an ongoing process. Regular review of:
- Unused properties and databases
- Outdated or redundant data
- Performance bottlenecks
- Structural improvements

Keeps Notion workspaces efficient, performant, and maintainable at scale.

How to install it Copy

1. Open the tool and start a new conversation, project or template.
2. Paste the text below wherever the tool keeps standing instructions
   — usually called system prompt, instructions, or persona.
3. Save it so it applies to every run rather than a single message.

Did it work for you?

Where it came from

2025 Anfernee