BOISE CODE CAMP 2026

Developer's Guide
to Networking

Modeling Human Connections with Database Associations

Rails · TypeORM · Sequelize · Prisma · JPA/Hibernate

@nerajno · developingdvlpr.com

"I'm bad
at networking."

Raise your hand if you've said this.

Most developers think networking is schmoozing.

It's not.

It's system design.

The Core Insight

Your network
is a schema.

Every person you know is a record.
Every relationship has a type.
The foreign key tells you who carries the responsibility.

Thank You to Our Sponsors

Boise Code Camp 2026 would not be possible without the support of our sponsors.
Please take a moment to connect with them and show them some love.

# Rails
class Post < ApplicationRecord
  belongs_to :user
  # user_id on posts table
end

# Sequelize
Post.belongsTo(User, {
  foreignKey: 'userId'
});

// TypeORM
@ManyToOne(() => User)
@JoinColumn()
author: User;

// Prisma
model Post {
  author   User
  authorId Int
  @relation(fields:[authorId],
            references:[id])
}

// JPA
@ManyToOne
@JoinColumn(name="user_id")
private User author;

# Rails
class User < ApplicationRecord
  has_one :profile
  # profile.user_id → users.id
end

# Sequelize
User.hasOne(Profile, {
  foreignKey: 'userId'
});

// TypeORM
@OneToOne(() => Profile)
profile: Profile;

// Prisma
model User {
  profile  Profile?
}

// JPA
@OneToOne(cascade = CascadeType.ALL)
@JoinColumn
private Profile profile;

# Rails
class User < ApplicationRecord
  has_many :posts
  has_many :mentees,
    class_name: "Developer"
end

# Sequelize
User.hasMany(Post, {
  foreignKey: 'userId'
});

// TypeORM
@OneToMany(() => Post, p => p.author)
posts: Post[];

// Prisma
model User {
  posts  Post[]
}

// JPA
@OneToMany(mappedBy = "author")
private List<Post> posts;

# Rails
class Doctor < ApplicationRecord
  has_many :appointments
  has_many :patients,
    through: :appointments
end

# Sequelize
Doctor.belongsToMany(Patient, {
  through: 'Appointment'
});

// TypeORM
@ManyToMany(() => Patient)
@JoinTable() // custom entity for data
patients: Patient[];

// Prisma (explicit join model)
model Appointment {
  doctor   Doctor
  patient  Patient
  at       DateTime
  @@id([doctorId, patientId])
}

// JPA
@ManyToMany
@JoinTable(name="appointments")
List<Patient> patients;

Where This Idea Comes From

Three Cups of Java

Vincent Mayers gave a talk at DevBCN 2023 that I keep coming back to.

"Communities affect our lives from an early age. It could be a church group, a book club, or a sports team. The fundamentals are the same worldwide, regardless of your involvement."

— Vincent Mayers (@vrm) · DevBCN 2023

His framing of community as a universal, cross-cultural pattern is the foundation of the habtm section you're about to see.

👉 mayers.io/blog/f/three-cups-of-java---devbcn-2023

The Big Takeaway

has_many :through
is the most
powerful pattern.

Because real career growth comes through existing relationships — not from scratch.

Warm introductions carry trust. Cold connections carry nothing.