Skip to main content

Overview

Integrate and analyze your Planning Center data with Parable

What is Planning Center?

Planning Center is a comprehensive suite of church management applications designed to help churches organize information, coordinate events, communicate with teams, connect with congregants, and manage their church operations.

How Parable Approaches Planning Center Data

Parable acts as a data warehouse that integrates with Planning Center to provide your church with unified, queryable access to all your ministry data:

  1. Syncs data from all your Planning Center apps automatically
  2. Stores it in a structured PostgreSQL database
  3. Provides SQL access so you can query across all your data
  4. Maintains relationships between different data types
  5. Keeps everything current with regular synchronization

Planning Center Apps in Parable

Parable integrates with all major Planning Center applications to provide unified insights across your church data:

People

Your church directory and member management system

Giving

Donation tracking, pledges, and financial reporting

Check-Ins

Event attendance and child safety tracking

Groups

Small groups, classes, and ministry management

Calendar

Events, resources, and scheduling

Services

Worship planning and volunteer scheduling

Registrations

Event signups and payments

Publishing

Media and sermon management

If you want a simple explanation of how Parable measures engagement, start with Engagement Scoring.

Core Concepts

Multi-Tenant Architecture

Every church (organization) in Parable has isolated data:

  • Each table includes a tenant_organization_id column
  • Data is automatically filtered by your organization
  • You can only see your church's data

Data Synchronization

Parable manages data synchronization behind the scenes:

Planning Center API → Parable Sync Engine → PostgreSQL Database → Your SQL Queries
Synchronization Details
  • Data syncs automatically every night
  • Full sync on initial setup
  • Nightly updates thereafter
  • Handles API rate limits gracefully
  • Retries on failures automatically

Database Schema Pattern

All Planning Center data follows a consistent pattern:

Main entity table
planning_center.{app}_{entity}
  - {entity}_id              Planning Center's ID
  - tenant_organization_id   Your church's ID
  - system_status            Data lifecycle (active/transferring/stale)
  - system_created_at        When Parable first synced the record
  - system_updated_at        When Parable last synced the record
  - created_at               When created in Planning Center
  - updated_at               When last updated in Planning Center
  - [entity fields]          The actual data fields

Relationship table (for connections between entities)
planning_center.{app}_{entity}_relationships
  - {entity}_id              Parent entity (plural table name, e.g. giving_donations_relationships.donation_id)
  - relationship_type        Type of related entity (e.g. 'Person', 'Fund')
  - relationship_id          ID of related entity

System Status Explained

Every record has a system_status field that tracks its lifecycle:

  • transferring - Being imported from Planning Center
  • active - Current, valid data
  • stale - Marked for removal in next sync

Parable's row-level security automatically filters to show only active records, so you don't need to filter manually.

Understanding Our Storage Approach

Why Separate Relationship Tables?

Planning Center's API returns relationships separately from main data. We mirror this structure for several reasons:

  1. Data Integrity - Relationships can change independently of entities
  2. Flexibility - One entity can have multiple relationship types
  3. Performance - Optimized indexes for different query patterns
  4. Consistency - Same pattern across all Planning Center apps

Example: Connecting People to Donations

Instead of a direct foreign key, we use relationship tables:

-- Find all donations with donor information
SELECT
    d.donation_id,
    d.amount_cents / 100.0 as amount,
    p.first_name,
    p.last_name
FROM planning_center.giving_donations d
JOIN planning_center.giving_donations_relationships dr
    ON d.donation_id = dr.donation_id
    AND dr.relationship_type = 'Person'
JOIN planning_center.giving_people p
    ON dr.relationship_id = p.person_id
WHERE d.received_at >= DATE_TRUNC('year', CURRENT_DATE);

Common Query Patterns

Basic Entity Query

-- Get all people
SELECT
    person_id,
    first_name,
    last_name,
    membership
FROM planning_center.people_people;

Joining Through Relationships

-- Get people with their household
SELECT
    p.first_name,
    p.last_name,
    h.name as household_name
FROM planning_center.people_people p
JOIN planning_center.people_people_relationships pr
    ON p.person_id = pr.person_id
    AND pr.relationship_type = 'Household'
JOIN planning_center.people_households h
    ON pr.relationship_id = h.household_id;

Cross-Module Queries

