8. Answer Ranking & Quality Scoring

Answer ranking is one of the most critical systems in a Q&A platform. Quora uses a sophisticated multi-factor ranking model that goes far beyond simple upvote counting.

8.1 Ranking Signals

8.2 Quality Score Formula (Simplified)

public class AnswerQualityScorer
{
    private const double AuthorExpertiseWeight = 0.20;
    private const double VoteScoreWeight = 0.30;
    private const double ContentQualityWeight = 0.15;
    private const double EngagementWeight = 0.15;
    private const double FreshnessWeight = 0.10;
    private const double PersonalizationWeight = 0.10;

    public double ComputeQualityScore(
        AnswerCandidate answer, UserContext viewer)
    {
        double authorScore = ComputeAuthorExpertise(answer.Author);
        double voteScore = ComputeVoteScore(
            answer.Upvotes, answer.Downvotes, answer.VoteVelocity);
        double contentScore = ComputeContentQuality(answer);
        double engagementScore = ComputeEngagementScore(answer);
        double freshnessScore = ComputeFreshnessScore(answer.CreatedAt);
        double personalScore = ComputePersonalizationScore(answer, viewer);

        double rawScore =
            AuthorExpertiseWeight * authorScore +
            VoteScoreWeight * voteScore +
            ContentQualityWeight * contentScore +
            EngagementWeight * engagementScore +
            FreshnessWeight * freshnessScore +
            PersonalizationWeight * personalScore;

        // Apply penalties
        if (answer.IsCollapsed) rawScore *= 0.1;
        if (answer.Downvotes > answer.Upvotes * 0.3) rawScore *= 0.3;
        if (answer.Author.IsBanned) rawScore *= 0.01;

        return Math.Max(0.001, rawScore);
    }

    private double ComputeVoteScore(
        int upvotes, int downvotes, double velocity)
    {
        // Wilson score interval for lower bound confidence
        int n = upvotes + downvotes;
        if (n == 0) return 0.01;
        double p = (double)upvotes / n;
        double z = 1.96; // 95% confidence
        double score = (p + z * z / (2 * n)
            - z * Math.Sqrt(
                (p * (1 - p) + z * z / (4 * n)) / n))
            / (1 + z * z / n);

        // Velocity boost: trending answers get a temporary boost
        double velocityBoost = Math.Min(2.0, 1.0 + velocity * 0.1);
        return Math.Max(0.001, score * velocityBoost);
    }

    private double ComputeContentQuality(AnswerCandidate answer)
    {
        double score = 0.5;
        int wordCount = answer.Content
            .Split(' ').Length;
        if (wordCount >= 100 && wordCount <= 1500)
            score += 0.2;
        else if (wordCount > 1500 && wordCount <= 3000)
            score += 0.15;
        else if (wordCount < 50)
            score -= 0.2;

        if (answer.HasCodeBlocks) score += 0.05;
        if (answer.HasImages) score += 0.05;
        if (answer.HasHeaders) score += 0.03;
        if (answer.HasLinks) score += 0.05;

        double readability = ComputeReadability(answer.Content);
        score += readability > 60 ? 0.1
            : readability > 40 ? 0.05 : -0.05;

        return Math.Clamp(score, 0, 1);
    }
}

8.3 Answer Collapse Logic

The Wilson score interval is crucial here — it provides a statistically rigorous way to rank answers even when vote counts are low. An answer with 5 upvotes and 0 downvotes can rank higher than one with 100 upvotes and 30 downvotes, because the confidence in the first answer's quality is higher.

9. Feed Generation System

The feed system is responsible for the most visible part of Quora — what users see when they open the app. It must balance relevance, freshness, diversity, and monetization across billions of daily impressions.

9.1 Feed Pipeline Details

Stage 1 — Candidate Retrieval: Retrieve ~10,000 candidate items from multiple sources in parallel: questions answered by people you follow (push-based, pre-computed), questions in topics you follow with new high-quality answers, trending questions with velocity signals, content from your interest graph, and promoted content (ads, Quora+ previews).

Stage 2 — Pre-Ranking: Lightweight model (logistic regression) scores each candidate in ~1ms per item. Uses basic features: author relationship strength, topic relevance, vote counts, age. Filters to ~1,000 items.

Stage 3 — Fine Ranking: Full ML model (gradient-boosted trees + neural features) scores each remaining candidate using 200+ features. Takes ~5ms per item.

Stage 4 — Blending & Diversity: Apply diversity constraints — no more than 3 consecutive items from the same topic, mix of question types, inject discovery items from outside normal interests (15% of feed).

Stage 5 — Post-Processing: Inject ads at natural break points (every 7-10 organic items). Deduplicate against recently-seen items. Apply content policy filters.

9.2 Feed Storage (ScyllaDB)

The home feed is pre-computed and stored in ScyllaDB every 15 minutes for active users. For less active users, the feed is computed on-demand at read time with a simpler model.

10. Notification System

10.1 Notification Types & Priority

10.2 Notification Batching

• Batch window: Low-priority notifications batched into digest groups every 4-6 hours
• Frequency cap: No more than 10 push notifications per user per day, 3 per hour
• Quiet hours: Respect user timezone-based quiet hours (default: 10 PM - 8 AM local)
• Smart grouping: 12 people upvoted your answer instead of 12 individual notifications
• Relevance gating: Only notify about answers from authors with credibility score > 0.5

11. Topic Graph & Follow System

Quora's topic system is a rich knowledge graph with millions of topics organized hierarchically and connected through semantic relationships.

11.1 Topic Relationship Types

11.2 Credential System

When a user writes multiple well-received answers in a topic (e.g., 5+ answers with >50 upvotes each), they automatically earn a topic credential like Expert in System Design. This credential is displayed next to their name and boosts their answer ranking weight in that topic.

