diff --git a/packages/common-ui/src/components/StudySession.vue b/packages/common-ui/src/components/StudySession.vue
index d0c298a15..4fd6c867e 100644
--- a/packages/common-ui/src/components/StudySession.vue
+++ b/packages/common-ui/src/components/StudySession.vue
@@ -11,10 +11,10 @@
     <div v-if="sessionFinished" class="text-h4">
       <p>Study session finished! Great job!</p>
       <p v-if="sessionController">{{ sessionController.report }}</p>
-      <p>
+      <!-- <p>
         Start <a @click="$emit('session-finished')">another study session</a>, or try
         <router-link :to="`/edit/${courseID}`">adding some new content</router-link> to challenge yourself and others!
-      </p>
+      </p> -->
       <heat-map :activity-records-getter="() => user.getActivityRecords()" />
     </div>
 
@@ -65,35 +65,35 @@
 </template>
 
 <script lang="ts">
-import { defineComponent, PropType, markRaw } from 'vue';
-import { isQuestionView } from '../composables/CompositionViewable';
-import { alertUser } from './SnackbarService';
+import { defineComponent, markRaw, PropType } from 'vue';
 import { ViewComponent } from '../composables';
+import { isQuestionView } from '../composables/CompositionViewable';
+import HeatMap from './HeatMap.vue';
 import SkMouseTrap from './SkMouseTrap.vue';
+import { alertUser } from './SnackbarService';
 import StudySessionTimer from './StudySessionTimer.vue';
-import HeatMap from './HeatMap.vue';
 import CardViewer from './cardRendering/CardViewer.vue';
 
+import { CourseElo, Status, toCourseElo, ViewData } from '@vue-skuilder/common';
 import {
-  ContentSourceID,
-  getStudySource,
-  isReview,
-  StudyContentSource,
-  StudySessionItem,
-  docIsDeleted,
   CardHistory,
   CardRecord,
-  isQuestionRecord,
+  ClassroomDBInterface,
+  ContentSourceID,
   CourseRegistrationDoc,
   DataLayerProvider,
+  docIsDeleted,
+  getStudySource,
+  HydratedCard,
+  isQuestionRecord,
+  isReview,
+  ResponseResult,
+  SessionController,
+  StudyContentSource,
+  StudySessionRecord,
   UserDBInterface,
-  ClassroomDBInterface,
 } from '@vue-skuilder/db';
-import { HydratedCard, SessionController, StudySessionRecord } from '@vue-skuilder/db';
-import { newInterval } from '@vue-skuilder/db';
-import { adjustCourseScores, CourseElo, toCourseElo, ViewData, Status } from '@vue-skuilder/common';
 import confetti from 'canvas-confetti';
-import moment from 'moment';
 
 import { StudySessionConfig } from './StudySession.types';
 
