System requirements


Functional:

  1. User Registration and Authentication:
  2. Users can create an account securely.
  3. Users can log in and log out.
  4. Password reset and account recovery mechanisms are supported.
  5. Posting Content:
  6. Users can submit text posts or links to various topics (subreddits).
  7. Support for formatting options like Markdown or Rich Text is provided.
  8. Voting System:
  9. Users can upvote or downvote content.
  10. Vote fuzzing is implemented to combat manipulation.
  11. Commenting and Discussion:
  12. Users can comment on posts and reply to other comments.
  13. Threaded discussions are supported to organize comments.
  14. Subreddit Management:
  15. Users can create new subreddits based on different topics.
  16. Moderators can manage content and users within their subreddit.
  17. User Profiles:
  18. Each user has a profile displaying their activity, posts, comments, and upvoted/downvoted content.
  19. Users can follow other users.
  20. Content Moderation:
  21. A system is in place to detect and remove spam, offensive content, and ensure content quality.
  22. Users can report inappropriate content.
  23. Recommendation Engine:
  24. Personalized content recommendations are provided based on user activity and preferences.
  25. Algorithms surface trending and popular content.
  26. Notifications:
  27. Users receive notifications for new comments, upvotes on their posts, and other relevant activities.
  28. Real-time notifications enhance user engagement.


Non-Functional:

  1. Scalability:
  2. The system should handle a large number of users, posts, and comments efficiently.
  3. Horizontal scaling should be supported to accommodate increasing load.
  4. Performance:
  5. Response times for user interactions such as posting, voting, and commenting should be minimal.
  6. The platform should be responsive even during peak usage times.
  7. Reliability:
  8. The system should be highly available and resilient to failures.
  9. Data integrity and consistency should be maintained at all times.
  10. Security:
  11. User data should be encrypted and protected against unauthorized access.
  12. Measures should be in place to prevent spam, hacking, and other security threats.
  13. Usability:
  14. The platform should have an intuitive user interface and be easy to navigate.
  15. Accessibility standards should be followed to ensure inclusivity.
  16. Maintainability:
  17. The codebase should be well-structured and documented to facilitate future updates and maintenance.
  18. Automated testing and deployment pipelines should be implemented to streamline development workflows.
  19. Compliance:
  20. The platform should comply with relevant data protection regulations such as GDPR.
  21. Content moderation policies should adhere to community guidelines and legal requirements.





Capacity estimation

Traffic Volume:

Let us assume the below numbers,


Total Users : 500 million

Daily Active Users (DAU): 50 million

Monthly Active Users (MAU): 330 million

Screen Views per Month: 21 billion

Visits in One Month: 1.6 billion

Total Subreddits: 2 million


Transaction Handling:

  1. Number of Transactions Per Second (TPS):
  2. Assuming a linear distribution of screen views and visits throughout the month, we can calculate the average TPS using the monthly values.
  3. Total Monthly TPS = Screen Views per Month + Visits in One Month
  4. Total Monthly TPS = 21 billion + 1.6 billion = 22.6 billion
  5. Average TPS = Total Monthly TPS / (30 days * 24 hours * 3600 seconds)
  6. Average TPS = 22.6 billion / (30 * 24 * 3600) ≈ 8,266 TPS
  7. Number of Write Requests Per Second for Posts:
  8. Given there are 2 million posts created in a day, we can calculate the number of new posts in a year.
  9. New Posts Per Year = 2 million * 365 days
  10. New Posts Per Year = 730 million
  11. Write Requests Per Second = New Posts Per Year / (365 days * 24 hours * 3600 seconds)
  12. Write Requests Per Second = 730 million / (365 * 24 * 3600) ≈ 23.14 TPS
  13. Number of Comment Requests Per Second:
  14. Assuming each post has an average of 25 comments, we can calculate the total comment requests per second.
  15. Total Comment Requests Per Second = New Posts Per Year * Average Comments Per Post / (365 days * 24 hours * 3600 seconds)
  16. Total Comment Requests Per Second = 730 million * 25 / (365 * 24 * 3600) ≈ 18.40 TPS