12. Search System

12.1 Query Understanding Pipeline

• Query Rewriting: Expand abbreviations (DS -> distributed systems), fix typos, expand synonyms
• Intent Classification: Determine if user wants a specific answer, topic exploration, or user lookup
• Entity Extraction: Identify mentioned topics, people, companies in the query
• Semantic Embedding: Generate embedding for hybrid keyword + vector retrieval

12.2 Search Ranking Features

13. Upvote/Downvote & Credential System

13.1 Vote Processing Pipeline

13.2 Credential System

14. Spaces & Communities

Spaces are Quora's answer to subreddits — community-driven spaces where users collaborate around specific topics. Each Space has its own feed, moderation rules, and member hierarchy.

14.1 Space Data Model

public class Space
{
    public long Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string Slug { get; set; } = string.Empty;
    public string Description { get; set; } = string.Empty;
    public long OwnerId { get; set; }
    public SpaceVisibility Visibility { get; set; }
    public int MembersCount { get; set; }
    public int PostsCount { get; set; }
    public SpaceSettings Settings { get; set; } = new();
    public DateTime CreatedAt { get; set; }
}

public class SpaceSettings
{
    public bool RequireApprovalToPost { get; set; } = true;
    public bool RequireApprovalToJoin { get; set; } = false;
    public int MaxModerators { get; set; } = 20;
    public List<string> BannedTopics { get; set; } = new();
    public ContentPolicy CustomPolicy { get; set; }
        = ContentPolicy.Standard;
    public bool AllowRevenueSharing { get; set; } = false;
    public string? CustomCssTheme { get; set; }
}

public enum SpaceVisibility
{
    Public,
    Restricted,
    Private
}

15. AI-Powered Suggestions (Quora+ & Poe)

Quora's AI integration operates at two levels: content assistance (helping writers create better answers) and AI-native Q&A (Poe — direct AI chatbot interactions).

15.1 AI Answer Assistance Pipeline

15.2 Poe Integration Architecture

public class PoeIntegrationService
{
    private readonly IModelRouter _modelRouter;
    private readonly IRateLimiter _rateLimiter;
    private readonly IUsageTracker _usageTracker;
    private readonly IKafkaProducer _kafkaProducer;

    public async Task<PoeResponse> ProcessQuery(
        PoeRequest request, UserProfile user)
    {
        var tier = user.SubscriptionTier;
        var limits = tier switch
        {
            SubscriptionTier.Free => new RateLimit(
                10, TimeSpan.FromHours(1)),
            SubscriptionTier.Plus => new RateLimit(
                300, TimeSpan.FromHours(1)),
            SubscriptionTier.Premium => new RateLimit(
                1000, TimeSpan.FromHours(1)),
            _ => throw new ArgumentException("Unknown tier")
        };

        if (!await _rateLimiter.AllowAsync(user.Id, limits))
        {
            return PoeResponse.RateLimited(
                "Query limit reached. Upgrade to Poe+.");
        }

        var modelSelection = _modelRouter.SelectModel(
            query: request.Query,
            preferredModel: user.PreferredModel,
            complexity: await _modelRouter
                .EstimateComplexity(request.Query),
            tier: tier
        );

        var ragContext = await BuildRagContext(
            request.Query, modelSelection.MaxContextTokens);

        var responseBuilder = new StringBuilder();
        var streamingResponse = _modelRouter.StreamCompletion(
            model: modelSelection.ModelId,
            systemPrompt: BuildSystemPrompt(ragContext),
            userMessage: request.Query,
            maxTokens: modelSelection.MaxTokens
        );

        await foreach (var chunk in streamingResponse)
        {
            responseBuilder.Append(chunk.Content);
            await request.ResponseWriter.WriteAsync(chunk);
        }

        await _usageTracker.RecordAsync(new UsageRecord
        {
            UserId = user.Id,
            ModelId = modelSelection.ModelId,
            InputTokens = ragContext.TokenCount
                + EstimateTokens(request.Query),
            OutputTokens = EstimateTokens(
                responseBuilder.ToString()),
            Timestamp = DateTime.UtcNow
        });

        return PoeResponse.Success(
            responseBuilder.ToString(),
            modelSelection.ModelId);
    }

    private string BuildSystemPrompt(RagContext context)
    {
        return $@"You are a helpful assistant powered by Poe.
Use the following context from Quora's knowledge base:
{context.RelevantAnswers}
Be accurate, cite sources, and format clearly.";
    }
}

15.3 AI Model Selection Matrix

16. Content Moderation & Policies

At 400M monthly users, content moderation is a critical operational challenge. Quora employs a multi-layered approach combining automated ML moderation, human review, and community-driven flagging.

16.1 Moderation Categories

17. Analytics for Creators

Creator analytics is essential for retention — writers who understand their audience produce more content.

public class CreatorAnalyticsService
{
    private readonly ClickHouseContext _clickhouse;
    private readonly RedisCache _cache;

    public async Task<CreatorDashboard> GetDashboardAsync(
        long userId, DateTimeRange range)
    {
        var cacheKey =
            $"creator:dash:{userId}:{range.GetHashCode()}";
        var cached = await _cache
            .GetAsync<CreatorDashboard>(cacheKey);
        if (cached != null) return cached;

        var dashboard = new CreatorDashboard
        {
            Overview = await GetOverviewMetrics(userId, range),
            ContentPerformance =
                await GetContentPerformance(userId, range),
            AudienceInsights =
                await GetAudienceInsights(userId, range),
            FollowerGrowth =
                await GetFollowerGrowth(userId, range),
            TopContent =
                await GetTopContent(userId, range, limit: 10),
            TopicBreakdown =
                await GetTopicBreakdown(userId, range),
            EngagementTimeline =
                await GetEngagementTimeline(userId, range),
            EarningsSummary =
                await GetEarningsSummary(userId, range)
        };

        await _cache.SetAsync(cacheKey, dashboard,
            TimeSpan.FromMinutes(15));
        return dashboard;
    }

