LinkedIn is a social network for professionals. The main goal of the site is to enable its members to connect with people they know and trust professionally, as well as to find new opportunities to grow their careers.

A LinkedIn member’s profile page, which emphasizes their skills, employment history, and education, has professional network news feeds with customizable modules.

LinkedIn is very similar to Facebook in terms of its layout and design. These features are more specialized because they cater to professionals, but in general, if you know how to use Facebook or any other similar social network, LinkedIn is somewhat comparable.

Features

We will focus on the following set of requirements while designing LinkedIn:

Each member should be able to add information about their basic profile, experiences, education, skills, and accomplishments.
Any user of our system should be able to search for other members or companies by their name.
Members should be able to send or accept connection requests from other members.
Any member will be able to request a recommendation from other members.
The system should be able to show basic stats about a profile, like the number of profile views, the total number of connections, and the total number of search appearances of the profile.
Members should be able to create new posts to share with their connections.
Members should be able to add comments to posts, as well as like or share a post or comment.
Any member should be able to send messages to other members.
The system should send a notification to a member whenever there is a new message, connection invitation or a comment on their post.
Members will be able to create a page for a Company and add job postings.
Members should be able to create groups and join any group they like.
Members should be able to follow other members or companies.

Rough Solution (LLD-Machine Coding)

// Enums representing various statuses in the system

public enum ConnectionInvitationStatus {
    PENDING,       // Invitation sent and waiting for response
    ACCEPTED,      // Invitation accepted but not yet confirmed
    CONFIRMED,     // Both parties confirmed the connection
    REJECTED,      // Invitation rejected by the recipient
    CANCELED,      // Invitation canceled by the sender
    EXPIRED        // Invitation expired due to no response in time
}

public enum AccountStatus {
    ACTIVE,        // Account is active
    BLOCKED,       // Account is blocked due to violations
    BANNED,        // Permanently banned
    COMPROMISED,   // Account security compromised
    ARCHIVED,      // Archived for inactivity
    CLOSED,        // Account closed by user or admin
    UNDER_REVIEW,  // Temporarily under review by admin
    UNKNOWN        // Unknown account status
}

public enum JobPostingStatus {
    OPEN,          // Job is open for applications
    CLOSED,        // Job closed for applications
    FILLED,        // Job has been filled
    CANCELED       // Job posting canceled before filling the position
}

public enum GroupStatus {
    ACTIVE,        // Group is active and accepting new members
    INACTIVE,      // Group is inactive
    ARCHIVED,      // Group is archived
    DELETED        // Group is deleted
}

public enum MessageStatus {
    SENT,          // Message has been sent
    DELIVERED,     // Message delivered to the recipient
    READ,          // Message read by the recipient
    FAILED,        // Sending message failed
    ARCHIVED,      // Message archived
    DELETED        // Message deleted by sender or recipient
}

public enum PostStatus {
    DRAFT,         // Post saved as draft
    PUBLISHED,     // Post published
    EDITED,        // Post edited after publishing
    DELETED        // Post deleted by author or admin
}

// Supporting classes

public class Address {
    private String streetAddress;
    private String city;
    private String state;
    private String zipCode;
    private String country;

    // Constructor and getters/setters omitted for brevity
}

public class Account {
    private String id;
    private String password;
    private AccountStatus status;
    private String name;
    private String email;

    public boolean resetPassword() {
        System.out.println("Password reset for account: " + id);
        return true;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    // Other methods and fields omitted for brevity
}

// Abstract Person class
public abstract class Person {
    private String name;
    private Address address;
    private String email;
    private String phone;
    private Account account;

    // Constructor and methods omitted for brevity
}

public class Member extends Person implements Observer {
    private Date dateOfMembership;
    private String headline;
    private byte[] photo;
    private List<Member> memberSuggestions;
    private List<Member> memberFollows;
    private List<Member> memberConnections;
    private List<Company> companyFollows;
    private List<Group> groupFollows;
    private Profile profile;

    public boolean sendMessage(Message message) {
        System.out.println("Message sent to: " + Arrays.toString(message.getSentTo()));
        return true;
    }

    public boolean createPost(Post post) {
        System.out.println("Post created by: " + profile.getSummary());
        return true;
    }

    public boolean sendConnectionInvitation(ConnectionInvitation invitation) {
        System.out.println("Connection invitation sent.");
        return true;
    }

    @Override
    public void update(String message) {
        System.out.println("Notification for " + getName() + ": " + message);
    }
}

public class Admin extends Person {
    public boolean blockUser(Member member) {
        System.out.println("User " + member.getName() + " blocked.");
        return true;
    }

    public boolean unblockUser(Member member) {
        System.out.println("User " + member.getName() + " unblocked.");
        return true;
    }
}

// Profile class representing a member's profile
public class Profile {
    private String summary;
    private List<Experience> experiences;
    private List<Education> educations;
    private List<Skill> skills;
    private List<Accomplishment> accomplishments;
    private List<Recommendation> recommendations;
    private List<Stat> stats;

    public boolean addExperience(Experience experience) {
        experiences.add(experience);
        System.out.println("Experience added.");
        return true;
    }

    // Other profile methods omitted for brevity

    public String getSummary() {
        return summary;
    }
}

public class Experience {
    private String title;
    private String company;
    private String location;
    private Date from;
    private Date to;
    private String description;