-- Find giving totals by group membership
SELECT
    g.name as group_name,
    COUNT(DISTINCT mr_person.relationship_id) as member_count,
    SUM(d.amount_cents) / 100.0 as total_giving
FROM planning_center.groups_groups g
JOIN planning_center.groups_memberships_relationships mr_group
    ON mr_group.relationship_id = g.group_id AND mr_group.relationship_type = 'Group'
JOIN planning_center.groups_memberships gm
    ON gm.membership_id = mr_group.membership_id
JOIN planning_center.groups_memberships_relationships mr_person
    ON mr_person.membership_id = gm.membership_id AND mr_person.relationship_type = 'Person'
JOIN planning_center.giving_donations_relationships dr
    ON mr_person.relationship_id = dr.relationship_id
    AND dr.relationship_type = 'Person'
JOIN planning_center.giving_donations d
    ON dr.donation_id = d.donation_id
WHERE d.received_at >= DATE_TRUNC('year', CURRENT_DATE)
GROUP BY g.name;

Ministry Health Metrics

Combine attendance, giving, and group participation data to understand overall engagement trends:

-- Get weekly giving totals with donor counts
SELECT
    DATE_TRUNC('week', d.received_at) as week_start,
    COUNT(DISTINCT dr.relationship_id) as unique_donors,  -- Count unique people
    SUM(d.amount_cents) / 100.0 as total_amount          -- Convert cents to dollars
FROM planning_center.giving_donations d
JOIN planning_center.giving_donations_relationships dr
    ON d.donation_id = dr.donation_id
    AND dr.relationship_type = 'Person'                  -- Only person relationships
WHERE d.received_at >= DATE_TRUNC('year', CURRENT_DATE)
GROUP BY DATE_TRUNC('week', d.received_at)
ORDER BY week_start DESC;

Tips for Junior Developers

Begin with basic SELECT statements on single tables:

-- Just get some data to explore
SELECT * FROM planning_center.people_people LIMIT 10;

Make your queries more readable:

-- Bad: Hard to read
SELECT planning_center.people_people.first_name
FROM planning_center.people_people;

-- Good: Clean and clear
SELECT p.first_name
FROM planning_center.people_people p;

Planning Center stores amounts in cents:

-- Wrong: Shows cents
SELECT amount_cents FROM planning_center.giving_donations;

-- Right: Shows dollars
SELECT amount_cents / 100.0 as amount FROM planning_center.giving_donations;

Document your logic for future reference and clarity

Troubleshooting Common Issues

Why don't I see recent data?

Check the last sync time. Data syncs periodically (usually hourly).

Why are some fields NULL?

Planning Center allows optional fields. NULL means the field wasn't provided.

How do I find the right relationship type?

Check the relationship table to see available types: sql SELECT DISTINCT relationship_type FROM planning_center.people_people_relationships;

Why do I get duplicate rows?

You might be joining incorrectly. Make sure to: - Include the relationship_type in your JOIN - Use DISTINCT when counting unique entities

  • Check if you need a GROUP BY clause

Best Practices

  1. Always use meaningful aliases for tables (p for people, d for donations)
  2. Comment complex logic in your queries
  3. Test with LIMIT before running large queries
  4. Use transactions for updates (though most queries are read-only)
  5. Index awareness - our tables are optimized for common query patterns
  6. Date filtering - use indexed date columns for performance

Key Benefits

Query across all your Planning Center apps with SQL, combining data that would normally require multiple exports

Your Planning Center data stays synchronized with Parable through nightly updates, ensuring you're working with up-to-date information

Connect to Power BI, Tableau, or other BI tools to create dashboards and reports beyond Planning Center's built-in capabilities

Discover patterns by connecting giving data with attendance, group participation with volunteer engagement, and more

All Planning Center data is accessed through Parable's secure, read-only connection. Your original Planning Center data remains unchanged.

Getting Started

To begin working with your Planning Center data in Parable:

  1. Connect Your Account: Link your Planning Center organization to Parable
  2. Explore Your Data: Use the SQL editor to query your synchronized data
  3. Build Dashboards: Create custom reports in your preferred BI tool
  4. Share Insights: Export results to share with leadership and ministry teams

Start with simple queries to familiarize yourself with the data structure, then gradually build more complex cross-app analyses. Remember: Every expert was once a beginner!

Next Steps

Ready to dive deeper? Check out our specific guides:

Getting Help

On this page