Storage Estimations (5 Years):

  1. User Data:
  2. Assuming user data includes basic profile information, authentication details, and activity logs.
  3. Let's estimate an average user data size of 1 MB.
  4. Total User Data Storage = Total Users * Average User Data Size
  5. Total User Data Storage = 500 million * 1 MB = 500 million MB
  6. Total User Data Storage = 500 TB
  7. Subreddit Metadata:
  8. Subreddit metadata includes information such as subreddit names, descriptions, and moderator lists.
  9. Assuming an average metadata size of 10 KB per subreddit.
  10. Total Subreddit Metadata Storage = Total Subreddits * Average Metadata Size
  11. Total Subreddit Metadata Storage = 2 million * 10 KB = 20 million KB
  12. Total Subreddit Metadata Storage = 20 GB
  13. Posts:
  14. Considering posts include text, links, and metadata, let's estimate an average post size of 100 KB.
  15. Assuming the number of new posts per year remains consistent.
  16. Total Post Storage Per Year = New Posts Per Year * Average Post Size
  17. Total Post Storage Per Year = 730 million * 100 KB = 73 PB
  18. Total Post Storage for 5 Years = Total Post Storage Per Year * 5
  19. Total Post Storage for 5 Years = 73 PB * 5 = 365 PB
  20. Comments:
  21. Similar to posts, let's estimate an average comment size of 10 KB.
  22. Total Comment Storage Per Year = New Posts Per Year * Average Comments Per Post * Average Comment Size
  23. Total Comment Storage Per Year = 730 million * 25 * 10 KB = 182.5 TB
  24. Total Comment Storage for 5 Years = Total Comment Storage Per Year * 5
  25. Total Comment Storage for 5 Years = 182.5 TB * 5 = 912.5 TB


These estimations provide a basis for understanding the storage requirements of the Reddit-like platform over a 5-year period, considering user data, subreddit metadata, posts, and comments.


API design


Below are the API which will be required in our design.


  1. User Management APIs:
  2. /register: Create a new user account.
  3. /login: Authenticate and log in a user.
  4. /logout: Log out the currently authenticated user.
  5. /user/profile: Retrieve user profile information.
  6. /user/update: Update user profile information.
  7. Post Management APIs:
  8. /post/create: Create a new post.
  9. /post/:postId: Retrieve details of a specific post.
  10. /post/:postId/update: Update an existing post.
  11. /post/:postId/delete: Delete a post.
  12. /post/:postId/upvote: Upvote a post.
  13. /post/:postId/downvote: Downvote a post.
  14. /post/:postId/comments: Retrieve comments for a post.
  15. /post/:postId/comments/create: Add a comment to a post.
  16. Subreddit Management APIs:
  17. /subreddit/create: Create a new subreddit.
  18. /subreddit/:subredditId: Retrieve details of a specific subreddit.
  19. /subreddit/:subredditId/update: Update subreddit details.
  20. /subreddit/:subredditId/delete: Delete a subreddit.
  21. /subreddit/:subredditId/posts: Retrieve posts within a subreddit.
  22. Comment Management APIs:
  23. /comment/:commentId: Retrieve details of a specific comment.
  24. /comment/:commentId/update: Update an existing comment.
  25. /comment/:commentId/delete: Delete a comment.
  26. /comment/:commentId/upvote: Upvote a comment.
  27. /comment/:commentId/downvote: Downvote a comment.
  28. Search and Discovery APIs:
  29. /search/posts: Search for posts by keyword or topic.
  30. /search/users: Search for users by username.
  31. /trending/posts: Retrieve trending posts based on upvote velocity.
  32. /recommended/posts: Get personalized content recommendations for a user.
  33. Moderation and Reporting APIs:
  34. /moderation/posts: Retrieve reported posts for moderation.
  35. /moderation/comments: Retrieve reported comments for moderation.
  36. /moderation/action: Take moderation actions on reported content.
  37. Notification APIs:
  38. /notifications: Retrieve notifications for the current user.
  39. /notifications/mark-read: Mark notifications as read.
  40. Miscellaneous APIs:
  41. /health: Check the health status of the system.
  42. /metrics: Retrieve system metrics for monitoring and analytics.