    private async Task<OverviewMetrics> GetOverviewMetrics(
        long userId, DateTimeRange range)
    {
        return await _clickhouse.QueryAsync<OverviewMetrics>($@"
            SELECT
                countIf(event_type = 'view') as total_views,
                countIf(event_type = 'upvote') as total_upvotes,
                countIf(event_type = 'comment') as total_comments,
                countIf(event_type = 'share') as total_shares,
                uniqExact(user_id) as unique_viewers,
                avg(duration_seconds) as avg_read_time
            FROM creator_events
            WHERE author_id = {userId}
              AND event_time >= '{range.Start:yyyy-MM-dd}'
              AND event_time < '{range.End:yyyy-MM-dd}'
        ");
    }
}

17.1 Available Metrics

18. Advertising Platform

18.1 Ad Targeting Parameters

19. Database Sharding Strategy

19.1 Shard Key Selection

19.2 Cross-Shard Query Handling

1. Materialized Views: Question-centric views pre-computed and stored in a separate shard
2. Scatter-Gather: Fan out to all shards and merge (used sparingly due to latency)
3. Denormalized Reads: Answer data denormalized into question shard for read-heavy access

public class ShardRouter
{
    private const int ShardCount = 16;
    private readonly Dictionary<int, DatabaseConnection>
        _shardConnections;

    public ShardRouter(IConfiguration config)
    {
        _shardConnections =
            new Dictionary<int, DatabaseConnection>();
        for (int i = 0; i < ShardCount; i++)
        {
            var connString = config[
                $"Shards:Shard_{i}:ConnectionString"];
            _shardConnections[i] =
                new DatabaseConnection(connString!);
        }
    }

    public int GetShardId(long entityId)
    {
        return (int)(entityId % ShardCount);
    }

    public DatabaseConnection GetShard(long entityId)
    {
        var shardId = GetShardId(entityId);
        return _shardConnections[shardId];
    }

    public async Task<T> ExecuteOnShard<T>(
        long shardKey,
        Func<DatabaseConnection, Task<T>> operation)
    {
        var shard = GetShard(shardKey);
        return await operation(shard);
    }

    public async Task<List<T>> ScatterGather<T>(
        Func<DatabaseConnection, Task<List<T>>> operation)
    {
        var tasks = _shardConnections.Values
            .Select(connection => operation(connection))
            .ToList();
        var results = await Task.WhenAll(tasks);
        return results
            .SelectMany(r => r).ToList();
    }

    public async Task<Dictionary<long, T>>
        ExecuteOnSpecificShards<T>(
            IEnumerable<long> shardKeys,
            Func<DatabaseConnection, IEnumerable<long>,
                Task<Dictionary<long, T>>> operation)
    {
        var grouped = shardKeys
            .GroupBy(GetShardId)
            .ToDictionary(
                g => g.Key, g => g.ToList());
        var tasks = grouped.Select(async kvp =>
        {
            var shard = _shardConnections[kvp.Key];
            return await operation(shard, kvp.Value);
        });
        var results = await Task.WhenAll(tasks);
        return results
            .SelectMany(r => r)
            .ToDictionary(
                r => r.Key, r => r.Value);
    }
}

20. Caching Strategy

20.1 Cache Hierarchy

20.2 Cache Invalidation Service

public class CacheInvalidationService
{
    private readonly RedisCluster _redis;
    private readonly IEventBus _eventBus;

    public CacheInvalidationService(
        RedisCluster redis, IEventBus eventBus)
    {
        _redis = redis;
        _eventBus = eventBus;
        _eventBus.Subscribe<QuestionUpdated>(
            OnQuestionUpdated);
        _eventBus.Subscribe<AnswerCreated>(
            OnAnswerCreated);
        _eventBus.Subscribe<VoteChanged>(
            OnVoteChanged);
        _eventBus.Subscribe<AnswerCollapsed>(
            OnAnswerCollapsed);
    }

    private async Task OnQuestionUpdated(
        QuestionUpdated evt)
    {
        await _redis.RemoveAsync(
            $"question:{evt.QuestionId}");
        await _redis.RemoveAsync(
            $"cdn:question:{evt.QuestionId}:html");
        await _redis.RemoveAsync(
            $"question:{evt.QuestionId}:answers");

        var fresh = await _repository
            .GetQuestionAsync(evt.QuestionId);
        await _redis.SetAsync(
            $"question:{evt.QuestionId}",
            fresh,
            TimeSpan.FromMinutes(30));
    }

    private async Task OnAnswerCreated(
        AnswerCreated evt)
    {
        await _redis.RemoveAsync(
            $"question:{evt.QuestionId}:answers");
        await _redis.RemoveAsync(
            $"user:{evt.AuthorId}:answers");

        var cached = await _redis.GetAsync
            <QuestionCache>(
                $"question:{evt.QuestionId}");
        if (cached != null)
        {
            cached.AnswerCount++;
            await _redis.SetAsync(
                $"question:{evt.QuestionId}",
                cached,
                TimeSpan.FromMinutes(30));
        }
    }

