The Rockefeller Rolodex - Build Your Personal Relationship Manager

Professor Aven From the Contacts in Your Phone to a Relationship Management System

Tutorial Overview

This tutorial walks you through building your own Rockefeller Rolodex: a personal relationship manager (PRM) you own outright, built in Obsidian, seeded from the contacts already in your phone, with AI to help you keep it current. It is the Human strand of your Personal Leadership Report: the deliverable engineered to outlive the transcript.

You will not be graded on polish. You will build the thing, run it once, and reflect on how your version will work in your life. The test is not “did AI write something.” The test is: did you build something you will actually keep using?

Where This Fits

Your Personal Leadership Report braids three strands:

The Science — what you learn in class and are tested on in the exam.
The Diagnostic — the report you submit: your networks, a firm’s culture and structure, the gap, the change proposal.
The Human — this. The Rockefeller Rolodex: the relationship system you keep.

The clean version: the exam tests whether you understand the ideas, the report tests whether you can use them, and the Rolodex tests whether you will keep using them.

Quick Facts

Deliverable	A working Obsidian PRM seeded from your phone + a short reflection on how you will run it
Starting data	The contacts already in your phone (Apple or Google)
The tool	Obsidian (on your virtual drive) + the `obsidian-vcf-contacts` plugin + Claude
Core primitive	One note per person, cross-linked to organizations, schools, non-profits, and events
The real goal	A relationship system you keep for ten years, not a homework file
Grading	Good-faith team build + individual reflection; not graded on polish

What You’ll Do

Understand David Rockefeller’s rolodex, and the two habits it teaches you.
Export your phone contacts to a .vcf file (Apple or Google).
Import them into Obsidian, one note per person, on your own drive.
Enrich your key contacts with context, links, and notes.
Cross-reference people to organizations, schools, non-profits, and events, and watch the graph draw your network.
Add AI as a helper, with judgment staying firmly with you.

Why This Matters

You already know hundreds of people. The problem is rarely access; it is memory and follow-through. The tie that goes cold because you forgot, the introduction you never returned, the contact you meant to make and didn’t. A system fixes that.

The people who compound relationship capital over a career are not the charismatic ones. They are the disciplined ones: the ones who logged the meeting, tracked the favor, and never dropped the follow-up. This tutorial makes that discipline cheap enough that you will actually keep it.

The alumnus interview built you one new relationship. The Rolodex is where that relationship, and every other tie worth having, gets maintained instead of lost.

🎯 Learning Objectives

By the end, you will be able to:

Explain the two relationship disciplines behind the rolodex (auditable reciprocity; logged, never-dropped follow-up) and encode each in your system.
Own a portable relationship graph in plain files, instead of renting one from a PRM subscription.
Import your real contacts and organize hundreds of them without starting from a blank page.
Model people, organizations, schools, non-profits, and events as one cross-linked graph.
Use AI to help enrich and maintain your notes while keeping judgment yourself.

The Process

Step	Activity	Output
1. Frame	Learn the two habits behind the rolodex	Clear intent
2. Export	Phone contacts to `.vcf`	A file of real people
3. Import	Into Obsidian via the plugin	One note per contact
4. Enrich	Context + links on key contacts	A working person note
5. Link	People to orgs, schools, events	A visible network graph
6. Amplify	AI enrichment + prep	A running system

🧩 The Intent: This Is Not a Contact List

Let me be direct about what this is for. On the surface it is “put your contacts in an app.” Underneath, it is the single most durable asset in the entire report.

Everything else you submit is a snapshot: your network as of this mini, a firm’s culture as of this scrape. The Rolodex is the one deliverable designed to keep working after you graduate. Five years from now the exam is a memory and the report is a PDF in a folder. The Rolodex, if you build it right, is still telling you who to call.

I am not checking whether you entered 800 contacts. I want you to build a system you will keep, seeded from people you already know, structured so that it makes you a sharper decision-maker about your own network every week.

A filing cabinet stores contacts. A living system tells you who to reach out to next. You are building the living system.

🏛️ David Rockefeller and his Rockefeller Rolodex

David Rockefeller shaking hands with Nelson Mandela — David Rockefeller with Nelson Mandela.

David Rockefeller (1915-2017) was an American economist and investment banker who served as chairman and chief executive of Chase Manhattan. From 2004 until his death in 2017 he was the oldest living member of the Rockefeller family’s third generation, and a grandson of John D. Rockefeller. Across banking, philanthropy, and civic life he built one of the most extensive personal networks of the twentieth century.

He ran it on a custom rolodex roughly five feet wide, an estimated 200,000 index cards shared between Chase and his personal office (Room 5600). Every card logged the relationship, not just the phone number: where they met, what was said, what he gave and what he received, who was ill or honored, and the date of every encounter so he always knew when he had last been in touch.

Just as important, he cross-referenced them. Separate cards tracked the organizations, non-profit boards, and events that tied people together, so any contact could be placed inside the web of shared affiliations they belonged to. Two people who sat on the same board or attended the same dinner were linked through it, whether or not they had ever met. He never dropped a follow-up.