By defining these APIs, we provide a clear interface for interacting with different aspects of the Reddit-like platform, enabling developers to build various client applications and integrate with third-party services efficiently.



Database design


Below is the class diagram that shows different classes and some of the properties.


Database Choices:

  • User Data:
  • Entities: User
  • Database Type: SQL (e.g., PostgreSQL)
  • Reasoning: User data typically requires ACID compliance and structured querying capabilities. SQL databases provide strong consistency and transactional support, making them suitable for managing user authentication, profiles, and activity logs.
  • CAP Theorem Focus: Consistency and Partition Tolerance (CP)
  • Post and Comment Data:
  • Entities: Post, Comment
  • Database Type: NoSQL (e.g., MongoDB)
  • Reasoning: Post and comment data can be semi-structured, and NoSQL databases offer flexibility in schema design and scalability for handling high-volume, read-heavy workloads typical of social media platforms. Additionally, MongoDB's document-oriented structure suits nested comments and post metadata well.
  • CAP Theorem Focus: Availability and Partition Tolerance (AP)
  • Subreddit Data:
  • Entities: Subreddit
  • Database Type: SQL (e.g., MySQL)
  • Reasoning: While subreddit data could also be stored in a NoSQL database, SQL databases provide relational modeling capabilities that can facilitate complex queries and relationships between subreddits and their moderators. This is particularly useful for managing subreddit hierarchies and permissions.
  • CAP Theorem Focus: Consistency and Partition Tolerance (CP)


Partitioning Strategy:

  • Partitioning Data Efficiently:
  • For relational databases (e.g., PostgreSQL for user data), partitioning can be based on user IDs or timestamps to distribute data across multiple shards or partitions. This allows for horizontal scaling and improved query performance.
  • For NoSQL databases (e.g., MongoDB for posts and comments), data can be partitioned based on post IDs or subreddit IDs. This ensures that related data is stored together, reducing the need for joins and improving read/write throughput.
  • Key Columns for Partitioning:
  • For User data: Partitioning based on user IDs or email domains can evenly distribute users across partitions.
  • For Post and Comment data: Partitioning based on post IDs ensures that all comments associated with a post are stored together, enhancing query efficiency.
  • For Subreddit data: Partitioning based on subreddit IDs allows for efficient retrieval of posts within a subreddit.


Geographical Partitioning:

  • Geographical partitioning may not be necessary for the core functionality of the system, as Reddit-like platforms typically serve users globally without significant geographical restrictions.
  • However, if there are regulatory or compliance requirements that mandate data localization, geographical partitioning may be implemented at the infrastructure level using distributed data centers.


Scaling Strategy:

  • Horizontal Scaling:
  • Horizontal scaling is the preferred strategy for scaling the system to accommodate increased user activity and data volume.
  • Each component of the system (user data, posts, comments, subreddits) can be horizontally scaled by adding more instances or partitions to distribute the load.
  • Load balancers can distribute incoming requests across multiple instances or partitions, ensuring even workload distribution and improved system performance.
  • Scaling Storage:
  • Storage solutions such as cloud-based object storage (e.g., Amazon S3) can be used to store large media files associated with posts (e.g., images, videos) to offload storage requirements from the database.
  • Content Delivery Networks (CDNs) can be utilized to cache and serve static content (e.g., post thumbnails, CSS, JavaScript) to users globally, reducing latency and bandwidth usage.