    private async Task OnVoteChanged(VoteChanged evt)
    {
        await _redis.RemoveAsync(
            $"vote:{evt.ViewerId}:{evt.TargetId}");
        await _redis.RemoveAsync(
            $"answer:{evt.AnswerId}");
        await _redis.StringIncrementAsync(
            $"counter:answer:{evt.AnswerId}:{evt.NewVoteType}",
            flags: CommandFlags.FireAndForget);
    }
}

20.3 Cache Stampede Prevention

• Request Coalescing: Distributed locks (Redis SETNX with TTL) ensure only one instance computes the cache value
• Stale-While-Revalidate: Serve stale cache while computing fresh data in background
• Jittered TTLs: Random +/-10% jitter to TTLs prevents synchronized expiration
• Probabilistic Early Expiration: Small probability of refreshing before TTL expires (PEpoch)

21. Multi-Region Design

21.1 Data Replication Strategy

21.2 Conflict Resolution

• Last-Writer-Wins (LWW) for vote toggling — most recent write wins based on synchronized timestamps
• CRDTs for counter operations — G-Counters for upvote/downvote counts merge correctly across regions
• Conflict log — all conflicts logged for manual review and system improvement

22. Cost Estimation

22.1 Cost Optimization Strategies

• Reserved Instances: 70% of compute on 1-year reserved instances saves ~30%
• Spot Instances: ML training and batch processing on spot saves ~60%
• Graviton Processors: ARM-based instances for application tier saves ~20%
• Intelligent Tiering: S3 intelligent tiering for infrequently accessed media
• AI Model Distillation: Smaller distilled models for non-critical AI features

22.2 Detailed Cost Breakdown by Category

AI Inference Cost Analysis ($2.5M/month)

AI inference dominates the budget, so understanding its internal breakdown is critical. With approximately 2M daily Poe queries (free tier: 70%, Plus: 20%, Premium: 10%) and varying model complexity, the token consumption follows a heavy-tailed distribution:

Note: Self-hosted Llama models on GPU instances ($81K) are significantly cheaper than API-based models, but require dedicated ML infrastructure for fine-tuning and serving. The remaining ~$856K gap from the $2.5M total covers GPU training costs, fine-tuning pipelines, A/B testing infrastructure, and model evaluation compute.

Personnel & Operational Costs

Infrastructure costs alone don't tell the full story. A platform of this scale requires a significant engineering and operations team:

Per-User Economics

Regional Cost Variations

Not all infrastructure costs are equal across regions. US-East typically serves as the primary write region and carries the highest compute costs, while read-heavy secondary regions benefit from reserved pricing and lower-tier instance types:

CDN costs are distributed globally with edge PoPs in 40+ cities. Object storage follows a similar pattern with S3-compatible storage replicated across regions for durability, though infrequently accessed media is automatically tiered to cheaper storage classes after 90 days.

3-Year Cost Projection

Assuming 30% annual user growth and corresponding infrastructure scaling:

AI/LLM costs grow faster than user count because usage intensity increases as features improve and user trust grows. Infrastructure costs benefit from economies of scale (bulk reserved pricing, improved utilization), growing roughly 1.2x per user growth point.

23. Interview Q&A

24. Full C# Implementation

Below is a complete, production-ready C# implementation of the core Q&A platform services.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

namespace QuoraPlatform.Core.Models
{
    public enum VoteType { None = 0, Up = 1, Down = -1 }
    public enum ContentType
    {
        Question = 1, Answer = 2, Comment = 3
    }
    public enum AccountStatus
    {
        Active, Suspended, Deleted,
        PendingVerification
    }
    public enum NotificationType
    {
        AnswerRequest, NewAnswer, VoteMilestone,
        NewFollower, Mention, AnswerCollapse,
        CredentialAward, SpaceActivity
    }
    public enum SpaceVisibility
    {
        Public, Restricted, Private
    }
    public enum SubscriptionTier
    {
        Free, Plus, Premium
    }

    public class User
    {
        public long Id { get; set; }
        public string Username { get; set; }
            = string.Empty;
        public string Email { get; set; }
            = string.Empty;
        public string DisplayName { get; set; }
            = string.Empty;
        public string? Bio { get; set; }
        public string? ProfileImageUrl { get; set; }
        public int FollowersCount { get; set; }
        public int FollowingCount { get; set; }
        public int TotalUpvotes { get; set; }
        public int AnswersCount { get; set; }
        public int QuestionsCount { get; set; }
        public AccountStatus Status { get; set; }
            = AccountStatus.Active;
        public SubscriptionTier Subscription { get; set; }
            = SubscriptionTier.Free;
        public DateTime CreatedAt { get; set; }
            = DateTime.UtcNow;
        public DateTime LastActiveAt { get; set; }
            = DateTime.UtcNow;
        public double TrustScore { get; set; } = 0.5;
    }

    public class Question
    {
        public long Id { get; set; }
        public long AuthorId { get; set; }
        public string Title { get; set; }
            = string.Empty;
        public string? Details { get; set; }
        public int FollowerCount { get; set; }
        public int AnswerCount { get; set; }
        public int ViewCount { get; set; }
        public List<long> TopicIds { get; set; }
            = new();
        public DateTime CreatedAt { get; set; }
            = DateTime.UtcNow;
        public DateTime UpdatedAt { get; set; }
            = DateTime.UtcNow;
        public bool IsDeleted { get; set; }
        public string TitleHash { get; set; }
            = string.Empty;

        public string ComputeTitleHash()
        {
            var normalized = Title.Trim()
                .ToLowerInvariant();
            var bytes = Encoding.UTF8
                .GetBytes(normalized);
            var hash = SHA256.HashData(bytes);
            return Convert.ToHexString(hash);
        }
    }

    public class Answer
    {
        public long Id { get; set; }
        public long QuestionId { get; set; }
        public long AuthorId { get; set; }
        public string Content { get; set; }
            = string.Empty;
        public int Upvotes { get; set; }
        public int Downvotes { get; set; }
        public int CommentsCount { get; set; }
        public bool IsCollapsed { get; set; }
        public bool IsAiGenerated { get; set; }
        public DateTime CreatedAt { get; set; }
            = DateTime.UtcNow;
        public DateTime UpdatedAt { get; set; }
            = DateTime.UtcNow;
        public bool IsDeleted { get; set; }

