diff --git a/migrations/2025-11-21-034447_repartition_follows_blocks_by_actor_id/down.sql b/migrations/2025-11-21-034447_repartition_follows_blocks_by_actor_id/down.sql
new file mode 100644
index 00000000..6b7210d9
--- /dev/null
+++ b/migrations/2025-11-21-034447_repartition_follows_blocks_by_actor_id/down.sql
@@ -0,0 +1,123 @@
+-- =============================================================================
+-- Revert follows and blocks partitioning back to rkey
+-- =============================================================================
+--
+-- This reverts the re-partitioning migration, restoring the original
+-- partitioning by rkey (7-day chunks).
+--
+-- WARNING: This will restore the performance issues:
+--   - getTimeline: "Get followed DIDs" = 140ms
+--   - getAuthorFeed: "Block check" = 377ms
+--
+-- =============================================================================
+
+-- =============================================================================
+-- SECTION 1: Backup follows table
+-- =============================================================================
+
+CREATE TABLE follows_backup AS SELECT * FROM follows;
+
+-- =============================================================================
+-- SECTION 2: Drop and re-create follows with rkey partitioning
+-- =============================================================================
+
+DROP TABLE follows CASCADE;
+
+CREATE TABLE follows (
+    actor_id integer NOT NULL,
+    rkey bigint NOT NULL,
+    subject_actor_id integer NOT NULL,
+    PRIMARY KEY (actor_id, rkey)
+);
+
+-- Partition by rkey (7-day chunks) - original strategy
+SELECT create_hypertable(
+    'follows',
+    by_range('rkey', 619315200000000),  -- 7 days in TID units
+    migrate_data => false,
+    if_not_exists => true
+);
+
+ALTER TABLE follows SET (
+    timescaledb.compress,
+    timescaledb.compress_segmentby = 'actor_id',
+    timescaledb.compress_orderby = 'rkey DESC'
+);
+
+SELECT enable_chunk_skipping('follows', 'actor_id');
+SELECT enable_chunk_skipping('follows', 'subject_actor_id');
+
+COMMENT ON TABLE follows IS 'TimescaleDB hypertable for follow relationships. Partitioned by rkey with 7-day chunks. Manual compression.';
+
+-- =============================================================================
+-- SECTION 3: Restore follows data
+-- =============================================================================
+
+INSERT INTO follows (actor_id, rkey, subject_actor_id)
+SELECT actor_id, rkey, subject_actor_id FROM follows_backup;
+
+-- =============================================================================
+-- SECTION 4: Create indexes on follows
+-- =============================================================================
+
+CREATE INDEX idx_follows_subject ON follows (subject_actor_id);
+CREATE INDEX follows_rkey_idx ON follows (rkey DESC);
+
+-- =============================================================================
+-- SECTION 5: Backup blocks table
+-- =============================================================================
+
+CREATE TABLE blocks_backup AS SELECT * FROM blocks;
+
+-- =============================================================================
+-- SECTION 6: Drop and re-create blocks with rkey partitioning
+-- =============================================================================
+
+DROP TABLE blocks CASCADE;
+
+CREATE TABLE blocks (
+    actor_id integer NOT NULL,
+    rkey bigint NOT NULL,
+    subject_actor_id integer NOT NULL,
+    PRIMARY KEY (actor_id, rkey)
+);
+
+-- Partition by rkey (7-day chunks) - original strategy
+SELECT create_hypertable(
+    'blocks',
+    by_range('rkey', 619315200000000),  -- 7 days in TID units
+    migrate_data => false,
+    if_not_exists => true
+);
+
+ALTER TABLE blocks SET (
+    timescaledb.compress,
+    timescaledb.compress_segmentby = 'actor_id',
+    timescaledb.compress_orderby = 'rkey DESC'
+);
+
+SELECT enable_chunk_skipping('blocks', 'actor_id');
+SELECT enable_chunk_skipping('blocks', 'subject_actor_id');
+
+COMMENT ON TABLE blocks IS 'TimescaleDB hypertable for block relationships. Partitioned by rkey with 7-day chunks. Manual compression.';
+
+-- =============================================================================
+-- SECTION 7: Restore blocks data
+-- =============================================================================
+
+INSERT INTO blocks (actor_id, rkey, subject_actor_id)
+SELECT actor_id, rkey, subject_actor_id FROM blocks_backup;
+
+-- =============================================================================
+-- SECTION 8: Create indexes on blocks
+-- =============================================================================
+
+CREATE INDEX idx_blocks_subject ON blocks (subject_actor_id);
+CREATE INDEX blocks_rkey_idx ON blocks (rkey DESC);
+
+-- =============================================================================
+-- SECTION 9: Cleanup
+-- =============================================================================
+
+DROP TABLE follows_backup;
+DROP TABLE blocks_backup;
diff --git a/migrations/2025-11-21-034447_repartition_follows_blocks_by_actor_id/up.sql b/migrations/2025-11-21-034447_repartition_follows_blocks_by_actor_id/up.sql
new file mode 100644
index 00000000..990f994c
--- /dev/null
+++ b/migrations/2025-11-21-034447_repartition_follows_blocks_by_actor_id/up.sql
@@ -0,0 +1,183 @@
+-- =============================================================================
+-- Re-partition follows and blocks tables by actor_id instead of rkey
+-- =============================================================================
+--
+-- PROBLEM: Current partitioning by rkey (timestamp) causes poor performance
+-- for queries that filter by actor_id:
+--   - getTimeline: "Get followed DIDs" = 140ms (scans 152 chunks)
+--   - getAuthorFeed: "Block check" = 377ms (scans 135 chunks)
+--
+-- SOLUTION: Partition by actor_id (100k per chunk, like actors table)
+--   - Following queries (WHERE actor_id = X): 1 chunk access = ~2ms
+--   - Reverse queries (WHERE subject_id = X): ~5 chunks + indexes = ~8ms
+--   - Total improvement: 20-30x faster
+--
+-- STRATEGY:
+--   1. Backup data to temporary tables
+--   2. Drop existing hypertables (CASCADE removes chunks)
+--   3. Re-create hypertables with actor_id partitioning
+--   4. Restore data (will be re-chunked automatically)
+--   5. Create indexes (including subject_actor_id for reverse queries)
+--   6. Apply compression settings
+--
+-- =============================================================================
+
+-- =============================================================================
+-- SECTION 1: Backup follows table
+-- =============================================================================
+
+CREATE TABLE follows_backup AS SELECT * FROM follows;
+
+COMMENT ON TABLE follows_backup IS 'Temporary backup during re-partitioning migration';
+
+-- =============================================================================
+-- SECTION 2: Drop and re-create follows as hypertable by actor_id
+-- =============================================================================
+
+-- Drop existing hypertable (CASCADE removes all chunks and indexes)
+DROP TABLE follows CASCADE;
+
+-- Re-create table with same schema
+CREATE TABLE follows (
+    actor_id integer NOT NULL,
+    rkey bigint NOT NULL,
+    subject_actor_id integer NOT NULL,
+    PRIMARY KEY (actor_id, rkey)
+);
+
+-- Convert to hypertable partitioned by actor_id (100k per chunk, like actors)
+SELECT create_hypertable(
+    'follows',
+    by_range('actor_id', 100000),
+    migrate_data => false,  -- No data yet
+    if_not_exists => true
+);
+
+-- Set compression with actor_id segmentby (groups by actor within chunks)
+ALTER TABLE follows SET (
+    timescaledb.compress,
+    timescaledb.compress_segmentby = 'actor_id',
+    timescaledb.compress_orderby = 'rkey DESC'
+);
+
+-- Enable chunk skipping for subject_actor_id (helps reverse queries)
+SELECT enable_chunk_skipping('follows', 'subject_actor_id');
+
+COMMENT ON TABLE follows IS 'TimescaleDB hypertable for follow relationships. Partitioned by actor_id with 100k chunks. Manual compression.';
+
+-- =============================================================================
+-- SECTION 3: Restore follows data (will be re-chunked by actor_id)
+-- =============================================================================
+
+INSERT INTO follows (actor_id, rkey, subject_actor_id)
+SELECT actor_id, rkey, subject_actor_id FROM follows_backup;
+
+-- =============================================================================
+-- SECTION 4: Create indexes on follows
+-- =============================================================================
+
+-- Index on subject_actor_id for reverse queries (who follows ME?)
+-- This is critical for good performance on followed_cte queries
+CREATE INDEX idx_follows_subject ON follows (subject_actor_id);
+
+-- Index on rkey for time-based queries (less common but still useful)
+CREATE INDEX follows_rkey_idx ON follows (rkey DESC);
+
+-- Note: actor_id index is implicit via PRIMARY KEY (actor_id, rkey)
+
+-- =============================================================================
+-- SECTION 5: Backup blocks table
+-- =============================================================================
+
+CREATE TABLE blocks_backup AS SELECT * FROM blocks;
+
+COMMENT ON TABLE blocks_backup IS 'Temporary backup during re-partitioning migration';
+
+-- =============================================================================
+-- SECTION 6: Drop and re-create blocks as hypertable by actor_id
+-- =============================================================================
+
+-- Drop existing hypertable (CASCADE removes all chunks and indexes)
+DROP TABLE blocks CASCADE;
+
+-- Re-create table with same schema
+CREATE TABLE blocks (
+    actor_id integer NOT NULL,
+    rkey bigint NOT NULL,
+    subject_actor_id integer NOT NULL,
+    PRIMARY KEY (actor_id, rkey)
+);
+
+-- Convert to hypertable partitioned by actor_id (100k per chunk, like actors)
+SELECT create_hypertable(
+    'blocks',
+    by_range('actor_id', 100000),
+    migrate_data => false,  -- No data yet
+    if_not_exists => true
+);
+
+-- Set compression with actor_id segmentby (groups by actor within chunks)
+ALTER TABLE blocks SET (
+    timescaledb.compress,
+    timescaledb.compress_segmentby = 'actor_id',
+    timescaledb.compress_orderby = 'rkey DESC'
+);
+
+-- Enable chunk skipping for subject_actor_id (helps reverse queries)
+SELECT enable_chunk_skipping('blocks', 'subject_actor_id');
+
+COMMENT ON TABLE blocks IS 'TimescaleDB hypertable for block relationships. Partitioned by actor_id with 100k chunks. Manual compression.';
+
+-- =============================================================================
+-- SECTION 7: Restore blocks data (will be re-chunked by actor_id)
+-- =============================================================================
+
+INSERT INTO blocks (actor_id, rkey, subject_actor_id)
+SELECT actor_id, rkey, subject_actor_id FROM blocks_backup;
+
+-- =============================================================================
+-- SECTION 8: Create indexes on blocks
+-- =============================================================================
+
+-- Index on subject_actor_id for reverse queries (who blocked ME?)
+-- This is critical for good performance on blocked_cte queries
+CREATE INDEX idx_blocks_subject ON blocks (subject_actor_id);
+
+-- Index on rkey for time-based queries (less common but still useful)
+CREATE INDEX blocks_rkey_idx ON blocks (rkey DESC);
+
+-- Note: actor_id index is implicit via PRIMARY KEY (actor_id, rkey)
+
+-- =============================================================================
+-- SECTION 9: Cleanup backup tables
+-- =============================================================================
+
+DROP TABLE follows_backup;
+DROP TABLE blocks_backup;
+
+-- =============================================================================
+-- SECTION 10: Re-create foreign key constraints
+-- =============================================================================
+
+-- Note: Foreign keys TO hypertables are not supported by TimescaleDB
+-- These constraints were dropped in the original hypertable migration
+-- and cannot be restored while follows/blocks are hypertables
+
+-- =============================================================================
+-- Migration Complete
+-- =============================================================================
+--
+-- Expected results:
+--   - follows: ~5 chunks (partitioned by actor_id)
+--   - blocks: ~5 chunks (partitioned by actor_id)
+--   - Queries by actor_id: 1 chunk access (~2ms)
+--   - Queries by subject_actor_id: ~5 chunks with indexes (~8ms)
+--   - Overall: 20-30x performance improvement
+--
+-- Next steps:
+--   - Test query performance
+--   - Optionally compress chunks manually:
+--       SELECT compress_chunk(i) FROM show_chunks('follows') i;
+--       SELECT compress_chunk(i) FROM show_chunks('blocks') i;
+--
+-- =============================================================================
diff --git a/parakeet/src/db.rs b/parakeet/src/db.rs
index b80c69f9..e348c75c 100644
--- a/parakeet/src/db.rs
+++ b/parakeet/src/db.rs
@@ -46,7 +46,7 @@ pub use notification_records::{get_follow_record, get_like_record, get_post_reco
 pub use notifications::{get_notification_state, get_unread_count, list_notifications, update_seen};
 pub use starterpacks::{get_all_starterpacks_with_owners, get_owner_starterpacks};
 pub use suggestions::{
-    get_collaborative_filter_suggestions, get_followed_dids, get_top_followed_actors,
+    get_collaborative_filter_suggestions, get_followed_dids, get_followed_dids_cached, get_top_followed_actors,
 };
 pub use posts::{get_pinned_post_uri, get_post_ids_by_uris, get_reposts_by_uris, get_root_post, get_threadgate_hiddens};
 pub use search::{
@@ -55,7 +55,7 @@ pub use search::{
 };
 pub use states::{
     get_list_state, get_list_states, get_post_state, get_post_states, get_profile_state,
-    get_profile_states, ListStateRet, PostStateRet, ProfileStateRet,
+    get_profile_states, get_profile_states_by_ids, ListStateRet, PostStateRet, ProfileStateByIdRet, ProfileStateRet,
 };
 pub use threads::{
     get_thread_children, get_thread_children_branching, get_thread_children_hidden,
diff --git a/parakeet/src/db/states.rs b/parakeet/src/db/states.rs
index 8aeb9773..62a87afd 100644
--- a/parakeet/src/db/states.rs
+++ b/parakeet/src/db/states.rs
@@ -86,6 +86,84 @@ pub async fn get_profile_states(
     .await
 }
 
+/// Profile state result when querying by actor_ids (optimized version)
+#[derive(Clone, Debug, QueryableByName)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+#[allow(unused_qualifications, reason = "Diesel QueryableByName macro generates unnecessary qualifications")]
+pub struct ProfileStateByIdRet {
+    #[diesel(sql_type = diesel::sql_types::Integer)]
+    pub subject_id: i32,
+    #[diesel(sql_type = Nullable<Bool>)]
+    pub muting: Option<bool>,
+    #[diesel(sql_type = Nullable<Bool>)]
+    pub blocked: Option<bool>,
+    #[diesel(sql_type = Nullable<diesel::sql_types::BigInt>)]
+    pub blocking: Option<i64>,
+    #[diesel(sql_type = Nullable<diesel::sql_types::BigInt>)]
+    pub following: Option<i64>,
+    #[diesel(sql_type = Nullable<diesel::sql_types::BigInt>)]
+    pub followed: Option<i64>,
+    #[diesel(sql_type = Nullable<Text>)]
+    pub list_block_owner_did: Option<String>,
+    #[diesel(sql_type = Nullable<diesel::sql_types::BigInt>)]
+    pub list_block_rkey: Option<i64>,
+    #[diesel(sql_type = Nullable<Text>)]
+    pub list_mute_owner_did: Option<String>,
+    #[diesel(sql_type = Nullable<diesel::sql_types::BigInt>)]
+    pub list_mute_rkey: Option<i64>,
+}
+
+impl ProfileStateByIdRet {
+    /// Get the list_block URI if present
+    pub fn list_block(&self) -> Option<String> {
+        match (&self.list_block_owner_did, self.list_block_rkey) {
+            (Some(did), Some(rkey)) => {
+                let encoded_rkey = parakeet_db::tid_util::encode_tid(rkey);
+                Some(format!("at://{}/app.bsky.graph.list/{}", did, encoded_rkey))
+            }
+            _ => None,
+        }
+    }
+
+    /// Get the list_mute URI if present
+    pub fn list_mute(&self) -> Option<String> {
+        match (&self.list_mute_owner_did, self.list_mute_rkey) {
+            (Some(did), Some(rkey)) => {
+                let encoded_rkey = parakeet_db::tid_util::encode_tid(rkey);
+                Some(format!("at://{}/app.bsky.graph.list/{}", did, encoded_rkey))
+            }
+            _ => None,
+        }
+    }
+}
+
+/// Get profile states by actor IDs (optimized version that avoids decompressing actors table)
+///
+/// This is an optimized version that uses IdCache to resolve DIDs to actor_ids first,
+/// then queries by actor_ids directly. This avoids decompressing the actors table.
+///
+/// Expected performance: 140ms → 5-10ms (20-30x faster)
+///
+/// # Arguments
+/// * `conn` - Database connection
+/// * `viewer_actor_id` - Viewer's actor_id (resolved from DID via IdCache)
+/// * `subject_actor_ids` - Subject actor_ids (resolved from DIDs via IdCache)
+pub async fn get_profile_states_by_ids(
+    conn: &mut AsyncPgConnection,
+    viewer_actor_id: i32,
+    subject_actor_ids: &[i32],
+) -> QueryResult<Vec<ProfileStateByIdRet>> {
+    use diesel::sql_types::Integer;
+
+    diesel_async::RunQueryDsl::load(
+        diesel::sql_query(include_str!("../sql/profile_state_by_ids.sql"))
+            .bind::<Integer, _>(viewer_actor_id)
+            .bind::<Array<Integer>, _>(subject_actor_ids),
+        conn,
+    )
+    .await
+}
+
 #[derive(Clone, Debug, QueryableByName)]
 #[diesel(check_for_backend(diesel::pg::Pg))]
 #[allow(unused_qualifications, reason = "Diesel QueryableByName macro generates unnecessary qualifications")]
diff --git a/parakeet/src/db/suggestions.rs b/parakeet/src/db/suggestions.rs
index a1378d61..56261705 100644
--- a/parakeet/src/db/suggestions.rs
+++ b/parakeet/src/db/suggestions.rs
@@ -32,6 +32,10 @@ pub async fn get_top_followed_actors(
 /// Get DIDs that a viewer follows
 ///
 /// Returns list of DIDs that the given viewer_did follows
+///
+/// OPTIMIZED: Queries follows table directly by actor_id without joins.
+/// Since follows is now partitioned by actor_id, this hits only 1 chunk.
+/// The actor_id resolution (DID → id) should use IdCache to avoid decompressing actors chunks.
 pub async fn get_followed_dids(
     conn: &mut AsyncPgConnection,
     viewer_did: &str,
@@ -55,6 +59,84 @@ pub async fn get_followed_dids(
     .map(|rows| rows.into_iter().map(|r| r.did).collect())
 }
 
+/// Get DIDs that a viewer follows (cached version)
+///
+/// Returns list of DIDs that the given viewer_did follows.
+///
+/// This is an optimized version that uses IdCache to avoid decompressing actors chunks:
+/// 1. Get actor_id from IdCache (or query actors table if cache miss)
+/// 2. Query follows table directly by actor_id (hits only 1 chunk due to actor_id partitioning)
+/// 3. Query actors table for subject DIDs in batch
+///
+/// Expected performance:
+/// - With cache hit: ~5-10ms (1 query to follows + 1 batch query for subject actors)
+/// - With cache miss: ~15-20ms (1 extra query to get actor_id)
+///
+/// This is 10x faster than the old version that decompresses all actor chunks (140ms → 10ms).
+pub async fn get_followed_dids_cached(
+    conn: &mut AsyncPgConnection,
+    id_cache: &parakeet_db::id_cache::IdCache,
+    viewer_did: &str,
+) -> QueryResult<Vec<String>> {
+    // Step 1: Get viewer's actor_id (try cache first)
+    let actor_id = match id_cache.get_actor_id_only(viewer_did).await {
+        Some(id) => id,
+        None => {
+            // Cache miss - query database and populate cache
+            #[derive(QueryableByName)]
+            struct ActorRow {
+                #[diesel(sql_type = diesel::sql_types::Integer)]
+                id: i32,
+            }
+
+            let row = diesel::sql_query("SELECT id FROM actors WHERE did = $1")
+                .bind::<diesel::sql_types::Text, _>(viewer_did)
+                .get_result::<ActorRow>(conn)
+                .await?;
+
+            // Populate cache for future requests
+            id_cache.set_actor_id_with_allowlist(viewer_did.to_string(), row.id, false).await;
+
+            row.id
+        }
+    };
+
+    // Step 2: Query follows table directly by actor_id (hits only 1 chunk!)
+    #[derive(QueryableByName)]
+    struct FollowRow {
+        #[diesel(sql_type = diesel::sql_types::Integer)]
+        subject_actor_id: i32,
+    }
+
+    let follows = diesel::sql_query(
+        "SELECT subject_actor_id FROM follows WHERE actor_id = $1"
+    )
+    .bind::<diesel::sql_types::Integer, _>(actor_id)
+    .load::<FollowRow>(conn)
+    .await?;
+
+    if follows.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    // Step 3: Get subject DIDs (batch query)
+    let subject_ids: Vec<i32> = follows.iter().map(|f| f.subject_actor_id).collect();
+
+    #[derive(QueryableByName)]
+    struct DidRow {
+        #[diesel(sql_type = diesel::sql_types::Text)]
+        did: String,
+    }
+
+    diesel::sql_query(
+        "SELECT did FROM actors WHERE id = ANY($1)"
+    )
+    .bind::<diesel::sql_types::Array<diesel::sql_types::Integer>, _>(&subject_ids)
+    .load::<DidRow>(conn)
+    .await
+    .map(|rows| rows.into_iter().map(|r| r.did).collect())
+}
+
 /// Get suggested follows using collaborative filtering
 ///
 /// Finds accounts followed by the target actor's followers (accounts similar to target)
diff --git a/parakeet/src/hydration/profile/builders.rs b/parakeet/src/hydration/profile/builders.rs
index d74e733c..b2887b9c 100644
--- a/parakeet/src/hydration/profile/builders.rs
+++ b/parakeet/src/hydration/profile/builders.rs
@@ -1,4 +1,4 @@
-use crate::db::ProfileStateRet;
+use crate::db::{ProfileStateRet, ProfileStateByIdRet};
 use crate::hydration::map_labels;
 use crate::loaders::ProfileLoaderRet;
 use crate::xrpc::cdn::BskyCdn;
@@ -72,6 +72,47 @@ pub(super) fn build_viewer(
     }
 }
 
+/// Build viewer state from ProfileStateByIdRet (optimized version that uses actor_ids)
+///
+/// This is similar to build_viewer but works with ProfileStateByIdRet which doesn't have
+/// did/subject fields. The DIDs must be passed as parameters.
+pub(super) fn build_viewer_by_id(
+    data: ProfileStateByIdRet,
+    viewer_did: &str,
+    subject_did: &str,
+    list_mute: Option<ListViewBasic>,
+    list_block: Option<ListViewBasic>,
+) -> ProfileViewerState {
+    let following = data.following.map(|rkey| {
+        let encoded_rkey = parakeet_db::tid_util::encode_tid(rkey);
+        format!("at://{}/app.bsky.graph.follow/{}", viewer_did, encoded_rkey)
+    });
+    let followed_by = data.followed.map(|rkey| {
+        let encoded_rkey = parakeet_db::tid_util::encode_tid(rkey);
+        format!(
+            "at://{}/app.bsky.graph.follow/{}",
+            subject_did, encoded_rkey
+        )
+    });
+
+    let blocking = data.list_block().or_else(|| {
+        data.blocking.map(|rkey| {
+            let encoded_rkey = parakeet_db::tid_util::encode_tid(rkey);
+            format!("at://{}/app.bsky.graph.block/{}", viewer_did, encoded_rkey)
+        })
+    });
+
+    ProfileViewerState {
+        muted: data.muting.unwrap_or_default(),
+        muted_by_list: list_mute,
+        blocked_by: data.blocked.unwrap_or_default(),
+        blocking,
+        blocking_by_list: list_block,
+        following,
+        followed_by,
+    }
+}
+
 fn build_status(status: crate::loaders::EnrichedStatus, cdn: &BskyCdn) -> Option<StatusView> {
     let s = Status::from_str(&status.status.status.to_string()).ok()?;
 
diff --git a/parakeet/src/hydration/profile/mod.rs b/parakeet/src/hydration/profile/mod.rs
index 4ca1a7c5..d81df0be 100644
--- a/parakeet/src/hydration/profile/mod.rs
+++ b/parakeet/src/hydration/profile/mod.rs
@@ -7,7 +7,7 @@ use lexica::app_bsky::actor::{
     ProfileView, ProfileViewBasic, ProfileViewDetailed, ProfileViewerState,
 };
 
-use builders::{build_basic, build_detailed, build_profile, build_viewer};
+use builders::{build_basic, build_detailed, build_profile, build_viewer, build_viewer_by_id};
 
 // Re-export verification items that need to be public
 pub use verification::TRUSTED_VERIFIERS;
@@ -64,30 +64,92 @@ impl super::StatefulHydrator<'_> {
         &self,
         actor_ids: Vec<i32>,
     ) -> HashMap<i32, ProfileViewBasic> {
+        let overall_start = std::time::Instant::now();
+
         // Load profiles by ID - this uses id_cache for DID/handle lookups
-        let profiles = self.loaders.profile_by_id.load_many(actor_ids).await;
+        let mut step_timer = std::time::Instant::now();
+        let profiles = self.loaders.profile_by_id.load_many(actor_ids.clone()).await;
+        let profile_load_time = step_timer.elapsed().as_secs_f64() * 1000.0;
 
         // Extract DIDs from loaded profiles for label/viewer/verif/stats lookups
         let dids: Vec<String> = profiles.values().map(|(did, _, _, _, _, _, _, _)| did.clone()).collect();
 
+        step_timer = std::time::Instant::now();
         let labels = self.get_profile_label_many(&dids).await;
-        let viewers = self.get_profile_viewer_states(&dids).await;
-        let verif = self.loaders.verification.load_many(dids.clone()).await;
+        let labels_time = step_timer.elapsed().as_secs_f64() * 1000.0;
+
+        // OPTIMIZED: Use actor_ids directly for viewer states (avoids decompressing actors table)
+        step_timer = std::time::Instant::now();
+        let viewers = if let Some(viewer_did) = &self.current_actor {
+            // Get viewer's actor_id from IdCache (or query if cache miss)
+            match self.loaders.profile_state.id_cache().get_actor_id_only(viewer_did).await {
+                Some(viewer_actor_id) => {
+                    // Query by actor_ids directly (avoids decompressing actors chunks!)
+                    let states = self.loaders.profile_state.get_many_by_ids(viewer_actor_id, &actor_ids).await;
+
+                    // Extract list URIs for hydration
+                    let lists: Vec<String> = states
+                        .values()
+                        .flat_map(|v| [v.list_block(), v.list_mute()])
+                        .flatten()
+                        .collect();
+                    let lists = self.hydrate_lists_basic(lists).await;
+
+                    // Convert from actor_id-keyed to DID-keyed HashMap
+                    states
+                        .into_iter()
+                        .filter_map(|(subject_actor_id, state)| {
+                            // Find the DID for this actor_id from the profiles we loaded
+                            profiles.get(&subject_actor_id).map(|(subject_did, _, _, _, _, _, _, _)| {
+                                let list_mute = state.list_mute().and_then(|v| lists.get(&v).cloned());
+                                let list_block = state.list_block().and_then(|v| lists.get(&v).cloned());
+                                (subject_did.clone(), build_viewer_by_id(state, viewer_did, subject_did, list_mute, list_block))
+                            })
+                        })
+                        .collect()
+                }
+                None => {
+                    // Cache miss - fall back to DID-based query (will be slow but rare)
+                    self.get_profile_viewer_states(&dids).await
+                }
+            }
+        } else {
+            HashMap::new()
+        };
+        let viewers_time = step_timer.elapsed().as_secs_f64() * 1000.0;
+
+        // OPTIMIZED: Use actor_ids directly for verifications (avoids decompressing actors table)
+        step_timer = std::time::Instant::now();
+        let verif_by_id = self.loaders.verification_raw.load_many_by_ids(&actor_ids).await;
+        let verif_time = step_timer.elapsed().as_secs_f64() * 1000.0;
+
+        step_timer = std::time::Instant::now();
         let stats = self.loaders.profile_stats.load_many(dids.clone()).await;
+        let stats_time = step_timer.elapsed().as_secs_f64() * 1000.0;
 
-        profiles
+        let result = profiles
             .into_iter()
             .map(|(actor_id, profile_info)| {
                 let did = profile_info.0.clone();
                 let labels = labels.get(&did).cloned().unwrap_or_default();
-                let verif = verif.get(&did).cloned();
+                let verif = verif_by_id.get(&actor_id).cloned();
                 let viewer = viewers.get(&did).cloned();
                 let stats = stats.get(&did).copied();
 
                 let v = build_basic(profile_info, stats, labels, verif, viewer, &self.cdn);
                 (actor_id, v)
             })
-            .collect()
+            .collect();
+
+        let overall_time = overall_start.elapsed().as_secs_f64() * 1000.0;
+        if overall_time > 20.0 || profile_load_time > 5.0 || labels_time > 5.0 || viewers_time > 5.0 || verif_time > 5.0 || stats_time > 5.0 {
+            tracing::info!(
+                "    → hydrate_profiles_by_id: {:.1}ms total ({} actors) | profile_load: {:.1}ms, labels: {:.1}ms, viewers: {:.1}ms, verif: {:.1}ms, stats: {:.1}ms",
+                overall_time, actor_ids.len(), profile_load_time, labels_time, viewers_time, verif_time, stats_time
+            );
+        }
+
+        result
     }
 
     pub async fn hydrate_profile(&self, did: String) -> Option<ProfileView> {
diff --git a/parakeet/src/loaders/misc.rs b/parakeet/src/loaders/misc.rs
index 919e7df2..63efa2b5 100644
--- a/parakeet/src/loaders/misc.rs
+++ b/parakeet/src/loaders/misc.rs
@@ -293,7 +293,7 @@ pub fn build_verifications_batch_query() -> &'static str {
          WHERE subject_a.did = ANY($1)"
 }
 
-pub struct VerificationLoader(pub(super) Pool<AsyncPgConnection>);
+pub struct VerificationLoader(pub(super) Pool<AsyncPgConnection>, pub(super) std::sync::Arc<parakeet_db::id_cache::IdCache>);
 impl BatchFn<String, Vec<EnrichedVerification>> for VerificationLoader {
     async fn load(&mut self, keys: &[String]) -> HashMap<String, Vec<EnrichedVerification>> {
         let mut conn = self.0.get().await.unwrap();
@@ -368,3 +368,109 @@ impl BatchFn<String, Vec<EnrichedVerification>> for VerificationLoader {
         result
     }
 }
+
+impl VerificationLoader {
+    /// Load verifications by actor_ids (cached version - avoids decompressing actors table)
+    ///
+    /// This is an optimized version that queries by actor_ids directly, avoiding the
+    /// 70-84ms penalty from joining and filtering the compressed actors table.
+    ///
+    /// Expected performance: 70-84ms → 5-10ms (7-15x faster)
+    ///
+    /// The caller must use IdCache to resolve DIDs after the query.
+    pub async fn load_many_by_ids(&self, subject_actor_ids: &[i32]) -> HashMap<i32, Vec<EnrichedVerification>> {
+        let mut conn = self.0.get().await.unwrap();
+
+        #[derive(diesel::QueryableByName)]
+        struct VerificationRowById {
+            #[diesel(sql_type = diesel::sql_types::BigInt)]
+            id: i64,
+            #[diesel(sql_type = diesel::sql_types::Integer)]
+            actor_id: i32,
+            #[diesel(sql_type = diesel::sql_types::BigInt)]
+            rkey: i64,
+            #[diesel(sql_type = diesel::sql_types::Binary)]
+            cid: Vec<u8>,
+            #[diesel(sql_type = diesel::sql_types::Timestamptz)]
+            created_at: chrono::DateTime<chrono::Utc>,
+            #[diesel(sql_type = diesel::sql_types::Integer)]
+            verifier_actor_id: i32,
+            #[diesel(sql_type = diesel::sql_types::Integer)]
+            subject_actor_id: i32,
+            #[diesel(sql_type = diesel::sql_types::Text)]
+            handle: String,
+            #[diesel(sql_type = diesel::sql_types::Text)]
+            display_name: String,
+        }
+
+        let verifications: Vec<VerificationRowById> = diesel_async::RunQueryDsl::load(
+            diesel::sql_query(include_str!("../sql/verification_by_ids.sql"))
+                .bind::<diesel::sql_types::Array<diesel::sql_types::Integer>, _>(subject_actor_ids),
+            &mut conn,
+        )
+        .await
+        .unwrap_or_else(|e| {
+            tracing::error!("verification load by ids failed: {e}");
+            vec![]
+        });
+
+        // Collect all actor_ids we need to resolve (subjects + verifiers)
+        let mut actor_ids_to_resolve: std::collections::HashSet<i32> = std::collections::HashSet::new();
+        for row in &verifications {
+            actor_ids_to_resolve.insert(row.subject_actor_id);
+            actor_ids_to_resolve.insert(row.verifier_actor_id);
+        }
+
+        // Batch resolve all actor_ids → DIDs using IdCache
+        let actor_ids_vec: Vec<i32> = actor_ids_to_resolve.into_iter().collect();
+        let id_to_actor_data = self.1.get_actor_data_many(&actor_ids_vec).await;
+
+        // Group by subject_actor_id
+        let mut result: HashMap<i32, Vec<EnrichedVerification>> = HashMap::new();
+        for row in verifications {
+            // Resolve DIDs from IdCache
+            let subject_did = match id_to_actor_data.get(&row.subject_actor_id) {
+                Some(data) => data.did.clone(),
+                None => {
+                    tracing::warn!("verification: missing subject DID for actor_id {}", row.subject_actor_id);
+                    continue;
+                }
+            };
+            let verifier_did = match id_to_actor_data.get(&row.verifier_actor_id) {
+                Some(data) => data.did.clone(),
+                None => {
+                    tracing::warn!("verification: missing verifier DID for actor_id {}", row.verifier_actor_id);
+                    continue;
+                }
+            };
+
+            // Encode TID using Rust utility function
+            let encoded_rkey = parakeet_db::tid_util::encode_tid(row.rkey);
+            let at_uri = format!("at://{}/dev.bsky.verification.verification/{}", subject_did, encoded_rkey);
+
+            let enriched = EnrichedVerification {
+                verification: models::Verification {
+                    id: row.id,
+                    actor_id: row.actor_id,
+                    rkey: row.rkey,
+                    cid: row.cid,
+                    verifier_actor_id: row.verifier_actor_id,
+                    subject_actor_id: row.subject_actor_id,
+                    handle: row.handle,
+                    display_name: row.display_name,
+                },
+                verifier: verifier_did,
+                at_uri,
+                created_at: row.created_at,
+            };
+            result.entry(row.subject_actor_id).or_default().push(enriched);
+        }
+
+        result
+    }
+
+    /// Get the IdCache for DID → actor_id resolution
+    pub fn id_cache(&self) -> &parakeet_db::id_cache::IdCache {
+        &self.1
+    }
+}
diff --git a/parakeet/src/loaders/mod.rs b/parakeet/src/loaders/mod.rs
index dca62c28..fbcef677 100644
--- a/parakeet/src/loaders/mod.rs
+++ b/parakeet/src/loaders/mod.rs
@@ -79,6 +79,8 @@ pub struct Dataloaders {
     pub starterpacks: CachingLoader<String, StarterPackLoaderRet, StarterPackLoader>,
     pub verification:
         CachingLoader<String, Vec<EnrichedVerification>, VerificationLoader>,
+    /// Raw verification loader for optimized actor_id-based queries
+    pub verification_raw: VerificationLoader,
 }
 
 impl Dataloaders {
@@ -107,7 +109,8 @@ impl Dataloaders {
             labeler: new_plc_loader(LabelServiceLoader(pool.clone()), "labeler:", 3600, 10_000),
             list: new_plc_loader(ListLoader(pool.clone()), "list:", 3600, 10_000),
             starterpacks: new_plc_loader(StarterPackLoader(pool.clone()), "starterpacks:", 3600, 10_000),
-            verification: new_plc_loader(VerificationLoader(pool.clone()), "verification:", 3600, 10_000),
+            verification: new_plc_loader(VerificationLoader(pool.clone(), id_cache.clone()), "verification:", 3600, 10_000),
+            verification_raw: VerificationLoader(pool.clone(), id_cache.clone()),
 
             // Cached stats: Profile stats change slowly enough to benefit from caching
             // 1 min TTL, 50k capacity
@@ -120,7 +123,7 @@ impl Dataloaders {
             list_state: ListStateLoader(pool.clone()),
             post_stats: NonCachedLoader::new(PostStatsLoader(pool.clone(), idxc, id_cache.clone())),
             post_state: PostStateLoader(pool.clone(), id_cache.clone()),
-            profile_state: ProfileStateLoader(pool.clone()),
+            profile_state: ProfileStateLoader(pool.clone(), id_cache.clone()),
         }
     }
 }
diff --git a/parakeet/src/loaders/profile.rs b/parakeet/src/loaders/profile.rs
index 762aa7f3..330ef2f1 100644
--- a/parakeet/src/loaders/profile.rs
+++ b/parakeet/src/loaders/profile.rs
@@ -704,7 +704,7 @@ impl BatchFn<String, parakeet_index::ProfileStats> for ProfileStatsLoader {
     }
 }
 
-pub struct ProfileStateLoader(pub(super) Pool<AsyncPgConnection>);
+pub struct ProfileStateLoader(pub(super) Pool<AsyncPgConnection>, pub(super) std::sync::Arc<parakeet_db::id_cache::IdCache>);
 impl ProfileStateLoader {
     pub async fn get(&self, did: &str, subject: &str) -> Option<db::ProfileStateRet> {
         let mut conn = self.0.get().await.unwrap();
@@ -732,4 +732,33 @@ impl ProfileStateLoader {
             }
         }
     }
+
+    /// Get profile states using actor_ids (cached version - avoids decompressing actors table)
+    ///
+    /// This is an optimized version that uses IdCache to resolve DIDs to actor_ids first,
+    /// then queries by actor_ids directly. This avoids the 140ms penalty from decompressing
+    /// the actors table.
+    ///
+    /// Expected performance: 140ms → 5-10ms (20-30x faster)
+    pub async fn get_many_by_ids(
+        &self,
+        viewer_actor_id: i32,
+        subject_actor_ids: &[i32],
+    ) -> HashMap<i32, db::ProfileStateByIdRet> {
+        let mut conn = self.0.get().await.unwrap();
+
+        let states_result = db::get_profile_states_by_ids(&mut conn, viewer_actor_id, subject_actor_ids).await;
+        match states_result {
+            Ok(res) => HashMap::from_iter(res.into_iter().map(|v| (v.subject_id, v))),
+            Err(e) => {
+                tracing::error!("profile state load by ids failed: {e}");
+                HashMap::new()
+            }
+        }
+    }
+
+    /// Get the IdCache for DID → actor_id resolution
+    pub fn id_cache(&self) -> &parakeet_db::id_cache::IdCache {
+        &self.1
+    }
 }
diff --git a/parakeet/src/sql/profile_state_by_ids.sql b/parakeet/src/sql/profile_state_by_ids.sql
new file mode 100644
index 00000000..7d7fffbd
--- /dev/null
+++ b/parakeet/src/sql/profile_state_by_ids.sql
@@ -0,0 +1,96 @@
+-- Profile state query using actor_ids instead of DIDs (optimized for IdCache usage)
+-- Reconstructs profile state from follows, blocks, mutes, and list_blocks/list_mutes
+-- Parameters: $1 = viewer actor_id (integer), $2 = array of subject actor_ids (integer[])
+--
+-- This is an optimized version that avoids decompressing the actors table by accepting
+-- actor_ids directly. The caller should use IdCache to resolve DIDs to actor_ids first.
+
+with viewer as (
+    select $1::integer as id
+),
+subjects as (
+    select unnest($2::integer[]) as id
+),
+-- Following relationship (return rkey bigint for encoding in Rust)
+following_cte as (
+    select s.id as subject_id, f.rkey as following
+    from follows f
+    inner join subjects s on f.subject_actor_id = s.id
+    where f.actor_id = (select id from viewer)
+),
+-- Followed relationship (return rkey bigint for encoding in Rust)
+followed_cte as (
+    select s.id as subject_id, f.rkey as followed
+    from follows f
+    inner join viewer v on f.subject_actor_id = v.id
+    inner join subjects s on f.actor_id = s.id
+),
+-- Blocking relationship (return rkey bigint for encoding in Rust)
+blocking_cte as (
+    select s.id as subject_id, b.rkey as blocking
+    from blocks b
+    inner join subjects s on b.subject_actor_id = s.id
+    where b.actor_id = (select id from viewer)
+),
+-- Blocked relationship
+blocked_cte as (
+    select s.id as subject_id, true as blocked
+    from blocks b
+    inner join viewer v on b.subject_actor_id = v.id
+    inner join subjects s on b.actor_id = s.id
+),
+-- Muting relationship
+muting_cte as (
+    select s.id as subject_id, true as muting
+    from mutes m
+    inner join subjects s on m.subject_actor_id = s.id
+    where m.actor_id = (select id from viewer)
+),
+-- List blocks (viewer has blocked subject via list)
+vlb as (
+    select s.id as subject_id, list_owner.did as list_owner_did, l.rkey as list_rkey
+    from list_blocks lb
+    inner join list_mutes lm on lm.list_id = lb.list_id
+    inner join lists l on l.id = lb.list_id
+    inner join actors list_owner on l.actor_id = list_owner.id
+    inner join subjects s on s.id = lb.actor_id
+    where lm.actor_id = (select id from viewer)
+),
+-- List blocks reverse (subject has blocked viewer via list)
+vlb2 as (
+    select s.id as subject_id, true as blocked
+    from list_blocks lb
+    inner join list_mutes lm on lm.list_id = lb.list_id
+    inner join viewer v on v.id = lb.actor_id
+    inner join subjects s on s.id = lm.actor_id
+),
+-- List mutes (viewer has muted subject via list)
+vlm as (
+    select s.id as subject_id, list_owner.did as list_owner_did, l.rkey as list_rkey
+    from list_items li
+    inner join list_mutes lm on lm.list_id = li.list_id
+    inner join lists l on l.id = li.list_id
+    inner join actors list_owner on l.actor_id = list_owner.id
+    inner join subjects s on s.id = li.subject_actor_id
+    where lm.actor_id = (select id from viewer)
+)
+select
+    s.id as subject_id,
+    muting.muting,
+    coalesce(blocked.blocked, vlb2.blocked, false) as blocked,
+    blocking.blocking,
+    following.following,
+    followed.followed,
+    vlb.list_owner_did as list_block_owner_did,
+    vlb.list_rkey as list_block_rkey,
+    vlm.list_owner_did as list_mute_owner_did,
+    vlm.list_rkey as list_mute_rkey
+from subjects s
+left join following_cte following on following.subject_id = s.id
+left join followed_cte followed on followed.subject_id = s.id
+left join blocking_cte blocking on blocking.subject_id = s.id
+left join blocked_cte blocked on blocked.subject_id = s.id
+left join muting_cte muting on muting.subject_id = s.id
+left join vlb on vlb.subject_id = s.id
+left join vlb2 on vlb2.subject_id = s.id
+left join vlm on vlm.subject_id = s.id;
diff --git a/parakeet/src/sql/verification_by_ids.sql b/parakeet/src/sql/verification_by_ids.sql
new file mode 100644
index 00000000..3ba5ad0a
--- /dev/null
+++ b/parakeet/src/sql/verification_by_ids.sql
@@ -0,0 +1,25 @@
+-- Optimized verification query that uses actor_ids instead of DIDs
+-- This avoids decompressing the actors table by using IdCache to resolve DIDs beforehand
+--
+-- Parameters:
+--   $1: subject_actor_ids (integer[]) - Array of subject actor IDs to fetch verifications for
+--
+-- Performance: ~70-84ms → ~5-10ms (7-15x faster)
+-- Avoids: 2x actors table joins and DID-based filtering (which forces decompression)
+--
+-- Note: Caller must use IdCache to:
+--   1. Resolve subject DIDs → actor_ids before this query
+--   2. Resolve subject_actor_id/verifier_actor_id → DIDs after this query
+
+SELECT
+    v.id,
+    v.actor_id,
+    v.rkey,
+    v.cid,
+    tid_timestamp(v.rkey) as created_at,
+    v.verifier_actor_id,
+    v.subject_actor_id,
+    v.handle,
+    v.display_name
+FROM verification v
+WHERE v.subject_actor_id = ANY($1)
diff --git a/parakeet/src/xrpc/app_bsky/actor.rs b/parakeet/src/xrpc/app_bsky/actor.rs
index 97500d58..7c205a5c 100644
--- a/parakeet/src/xrpc/app_bsky/actor.rs
+++ b/parakeet/src/xrpc/app_bsky/actor.rs
@@ -323,8 +323,8 @@ pub async fn get_suggestions(
         let viewer_did = &auth.0;
         let mut conn = state.pool.get().await?;
 
-        // Get accounts viewer follows
-        let followed_dids = crate::db::get_followed_dids(&mut conn, viewer_did)
+        // Get accounts viewer follows (uses IdCache to avoid decompressing actors chunks)
+        let followed_dids = crate::db::get_followed_dids_cached(&mut conn, &state.id_cache, viewer_did)
             .await
             .unwrap_or_default();
 
diff --git a/parakeet/src/xrpc/app_bsky/feed/get_timeline.rs b/parakeet/src/xrpc/app_bsky/feed/get_timeline.rs
index a9add6d7..14eb461a 100644
--- a/parakeet/src/xrpc/app_bsky/feed/get_timeline.rs
+++ b/parakeet/src/xrpc/app_bsky/feed/get_timeline.rs
@@ -91,9 +91,9 @@ pub async fn get_timeline(
         Some(auth.clone()),
     );
 
-    // Get the accounts the user follows
+    // Get the accounts the user follows (uses IdCache to avoid decompressing actors chunks)
     step_timer = std::time::Instant::now();
-    let follows = crate::db::get_followed_dids(&mut conn, &user_did).await?;
+    let follows = crate::db::get_followed_dids_cached(&mut conn, &state.id_cache, &user_did).await?;
     let follows_time = step_timer.elapsed().as_secs_f64() * 1000.0;
     if follows_time >= 1.0 {
         tracing::info!("  ├─ Get followed DIDs: {:.1} ms ({} follows)", follows_time, follows.len());
diff --git a/parakeet/src/xrpc/app_bsky/unspecced/mod.rs b/parakeet/src/xrpc/app_bsky/unspecced/mod.rs
index eac5742e..aefc39a2 100644
--- a/parakeet/src/xrpc/app_bsky/unspecced/mod.rs
+++ b/parakeet/src/xrpc/app_bsky/unspecced/mod.rs
@@ -258,8 +258,8 @@ pub async fn get_suggested_users(
         let viewer_did = &auth.0;
         let mut conn = state.pool.get().await?;
 
-        // Get accounts viewer follows
-        let followed_dids = crate::db::get_followed_dids(&mut conn, viewer_did)
+        // Get accounts viewer follows (uses IdCache to avoid decompressing actors chunks)
+        let followed_dids = crate::db::get_followed_dids_cached(&mut conn, &state.id_cache, viewer_did)
             .await
             .unwrap_or_default();