By implementing these partitioning and scaling strategies, the system can efficiently handle increasing user activity and data volume while maintaining performance and reliability.



High-level design

  1. Client Applications (Web and Mobile):
  2. Responsible for providing user interfaces for interacting with the platform, allowing users to browse content, submit posts, comment, and interact with other users.
  3. Frontend Services:
  4. Authentication Service: Handles user authentication and authorization, ensuring secure access to the platform.
  5. Notification Service: Sends real-time notifications to users for activities such as new comments on their posts or replies to their comments.
  6. Backend Services:
  7. API Gateway: Acts as a single entry point for client applications to access backend services, managing requests and routing them to the appropriate service.
  8. User Service: Manages user accounts, profiles, authentication, and user-related operations.
  9. Post Service: Handles creation, retrieval, update, and deletion of posts, along with operations such as upvoting and downvoting.
  10. Comment Service: Manages comments associated with posts, including creation, retrieval, and moderation.
  11. Subreddit Service: Manages subreddits, including creation, retrieval, and moderation of subreddit-related content.
  12. Search Service: Enables users to search for posts, comments, and users based on keywords or criteria.
  13. Recommendation Service: Provides personalized content recommendations to users based on their activity and preferences.
  14. Moderation Service: Handles content moderation, including detecting and removing spam, offensive content, and enforcing community guidelines.
  15. Notification Service: Sends notifications to users for various activities, enhancing user engagement and interaction.
  16. Analytics Service: Collects and analyzes data on user interactions, content popularity, and platform usage to provide insights for optimization and decision-making.
  17. Infrastructure Components:
  18. Load Balancer: Distributes incoming traffic across multiple instances or servers to ensure optimal performance and availability.
  19. Caching Layer: Stores frequently accessed data to reduce database load and improve response times.
  20. CDN (Content Delivery Network): Delivers static content to users from edge servers located closer to their geographical locations, reducing latency and bandwidth usage.
  21. Database Clusters: Store and manage structured and unstructured data efficiently, providing scalability, reliability, and data integrity.
  22. Object Storage: Stores large media files associated with posts, such as images and videos, offloading storage requirements from the database.
  23. Messaging Queue: Facilitates asynchronous communication between different components of the system, ensuring reliable message delivery and decoupling services.
  24. Monitoring and Logging Tools: Monitor system health, performance, and security, providing insights for troubleshooting, optimization, and compliance.
  25. Security and Firewall Components: Protect the system from unauthorized access, malicious attacks, and data breaches, ensuring data confidentiality, integrity, and availability.





Request flows


  1. User Creates a New Post:
  2. The client application (web or mobile) sends a request to the API Gateway to create a new post.
  3. The API Gateway routes the request to the Post Service.
  4. The Post Service validates the request, creates a new post object, and saves it to the database.
  5. The Post Service triggers notifications to subscribers of the subreddit where the post was created.
  6. Moderator Reviews and Approves the Post:
  7. The moderator accesses the moderation dashboard in the client application.
  8. The client application sends a request to retrieve pending posts to the API Gateway.
  9. The API Gateway routes the request to the Moderation Service.
  10. The Moderation Service retrieves pending posts from the database and presents them to the moderator.
  11. The moderator reviews the post and decides to approve it.
  12. The client application sends a request to approve the post to the API Gateway.
  13. The API Gateway routes the request to the Moderation Service.
  14. The Moderation Service updates the status of the post in the database to "approved".





Detailed component design

Dig deeper into 2-3 components and explain in detail how they work. For example, how well does each component scale? Any relevant algorithm or data structure you like to use for a component? Also you could draw a diagram using the diagramming tool to enhance your design...








Trade offs/Tech choices

Explain any trade offs you have made and why you made certain tech choices...






Failure scenarios/bottlenecks

Try to discuss as many failure scenarios/bottlenecks as possible.






Future improvements

What are some future improvements you would make? How would you mitigate the failure scenario(s) you described above?