        public double NetScore =>
            Upvotes - Downvotes;
        public double VoteRatio =>
            (Upvotes + Downvotes) == 0
                ? 0
                : (double)Upvotes
                    / (Upvotes + Downvotes);
    }

    public class Vote
    {
        public long Id { get; set; }
        public long UserId { get; set; }
        public long TargetId { get; set; }
        public ContentType TargetType { get; set; }
        public VoteType VoteType { get; set; }
        public DateTime CreatedAt { get; set; }
            = DateTime.UtcNow;
        public DateTime? UpdatedAt { get; set; }
    }

    public class Topic
    {
        public long Id { get; set; }
        public string Name { get; set; }
            = string.Empty;
        public string Slug { get; set; }
            = string.Empty;
        public string? Description { get; set; }
        public long? ParentTopicId { get; set; }
        public int FollowersCount { get; set; }
        public int QuestionCount { get; set; }
    }

    public class Credential
    {
        public long Id { get; set; }
        public long UserId { get; set; }
        public string DisplayText { get; set; }
            = string.Empty;
        public string? OrganizationName { get; set; }
        public long? TopicId { get; set; }
        public double TrustScore { get; set; }
        public bool IsVerified { get; set; }
        public DateTime VerifiedAt { get; set; }
    }

    public class Space
    {
        public long Id { get; set; }
        public string Name { get; set; }
            = string.Empty;
        public string Slug { get; set; }
            = string.Empty;
        public string Description { get; set; }
            = string.Empty;
        public long OwnerId { get; set; }
        public SpaceVisibility Visibility { get; set; }
        public int MembersCount { get; set; }
        public int PostsCount { get; set; }
        public bool RequireApprovalToPost { get; set; }
            = true;
        public DateTime CreatedAt { get; set; }
            = DateTime.UtcNow;
    }

    public class Notification
    {
        public long Id { get; set; }
        public long UserId { get; set; }
        public NotificationType Type { get; set; }
        public long SourceId { get; set; }
        public ContentType SourceType { get; set; }
        public string Content { get; set; }
            = string.Empty;
        public bool IsRead { get; set; }
        public DateTime CreatedAt { get; set; }
            = DateTime.UtcNow;
    }

    public class FeedItem
    {
        public string Id { get; set; }
            = string.Empty;
        public ContentType ContentType { get; set; }
        public long ContentId { get; set; }
        public long AuthorId { get; set; }
        public double RelevanceScore { get; set; }
        public string Reason { get; set; }
            = string.Empty;
        public DateTime CreatedAt { get; set; }
    }

    public record PoeRequest(
        string Query, string? PreferredModel);
    public record PoeResponse(
        bool Success, string Content,
        string ModelUsed, string? Error = null);
}

namespace QuoraPlatform.Core.Services
{
    using QuoraPlatform.Core.Models;
    using Microsoft.Extensions.Logging;

    public interface IVoteRepository
    {
        Task<Vote?> GetVoteAsync(
            long userId, long targetId,
            ContentType targetType);
        Task<Vote> CreateVoteAsync(Vote vote);
        Task<Vote> UpdateVoteAsync(Vote vote);
        Task<int[]> GetVoteCountsAsync(
            long targetId, ContentType targetType);
    }

    public interface IQuestionRepository
    {
        Task<Question?> GetByIdAsync(long id);
        Task<Question> CreateAsync(Question question);
        Task<bool> ExistsByTitleHashAsync(
            string titleHash);
        Task<List<Question>>
            GetSimilarQuestionsAsync(
                string title, int limit = 5);
        Task<List<Question>> GetByTopicAsync(
            long topicId, int offset, int limit);
        Task<List<Question>> GetByAuthorAsync(
            long authorId, int offset, int limit);
        Task<int> GetAnswerCountAsync(long questionId);
    }

    public interface IAnswerRepository
    {
        Task<Answer?> GetByIdAsync(long id);
        Task<Answer> CreateAsync(Answer answer);
        Task<List<Answer>> GetByQuestionAsync(
            long questionId, int offset, int limit);
        Task<List<Answer>> GetByAuthorAsync(
            long authorId, int offset, int limit);
        Task<int> GetUpvoteCountAsync(long answerId);
    }

    public interface IUserRepository
    {
        Task<User?> GetByIdAsync(long id);
        Task<List<User>> GetFollowersAsync(
            long userId, int offset, int limit);
        Task<bool> IsFollowingAsync(
            long followerId, long followeeId);
    }

    public interface ICacheService
    {
        Task<T?> GetAsync<T>(string key);
        Task SetAsync<T>(
            string key, T value,
            TimeSpan? expiry = null);
        Task RemoveAsync(string key);
        Task<long> IncrementAsync(string key);
        Task<bool> SetAddAsync(
            string key, string value);
        Task<bool> SetContainsAsync(
            string key, string value);
        Task<double> SortedSetIncrementAsync(
            string key, string member, double value);
    }

    public interface IEventBus
    {
        Task PublishAsync<T>(
            string topic, T eventData);
        void Subscribe<T>(
            string topic,
            Func<T, Task> handler);
    }

    public interface INotificationService
    {
        Task SendNotificationAsync(
            long userId,
            NotificationType type,
            long sourceId,
            ContentType sourceType,
            string content);
        Task<int> GetUnreadCountAsync(long userId);
    }

    public interface ISearchService
    {
        Task<List<SearchResult>> SearchAsync(
            string query, string? language,
            int offset, int limit);
        Task IndexQuestionAsync(Question question);
        Task IndexAnswerAsync(Answer answer);
        Task RemoveFromIndexAsync(
            long id, ContentType type);
    }

    public record SearchResult(
        long Id, ContentType Type,
        string Title, string Preview,
        double Score, string? AuthorName);