    // Constructor and methods omitted for brevity
}

public class Company {
    private String name;
    private String description;
    private String type;
    private int companySize;
    private List<JobPosting> activeJobPostings;

    // Constructor and methods omitted for brevity
}

public class JobPosting {
    private Date dateOfPosting;
    private String description;
    private String employmentType;
    private String location;
    private boolean isFulfilled;
    private JobPostingStatus status;

    // Constructor and methods omitted for brevity
}

public class Group {
    private String name;
    private String description;
    private int totalMembers;
    private List<Member> members;

    public boolean addMember(Member member) {
        members.add(member);
        System.out.println("Member added to group.");
        return true;
    }

    public boolean updateDescription(String description) {
        this.description = description;
        System.out.println("Group description updated.");
        return true;
    }
}

public class Post {
    private String text;
    private int totalLikes;
    private int totalShares;
    private Member owner;
    private PostStatus status;

    // Constructor and methods omitted for brevity
}

public class Message {
    private Member[] sentTo;
    private String messageBody;
    private byte[] media;

    public Member[] getSentTo() {
        return sentTo;
    }

    // Constructor and methods omitted for brevity
}

// Connection invitation class to handle connections between members
public class ConnectionInvitation {
    private Member from;
    private Member to;
    private ConnectionInvitationStatus status;

    public ConnectionInvitation(Member from, Member to) {
        this.from = from;
        this.to = to;
        this.status = ConnectionInvitationStatus.PENDING;
    }

    public boolean accept() {
        this.status = ConnectionInvitationStatus.ACCEPTED;
        System.out.println("Connection invitation accepted.");
        return true;
    }

    public boolean reject() {
        this.status = ConnectionInvitationStatus.REJECTED;
        System.out.println("Connection invitation rejected.");
        return true;
    }
}

// Observer pattern for notifications
interface Observer {
    void update(String message);
}

class SystemNotifier {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

// Search functionality for finding members, companies, and jobs
public interface Search {
    public List<Member> searchMember(String name);
    public List<Company> searchCompany(String name);
    public List<JobPosting> searchJob(String title);
}

public class SearchIndex implements Search {
    private HashMap<String, List<Member>> memberNames = new HashMap<>();
    private HashMap<String, List<Company>> companyNames = new HashMap<>();
    private HashMap<String, List<JobPosting>> jobTitles = new HashMap<>();

    public boolean addMember(Member member) {
        memberNames.putIfAbsent(member.getName(), new ArrayList<>());
        memberNames.get(member.getName()).add(member);
        return true;
    }

    public boolean addCompany(Company company) {
        companyNames.putIfAbsent(company.getName(), new ArrayList<>());
        companyNames.get(company.getName()).add(company);
        return true;
    }

    public boolean addJobPosting(JobPosting jobPosting) {
        jobTitles.putIfAbsent(jobPosting.getDescription(), new ArrayList<>());
        jobTitles.get(jobPosting.getDescription()).add(jobPosting);
        return true;
    }

    public List<Member> searchMember(String name) {
        return memberNames.getOrDefault(name, new ArrayList<>());
    }

    public List<Company> searchCompany(String name) {
        return companyNames.getOrDefault(name, new ArrayList<>());
    }

    public List<JobPosting> searchJob(String title) {
        return jobTitles.getOrDefault(title, new ArrayList<>());
    }
}

// Example Main Class to demonstrate the Observer pattern in use
public class Main {
    public static void main(String[] args) {
        // Create members
        Member alice = new Member();
        alice.setName("Alice");
        Member bob = new Member();
        bob.setName("Bob");

        // Add members to the notification system
        SystemNotifier notifier = new SystemNotifier();
        notifier.addObserver(alice);
        notifier.addObserver(bob);

        // Notify members of a new connection invitation
        notifier.notifyObservers("You have a new connection invitation!");

        // Create a connection invitation
        ConnectionInvitation invitation = new ConnectionInvitation(alice, bob);
        invitation.accept();

        // Search example
        SearchIndex searchIndex = new SearchIndex();
        searchIndex.addMember(alice);
        List<Member> foundMembers = searchIndex.searchMember("Alice");
        System.out.println("Found members: " + foundMembers.size());
    }
}

Drawbacks and Issues

💡 1️⃣ Enhanced Notification System with Observer Pattern

❌ Problem:

The current notification mechanism does not support asynchronous delivery, leading to latency issues.
Notifications are sent directly, which may slow down other critical operations.

✅ Solution: Will be covered in our course.

💡 2️⃣ Efficient Connection Request Handling

❌ Problem:

Directly storing connections as a list may lead to O(n) complexity for finding connections or sending requests.
Lack of a dedicated class to manage connections.

✅ Solution: Will be covered in our course.

💡 3️⃣ Message Handling Optimization

❌ Problem:

The current message handling is synchronous, which can block the UI and cause delays in message delivery.
There is no support for message batching or offline storage.

✅ Solution: Will be covered in our course.

💡 4️⃣ Group Management with Advanced Features

❌ Problem:

Groups are managed directly within the Member class, making it hard to scale and maintain.
No support for admin and moderator roles within groups.

✅ Solution: Will be covered in our course.

💡 5️⃣ Profile Stats Calculation Optimization

❌ Problem:

Calculating stats like profile views and connection count can be expensive and slow.
Stats are recalculated every time they are requested.

Design (LLD) LinkedIn - Machine Coding