Building a Laravel Package for Following, Followers & Friend System

A complete guide to designing and developing a reusable Laravel package for user connections.

Introduction

Social interaction is no longer limited to social networks. Modern SaaS platforms, marketplaces, community apps, learning portals, and enterprise systems often require user-to-user relationships such as following, followers and friend connections.

Instead of rewriting this logic repeatedly, building a reusable Laravel package allows developers to integrate connection-based features cleanly across projects.

Understanding the Relationship Models

Before writing code, we must clearly define the relationship logic. There are three common patterns:

1. Following System (One-Way)

In a following model, User A can follow User B without requiring approval. This is commonly used in content platforms and creator-based ecosystems.

2. Followers

Followers are simply the inverse of the following relationship. If A follows B, then B has A as a follower.

3. Friend System (Two-Way)

A friend relationship typically requires approval. User A sends a request, and User B accepts it. Only after acceptance does the relationship become mutual.

Database Design Strategy

A scalable design usually involves a pivot table to store user connections.

connections
-----------
id
sender_id
receiver_id
type (follow, friend)
status (pending, accepted, rejected)
created_at
updated_at

This unified structure allows flexibility while preventing schema duplication.
Indexing sender_id and receiver_id ensures high performance at scale.

Defining Eloquent Relationships

Laravel’s Eloquent ORM makes relationship modeling expressive and readable.

public function following()
{
    return $this->belongsToMany(User::class, 'connections', 
        'sender_id', 'receiver_id')
        ->wherePivot('type', 'follow');
}

Similar methods can be defined for followers and friends using pivot conditions.

Building It as a Laravel Package

To convert this feature into a reusable package:

• Create a Service Provider
• Publish migrations
• Expose traits for User models
• Provide configuration options
• Support API-ready responses

A trait such as HasConnections can be added to the User model to enable plug-and-play functionality.

Event-Driven Architecture

Trigger events when actions occur:

• UserFollowed
• FriendRequestSent
• FriendRequestAccepted

These events can be used for notifications, activity feeds, analytics, or recommendation engines.

Notifications & Real-Time Updates

Laravel’s notification system allows email, database, and broadcast notifications. When combined with WebSockets or Pusher, you can enable real-time updates for friend requests and followers.

API-Ready Design

A well-designed package should expose clean controller methods or service classes for:

• Follow user
• Unfollow user
• Send friend request
• Accept or reject friend request
• Get followers list
• Get mutual friends

Response transformation using API Resources ensures consistent JSON structures.

Scaling Considerations

As your platform grows, connection tables may expand rapidly.
Consider:

• Database indexing
• Caching follower counts
• Queue-based notifications
• Read replicas for large-scale systems

Architectural decisions made early can prevent performance bottlenecks later.

Security & Validation

Always validate:

• Users cannot follow themselves
• Duplicate relationships are prevented
• Authorization checks are enforced

Leveraging Laravel policies ensures clean access control.

Conclusion

A Laravel package for following, followers, and friend systems transforms social interaction into a modular and reusable component. By designing flexible database structures, leveraging Eloquent relationships, and embracing event-driven architecture, developers can create scalable, production-ready connection systems.

Whether you’re building a SaaS platform, a marketplace, or a community-driven application, user relationships can significantly increase engagement and retention.