    public class ContentQualityScorer
    {
        private const double AuthorW = 0.20;
        private const double VoteW = 0.30;
        private const double ContentW = 0.15;
        private const double EngageW = 0.15;
        private const double FreshW = 0.10;
        private const double PersonalW = 0.10;

        public double ComputeQualityScore(
            Answer answer, User author,
            Dictionary<string, double> signals,
            double personalScore = 0.5)
        {
            double aScore =
                ComputeAuthorExpertise(author);
            double vScore =
                ComputeVoteScore(answer);
            double cScore =
                ComputeContentQuality(answer);
            double eScore =
                ComputeEngagementScore(signals);
            double fScore =
                ComputeFreshnessScore(
                    answer.CreatedAt);

            double raw =
                AuthorW * aScore +
                VoteW * vScore +
                ContentW * cScore +
                EngageW * eScore +
                FreshW * fScore +
                PersonalW * personalScore;

            if (answer.IsCollapsed) raw *= 0.1;
            if (answer.Downvotes
                > answer.Upvotes * 0.3)
                raw *= 0.3;
            if (author.Status
                == AccountStatus.Suspended)
                raw *= 0.01;

            return Math.Max(0.001, raw);
        }

        private double ComputeAuthorExpertise(
            User author)
        {
            double score = 0.3;
            score += Math.Min(0.3,
                author.TotalUpvotes
                    / 10000.0 * 0.3);
            score += Math.Min(0.2,
                author.AnswersCount
                    / 500.0 * 0.2);
            score += author.TrustScore * 0.2;
            return Math.Clamp(score, 0, 1);
        }

        private double ComputeVoteScore(Answer answer)
        {
            int n = answer.Upvotes
                + answer.Downvotes;
            if (n == 0) return 0.01;
            double p = (double)answer.Upvotes / n;
            double z = 1.96;
            double denom = 1 + z * z / n;
            double center = p + z * z / (2 * n);
            double spread = z * Math.Sqrt(
                (p * (1 - p) + z * z / (4 * n))
                / n);
            return Math.Max(0.001,
                (center - spread) / denom);
        }

        private double ComputeContentQuality(
            Answer answer)
        {
            double score = 0.5;
            int wc = answer.Content.Split(
                ' ',
                StringSplitOptions.RemoveEmptyEntries
            ).Length;
            if (wc >= 100 && wc <= 1500)
                score += 0.2;
            else if (wc > 1500 && wc <= 3000)
                score += 0.15;
            else if (wc < 50)
                score -= 0.2;
            if (answer.Content.Contains("```"))
                score += 0.05;
            if (answer.Content.Contains("![image"))
                score += 0.05;
            if (answer.Content.Contains("## "))
                score += 0.03;
            if (answer.Content.Contains("http"))
                score += 0.05;
            if (answer.IsAiGenerated)
                score -= 0.1;
            return Math.Clamp(score, 0, 1);
        }

        private double ComputeEngagementScore(
            Dictionary<string, double> s)
        {
            double score = 0;
            if (s.TryGetValue("comments", out double c))
                score += Math.Min(0.3, c / 50.0 * 0.3);
            if (s.TryGetValue("shares", out double sh))
                score += Math.Min(0.2, sh / 100.0 * 0.2);
            if (s.TryGetValue("avgReadTime", out double rt))
                score += Math.Min(0.3, rt / 300.0 * 0.3);
            if (s.TryGetValue("bookmarks", out double b))
                score += Math.Min(0.2, b / 200.0 * 0.2);
            return Math.Clamp(score, 0, 1);
        }

        private double ComputeFreshnessScore(
            DateTime createdAt)
        {
            double hrs =
                (DateTime.UtcNow - createdAt)
                    .TotalHours;
            return Math.Max(0.01,
                1.0 / (1.0 + hrs / 168.0));
        }
    }

    public class VoteService
    {
        private readonly IVoteRepository _votes;
        private readonly ICacheService _cache;
        private readonly IEventBus _eventBus;
        private readonly IQuestionRepository _questions;
        private readonly IAnswerRepository _answers;
        private readonly ILogger<VoteService> _logger;

        public VoteService(
            IVoteRepository votes,
            ICacheService cache,
            IEventBus eventBus,
            IQuestionRepository questions,
            IAnswerRepository answers,
            ILogger<VoteService> logger)
        {
            _votes = votes;
            _cache = cache;
            _eventBus = eventBus;
            _questions = questions;
            _answers = answers;
            _logger = logger;
        }

        public async Task<(VoteType newType,
            int newCount)> CastVoteAsync(
                long userId,
                long targetId,
                ContentType targetType,
                VoteType requestedType)
        {
            var existing = await _votes.GetVoteAsync(
                userId, targetId, targetType);

            if (existing != null
                && existing.VoteType
                    == requestedType)
            {
                throw new InvalidOperationException(
                    "User already cast this vote type");
            }

            Vote vote;
            if (existing != null)
            {
                existing.VoteType = requestedType;
                existing.UpdatedAt = DateTime.UtcNow;
                vote = await _votes.UpdateVoteAsync(
                    existing);
            }
            else
            {
                vote = await _votes.CreateVoteAsync(
                    new Vote
                    {
                        UserId = userId,
                        TargetId = targetId,
                        TargetType = targetType,
                        VoteType = requestedType,
                        CreatedAt = DateTime.UtcNow
                    });
            }

            var counts = await _votes
                .GetVoteCountsAsync(
                    targetId, targetType);
            int netCount = counts[0] - counts[1];

            await _cache.RemoveAsync(
                $"vote:{userId}:{targetId}");
            await _cache.RemoveAsync(
                $"answer:{targetId}");

            await _eventBus.PublishAsync(
                "votes",
                new VoteChangedEvent
                {
                    UserId = userId,
                    TargetId = targetId,
                    TargetType = targetType,
                    NewVoteType = requestedType,
                    PreviousVoteType =
                        existing?.VoteType
                            ?? VoteType.None,
                    NetCount = netCount,
                    Timestamp = DateTime.UtcNow
                });

            _logger.LogInformation(
                "User {UserId} cast {Type} on " +
                "{TargetType} {TargetId}. " +
                "Net count: {Count}",
                userId, requestedType,
                targetType, targetId, netCount);

            return (requestedType, netCount);
        }