@@ -371,140 +371,83 @@ export default defineComponent({
       this.currentCard.records.push(r);
 
       console.log(`[StudySession] StudySession.processResponse is running...`);
+      // DEBUG: Added logging to track hanging issue - can be removed if issue resolved
+      // console.log(`[StudySession] About to call logCardRecord...`);
       const cardHistory = this.logCardRecord(r);
+      // console.log(`[StudySession] logCardRecord called, cardHistory promise created...`);
+
+      // Get view constraints for response processing
+      let maxAttemptsPerView = 1;
+      let maxSessionViews = 1;
+      if (isQuestionView(this.$refs.cardViewer?.$refs.activeView)) {
+        const view = this.$refs.cardViewer.$refs.activeView;
+        maxAttemptsPerView = view.maxAttemptsPerView;
+        maxSessionViews = view.maxSessionViews;
+      }
+      const sessionViews = this.countCardViews(this.courseID, this.cardID);
+
+      // Process response through SessionController
+      // DEBUG: Added logging to track hanging issue - can be removed if issue resolved
+      // console.log(`[StudySession] About to call submitResponse...`);
+      const result: ResponseResult = await this.sessionController!.submitResponse(
+        r,
+        cardHistory,
+        this.userCourseRegDoc!,
+        this.currentCard,
+        this.courseID,
+        this.cardID,
+        maxAttemptsPerView,
+        maxSessionViews,
+        sessionViews
+      );
+      // DEBUG: Added logging to track hanging issue - can be removed if issue resolved
+      // console.log(`[StudySession] submitResponse completed, result:`, result);
+
+      // Handle UI feedback based on result
+      this.handleUIFeedback(result);
+
+      // Handle navigation based on result
+      if (result.shouldLoadNextCard) {
+        this.loadCard(await this.sessionController!.nextCard(result.nextCardAction));
+      }
 
-      if (isQuestionRecord(r)) {
-        console.log(`[StudySession] Question is ${r.isCorrect ? '' : 'in'}correct`);
-        if (r.isCorrect) {
-          try {
-            if (this.$refs.shadowWrapper) {
-              this.$refs.shadowWrapper.setAttribute(
-                'style',
-                `--r: ${255 * (1 - (r.performance as number))}; --g:${255}`
-              );
-              this.$refs.shadowWrapper.classList.add('correct');
-            }
-          } catch (e) {
-            // swallow error
-            console.warn(`[StudySession] Error setting shadowWrapper style: ${e}`);
-          }
-
-          if (this.sessionConfig.likesConfetti) {
-            confetti({
-              origin: {
-                y: 1,
-                x: 0.25 + 0.5 * Math.random(),
-              },
-              disableForReducedMotion: true,
-              angle: 60 + 60 * Math.random(),
-            });
-          }
+      // Clear feedback shadow if requested
+      if (result.shouldClearFeedbackShadow) {
+        this.clearFeedbackShadow();
+      }
+    },
 
-          if (r.priorAttemps === 0) {
-            const item: StudySessionItem = {
-              ...this.currentCard.item,
-            };
-            this.loadCard(await this.sessionController!.nextCard('dismiss-success'));
-
-            cardHistory.then((history: CardHistory<CardRecord>) => {
-              this.scheduleReview(history, item);
-              if (history.records.length === 1) {
-                this.updateUserAndCardElo(0.5 + (r.performance as number) / 2, this.courseID, this.cardID);
-              } else {
-                const k = Math.ceil(32 / history.records.length);
-                this.updateUserAndCardElo(0.5 + (r.performance as number) / 2, this.courseID, this.cardID, k);
-              }
-            });
-          } else {
-            this.loadCard(await this.sessionController!.nextCard('marked-failed'));
-          }
-        } else {
-          /* !r.isCorrect */
-          try {
-            if (this.$refs.shadowWrapper) {
-              this.$refs.shadowWrapper.classList.add('incorrect');
-            }
-          } catch (e) {
-            // swallow error
-            console.warn(`[StudySession] Error setting shadowWrapper style: ${e}`);
+    handleUIFeedback(result: ResponseResult) {
+      if (result.isCorrect) {
+        // Handle correct response UI
+        try {
+          if (this.$refs.shadowWrapper && result.performanceScore !== undefined) {
+            this.$refs.shadowWrapper.setAttribute('style', `--r: ${255 * (1 - result.performanceScore)}; --g:${255}`);
+            this.$refs.shadowWrapper.classList.add('correct');
           }
+        } catch (e) {
+          console.warn(`[StudySession] Error setting shadowWrapper style: ${e}`);
+        }
 
-          cardHistory.then((history: CardHistory<CardRecord>) => {
-            if (history.records.length !== 1 && r.priorAttemps === 0) {
-              this.updateUserAndCardElo(0, this.courseID, this.cardID);
-            }
+        // Show confetti for correct responses
+        if (this.sessionConfig.likesConfetti) {
+          confetti({
+            origin: {
+              y: 1,
+              x: 0.25 + 0.5 * Math.random(),
+            },
+            disableForReducedMotion: true,
+            angle: 60 + 60 * Math.random(),
           });
-
-          // [ ]  v3 version. Keep an eye on this -
-          if (isQuestionView(this.$refs.cardViewer?.$refs.activeView)) {
-            const view = this.$refs.cardViewer.$refs.activeView;
-
-            if (this.currentCard.records.length >= view.maxAttemptsPerView) {
-              const sessionViews: number = this.countCardViews(this.courseID, this.cardID);
-              if (sessionViews >= view.maxSessionViews) {
-                this.loadCard(await this.sessionController!.nextCard('dismiss-failed'));
-                this.updateUserAndCardElo(0, this.courseID, this.cardID);
-              } else {
-                this.loadCard(await this.sessionController!.nextCard('marked-failed'));
-              }
-            }
-          }
         }
       } else {
-        this.loadCard(await this.sessionController!.nextCard('dismiss-success'));
-      }
-
-      this.clearFeedbackShadow();
-    },
-
-    async updateUserAndCardElo(userScore: number, course_id: string, card_id: string, k?: number) {
-      if (k) {
-        console.warn(`k value interpretation not currently implemented`);
-      }
-      const courseDB = this.dataLayer.getCourseDB(this.currentCard.card.course_id);
-      const userElo = toCourseElo(this.userCourseRegDoc!.courses.find((c) => c.courseID === course_id)!.elo);
-      const cardElo = (await courseDB.getCardEloData([this.currentCard.card.card_id]))[0];
-
-      if (cardElo && userElo) {
-        const eloUpdate = adjustCourseScores(userElo, cardElo, userScore);
-        this.userCourseRegDoc!.courses.find((c) => c.courseID === course_id)!.elo = eloUpdate.userElo;
-
-        const results = await Promise.allSettled([
-          this.user!.updateUserElo(course_id, eloUpdate.userElo),
-          courseDB.updateCardElo(card_id, eloUpdate.cardElo),
-        ]);
-
-        // Check the results of each operation
-        const userEloStatus = results[0].status === 'fulfilled';
-        const cardEloStatus = results[1].status === 'fulfilled';
-
-        if (userEloStatus && cardEloStatus) {
-          const user = results[0].value;
-          const card = results[1].value;
-
-          if (user.ok && card && card.ok) {
-            console.log(
-              `[StudySession] Updated ELOS:
-              \tUser: ${JSON.stringify(eloUpdate.userElo)})
-              \tCard: ${JSON.stringify(eloUpdate.cardElo)})
-              `
-            );
-          }
-        } else {
-          // Log which operations succeeded and which failed
-          console.log(
-            `[StudySession] Partial ELO update:
-            \tUser ELO update: ${userEloStatus ? 'SUCCESS' : 'FAILED'}
-            \tCard ELO update: ${cardEloStatus ? 'SUCCESS' : 'FAILED'}`
-          );
-
-          if (!userEloStatus && results[0].status === 'rejected') {
-            console.error('[StudySession] User ELO update error:', results[0].reason);
-          }
-
-          if (!cardEloStatus && results[1].status === 'rejected') {
-            console.error('[StudySession] Card ELO update error:', results[1].reason);
+        // Handle incorrect response UI
+        try {
+          if (this.$refs.shadowWrapper) {
+            this.$refs.shadowWrapper.classList.add('incorrect');
           }
+        } catch (e) {
+          console.warn(`[StudySession] Error setting shadowWrapper style: ${e}`);
         }
       }
     },
@@ -523,26 +466,11 @@ export default defineComponent({
     },
 
     async logCardRecord(r: CardRecord): Promise<CardHistory<CardRecord>> {
-      return await this.user!.putCardRecord(r);
-    },
-
-    async scheduleReview(history: CardHistory<CardRecord>, item: StudySessionItem) {
-      const nextInterval = newInterval(this.$props.user, history);
-      const nextReviewTime = moment.utc().add(nextInterval, 'seconds');
-
-      if (isReview(item)) {
-        console.log(`[StudySession] Removing previously scheduled review for: ${item.cardID}`);
-        this.user!.removeScheduledCardReview(item.reviewID);
-      }
-
-      this.user!.scheduleCardReview({
-        user: this.user!.getUsername(),
-        course_id: history.courseID,
-        card_id: history.cardID,
-        time: nextReviewTime,
-        scheduledFor: item.contentSourceType,
-        schedulingAgentId: item.contentSourceID,
-      });
+      // DEBUG: Added logging to track hanging issue - can be removed if issue resolved
+      // console.log(`[StudySession] About to call user.putCardRecord...`);
+      const result = await this.user!.putCardRecord(r);
+      // console.log(`[StudySession] user.putCardRecord completed`);
+      return result;
     },
 
     async loadCard(card: HydratedCard | null) {
diff --git a/packages/db/src/impl/couch/updateQueue.ts b/packages/db/src/impl/couch/updateQueue.ts
index ee91ecf04..cd83a1611 100644
--- a/packages/db/src/impl/couch/updateQueue.ts
+++ b/packages/db/src/impl/couch/updateQueue.ts
@@ -44,9 +44,10 @@ export default class UpdateQueue extends Loggable {
   ): Promise<T & PouchDB.Core.GetMeta & PouchDB.Core.RevisionIdMeta> {
     logger.debug(`Applying updates on doc: ${id}`);
     if (this.inprogressUpdates[id]) {
-      // console.log(`Updates in progress...`);
-      await this.readDB.info(); // stall for a round trip
-      // console.log(`Retrying...`);
+      // Poll instead of recursing to avoid infinite recursion
+      while (this.inprogressUpdates[id]) {
+        await new Promise(resolve => setTimeout(resolve, Math.random() * 50));
+      }
       return this.applyUpdates<T>(id);
     } else {
       if (this.pendingUpdates[id] && this.pendingUpdates[id].length > 0) {
diff --git a/packages/db/src/study/ItemQueue.ts b/packages/db/src/study/ItemQueue.ts
new file mode 100644
index 000000000..840263ebc
--- /dev/null
+++ b/packages/db/src/study/ItemQueue.ts
@@ -0,0 +1,58 @@
+export class ItemQueue<T> {
+  private q: T[] = [];
+  private seenCardIds: string[] = [];
+  private _dequeueCount: number = 0;
+  public get dequeueCount(): number {
+    return this._dequeueCount;
+  }
+
+  public add(item: T, cardId: string) {
+    if (this.seenCardIds.find((d) => d === cardId)) {
+      return; // do not re-add a card to the same queue
+    }
+
+    this.seenCardIds.push(cardId);
+    this.q.push(item);
+  }
+
+  public addAll(items: T[], cardIdExtractor: (item: T) => string) {
+    items.forEach((i) => this.add(i, cardIdExtractor(i)));
+  }
+
+  public get length() {
+    return this.q.length;
+  }
+
+  public peek(index: number): T {
+    return this.q[index];
+  }
+
+  public dequeue(cardIdExtractor?: (item: T) => string): T | null {
+    if (this.q.length !== 0) {
+      this._dequeueCount++;
+      const item = this.q.splice(0, 1)[0];
+
+      // Remove cardId from seenCardIds when dequeuing to allow re-queueing
+      if (cardIdExtractor) {
+        const cardId = cardIdExtractor(item);
+        const index = this.seenCardIds.indexOf(cardId);
+        if (index > -1) {
+          this.seenCardIds.splice(index, 1);
+        }
+      }
+
+      return item;
+    } else {
+      return null;
+    }
+  }
+
+  public get toString(): string {
+    return (
+      `${typeof this.q[0]}:\n` +
+      this.q
+        .map((i) => `\t${(i as any).courseID}+${(i as any).cardID}: ${(i as any).status}`)
+        .join('\n')
+    );
+  }
+}
\ No newline at end of file
diff --git a/packages/db/src/study/SessionController.ts b/packages/db/src/study/SessionController.ts
index 6642e7248..b3f514b24 100644
--- a/packages/db/src/study/SessionController.ts
+++ b/packages/db/src/study/SessionController.ts
@@ -1,3 +1,8 @@
+import { SrsService } from './services/SrsService';
+import { EloService } from './services/EloService';
+import { ResponseProcessor } from './services/ResponseProcessor';
+import { CardHydrationService, HydratedCard } from './services/CardHydrationService';
+import { ItemQueue } from './ItemQueue';
 import {
   isReview,
   StudyContentSource,
@@ -7,10 +12,9 @@ import {
   StudySessionReviewItem,
 } from '@db/impl/couch';
 
-import { CardRecord } from '@db/core';
+import { CardRecord, CardHistory, CourseRegistrationDoc } from '@db/core';
 import { Loggable } from '@db/util';
 import { ScheduledCard } from '@db/core/types/user';
-import { ViewData } from '@vue-skuilder/common';
 
 function randomInt(min: number, max: number): number {
   return Math.floor(Math.random() * (max - min + 1)) + min;
@@ -26,84 +30,53 @@ export interface StudySessionRecord {
   records: CardRecord[];
 }
 
-export interface HydratedCard<TView = unknown> {
-  item: StudySessionItem;
-  view: TView;
-  data: ViewData[];
-}
+import { DataLayerProvider } from '@db/core';
 
-import {
-  CardData,
-  DisplayableData,
-  displayableDataToViewData,
-  isCourseElo,
-  toCourseElo,
-} from '@vue-skuilder/common';
-
-class ItemQueue<T> {
-  private q: T[] = [];
-  private seenCardIds: string[] = [];
-  private _dequeueCount: number = 0;
-  public get dequeueCount(): number {
-    return this._dequeueCount;
-  }
+export type SessionAction =
+  | 'dismiss-success'
+  | 'dismiss-failed'
+  | 'marked-failed'
+  | 'dismiss-error';
 
-  public add(item: T, cardId: string) {
-    if (this.seenCardIds.find((d) => d === cardId)) {
-      return; // do not re-add a card to the same queue
-    }
+export interface ResponseResult {
+  // Navigation
+  nextCardAction: Exclude<SessionAction, 'dismiss-error'> | 'none';
+  shouldLoadNextCard: boolean;
 
-    this.seenCardIds.push(cardId);
-    this.q.push(item);
-  }
-  public addAll(items: T[], cardIdExtractor: (item: T) => string) {
-    items.forEach((i) => this.add(i, cardIdExtractor(i)));
-  }
-  public get length() {
-    return this.q.length;
-  }
-  public peek(index: number): T {
-    return this.q[index];
-  }
-
-  public dequeue(): T | null {
-    if (this.q.length !== 0) {
-      this._dequeueCount++;
-      return this.q.splice(0, 1)[0];
-    } else {
-      return null;
-    }
-  }
+  // UI Data (let view decide how to render)
+  isCorrect: boolean;
+  performanceScore?: number; // for shadow color calculation
 
-  public get toString(): string {
-    return (
-      `${typeof this.q[0]}:\n` +
-      this.q
-        .map((i) => `\t${(i as any).courseID}+${(i as any).cardID}: ${(i as any).status}`)
-        .join('\n')
-    );
-  }
+  // Cleanup
+  shouldClearFeedbackShadow: boolean;
 }
 
-import { DataLayerProvider } from '@db/core';
+interface SessionServices {
+  response: ResponseProcessor;
+}
 
 export class SessionController<TView = unknown> extends Loggable {
   _className = 'SessionController';
+
+  public services: SessionServices;
+  private srsService: SrsService;
+  private eloService: EloService;
+  private hydrationService: CardHydrationService<TView>;
+
   private sources: StudyContentSource[];
-  private dataLayer: DataLayerProvider;
-  private getViewComponent: (viewId: string) => TView;
+  // dataLayer and getViewComponent now injected into CardHydrationService
   private _sessionRecord: StudySessionRecord[] = [];
   public set sessionRecord(r: StudySessionRecord[]) {
     this._sessionRecord = r;
   }
 
+  // Session card stores
+  private _currentCard: HydratedCard<TView> | null = null;
+
   private reviewQ: ItemQueue<StudySessionReviewItem> = new ItemQueue<StudySessionReviewItem>();
   private newQ: ItemQueue<StudySessionNewItem> = new ItemQueue<StudySessionNewItem>();
   private failedQ: ItemQueue<StudySessionFailedItem> = new ItemQueue<StudySessionFailedItem>();
-  private hydratedQ: ItemQueue<HydratedCard<TView>> = new ItemQueue<HydratedCard<TView>>();
-  private failedCardCache: Map<string, HydratedCard<TView>> = new Map();
-  private _currentCard: HydratedCard<TView> | null = null;
-  private hydration_in_progress: boolean = false;
+  // END   Session card stores
 
   private startTime: Date;
   private endTime: Date;
@@ -131,12 +104,25 @@ export class SessionController<TView = unknown> extends Loggable {
   ) {
     super();
 
+    this.srsService = new SrsService(dataLayer.getUserDB());
+    this.eloService = new EloService(dataLayer, dataLayer.getUserDB());
+
+    this.hydrationService = new CardHydrationService<TView>(
+      getViewComponent,
+      (courseId: string) => dataLayer.getCourseDB(courseId),
+      () => this._selectNextItemToHydrate(),
+      (item: StudySessionItem) => this.removeItemFromQueue(item),
+      () => this.hasAvailableCards()
+    );
+
+    this.services = {
+      response: new ResponseProcessor(this.srsService, this.eloService),
+    };
+
     this.sources = sources;
     this.startTime = new Date();
     this._secondsRemaining = time;
     this.endTime = new Date(this.startTime.valueOf() + 1000 * this._secondsRemaining);
-    this.dataLayer = dataLayer;
-    this.getViewComponent = getViewComponent;
 
     this.log(`Session constructed:
     startTime: ${this.startTime}
@@ -200,7 +186,7 @@ export class SessionController<TView = unknown> extends Loggable {
       this.error('Error preparing study session:', e);
     }
 
-    await this._fillHydratedQueue();
+    await this.hydrationService.ensureHydratedCards();
 
     this._intervalHandle = setInterval(() => {
       this.tick();
@@ -349,11 +335,7 @@ export class SessionController<TView = unknown> extends Loggable {
   }
 
   public async nextCard(
-    action:
-      | 'dismiss-success'
-      | 'dismiss-failed'
-      | 'marked-failed'
-      | 'dismiss-error' = 'dismiss-success'
+    action: SessionAction = 'dismiss-success'
   ): Promise<HydratedCard<TView> | null> {
     // dismiss (or sort to failedQ) the current card
     this.dismissCurrentCard(action);
@@ -363,18 +345,15 @@ export class SessionController<TView = unknown> extends Loggable {
       return null;
     }
 
-    let card = this.hydratedQ.dequeue();
+    let card = this.hydrationService.dequeueHydratedCard();
 
     // If no hydrated card but source cards available, wait for hydration
     if (!card && this.hasAvailableCards()) {
-      void this._fillHydratedQueue(); // Start hydration in background
-      card = await this.nextHydratedCard(); // Wait for first available card
+      card = await this.hydrationService.waitForHydratedCard();
     }
 
     // Trigger background hydration to maintain cache (async, non-blocking)
-    if (this.hydratedQ.length < 3) {
-      void this._fillHydratedQueue();
-    }
+    await this.hydrationService.ensureHydratedCards();
 
     if (card) {
       this._currentCard = card;
@@ -385,13 +364,49 @@ export class SessionController<TView = unknown> extends Loggable {
     return card;
   }
 
-  private dismissCurrentCard(
-    action:
-      | 'dismiss-success'
-      | 'dismiss-failed'
-      | 'marked-failed'
-      | 'dismiss-error' = 'dismiss-success'
-  ) {
+  /**
+   * Public API for processing user responses to cards.
+   * @param cardRecord User's response record
+   * @param cardHistory Promise resolving to the card's history
+   * @param courseRegistrationDoc User's course registration document
+   * @param currentCard Current study session record
+   * @param courseId Course identifier
+   * @param cardId Card identifier
+   * @param maxAttemptsPerView Maximum attempts allowed per view
+   * @param maxSessionViews Maximum session views for this card
+   * @param sessionViews Current number of session views
+   * @returns ResponseResult with navigation and UI instructions
+   */
+  public async submitResponse(
+    cardRecord: CardRecord,
+    cardHistory: Promise<CardHistory<CardRecord>>,
+    courseRegistrationDoc: CourseRegistrationDoc,
+    currentCard: StudySessionRecord,
+    courseId: string,
+    cardId: string,
+    maxAttemptsPerView: number,
+    maxSessionViews: number,
+    sessionViews: number
+  ): Promise<ResponseResult> {
+    const studySessionItem: StudySessionItem = {
+      ...currentCard.item,
+    };
+
+    return await this.services.response.processResponse(
+      cardRecord,
+      cardHistory,
+      studySessionItem,
+      courseRegistrationDoc,
+      currentCard,
+      courseId,
+      cardId,
+      maxAttemptsPerView,
+      maxSessionViews,
+      sessionViews
+    );
+  }
+
+  private dismissCurrentCard(action: SessionAction = 'dismiss-success') {
     if (this._currentCard) {
       // this.log(`Running dismissCurrentCard on ${this._currentCard!.qualifiedID}`);
       // if (action.includes('dismiss')) {
@@ -406,7 +421,7 @@ export class SessionController<TView = unknown> extends Loggable {
       if (action === 'dismiss-success') {
         // schedule a review - currently done in Study.vue
       } else if (action === 'marked-failed') {
-        this.failedCardCache.set(this._currentCard.item.cardID, this._currentCard);
+        this.hydrationService.cacheFailedCard(this._currentCard);
 
         let failedItem: StudySessionFailedItem;
 
@@ -442,79 +457,16 @@ export class SessionController<TView = unknown> extends Loggable {
     return this.reviewQ.length > 0 || this.newQ.length > 0 || this.failedQ.length > 0;
   }
 
-  private async nextHydratedCard(): Promise<HydratedCard<TView> | null> {
-    // Wait for a card to become available in hydratedQ
-    while (this.hydratedQ.length === 0 && this.hasAvailableCards()) {
-      await new Promise((resolve) => setTimeout(resolve, 25)); // Short polling interval
-    }
-    return this.hydratedQ.dequeue();
-  }
-
-  private async _fillHydratedQueue() {
-    if (this.hydration_in_progress) {
-      return; // Prevent concurrent hydration
-    }
-
-    const BUFFER_SIZE = 5;
-    this.hydration_in_progress = true;
-
-    while (this.hydratedQ.length < BUFFER_SIZE) {
-      const nextItem = this._selectNextItemToHydrate();
-      if (!nextItem) {
-        this.hydration_in_progress = false;
-        return; // No more cards to hydrate
-      }
-
-      try {
-        // If the card is a failed card, it may be in the cache
-        if (this.failedCardCache.has(nextItem.cardID)) {
-          const cachedCard = this.failedCardCache.get(nextItem.cardID)!;
-          this.hydratedQ.add(cachedCard, cachedCard.item.cardID);
-          this.failedCardCache.delete(nextItem.cardID);
-        } else {
-          const cardData = await this.dataLayer
-            .getCourseDB(nextItem.courseID)
-            .getCourseDoc<CardData>(nextItem.cardID);
-
-          if (!isCourseElo(cardData.elo)) {
-            cardData.elo = toCourseElo(cardData.elo);
-          }
-
-          const view = this.getViewComponent(cardData.id_view);
-          const dataDocs = await Promise.all(
-            cardData.id_displayable_data.map((id: string) =>
-              this.dataLayer.getCourseDB(nextItem.courseID).getCourseDoc<DisplayableData>(id, {
-                attachments: true,
-                binary: true,
-              })
-            )
-          );
-
-          const data = dataDocs.map(displayableDataToViewData).reverse();
-
-          this.hydratedQ.add(
-            {
-              item: nextItem,
-              view,
-              data,
-            },
-            nextItem.cardID
-          );
-        }
-      } catch (e) {
-        this.error(`Error hydrating card ${nextItem.cardID}:`, e);
-      } finally {
-        // Remove the item from the original queue, regardless of success/failure/cache
-        if (this.reviewQ.peek(0) === nextItem) {
-          this.reviewQ.dequeue();
-        } else if (this.newQ.peek(0) === nextItem) {
-          this.newQ.dequeue();
-        } else {
-          this.failedQ.dequeue();
-        }
-      }
+  /**
+   * Helper method for CardHydrationService to remove items from appropriate queue.
+   */
+  private removeItemFromQueue(item: StudySessionItem): void {
+    if (this.reviewQ.peek(0) === item) {
+      this.reviewQ.dequeue((queueItem) => queueItem.cardID);
+    } else if (this.newQ.peek(0) === item) {
+      this.newQ.dequeue((queueItem) => queueItem.cardID);
+    } else {
+      this.failedQ.dequeue((queueItem) => queueItem.cardID);
     }
-
-    this.hydration_in_progress = false;
   }
 }
diff --git a/packages/db/src/study/services/CardHydrationService.ts b/packages/db/src/study/services/CardHydrationService.ts
new file mode 100644
index 000000000..753a6d27f
--- /dev/null
+++ b/packages/db/src/study/services/CardHydrationService.ts
@@ -0,0 +1,153 @@
+import {
+  displayableDataToViewData,
+  CardData,
+  DisplayableData,
+  isCourseElo,
+  toCourseElo,
+} from '@vue-skuilder/common';
+import { StudySessionItem } from '@db/impl/couch';
+import { logger } from '@db/util/logger';
+import { ItemQueue } from '../ItemQueue';
+import { CourseDBInterface } from '@db/core';
+
+export interface HydratedCard<TView = unknown> {
+  item: StudySessionItem;
+  view: TView;
+  data: any[];
+}
+
+// ItemQueue now imported from separate file
+
+/**
+ * Service responsible for managing a queue of hydrated (ready-to-display) cards.
+ * Handles pre-fetching card data, caching failed cards, and maintaining optimal buffer size.
+ */
+export class CardHydrationService<TView = unknown> {
+  private hydratedQ: ItemQueue<HydratedCard<TView>> = new ItemQueue<HydratedCard<TView>>();
+  private failedCardCache: Map<string, HydratedCard<TView>> = new Map();
+  private hydrationInProgress: boolean = false;
+  private readonly BUFFER_SIZE = 5;
+
+  constructor(
+    private getViewComponent: (viewId: string) => TView,
+    private getCourseDB: (courseId: string) => CourseDBInterface,
+    private selectNextItemToHydrate: () => StudySessionItem | null,
+    private removeItemFromQueue: (item: StudySessionItem) => void,
+    private hasAvailableCards: () => boolean
+  ) {}
+
+  /**
+   * Get the next hydrated card from the queue.
+   * @returns Hydrated card or null if none available
+   */
+  public dequeueHydratedCard(): HydratedCard<TView> | null {
+    return this.hydratedQ.dequeue((item) => item.item.cardID);
+  }
+
+  /**
+   * Check if hydration should be triggered and start background hydration if needed.
+   */
+  public async ensureHydratedCards(): Promise<void> {
+    // Trigger background hydration to maintain cache (async, non-blocking)
+    if (this.hydratedQ.length < 3) {
+      void this.fillHydratedQueue();
+    }
+  }
+
+  /**
+   * Wait for a hydrated card to become available.
+   * @returns Promise that resolves to a hydrated card or null
+   */
+  public async waitForHydratedCard(): Promise<HydratedCard<TView> | null> {
+    // If no hydrated card but source cards available, start hydration
+    if (this.hydratedQ.length === 0 && this.hasAvailableCards()) {
+      void this.fillHydratedQueue(); // Start hydration in background
+    }
+
+    // Wait for a card to become available in hydratedQ
+    while (this.hydratedQ.length === 0 && this.hasAvailableCards()) {
+      await new Promise((resolve) => setTimeout(resolve, 25)); // Short polling interval
+    }
+
+    return this.dequeueHydratedCard();
+  }
+
+  /**
+   * Get current hydrated queue length.
+   */
+  public get hydratedCount(): number {
+    return this.hydratedQ.length;
+  }
+
+  /**
+   * Fill the hydrated queue up to BUFFER_SIZE with pre-fetched cards.
+   */
+  private async fillHydratedQueue(): Promise<void> {
+    if (this.hydrationInProgress) {
+      return; // Prevent concurrent hydration
+    }
+
+    this.hydrationInProgress = true;
+
+    try {
+      while (this.hydratedQ.length < this.BUFFER_SIZE) {
+        const nextItem = this.selectNextItemToHydrate();
+        if (!nextItem) {
+          return; // No more cards to hydrate
+        }
+
+        try {
+          // Check cache first for failed cards
+          if (this.failedCardCache.has(nextItem.cardID)) {
+            const cachedCard = this.failedCardCache.get(nextItem.cardID)!;
+            this.hydratedQ.add(cachedCard, cachedCard.item.cardID);
+            this.failedCardCache.delete(nextItem.cardID);
+          } else {
+            // Hydrate new card using original logic pattern
+            const courseDB = this.getCourseDB(nextItem.courseID);
+            const cardData = await courseDB.getCourseDoc<CardData>(nextItem.cardID);
+
+            if (!isCourseElo(cardData.elo)) {
+              cardData.elo = toCourseElo(cardData.elo);
+            }
+
+            const view = this.getViewComponent(cardData.id_view);
+            const dataDocs = await Promise.all(
+              cardData.id_displayable_data.map((id: string) =>
+                courseDB.getCourseDoc<DisplayableData>(id, {
+                  attachments: true,
+                  binary: true,
+                })
+              )
+            );
+
+            const data = dataDocs.map(displayableDataToViewData).reverse();
+
+            this.hydratedQ.add(
+              {
+                item: nextItem,
+                view,
+                data,
+              },
+              nextItem.cardID
+            );
+          }
+        } catch (e) {
+          logger.error(`Error hydrating card ${nextItem.cardID}:`, e);
+        } finally {
+          // Remove the item from the original queue, regardless of success/failure/cache
+          this.removeItemFromQueue(nextItem);
+        }
+      }
+    } finally {
+      this.hydrationInProgress = false;
+    }
+  }
+
+  /**
+   * Cache a failed card for quick re-access.
+   */
+  public cacheFailedCard(card: HydratedCard<TView>): void {
+    this.failedCardCache.set(card.item.cardID, card);
+  }
+}
diff --git a/packages/db/src/study/services/EloService.ts b/packages/db/src/study/services/EloService.ts
new file mode 100644
index 000000000..4e15e2527
--- /dev/null
+++ b/packages/db/src/study/services/EloService.ts
@@ -0,0 +1,85 @@
+import { adjustCourseScores, toCourseElo } from '@vue-skuilder/common';
+import { DataLayerProvider, UserDBInterface, CourseRegistrationDoc } from '@db/core';
+import { StudySessionRecord } from '../SessionController';
+import { logger } from '@db/util/logger';
+
+/**
+ * Service responsible for ELO rating calculations and updates.
+ */
+export class EloService {
+  private dataLayer: DataLayerProvider;
+  private user: UserDBInterface;
+
+  constructor(dataLayer: DataLayerProvider, user: UserDBInterface) {
+    this.dataLayer = dataLayer;
+    this.user = user;
+  }
+
+  /**
+   * Updates both user and card ELO ratings based on user performance.
+   * @param userScore Score between 0-1 representing user performance
+   * @param course_id Course identifier
+   * @param card_id Card identifier  
+   * @param userCourseRegDoc User's course registration document (will be mutated)
+   * @param currentCard Current card session record
+   * @param k Optional K-factor for ELO calculation
+   */
+  public async updateUserAndCardElo(
+    userScore: number,
+    course_id: string,
+    card_id: string,
+    userCourseRegDoc: CourseRegistrationDoc,
+    currentCard: StudySessionRecord,
+    k?: number
+  ): Promise<void> {
+    if (k) {
+      logger.warn(`k value interpretation not currently implemented`);
+    }
+    const courseDB = this.dataLayer.getCourseDB(currentCard.card.course_id);
+    const userElo = toCourseElo(userCourseRegDoc.courses.find((c) => c.courseID === course_id)!.elo);
+    const cardElo = (await courseDB.getCardEloData([currentCard.card.card_id]))[0];
+
+    if (cardElo && userElo) {
+      const eloUpdate = adjustCourseScores(userElo, cardElo, userScore);
+      userCourseRegDoc.courses.find((c) => c.courseID === course_id)!.elo = eloUpdate.userElo;
+
+      const results = await Promise.allSettled([
+        this.user.updateUserElo(course_id, eloUpdate.userElo),
+        courseDB.updateCardElo(card_id, eloUpdate.cardElo),
+      ]);
+
+      // Check the results of each operation
+      const userEloStatus = results[0].status === 'fulfilled';
+      const cardEloStatus = results[1].status === 'fulfilled';
+
+      if (userEloStatus && cardEloStatus) {
+        const user = (results[0] as PromiseFulfilledResult<any>).value;
+        const card = (results[1] as PromiseFulfilledResult<any>).value;
+
+        if (user.ok && card && card.ok) {
+          logger.info(
+            `[EloService] Updated ELOS:
+            \tUser: ${JSON.stringify(eloUpdate.userElo)})
+            \tCard: ${JSON.stringify(eloUpdate.cardElo)})
+            `
+          );
+        }
+      } else {
+        // Log which operations succeeded and which failed
+        logger.warn(
+          `[EloService] Partial ELO update:
+          \tUser ELO update: ${userEloStatus ? 'SUCCESS' : 'FAILED'}
+          \tCard ELO update: ${cardEloStatus ? 'SUCCESS' : 'FAILED'}`
+        );
+
+        if (!userEloStatus && results[0].status === 'rejected') {
+          logger.error('[EloService] User ELO update error:', results[0].reason);
+        }
+
+        if (!cardEloStatus && results[1].status === 'rejected') {
+          logger.error('[EloService] Card ELO update error:', results[1].reason);
+        }
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/packages/db/src/study/services/ResponseProcessor.ts b/packages/db/src/study/services/ResponseProcessor.ts
new file mode 100644
index 000000000..5f44cbd97
--- /dev/null
+++ b/packages/db/src/study/services/ResponseProcessor.ts
@@ -0,0 +1,224 @@
+import {
+  CardHistory,
+  CardRecord,
+  CourseRegistrationDoc,
+  isQuestionRecord,
+  QuestionRecord,
+  StudySessionItem,
+} from '@db/core';
+import { logger } from '@db/util/logger';
+import { ResponseResult, StudySessionRecord } from '../SessionController';
+import { EloService } from './EloService';
+import { SrsService } from './SrsService';
+
+/**
+ * Service responsible for orchestrating the complete response processing workflow.
+ * Coordinates SRS scheduling and ELO updates for user card interactions.
+ */
+export class ResponseProcessor {
+  private srsService: SrsService;
+  private eloService: EloService;
+
+  constructor(srsService: SrsService, eloService: EloService) {
+    this.srsService = srsService;
+    this.eloService = eloService;
+  }
+
+  /**
+   * Processes a user's response to a card, handling SRS scheduling and ELO updates.
+   * @param cardRecord User's response record
+   * @param cardHistory Promise resolving to the card's history
+   * @param studySessionItem Current study session item
+   * @param courseRegistrationDoc User's course registration (for ELO updates)
+   * @param currentCard Current study session record
+   * @param courseId Course identifier
+   * @param cardId Card identifier
+   * @param maxAttemptsPerView Maximum attempts allowed per view
+   * @param maxSessionViews Maximum session views for this card
+   * @param sessionViews Current number of session views
+   * @returns ResponseResult with navigation and UI instructions
+   */
+  public async processResponse(
+    cardRecord: CardRecord,
+    cardHistory: Promise<CardHistory<CardRecord>>,
+    studySessionItem: StudySessionItem,
+    courseRegistrationDoc: CourseRegistrationDoc,
+    currentCard: StudySessionRecord,
+    courseId: string,
+    cardId: string,
+    maxAttemptsPerView: number,
+    maxSessionViews: number,
+    sessionViews: number
+  ): Promise<ResponseResult> {
+    // Handle non-question records (simple dismiss)
+    if (!isQuestionRecord(cardRecord)) {
+      return {
+        nextCardAction: 'dismiss-success',
+        shouldLoadNextCard: true,
+        isCorrect: true, // non-question records are considered "correct"
+        shouldClearFeedbackShadow: true,
+      };
+    }
+
+    const history = await cardHistory;
+
+    // Handle correct responses
+    if (cardRecord.isCorrect) {
+      return await this.processCorrectResponse(
+        cardRecord,
+        history,
+        studySessionItem,
+        courseRegistrationDoc,
+        currentCard,
+        courseId,
+        cardId
+      );
+    } else {
+      // Handle incorrect responses
+      return await this.processIncorrectResponse(
+        cardRecord,
+        history,
+        courseRegistrationDoc,
+        currentCard,
+        courseId,
+        cardId,
+        maxAttemptsPerView,
+        maxSessionViews,
+        sessionViews
+      );
+    }
+  }
+
+  /**
+   * Handles processing for correct responses: SRS scheduling and ELO updates.
+   */
+  private async processCorrectResponse(
+    cardRecord: QuestionRecord,
+    history: CardHistory<CardRecord>,
+    studySessionItem: StudySessionItem,
+    courseRegistrationDoc: CourseRegistrationDoc,
+    currentCard: StudySessionRecord,
+    courseId: string,
+    cardId: string
+  ): Promise<ResponseResult> {
+    // Only schedule and update ELO for first-time attempts
+    if (cardRecord.priorAttemps === 0) {
+      // Schedule the card for future review based on performance
+      await this.srsService.scheduleReview(history, studySessionItem);
+
+      // Update ELO ratings
+      if (history.records.length === 1) {
+        // First interaction with this card - standard ELO update
+        const userScore = 0.5 + (cardRecord.performance as number) / 2;
+        await this.eloService.updateUserAndCardElo(
+          userScore,
+          courseId,
+          cardId,
+          courseRegistrationDoc,
+          currentCard
+        );
+      } else {
+        // Multiple interactions - reduce K-factor to limit ELO volatility
+        const k = Math.ceil(32 / history.records.length);
+        const userScore = 0.5 + (cardRecord.performance as number) / 2;
+        await this.eloService.updateUserAndCardElo(
+          userScore,
+          courseId,
+          cardId,
+          courseRegistrationDoc,
+          currentCard,
+          k
+        );
+      }
+
+      logger.info(
+        '[ResponseProcessor] Processed correct response with SRS scheduling and ELO update'
+      );
+
+      return {
+        nextCardAction: 'dismiss-success',
+        shouldLoadNextCard: true,
+        isCorrect: true,
+        performanceScore: cardRecord.performance as number,
+        shouldClearFeedbackShadow: true,
+      };
+    } else {
+      logger.info(
+        '[ResponseProcessor] Processed correct response (retry attempt - no scheduling/ELO)'
+      );
+
+      return {
+        nextCardAction: 'marked-failed',
+        shouldLoadNextCard: true,
+        isCorrect: true,
+        performanceScore: cardRecord.performance as number,
+        shouldClearFeedbackShadow: true,
+      };
+    }
+  }
+
+  /**
+   * Handles processing for incorrect responses: ELO updates only.
+   */
+  private async processIncorrectResponse(
+    cardRecord: QuestionRecord,
+    history: CardHistory<CardRecord>,
+    courseRegistrationDoc: CourseRegistrationDoc,
+    currentCard: StudySessionRecord,
+    courseId: string,
+    cardId: string,
+    maxAttemptsPerView: number,
+    maxSessionViews: number,
+    sessionViews: number
+  ): Promise<ResponseResult> {
+    // Update ELO for first-time failures (not subsequent attempts on same card)
+    if (history.records.length !== 1 && cardRecord.priorAttemps === 0) {
+      await this.eloService.updateUserAndCardElo(
+        0, // Failed response = 0 score
+        courseId,
+        cardId,
+        courseRegistrationDoc,
+        currentCard
+      );
+      logger.info('[ResponseProcessor] Processed incorrect response with ELO update');
+    } else {
+      logger.info('[ResponseProcessor] Processed incorrect response (no ELO update needed)');
+    }
+
+    // Determine navigation based on attempt limits
+    if (currentCard.records.length >= maxAttemptsPerView) {
+      if (sessionViews >= maxSessionViews) {
+        // Too many session views - dismiss completely with ELO penalty
+        await this.eloService.updateUserAndCardElo(
+          0,
+          courseId,
+          cardId,
+          courseRegistrationDoc,
+          currentCard
+        );
+        return {
+          nextCardAction: 'dismiss-failed',
+          shouldLoadNextCard: true,
+          isCorrect: false,
+          shouldClearFeedbackShadow: true,
+        };
+      } else {
+        // Mark as failed for later retry
+        return {
+          nextCardAction: 'marked-failed',
+          shouldLoadNextCard: true,
+          isCorrect: false,
+          shouldClearFeedbackShadow: true,
+        };
+      }
+    } else {
+      // Allow more attempts on same card
+      return {
+        nextCardAction: 'none',
+        shouldLoadNextCard: false,
+        isCorrect: false,
+        shouldClearFeedbackShadow: true,
+      };
+    }
+  }
+}
diff --git a/packages/db/src/study/services/SrsService.ts b/packages/db/src/study/services/SrsService.ts
new file mode 100644
index 000000000..e0713a9d1
--- /dev/null
+++ b/packages/db/src/study/services/SrsService.ts
@@ -0,0 +1,44 @@
+import moment from 'moment';
+import { CardHistory, CardRecord, UserDBInterface } from '@db/core';
+import { isReview, StudySessionItem } from '@db/impl/couch';
+import { newInterval } from '../SpacedRepetition';
+import { logger } from '@db/util/logger';
+
+/**
+ * Service responsible for Spaced Repetition System (SRS) scheduling logic.
+ */
+export class SrsService {
+  private user: UserDBInterface;
+
+  constructor(user: UserDBInterface) {
+    this.user = user;
+  }
+
+  /**
+   * Calculates the next review time for a card based on its history and
+   * schedules it in the user's database.
+   * @param history The full history of the card.
+   * @param item The study session item, used to determine if a previous review needs to be cleared.
+   */
+  public async scheduleReview(
+    history: CardHistory<CardRecord>,
+    item: StudySessionItem
+  ): Promise<void> {
+    const nextInterval = newInterval(this.user, history);
+    const nextReviewTime = moment.utc().add(nextInterval, 'seconds');
+
+    if (isReview(item)) {
+      logger.info(`[SrsService] Removing previously scheduled review for: ${item.cardID}`);
+      void this.user.removeScheduledCardReview(item.reviewID);
+    }
+
+    void this.user.scheduleCardReview({
+      user: this.user.getUsername(),
+      course_id: history.courseID,
+      card_id: history.cardID,
+      time: nextReviewTime,
+      scheduledFor: item.contentSourceType,
+      schedulingAgentId: item.contentSourceID,
+    });
+  }
+}