Two disciplines live in those cards, and your system will encode both.

The Two Relationship Habits Behind the Rolodex
The Habit	On David’s Cards	In Your System
Track what you give and receive	Cards recorded favors in both directions: a beaded belt received from Nelson Mandela, dinners hosted, flowers sent when someone was ill. Reciprocity made visible.	The `## Ledger` block: what you gave, what you received.
Log every interaction	Every meeting was dated with its context, so a follow-up never slipped and the next move was always obvious.	The `## Log` block: every interaction dated, so no follow-up slips.

What a Real Card Looked Like

David Rockefeller's index card for Nelson Mandela — Nelson Mandela

David Rockefeller's index card for John F. Kennedy — John F. Kennedy

David Rockefeller's index card for Henry Kissinger — Henry Kissinger

David Rockefeller's index card for Donald J. Trump — Donald J. Trump

Actual cards from David Rockefeller’s file. Note what each one tracks: dates, context, gifts given and received, and the next thing owed.

Popular writing calls David’s approach “transformational, never transactional.” That is the target posture: you are not favor-trading, you are adding value and keeping track, and the returns compound over decades.

💾 Why Obsidian: Own the Graph, Do Not Rent It

We build this in Obsidian, and the choice is deliberate. A few things make it the right home for a relationship system you intend to keep for a decade.

It is free. The app costs nothing for personal use. Every feature you need here, the notes, the links, the graph view, the plugins, works on the free tier with no trial clock and no paywall. Optional paid add-ons exist, like cross-device Sync, but you never need them for this assignment.

Your content lives on your own drive. Every contact is a plain Markdown text file in a folder you control, not a row in someone else’s database. You own it outright and it is portable: readable in any text editor, backed up however you like, moved anywhere at any time without an export tool. When a paid PRM shuts down or you stop paying, its graph disappears. Yours does not, because it was never theirs to hold.

It visualizes your network. Obsidian’s graph view renders every note and link as a live, interactive network diagram. As you cross-reference people to firms, schools, and events, your network draws itself on screen: the clusters and the connectors, now visible in your own contacts.

It works well with AI. Because your notes are ordinary text files, AI reads them natively. Free plugins like Smart Connections and Copilot for Obsidian let you run semantic search and chat directly over your vault, either with a local model that sends your data nowhere or with your own API key. The graph you build becomes something you can query: who am I overdue to contact, who connects me into that firm, what do I owe this person.

That is the trade. You do a little more recording by hand, and in return the system is yours, it is free, and it gets smarter as AI does.

📤 Step 1: Export Your Phone Contacts

Start from the people you already know, not a blank vault. Get them out of your phone as a single .vcf (vCard) file.

iPhone / Apple Contacts

Easiest (Mac): open the Contacts app, Edit > Select All (or Cmd-A), then drag the selection to your Desktop, or File > Export > Export vCard. You get one .vcf with everyone in it.
From iCloud: sign in at icloud.com > Contacts > select all > the gear/settings icon > Export vCard.

Google Contacts

Go to contacts.google.com > Export (left sidebar) > choose vCard (for iOS Contacts) > Export. You get a .vcf.

Save the file somewhere you can find it. Do not clean it up yet. Messy is fine; you will organize inside Obsidian, where it is faster.

Privacy note: this file has real people’s data in it. Keep it on your own virtual drive. Do not upload the raw file anywhere you would not put your own phone.

📥 Step 2: Import Into Obsidian

Obsidian is already on your virtual drive. If you have never opened it, launch it and create a new vault called Rolodex (or point it at a new folder).

Install the plugin. Settings > Community plugins > Browse > search “VCF Contacts” (obsidian-vcf-contacts by broekema41) > Install > Enable. Repo: github.com/broekema41/obsidian-vcf-contacts.
Point it at a folder. In the plugin settings, set the contacts folder to people/.
Import your .vcf. Use the plugin’s import command (Command palette: Ctrl/Cmd-P > “VCF” > import). Each contact becomes its own note with vCard frontmatter (FN, EMAIL, TEL, ORG, TITLE, and so on).
Breathe. You now have hundreds of notes. That is correct. You are about to organize them, not perfect them.

If you would rather not use a community plugin, you can export contacts as CSV and convert them to notes with a short script; ask and there is a no-plugin path. The plugin is just the fast lane.

🗂️ Step 3: The Entity Model

Everything in the vault is a note. Relationships between notes are [[wikilinks]]. That single idea is what lets a person’s page connect to any other person, or to the organization, school, or event that places them.

You will use six note types:

The Six Note Types
Type	Frontmatter	Folder	What It Holds
Person	`type: person`	`people/`	The contact. The heart of the system.
Organization	`type: org`	`organizations/`	Firms AND non-profits (`subtype: company / nonprofit / board`).
School	`type: school`	`schools/`	Universities, programs, cohorts. Shared-background ties.
Event	`type: event`	`events/`	Conferences, dinners, meetings. Where ties form.
Note / Log	`type: log`	`logs/`	A meeting note big enough to deserve its own page.
Tag	(inline `#`)		Cross-cutting segments: `#board`, `#mentor`, `#pittsburgh`.