        private async Task<int> GetNetVoteCount(
            long targetId, ContentType targetType)
        {
            var counts = await _votes
                .GetVoteCountsAsync(
                    targetId, targetType);
            return counts[0] - counts[1];
        }
    }

    public class FeedGenerator
    {
        private readonly ICacheService _cache;
        private readonly IQuestionRepository _questions;
        private readonly IAnswerRepository _answers;
        private readonly IUserRepository _users;
        private readonly ContentQualityScorer _scorer;
        private readonly ILogger<FeedGenerator> _log;

        public const int PageSize = 20;
        public const int CandidatePool = 200;
        public const double MinScore = 0.1;
        public const int MaxSameTopic = 3;

        public FeedGenerator(
            ICacheService cache,
            IQuestionRepository questions,
            IAnswerRepository answers,
            IUserRepository users,
            ContentQualityScorer scorer,
            ILogger<FeedGenerator> log)
        {
            _cache = cache;
            _questions = questions;
            _answers = answers;
            _users = users;
            _scorer = scorer;
            _log = log;
        }

        public async Task<List<FeedItem>>
            GenerateFeedAsync(
                long userId,
                string? cursor,
                int pageSize = PageSize)
        {
            var cacheKey = $"feed:home:{userId}";
            var cached = await _cache
                .GetAsync<List<FeedItem>>(cacheKey);

            if (cached != null && cursor == null)
            {
                _log.LogDebug(
                    "Serving cached feed for {UserId}",
                    userId);
                return Paginate(
                    cached, cursor, pageSize);
            }

            var candidates = await RetrieveAsync(
                userId);
            var ranked = await RankAsync(
                candidates, userId);
            var diversified = Diversify(ranked);
            var feed = diversified
                .Take(pageSize + 1).ToList();

            await _cache.SetAsync(
                cacheKey, feed,
                TimeSpan.FromMinutes(15));

            return Paginate(
                feed, cursor, pageSize);
        }

        private async Task<List<FeedItem>>
            RetrieveAsync(long userId)
        {
            var items = new List<FeedItem>();
            var seen = await _cache
                .GetAsync<HashSet<long>>(
                    $"feed:seen:{userId}")
                ?? new HashSet<long>();

            var hotQuestions = await _questions
                .GetByTopicAsync(
                    0, 0, CandidatePool / 2);

            foreach (var q in hotQuestions.Where(
                q => !seen.Contains(q.Id)))
            {
                items.Add(new FeedItem
                {
                    Id = $"q:{q.Id}",
                    ContentType =
                        ContentType.Question,
                    ContentId = q.Id,
                    AuthorId = q.AuthorId,
                    CreatedAt = q.CreatedAt,
                    Reason = "Trending question"
                });
            }

            return items;
        }

        private async Task<List<FeedItem>>
            RankAsync(
                List<FeedItem> candidates,
                long userId)
        {
            var user = await _users
                .GetByIdAsync(userId);
            if (user == null) return candidates;

            foreach (var item in candidates)
            {
                var answer = await _answers
                    .GetByIdAsync(item.ContentId);
                var author = await _users
                    .GetByIdAsync(
                        item.AuthorId);

                if (answer != null
                    && author != null)
                {
                    item.RelevanceScore =
                        _scorer.ComputeQualityScore(
                            answer, author,
                            new Dictionary
                                <string, double>());
                }
                else
                {
                    item.RelevanceScore = 0.5;
                }
            }

            return candidates
                .OrderByDescending(
                    i => i.RelevanceScore)
                .Where(i => i.RelevanceScore
                    >= MinScore)
                .ToList();
        }

        private List<FeedItem> Diversify(
            List<FeedItem> items)
        {
            var result = new List<FeedItem>();
            var topicCounts =
                new Dictionary<long, int>();

            foreach (var item in items)
            {
                if (result.Count >= PageSize * 2)
                    break;
                result.Add(item);
            }

            return result;
        }

        private List<FeedItem> Paginate(
            List<FeedItem> items,
            string? cursor,
            int pageSize)
        {
            if (string.IsNullOrEmpty(cursor))
                return items.Take(pageSize).ToList();

            var startIndex = items.FindIndex(
                i => i.Id == cursor);
            if (startIndex < 0) startIndex = 0;

            return items
                .Skip(startIndex)
                .Take(pageSize)
                .ToList();
        }
    }

    public class NotificationService
        : INotificationService
    {
        private readonly ICacheService _cache;
        private readonly IEventBus _eventBus;
        private readonly ILogger<NotificationService>
            _log;
        private readonly Dictionary
            <NotificationType, int> _dailyLimits =
            new()
        {
            [NotificationType.AnswerRequest] = 50,
            [NotificationType.NewAnswer] = 30,
            [NotificationType.VoteMilestone] = 10,
            [NotificationType.NewFollower] = 20,
            [NotificationType.Mention] = 50,
            [NotificationType.AnswerCollapse] = 5,
            [NotificationType.CredentialAward] = 10,
            [NotificationType.SpaceActivity] = 15
        };

        public NotificationService(
            ICacheService cache,
            IEventBus eventBus,
            ILogger<NotificationService> log)
        {
            _cache = cache;
            _eventBus = eventBus;
            _log = log;
        }

        public async Task SendNotificationAsync(
            long userId,
            NotificationType type,
            long sourceId,
            ContentType sourceType,
            string content)
        {
            var dailyKey =
                $"notif:daily:{userId}:{type}";
            var countStr = await _cache
                .GetAsync<string>(dailyKey);
            int currentCount = countStr != null
                ? int.Parse(countStr) : 0;

            var limit = _dailyLimits
                .GetValueOrDefault(type, 20);

            if (currentCount >= limit)
            {
                _log.LogDebug(
                    "Notification throttled for " +
                    "{UserId} type {Type}: " +
                    "{Count}/{Limit}",
                    userId, type,
                    currentCount, limit);
                return;
            }

            var notification = new Notification
            {
                UserId = userId,
                Type = type,
                SourceId = sourceId,
                SourceType = sourceType,
                Content = content,
                CreatedAt = DateTime.UtcNow
            };

            await _cache.IncrementAsync(dailyKey);

            var unreadKey =
                $"notif:unread:{userId}";
            await _cache.IncrementAsync(unreadKey);

            await _eventBus.PublishAsync(
                "notifications",
                notification);

            _log.LogInformation(
                "Notification sent: {Type} to " +
                "{UserId} about {SourceType} " +
                "{SourceId}",
                type, userId, sourceType, sourceId);
        }

        public async Task<int>
            GetUnreadCountAsync(long userId)
        {
            var count = await _cache
                .GetAsync<string>(
                    $"notif:unread:{userId}");
            return count != null
                ? int.Parse(count) : 0;
        }
    }

    public record VoteChangedEvent
    {
        public long UserId { get; init; }
        public long TargetId { get; init; }
        public ContentType TargetType { get; init; }
        public VoteType NewVoteType { get; init; }
        public VoteType PreviousVoteType
            { get; init; }
        public int NetCount { get; init; }
        public DateTime Timestamp { get; init; }
    }

    public class QuestionCreationService
    {
        private readonly IQuestionRepository _repo;
        private readonly ICacheService _cache;
        private readonly IEventBus _eventBus;
        private readonly ISearchService _search;
        private readonly ILogger<QuestionCreationService>
            _log;

        public QuestionCreationService(
            IQuestionRepository repo,
            ICacheService cache,
            IEventBus eventBus,
            ISearchService search,
            ILogger<QuestionCreationService> log)
        {
            _repo = repo;
            _cache = cache;
            _eventBus = eventBus;
            _search = search;
            _log = log;
        }

        public async Task<Question> CreateAsync(
            long authorId, string title,
            string? details,
            List<long> topicIds,
            List<long>? requestedAnswererIds)
        {
            var normalized = title.Trim()
                .ToLowerInvariant();
            var hashBytes = Encoding.UTF8
                .GetBytes(normalized);
            var hash = Convert.ToHexString(
                SHA256.HashData(hashBytes));

            var exists = await _repo
                .ExistsByTitleHashAsync(hash);
            if (exists)
            {
                var similar = await _repo
                    .GetSimilarQuestionsAsync(title);
                throw new QuestionDuplicateException(
                    "Similar question exists",
                    similar.Select(q => q.Id)
                        .ToList());
            }

            var question = new Question
            {
                AuthorId = authorId,
                Title = title,
                Details = details,
                TopicIds = topicIds,
                TitleHash = hash,
                CreatedAt = DateTime.UtcNow,
                UpdatedAt = DateTime.UtcNow
            };

            var created = await _repo
                .CreateAsync(question);

            await _search.IndexQuestionAsync(
                created);

            await _eventBus.PublishAsync(
                "questions",
                new QuestionCreatedEvent
                {
                    Question = created,
                    RequestedAnswererIds =
                        requestedAnswererIds
                            ?? new List<long>(),
                    Timestamp = DateTime.UtcNow
                });

            _log.LogInformation(
                "Question {Id} created by " +
                "user {Author}",
                created.Id, authorId);

            return created;
        }
    }

    public class QuestionDuplicateException
        : Exception
    {
        public List<long> SimilarQuestionIds
            { get; }
        public QuestionDuplicateException(
            string message,
            List<long> similarIds)
            : base(message)
        {
            SimilarQuestionIds = similarIds;
        }
    }

    public record QuestionCreatedEvent
    {
        public Question Question { get; init; }
            = new();
        public List<long> RequestedAnswererIds
            { get; init; } = new();
        public DateTime Timestamp { get; init; }
    }
}

25. Conclusion

Designing a Q&A knowledge platform at Quora's scale requires mastering the intersection of multiple distributed systems disciplines. We've covered the complete architecture from data modeling through multi-region deployment, demonstrating how each subsystem — feed generation, answer ranking, topic graphs, search, notifications, and AI integration — works together to serve 400M+ monthly users.

The key architectural principles that emerge from this design are:

• Event-driven architecture with Kafka as the backbone for all state mutations, enabling loose coupling and eventual consistency where appropriate
• CQRS pattern separating write models (PostgreSQL) from specialized read models (ScyllaDB, Elasticsearch, Redis)
• ML-first ranking using Wilson score intervals, gradient-boosted trees, and personalization signals to surface quality content
• Multi-tier caching with browser, CDN, application, and distributed layers preventing cache stampedes and ensuring sub-200ms p99 latency
• Hybrid push/pull feed balancing write amplification against read latency for different user segments

The AI integration through Poe represents the future of knowledge platforms — combining the best of human-generated content with AI-powered synthesis. As these systems evolve, the boundary between search, feed, and AI chat will continue to blur, requiring even more sophisticated ranking and personalization infrastructure.

For system design interviews, this architecture demonstrates the depth of thinking expected at the Staff+ level: understanding trade-offs, choosing appropriate consistency models, designing for graceful degradation, and balancing technical elegance with operational reality.