Your folder tree:

Rolodex/
├── people/            # one note per person   (type: person)
├── organizations/     # firms + non-profits   (type: org)
├── schools/           # universities, cohorts (type: school)
├── events/            # conferences, dinners  (type: event)
├── logs/              # optional meeting notes (type: log)
└── _templates/        # note templates

Non-profits are just organizations with subtype: nonprofit. Boards, clubs, and volunteer groups live here too; they are some of the highest-value, lowest-competition ties you have.

📇 Step 4: The Person Note

This is the schema that turns an address-book row into a note you can actually use. The top block is standard vCard (so it round-trips with the plugin). The rest is the context a normal contacts app does not keep: how you know them, and what has passed between you.

---
type: person
name:                       # canonical full name (= the note title)
aka:                        # nickname / preferred name
photo:

# --- reach (vCard fields) ---
email:
email_secondary:            # match on EITHER email; invites drift between them
phone:
linkedin:
twitter:
website:

# --- placement (links, not free text) ---
company: "[[Organization]]"
title:
school: "[[School]]"
city:
country:

# --- context ---
first_met:                  # YYYY-MM-DD
how_we_met:
last_contact:               # YYYY-MM-DD
birthday:

# --- provenance + segments ---
source: [apple-contacts]    # where this record came from
groups: []
tags: []
---

## Bio
One paragraph: who they are, why they matter to your goals.

## Ledger        <!-- reciprocity, made auditable: what you gave, what you received -->
| Date | Gave | Received | Note |
|------|------|----------|------|

## Log           <!-- David R.'s cards: log every interaction -->
- 2026-07-14 — met at [[Some Event]]; discussed X. I owe them Y.

## Follow-ups
- [ ] Send the report I promised  ⏳ 2026-08-01

🔗 Step 5: Cross-Reference, and Watch the Graph Draw Itself

Here is the move that makes this a network, not a list. Every person links out to the things that place them: their employer, their school, the event where you met, and the person who introduced you.

Three Ways to Connect the Cards

Links are what turn a pile of notes into a graph. There are three ways to make them, and you will use all three.

1. Through a shared entity. This is the tutorial’s whole trick, and it is what actually draws the network. Give each person a linked organization by making the property itself a link:

company: "[[Dartmouth College]]"

Anyone else whose note carries company: "[[CMU]]" now clusters with every other CMU contact. Create a CMU.md note and its Backlinks panel instantly lists everyone at CMU. Two people at the same org are connected through that org node in the graph, even though you never linked them to each other. The same move works for any shared entity, a school, a non-profit, or the event where you met. (Inside a property, typing [[CMU]] renders as a real link, the same as it does in the body.)

2. Person to person, directly. When someone introduces you to someone else, or you just want to link two people, record it in the body:

- 2026-07-14 — met [[Oliver Hahl]] at ASA, introduced by [[Linda Argote]]

Now both [[Oliver Hahl]] and [[Linda Argote]] show up in each other’s backlinks, and the connection is visible in the graph.

3. Unresolved links are fine. You do not need the target note to exist first. [[CMU]] typed before any CMU note exists simply shows as a faded node. Click it and Obsidian creates the note for you. The graph fills in as you go, so link freely and let the entities catch up.

Now open Graph view (the icon in the left ribbon). Filter to path:people. That is your network, drawn from your own data, with every node clickable and every cluster a place you can act.

A tight ball of nodes all linked to one [[Organization]]? That is a cluster. If it is your only cluster, that is a signal you may be over-concentrated in one world.
Two dense clusters with a single person connecting them? That person is a rare bridge between otherwise separate groups. Guard that tie.
A group your goals need, with no one in it yet? That is a gap. Create a placeholder note for the kind of person you want to meet, so the gap stays visible until you fill it.

This is why the organization, school, non-profit, and event notes matter. They are not filing categories. They are the affiliations that generate (and limit) your reach.

🤖 Step 6: Add AI (Judgment Stays With You)

AI sits on top of your vault as a helper. Because your notes are plain text, you can point Claude (or a local model through the plugins above) straight at them. Three jobs.

Weekly review. Point Claude at your people/ folder with a prompt like:

“Look through my people notes. Give me a short brief: five people I have not contacted in a while and should, anyone with a birthday coming up, and one specific, low-friction move for each.”

Enrichment. Paste a LinkedIn profile or an email signature:

“Draft a person note in my schema from this LinkedIn profile. Fill company, title, school, and city as wikilinks. Leave how_we_met blank for me to set. Do not invent anything not on the page.”

Meeting prep. Before a conversation:

“I am meeting [[Name]] tomorrow. From their note, give me: who they are in one line, when we last spoke, any open item in their Ledger, and one thing to offer or ask. Keep it to four lines.”

That meeting-prep move is precisely how your professor’s own system surfaces a person 45 minutes before every calendar event. You are copying a working pattern.

Tutorial created by Prof. Brandy Aven, PhD Carnegie Mellon University | Tepper School of Business Course: Managing Networks & Organizations