From 8585ccb8549bc83eb08f34e80c7b42b47e712ab6 Mon Sep 17 00:00:00 2001
From: Lesia Soloviova <solovyova.lesya@gmail.com>
Date: Tue, 13 Jan 2026 19:56:04 +0200
Subject: [PATCH] feat(quiz): timer fix, answer verification retry, new quiz
 seeds

- Fix timer restart on language switch (use startedAt prop)
- Fix progress bar initial state calculation
- Add answer verification retry with toast notifications
- Hide score display for incomplete quizzes
- Fix guest message condition for incomplete results
- Add Button accent variant (prepared for future use)
- Reorder categories: Next.js before Angular
- Add seed quizzes: Angular, Vue, Node.js (40 questions each)
---
 .gitignore                                    |   1 +
 frontend/components/quiz/CountdownTimer.tsx   |  10 +-
 frontend/components/quiz/QuizContainer.tsx    |  92 +++-
 frontend/components/quiz/QuizResult.tsx       |  50 +-
 frontend/components/ui/button.tsx             |   4 +-
 frontend/data/category.ts                     |   4 +-
 frontend/db/seed-quiz-angular-advanced.ts     | 244 ++++++++++
 frontend/db/seed-quiz-angular.ts              | 244 ++++++++++
 frontend/db/seed-quiz-nodejs-advanced.ts      | 244 ++++++++++
 frontend/db/seed-quiz-nodejs.ts               | 244 ++++++++++
 frontend/db/seed-quiz-vue.ts                  | 243 ++++++++++
 frontend/messages/en.json                     |   4 +-
 frontend/messages/pl.json                     |   6 +-
 frontend/messages/uk.json                     |   4 +-
 .../advanced/angular-advanced-quiz-part1.json | 434 ++++++++++++++++++
 .../advanced/angular-advanced-quiz-part2.json | 434 ++++++++++++++++++
 .../advanced/angular-advanced-quiz-part3.json | 434 ++++++++++++++++++
 .../advanced/angular-advanced-quiz-part4.json | 434 ++++++++++++++++++
 .../advanced/seed-quiz-angular-advanced.ts    | 240 ++++++++++
 .../beginner_medium/angular-quiz-part1.json   | 434 ++++++++++++++++++
 .../beginner_medium/angular-quiz-part2.json   | 434 ++++++++++++++++++
 .../beginner_medium/angular-quiz-part3.json   | 434 ++++++++++++++++++
 .../beginner_medium/angular-quiz-part4.json   | 434 ++++++++++++++++++
 .../beginner_medium/seed-quiz-angular.ts      | 240 ++++++++++
 .../advanced/nodejs-advanced-quiz-part1.json  | 434 ++++++++++++++++++
 .../advanced/nodejs-advanced-quiz-part2.json  | 434 ++++++++++++++++++
 .../advanced/nodejs-advanced-quiz-part3.json  | 434 ++++++++++++++++++
 .../advanced/nodejs-advanced-quiz-part4.json  | 434 ++++++++++++++++++
 .../advanced/seed-quiz-nodejs-advanced.ts     | 240 ++++++++++
 .../beginner_medium/nodejs-quiz-part1.json    | 434 ++++++++++++++++++
 .../beginner_medium/nodejs-quiz-part2.json    | 434 ++++++++++++++++++
 .../beginner_medium/nodejs-quiz-part3.json    | 434 ++++++++++++++++++
 .../beginner_medium/nodejs-quiz-part4.json    | 434 ++++++++++++++++++
 .../seed-quiz-nodejs-fundamentals.ts          | 240 ++++++++++
 .../vue/beginner_medium/seed-quiz-vue.ts      | 239 ++++++++++
 .../vue/beginner_medium/vue-quiz-part1.json   | 434 ++++++++++++++++++
 .../vue/beginner_medium/vue-quiz-part2.json   | 434 ++++++++++++++++++
 .../vue/beginner_medium/vue-quiz-part3.json   | 434 ++++++++++++++++++
 .../vue/beginner_medium/vue-quiz-part4.json   | 434 ++++++++++++++++++
 39 files changed, 11220 insertions(+), 53 deletions(-)
 create mode 100644 frontend/db/seed-quiz-angular-advanced.ts
 create mode 100644 frontend/db/seed-quiz-angular.ts
 create mode 100644 frontend/db/seed-quiz-nodejs-advanced.ts
 create mode 100644 frontend/db/seed-quiz-nodejs.ts
 create mode 100644 frontend/db/seed-quiz-vue.ts
 create mode 100644 json/quizzes/angular/advanced/angular-advanced-quiz-part1.json
 create mode 100644 json/quizzes/angular/advanced/angular-advanced-quiz-part2.json
 create mode 100644 json/quizzes/angular/advanced/angular-advanced-quiz-part3.json
 create mode 100644 json/quizzes/angular/advanced/angular-advanced-quiz-part4.json
 create mode 100644 json/quizzes/angular/advanced/seed-quiz-angular-advanced.ts
 create mode 100644 json/quizzes/angular/beginner_medium/angular-quiz-part1.json
 create mode 100644 json/quizzes/angular/beginner_medium/angular-quiz-part2.json
 create mode 100644 json/quizzes/angular/beginner_medium/angular-quiz-part3.json
 create mode 100644 json/quizzes/angular/beginner_medium/angular-quiz-part4.json
 create mode 100644 json/quizzes/angular/beginner_medium/seed-quiz-angular.ts
 create mode 100644 json/quizzes/node/advanced/nodejs-advanced-quiz-part1.json
 create mode 100644 json/quizzes/node/advanced/nodejs-advanced-quiz-part2.json
 create mode 100644 json/quizzes/node/advanced/nodejs-advanced-quiz-part3.json
 create mode 100644 json/quizzes/node/advanced/nodejs-advanced-quiz-part4.json
 create mode 100644 json/quizzes/node/advanced/seed-quiz-nodejs-advanced.ts
 create mode 100644 json/quizzes/node/beginner_medium/nodejs-quiz-part1.json
 create mode 100644 json/quizzes/node/beginner_medium/nodejs-quiz-part2.json
 create mode 100644 json/quizzes/node/beginner_medium/nodejs-quiz-part3.json
 create mode 100644 json/quizzes/node/beginner_medium/nodejs-quiz-part4.json
 create mode 100644 json/quizzes/node/beginner_medium/seed-quiz-nodejs-fundamentals.ts
 create mode 100644 json/quizzes/vue/beginner_medium/seed-quiz-vue.ts
 create mode 100644 json/quizzes/vue/beginner_medium/vue-quiz-part1.json
 create mode 100644 json/quizzes/vue/beginner_medium/vue-quiz-part2.json
 create mode 100644 json/quizzes/vue/beginner_medium/vue-quiz-part3.json
 create mode 100644 json/quizzes/vue/beginner_medium/vue-quiz-part4.json

diff --git a/.gitignore b/.gitignore
index e7d1e0e3..3f78fe62 100644
--- a/.gitignore
+++ b/.gitignore
@@ -72,3 +72,4 @@ frontend/.env.bak
 frontend/.env*.bak
 frontend/.env.bak
 
+tmpclaude-*
diff --git a/frontend/components/quiz/CountdownTimer.tsx b/frontend/components/quiz/CountdownTimer.tsx
index 55dcead5..01bb05c2 100644
--- a/frontend/components/quiz/CountdownTimer.tsx
+++ b/frontend/components/quiz/CountdownTimer.tsx
@@ -8,17 +8,21 @@ interface CountdownTimerProps {
   timeLimitSeconds: number;
   onTimeUp: () => void;
   isActive: boolean;
+  startedAt: Date;
 }
 
 export function CountdownTimer({
   timeLimitSeconds,
   onTimeUp,
   isActive,
+  startedAt,
 }: CountdownTimerProps) {
   const t = useTranslations('quiz.timer');
-  const [endTime] = useState(() => Date.now() + timeLimitSeconds * 1000);
-  const [remainingSeconds, setRemainingSeconds] = useState(timeLimitSeconds);
-
+  const endTime = startedAt.getTime() + timeLimitSeconds * 1000;
+  const [remainingSeconds, setRemainingSeconds] = useState(() => 
+    Math.max(0, Math.floor((endTime - Date.now()) / 1000))
+  );
+  
   useEffect(() => {
     if (!isActive) return;
 
diff --git a/frontend/components/quiz/QuizContainer.tsx b/frontend/components/quiz/QuizContainer.tsx
index a17c9339..e00896a3 100644
--- a/frontend/components/quiz/QuizContainer.tsx
+++ b/frontend/components/quiz/QuizContainer.tsx
@@ -2,9 +2,8 @@
 
 import { useLocale, useTranslations } from 'next-intl';
 import { useRouter, useSearchParams } from 'next/navigation';
-import { useEffect } from 'react';
-import { savePendingQuizResult } from '@/lib/quiz/guest-quiz';
-import { useReducer, useTransition, useState } from 'react';
+import { useReducer, useTransition, useState, useEffect, useCallback } from 'react';
+import { toast } from 'sonner';
 import { useAntiCheat } from '@/hooks/useAntiCheat';
 import { useQuizSession } from '@/hooks/useQuizSession';
 import { useQuizGuards } from '@/hooks/useQuizGuards';
@@ -12,11 +11,12 @@ import { QuizProgress } from './QuizProgress';
 import { QuizQuestion } from './QuizQuestion';
 import { QuizResult } from './QuizResult';
 import { CountdownTimer } from './CountdownTimer';
-import { Button } from '@/components/ui/button';
 import { submitQuizAttempt } from '@/actions/quiz';
 import { clearQuizSession, type QuizSessionData } from '@/lib/quiz/quiz-session';
+import { savePendingQuizResult } from '@/lib/quiz/guest-quiz';
 import type { QuizQuestionClient } from '@/db/queries/quiz';
 import { ConfirmModal } from '@/components/ui/confirm-modal';
+import { Button } from '@/components/ui/button';
 
 interface Answer {
   questionId: string;
@@ -58,12 +58,15 @@ function quizReducer(state: QuizState, action: QuizAction): QuizState {
       };
 
     case 'ANSWER_SELECTED':
+      const answersWithoutThisQuestion = state.answers.filter(
+        a => a.questionId !== action.payload.questionId
+      );
       return {
         ...state,
         selectedAnswerId: action.payload.answerId,
         questionStatus: 'revealed',
         answers: [
-          ...state.answers,
+          ...answersWithoutThisQuestion,
           {
             questionId: action.payload.questionId,
             selectedAnswerId: action.payload.answerId,
@@ -144,6 +147,7 @@ export function QuizContainer({
 }: QuizContainerProps) {
   const tRules = useTranslations('quiz.rules');
   const tExit = useTranslations('quiz.exitModal');
+  const tQuestion = useTranslations('quiz.question');
   const [isPending, startTransition] = useTransition();
   const [state, dispatch] = useReducer(quizReducer, {
     status: 'rules',
@@ -156,7 +160,8 @@ export function QuizContainer({
     isIncomplete: false,
   });
   const [showExitModal, setShowExitModal] = useState(false);
-  
+  const [isVerifyingAnswer, setIsVerifyingAnswer] = useState(false);
+
   const locale = useLocale();
   const router = useRouter();
   const searchParams = useSearchParams();
@@ -169,10 +174,15 @@ export function QuizContainer({
   const currentQuestion = questions[state.currentIndex];
   const totalQuestions = questions.length;
 
-  useQuizSession({
+  const handleRestoreSession = useCallback(
+  (data: QuizSessionData) => dispatch({ type: 'RESTORE_SESSION', payload: data }),
+  []
+);
+
+useQuizSession({
   quizId,
   state,
-  onRestore: data => dispatch({ type: 'RESTORE_SESSION', payload: data }),
+  onRestore: handleRestoreSession,
 });
 
 const { markQuitting } = useQuizGuards({
@@ -200,7 +210,7 @@ const { markQuitting } = useQuizGuards({
     dispatch({ type: 'START_QUIZ' });
   };
 
- const handleAnswer = async (answerId: string) => {
+  const verifyAnswer = async (answerId: string) => {
   const response = await fetch('/api/quiz/verify-answer', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -210,19 +220,60 @@ const { markQuitting } = useQuizGuards({
       encryptedAnswers,
     }),
   });
-  
-  const { isCorrect } = await response.json();
 
-  dispatch({
-    type: 'ANSWER_SELECTED',
-    payload: {
-      answerId,
-      isCorrect,
-      questionId: currentQuestion.id,
-    },
-  });
+  if (!response.ok) {
+    throw new Error('Verify answer failed');
+  }
+
+  const data = await response.json();
+
+  if (typeof data.isCorrect !== 'boolean') {
+    throw new Error('Invalid verify response');
+  }
+
+  return data.isCorrect;
 };
 
+const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+
+const handleAnswer = async (answerId: string) => {
+  if (state.questionStatus !== 'answering') return;
+  if (isVerifyingAnswer) return;
+
+  setIsVerifyingAnswer(true);
+
+  const maxRetries = 1;
+  let attempt = 0;
+
+  try {
+    while (true) {
+      try {
+        const isCorrect = await verifyAnswer(answerId);
+
+        dispatch({
+          type: 'ANSWER_SELECTED',
+          payload: {
+            answerId,
+            isCorrect,
+            questionId: currentQuestion.id,
+          },
+        });
+        return;
+      } catch {
+        if (attempt >= maxRetries) {
+          toast.error(tQuestion('verifyFailed'));
+          return;
+        }
+        attempt += 1;
+        toast(tQuestion('verifyRetry'));
+        await sleep(600);
+      }
+    }
+  } finally {
+    setIsVerifyingAnswer(false);
+  }
+};
 
   const handleNext = () => {
     if (state.currentIndex + 1 >= totalQuestions) {
@@ -373,7 +424,7 @@ const confirmQuit = () => {
           </div>
         </div>
 
-        <Button onClick={handleStart} className="w-full" size="lg">
+        <Button onClick={handleStart} className="w-full" size="md">
           {tRules('startButton')}
         </Button>
       </div>
@@ -429,6 +480,7 @@ const confirmQuit = () => {
             timeLimitSeconds={calculatedTime}
             onTimeUp={handleTimeUp}
             isActive={state.status === 'in_progress'}
+            startedAt={state.startedAt!}
           />
         );
       })()}
diff --git a/frontend/components/quiz/QuizResult.tsx b/frontend/components/quiz/QuizResult.tsx
index 41acf898..bc3ae888 100644
--- a/frontend/components/quiz/QuizResult.tsx
+++ b/frontend/components/quiz/QuizResult.tsx
@@ -90,27 +90,31 @@ export function QuizResult({
   return (
     <div className="max-w-2xl mx-auto space-y-8">
       <div className="text-center text-6xl">{motivation.emoji}</div>
-      <div className="text-center space-y-2">
-        <h2 className="text-4xl font-bold text-gray-900 dark:text-gray-100">
-          {score} / {total}
-        </h2>
-        <p className="text-xl text-gray-600 dark:text-gray-400">
-          {percentage.toFixed(0)}% {t('correctAnswers')}
-        </p>
-      </div>
-      <div className="space-y-2">
-        <div className="h-4 bg-gray-200 dark:bg-gray-800 rounded-full overflow-hidden">
-          <div
-            className={cn(
-              'h-full transition-all duration-1000 ease-out',
-              percentage < 50 && 'bg-red-500',
-              percentage >= 50 && percentage < 80 && 'bg-orange-500',
-              percentage >= 80 && 'bg-green-500'
-            )}
-            style={{ width: `${percentage}%` }}
-          />
-        </div>
-      </div>
+      {!isIncomplete && (
+        <>
+          <div className="text-center space-y-2">
+            <h2 className="text-4xl font-bold text-gray-900 dark:text-gray-100">
+              {score} / {total}
+            </h2>
+            <p className="text-xl text-gray-600 dark:text-gray-400">
+              {percentage.toFixed(0)}% {t('correctAnswers')}
+            </p>
+          </div>
+          <div className="space-y-2">
+            <div className="h-4 bg-gray-200 dark:bg-gray-800 rounded-full overflow-hidden">
+              <div
+                className={cn(
+                  'h-full transition-all duration-1000 ease-out',
+                  percentage < 50 && 'bg-red-500',
+                  percentage >= 50 && percentage < 80 && 'bg-orange-500',
+                  percentage >= 80 && 'bg-green-500'
+                )}
+                style={{ width: `${percentage}%` }}
+              />
+            </div>
+          </div>
+        </>
+      )}
       <div className="text-center space-y-2">
         <h3 className={cn('text-xl font-semibold', motivation.color)}>
           {motivation.title}
@@ -141,7 +145,7 @@ export function QuizResult({
           </p>
         </div>
       )}
-      {isGuest ? (
+      {isGuest && !isIncomplete ? (
   <div className="space-y-4">
     <div className="p-4 rounded-xl bg-blue-50 dark:bg-blue-900/20 border border-blue-200 dark:border-blue-800">
       <p className="text-center text-blue-800 dark:text-blue-200 font-medium">
@@ -154,7 +158,7 @@ export function QuizResult({
       const url = `/${locale}/login?returnTo=/quiz/${quizSlug}`;
       window.location.href = url;
     }}
-    variant="primary">
+   >
     {t('loginButton')}
   </Button>
   <Button
diff --git a/frontend/components/ui/button.tsx b/frontend/components/ui/button.tsx
index deb82d90..90d71d5f 100644
--- a/frontend/components/ui/button.tsx
+++ b/frontend/components/ui/button.tsx
@@ -3,7 +3,7 @@
 
   export interface ButtonProps
     extends React.ButtonHTMLAttributes<HTMLButtonElement> {
-    variant?: 'primary' | 'secondary' | 'outline';
+    variant?: 'primary' | 'secondary' | 'outline'| 'accent';
     size?: 'sm' | 'md' | 'lg';
   }
 
@@ -17,6 +17,8 @@
             'disabled:opacity-50 disabled:pointer-events-none',
 
             // Variants
+            variant === 'accent' &&
+              'bg-accent text-accent-foreground hover:bg-accent/90',
             variant === 'primary' &&
               'bg-blue-600 text-white hover:bg-blue-700 active:bg-blue-800',
             variant === 'secondary' &&
diff --git a/frontend/data/category.ts b/frontend/data/category.ts
index d5c02471..3dc021c9 100644
--- a/frontend/data/category.ts
+++ b/frontend/data/category.ts
@@ -15,8 +15,8 @@ export const categoryData = [
   createCategory('javascript', 'JavaScript', 3),
   createCategory('typescript', 'TypeScript', 4),
   createCategory('react', 'React', 5),
-  createCategory('angular', 'Angular', 6),
+  createCategory('next', 'Next.js', 6),
   createCategory('vue', 'Vue.js', 7),
-  createCategory('next', 'Next.js', 8),
+  createCategory('angular', 'Angular', 8),
   createCategory('node', 'Node.js', 9),
 ];
diff --git a/frontend/db/seed-quiz-angular-advanced.ts b/frontend/db/seed-quiz-angular-advanced.ts
new file mode 100644
index 00000000..e47306ab
--- /dev/null
+++ b/frontend/db/seed-quiz-angular-advanced.ts
@@ -0,0 +1,244 @@
+import { eq } from 'drizzle-orm';
+import { readFileSync,existsSync } from 'fs';
+import { join } from 'path';
+import { db } from './index';
+import { categories } from './schema/categories';
+import {
+  quizzes,
+  quizTranslations,
+  quizQuestions,
+  quizQuestionContent,
+  quizAnswers,
+  quizAnswerTranslations,
+  quizAttempts,
+} from './schema/quiz';
+
+type Locale = 'uk' | 'en' | 'pl';
+const LOCALES: Locale[] = ['uk', 'en', 'pl'];
+
+interface QuestionData {
+  id: string;
+  order: number;
+  difficulty: 'beginner' | 'medium' | 'advanced';
+  uk: { q: string; exp: string };
+  en: { q: string; exp: string };
+  pl: { q: string; exp: string };
+  answers: {
+    uk: string;
+    en: string;
+    pl: string;
+    correct: boolean;
+  }[];
+}
+
+interface QuizPartData {
+  questions: QuestionData[];
+}
+
+const CATEGORY_SLUG = 'angular';
+
+const QUIZ_METADATA = {
+  slug: 'angular-advanced',
+  questionsCount: 40,
+  timeLimitSeconds: 2400,
+  translations: {
+    uk: {
+      title: 'Angular Advanced',
+      description: 'Поглиблені концепції Angular: lifecycle hooks, DI декоратори, NgRx, кастомні директиви, SSR, Signals, OnPush та оптимізація продуктивності.',
+    },
+    en: {
+      title: 'Angular Advanced',
+      description: 'Advanced Angular concepts: lifecycle hooks, DI decorators, NgRx, custom directives, SSR, Signals, OnPush and performance optimization.',
+    },
+    pl: {
+      title: 'Angular Advanced',
+      description: 'Zaawansowane koncepcje Angular: lifecycle hooks, dekoratory DI, NgRx, niestandardowe dyrektywy, SSR, Signals, OnPush i optymalizacja wydajności.',
+    },
+  },
+};
+
+function createExplanation(text: string) {
+  return [{ type: 'paragraph' as const, children: [{ text }] }];
+}
+
+const projectRoot = existsSync(join(process.cwd(), 'json'))
+  ? process.cwd()
+  : join(process.cwd(), '..');
+
+async function loadQuestions(partNumber: number): Promise<QuestionData[]> {
+  const partPath = join(projectRoot, 'json', 'quizzes', 'angular', 'advanced', `angular-advanced-quiz-part${partNumber}.json`);
+  const partData: QuizPartData = JSON.parse(readFileSync(partPath, 'utf-8'));
+  return partData.questions;
+}
+
+async function ensureQuizExists(): Promise<string> {
+  console.log('Ensuring quiz exists...');
+
+  // Find category by slug
+  const [category] = await db
+    .select()
+    .from(categories)
+    .where(eq(categories.slug, CATEGORY_SLUG))
+    .limit(1);
+
+  if (!category) {
+    throw new Error(`Category "${CATEGORY_SLUG}" not found. Run seed:categories first.`);
+  }
+
+  // Clean up old quiz by slug
+  const existing = await db.query.quizzes.findFirst({
+    where: eq(quizzes.slug, QUIZ_METADATA.slug),
+  });
+  if (existing) {
+    const existingAttempt = await db.query.quizAttempts.findFirst({
+      where: eq(quizAttempts.quizId, existing.id),
+    });
+    if (existingAttempt) {
+      throw new Error(`Quiz ${QUIZ_METADATA.slug} has existing attempts. Aborting to avoid data loss.`);
+    }
+
+    await db.delete(quizQuestions).where(eq(quizQuestions.quizId, existing.id));
+    await db.delete(quizTranslations).where(eq(quizTranslations.quizId, existing.id));
+    await db.update(quizzes).set({
+      categoryId: category.id,
+      slug: QUIZ_METADATA.slug,
+      displayOrder: 2,
+      questionsCount: QUIZ_METADATA.questionsCount,
+      timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+      isActive: true,
+    }).where(eq(quizzes.id, existing.id));
+
+    const quizId = existing.id;
+    for (const locale of LOCALES) {
+      await db.insert(quizTranslations).values({
+        quizId,
+        locale,
+        title: QUIZ_METADATA.translations[locale].title,
+        description: QUIZ_METADATA.translations[locale].description,
+      });
+    }
+
+    return quizId;
+  }
+
+  const [quiz] = await db.insert(quizzes).values({
+    categoryId: category.id,
+    slug: QUIZ_METADATA.slug,
+    displayOrder: 2,
+    questionsCount: QUIZ_METADATA.questionsCount,
+    timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+    isActive: true,
+  }).returning();
+
+  for (const locale of LOCALES) {
+    await db.insert(quizTranslations).values({
+      quizId: quiz.id,
+      locale,
+      title: QUIZ_METADATA.translations[locale].title,
+      description: QUIZ_METADATA.translations[locale].description,
+    });
+  }
+
+  return quiz.id;
+}
+
+async function seedQuestions(questions: QuestionData[], quizId: string, partNumber: number) {
+  console.log(`Seeding ${questions.length} questions from part ${partNumber}...`);
+
+  for (const question of questions) {
+    const [q] = await db.insert(quizQuestions).values({
+      quizId,
+      displayOrder: question.order,
+      difficulty: question.difficulty,
+    }).returning();
+
+    for (const locale of LOCALES) {
+      await db.insert(quizQuestionContent).values({
+        quizQuestionId: q.id,
+        locale,
+        questionText: question[locale].q,
+        explanation: createExplanation(question[locale].exp),
+      });
+    }
+
+    for (let i = 0; i < question.answers.length; i++) {
+      const answer = question.answers[i];
+      
+      const [a] = await db.insert(quizAnswers).values({
+        quizQuestionId: q.id,
+        displayOrder: i + 1,
+        isCorrect: answer.correct,
+      }).returning();
+
+      for (const locale of LOCALES) {
+        await db.insert(quizAnswerTranslations).values({
+          quizAnswerId: a.id,
+          locale,
+          answerText: answer[locale],
+        });
+      }
+    }
+  }
+
+  console.log(`Part ${partNumber} completed (${questions.length} questions)`);
+}
+
+async function seedQuizFromJson() {
+  const args = process.argv.slice(2);
+  const partArg = args[0];
+
+  if (!partArg) {
+    console.error('Error: Please specify which part to upload');
+    console.log('Usage: npx tsx db/seeds/seed-quiz-angular-advanced.ts <part-number>');
+    console.log('Example: npx tsx db/seeds/seed-quiz-angular-advanced.ts 1');
+    console.log('Or upload all: npx tsx db/seeds/seed-quiz-angular-advanced.ts all');
+    process.exit(1);
+  }
+
+  console.log('Starting Angular Advanced quiz seed...\n');
+
+  try {
+    const quizId = await ensureQuizExists();
+
+    if (partArg.toLowerCase() === 'all') {
+      console.log('Uploading all parts...\n');
+      let totalQuestions = 0;
+
+      for (let i = 1; i <= 4; i++) {
+        const questions = await loadQuestions(i);
+        await seedQuestions(questions, quizId, i);
+        totalQuestions += questions.length;
+      }
+
+      console.log('\nAll parts seeded successfully!');
+      console.log(`   - 1 quiz with ${LOCALES.length} translations`);
+      console.log(`   - ${totalQuestions} questions total`);
+      console.log(`   - ${totalQuestions * 4} answers with ${LOCALES.length} translations each`);
+    } else {
+      const partNumber = parseInt(partArg, 10);
+
+      if (isNaN(partNumber) || partNumber < 1 || partNumber > 4) {
+        console.error('Error: Part number must be between 1 and 4');
+        process.exit(1);
+      }
+
+      const questions = await loadQuestions(partNumber);
+      await seedQuestions(questions, quizId, partNumber);
+
+      console.log('\nPart seeded successfully!');
+      console.log(`   - Quiz: ${QUIZ_METADATA.translations.en.title}`);
+      console.log(`   - Part ${partNumber}: ${questions.length} questions`);
+      console.log(`   - ${questions.length * 4} answers with ${LOCALES.length} translations each`);
+    }
+  } catch (error) {
+    console.error('\nError seeding quiz:', error);
+    throw error;
+  }
+}
+
+seedQuizFromJson()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/frontend/db/seed-quiz-angular.ts b/frontend/db/seed-quiz-angular.ts
new file mode 100644
index 00000000..5cf798f4
--- /dev/null
+++ b/frontend/db/seed-quiz-angular.ts
@@ -0,0 +1,244 @@
+import { eq } from 'drizzle-orm';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { db } from './index';
+import { categories } from './schema/categories';
+import {
+  quizzes,
+  quizTranslations,
+  quizQuestions,
+  quizQuestionContent,
+  quizAnswers,
+  quizAnswerTranslations,
+  quizAttempts,
+} from './schema/quiz';
+
+type Locale = 'uk' | 'en' | 'pl';
+const LOCALES: Locale[] = ['uk', 'en', 'pl'];
+
+interface QuestionData {
+  id: string;
+  order: number;
+  difficulty: 'beginner' | 'medium' | 'advanced';
+  uk: { q: string; exp: string };
+  en: { q: string; exp: string };
+  pl: { q: string; exp: string };
+  answers: {
+    uk: string;
+    en: string;
+    pl: string;
+    correct: boolean;
+  }[];
+}
+
+interface QuizPartData {
+  questions: QuestionData[];
+}
+
+const CATEGORY_SLUG = 'angular';
+
+const QUIZ_METADATA = {
+  slug: 'angular-fundamentals',
+  questionsCount: 40,
+  timeLimitSeconds: 1200,
+  translations: {
+    uk: {
+      title: 'Основи Angular',
+      description: 'Перевірте свої знання базових концепцій Angular: компоненти, директиви, сервіси, DI, маршрутизація, форми, Signals та RxJS.',
+    },
+    en: {
+      title: 'Angular Fundamentals',
+      description: 'Test your knowledge of Angular basics: components, directives, services, DI, routing, forms, Signals, and RxJS.',
+    },
+    pl: {
+      title: 'Podstawy Angular',
+      description: 'Sprawdź swoją wiedzę o podstawach Angular: komponenty, dyrektywy, serwisy, DI, routing, formularze, Signals i RxJS.',
+    },
+  },
+};
+
+function createExplanation(text: string) {
+  return [{ type: 'paragraph' as const, children: [{ text }] }];
+}
+
+const projectRoot = existsSync(join(process.cwd(), 'json'))
+  ? process.cwd()
+  : join(process.cwd(), '..');
+
+async function loadQuestions(partNumber: number): Promise<QuestionData[]> {
+  const partPath = join(projectRoot, 'json', 'quizzes', 'angular', 'beginner_medium', `angular-quiz-part${partNumber}.json`);
+  const partData: QuizPartData = JSON.parse(readFileSync(partPath, 'utf-8'));
+  return partData.questions;
+}
+
+async function ensureQuizExists(): Promise<string> {
+  console.log('Ensuring quiz exists...');
+
+  // Find category by slug
+  const [category] = await db
+    .select()
+    .from(categories)
+    .where(eq(categories.slug, CATEGORY_SLUG))
+    .limit(1);
+
+  if (!category) {
+    throw new Error(`Category "${CATEGORY_SLUG}" not found. Run seed:categories first.`);
+  }
+
+  // Clean up old quiz by slug
+  const existing = await db.query.quizzes.findFirst({
+    where: eq(quizzes.slug, QUIZ_METADATA.slug),
+  });
+  if (existing) {
+    const existingAttempt = await db.query.quizAttempts.findFirst({
+      where: eq(quizAttempts.quizId, existing.id),
+    });
+    if (existingAttempt) {
+      throw new Error(`Quiz ${QUIZ_METADATA.slug} has existing attempts. Aborting to avoid data loss.`);
+    }
+
+    await db.delete(quizQuestions).where(eq(quizQuestions.quizId, existing.id));
+    await db.delete(quizTranslations).where(eq(quizTranslations.quizId, existing.id));
+    await db.update(quizzes).set({
+      categoryId: category.id,
+      slug: QUIZ_METADATA.slug,
+      displayOrder: 1,
+      questionsCount: QUIZ_METADATA.questionsCount,
+      timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+      isActive: true,
+    }).where(eq(quizzes.id, existing.id));
+
+    const quizId = existing.id;
+    for (const locale of LOCALES) {
+      await db.insert(quizTranslations).values({
+        quizId,
+        locale,
+        title: QUIZ_METADATA.translations[locale].title,
+        description: QUIZ_METADATA.translations[locale].description,
+      });
+    }
+
+    return quizId;
+  }
+
+  const [quiz] = await db.insert(quizzes).values({
+    categoryId: category.id,
+    slug: QUIZ_METADATA.slug,
+    displayOrder: 1,
+    questionsCount: QUIZ_METADATA.questionsCount,
+    timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+    isActive: true,
+  }).returning();
+
+  for (const locale of LOCALES) {
+    await db.insert(quizTranslations).values({
+      quizId: quiz.id,
+      locale,
+      title: QUIZ_METADATA.translations[locale].title,
+      description: QUIZ_METADATA.translations[locale].description,
+    });
+  }
+
+  return quiz.id;
+}
+
+async function seedQuestions(questions: QuestionData[], quizId: string, partNumber: number) {
+  console.log(`Seeding ${questions.length} questions from part ${partNumber}...`);
+
+  for (const question of questions) {
+    const [q] = await db.insert(quizQuestions).values({
+      quizId,
+      displayOrder: question.order,
+      difficulty: question.difficulty,
+    }).returning();
+
+    for (const locale of LOCALES) {
+      await db.insert(quizQuestionContent).values({
+        quizQuestionId: q.id,
+        locale,
+        questionText: question[locale].q,
+        explanation: createExplanation(question[locale].exp),
+      });
+    }
+
+    for (let i = 0; i < question.answers.length; i++) {
+      const answer = question.answers[i];
+      
+      const [a] = await db.insert(quizAnswers).values({
+        quizQuestionId: q.id,
+        displayOrder: i + 1,
+        isCorrect: answer.correct,
+      }).returning();
+
+      for (const locale of LOCALES) {
+        await db.insert(quizAnswerTranslations).values({
+          quizAnswerId: a.id,
+          locale,
+          answerText: answer[locale],
+        });
+      }
+    }
+  }
+
+  console.log(`Part ${partNumber} completed (${questions.length} questions)`);
+}
+
+async function seedQuizFromJson() {
+  const args = process.argv.slice(2);
+  const partArg = args[0];
+
+  if (!partArg) {
+    console.error('Error: Please specify which part to upload');
+    console.log('Usage: npx tsx db/seeds/seed-quiz-angular.ts <part-number>');
+    console.log('Example: npx tsx db/seeds/seed-quiz-angular.ts 1');
+    console.log('Or upload all: npx tsx db/seeds/seed-quiz-angular.ts all');
+    process.exit(1);
+  }
+
+  console.log('Starting Angular quiz seed...\n');
+
+  try {
+    const quizId = await ensureQuizExists();
+
+    if (partArg.toLowerCase() === 'all') {
+      console.log('Uploading all parts...\n');
+      let totalQuestions = 0;
+
+      for (let i = 1; i <= 4; i++) {
+        const questions = await loadQuestions(i);
+        await seedQuestions(questions, quizId, i);
+        totalQuestions += questions.length;
+      }
+
+      console.log('\nAll parts seeded successfully!');
+      console.log(`   - 1 quiz with ${LOCALES.length} translations`);
+      console.log(`   - ${totalQuestions} questions total`);
+      console.log(`   - ${totalQuestions * 4} answers with ${LOCALES.length} translations each`);
+    } else {
+      const partNumber = parseInt(partArg, 10);
+
+      if (isNaN(partNumber) || partNumber < 1 || partNumber > 4) {
+        console.error('Error: Part number must be between 1 and 4');
+        process.exit(1);
+      }
+
+      const questions = await loadQuestions(partNumber);
+      await seedQuestions(questions, quizId, partNumber);
+
+      console.log('\nPart seeded successfully!');
+      console.log(`   - Quiz: ${QUIZ_METADATA.translations.en.title}`);
+      console.log(`   - Part ${partNumber}: ${questions.length} questions`);
+      console.log(`   - ${questions.length * 4} answers with ${LOCALES.length} translations each`);
+    }
+  } catch (error) {
+    console.error('\nError seeding quiz:', error);
+    throw error;
+  }
+}
+
+seedQuizFromJson()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/frontend/db/seed-quiz-nodejs-advanced.ts b/frontend/db/seed-quiz-nodejs-advanced.ts
new file mode 100644
index 00000000..9ecdbda6
--- /dev/null
+++ b/frontend/db/seed-quiz-nodejs-advanced.ts
@@ -0,0 +1,244 @@
+import { eq } from 'drizzle-orm';
+import { readFileSync, existsSync} from 'fs';
+import { join } from 'path';
+import { db } from './index';
+import { categories } from './schema/categories';
+import {
+  quizzes,
+  quizTranslations,
+  quizQuestions,
+  quizQuestionContent,
+  quizAnswers,
+  quizAnswerTranslations,
+  quizAttempts,
+} from './schema/quiz';
+
+type Locale = 'uk' | 'en' | 'pl';
+const LOCALES: Locale[] = ['uk', 'en', 'pl'];
+
+interface QuestionData {
+  id: string;
+  order: number;
+  difficulty: 'beginner' | 'medium' | 'advanced';
+  uk: { q: string; exp: string };
+  en: { q: string; exp: string };
+  pl: { q: string; exp: string };
+  answers: {
+    uk: string;
+    en: string;
+    pl: string;
+    correct: boolean;
+  }[];
+}
+
+interface QuizPartData {
+  questions: QuestionData[];
+}
+
+const CATEGORY_SLUG = 'node';
+
+const QUIZ_METADATA = {
+  slug: 'node-advanced',
+  questionsCount: 40,
+  timeLimitSeconds: 1200,
+  translations: {
+    uk: {
+      title: 'Node.js Advanced',
+      description: 'Поглиблені знання Node.js: мікросервіси, gRPC, GraphQL, NestJS, serverless, CI/CD, Kubernetes, безпека та масштабування.',
+    },
+    en: {
+      title: 'Node.js Advanced',
+      description: 'Advanced Node.js knowledge: microservices, gRPC, GraphQL, NestJS, serverless, CI/CD, Kubernetes, security, and scaling.',
+    },
+    pl: {
+      title: 'Node.js Advanced',
+      description: 'Zaawansowana wiedza o Node.js: mikroserwisy, gRPC, GraphQL, NestJS, serverless, CI/CD, Kubernetes, bezpieczeństwo i skalowanie.',
+    },
+  },
+};
+
+function createExplanation(text: string) {
+  return [{ type: 'paragraph' as const, children: [{ text }] }];
+}
+
+const projectRoot = existsSync(join(process.cwd(), 'json'))
+  ? process.cwd()
+  : join(process.cwd(), '..');
+
+async function loadQuestions(partNumber: number): Promise<QuestionData[]> {
+  const partPath = join(projectRoot, 'json', 'quizzes', 'node', 'advanced', `nodejs-advanced-quiz-part${partNumber}.json`);
+  const partData: QuizPartData = JSON.parse(readFileSync(partPath, 'utf-8'));
+  return partData.questions;
+}
+
+async function ensureQuizExists(): Promise<string> {
+  console.log('Ensuring quiz exists...');
+
+  // Find category by slug
+  const [category] = await db
+    .select()
+    .from(categories)
+    .where(eq(categories.slug, CATEGORY_SLUG))
+    .limit(1);
+
+  if (!category) {
+    throw new Error(`Category "${CATEGORY_SLUG}" not found. Run seed:categories first.`);
+  }
+
+  // Clean up old quiz by slug
+  const existing = await db.query.quizzes.findFirst({
+    where: eq(quizzes.slug, QUIZ_METADATA.slug),
+  });
+  if (existing) {
+    const existingAttempt = await db.query.quizAttempts.findFirst({
+      where: eq(quizAttempts.quizId, existing.id),
+    });
+    if (existingAttempt) {
+      throw new Error(`Quiz ${QUIZ_METADATA.slug} has existing attempts. Aborting to avoid data loss.`);
+    }
+
+    await db.delete(quizQuestions).where(eq(quizQuestions.quizId, existing.id));
+    await db.delete(quizTranslations).where(eq(quizTranslations.quizId, existing.id));
+    await db.update(quizzes).set({
+      categoryId: category.id,
+      slug: QUIZ_METADATA.slug,
+      displayOrder: 2,
+      questionsCount: QUIZ_METADATA.questionsCount,
+      timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+      isActive: true,
+    }).where(eq(quizzes.id, existing.id));
+
+    const quizId = existing.id;
+    for (const locale of LOCALES) {
+      await db.insert(quizTranslations).values({
+        quizId,
+        locale,
+        title: QUIZ_METADATA.translations[locale].title,
+        description: QUIZ_METADATA.translations[locale].description,
+      });
+    }
+
+    return quizId;
+  }
+
+  const [quiz] = await db.insert(quizzes).values({
+    categoryId: category.id,
+    slug: QUIZ_METADATA.slug,
+    displayOrder: 2,
+    questionsCount: QUIZ_METADATA.questionsCount,
+    timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+    isActive: true,
+  }).returning();
+
+  for (const locale of LOCALES) {
+    await db.insert(quizTranslations).values({
+      quizId: quiz.id,
+      locale,
+      title: QUIZ_METADATA.translations[locale].title,
+      description: QUIZ_METADATA.translations[locale].description,
+    });
+  }
+
+  return quiz.id;
+}
+
+async function seedQuestions(questions: QuestionData[], quizId: string, partNumber: number) {
+  console.log(`Seeding ${questions.length} questions from part ${partNumber}...`);
+
+  for (const question of questions) {
+    const [q] = await db.insert(quizQuestions).values({
+      quizId,
+      displayOrder: question.order,
+      difficulty: question.difficulty,
+    }).returning();
+
+    for (const locale of LOCALES) {
+      await db.insert(quizQuestionContent).values({
+        quizQuestionId: q.id,
+        locale,
+        questionText: question[locale].q,
+        explanation: createExplanation(question[locale].exp),
+      });
+    }
+
+    for (let i = 0; i < question.answers.length; i++) {
+      const answer = question.answers[i];
+      
+      const [a] = await db.insert(quizAnswers).values({
+        quizQuestionId: q.id,
+        displayOrder: i + 1,
+        isCorrect: answer.correct,
+      }).returning();
+
+      for (const locale of LOCALES) {
+        await db.insert(quizAnswerTranslations).values({
+          quizAnswerId: a.id,
+          locale,
+          answerText: answer[locale],
+        });
+      }
+    }
+  }
+
+  console.log(`Part ${partNumber} completed (${questions.length} questions)`);
+}
+
+async function seedQuizFromJson() {
+  const args = process.argv.slice(2);
+  const partArg = args[0];
+
+  if (!partArg) {
+    console.error('Error: Please specify which part to upload');
+    console.log('Usage: npx tsx db/seeds/seed-quiz-nodejs-advanced.ts <part-number>');
+    console.log('Example: npx tsx db/seeds/seed-quiz-nodejs-advanced.ts 1');
+    console.log('Or upload all: npx tsx db/seeds/seed-quiz-nodejs-advanced.ts all');
+    process.exit(1);
+  }
+
+  console.log('Starting Node.js Advanced quiz seed...\n');
+
+  try {
+    const quizId = await ensureQuizExists();
+
+    if (partArg.toLowerCase() === 'all') {
+      console.log('Uploading all parts...\n');
+      let totalQuestions = 0;
+
+      for (let i = 1; i <= 4; i++) {
+        const questions = await loadQuestions(i);
+        await seedQuestions(questions, quizId, i);
+        totalQuestions += questions.length;
+      }
+
+      console.log('\nAll parts seeded successfully!');
+      console.log(`   - 1 quiz with ${LOCALES.length} translations`);
+      console.log(`   - ${totalQuestions} questions total`);
+      console.log(`   - ${totalQuestions * 4} answers with ${LOCALES.length} translations each`);
+    } else {
+      const partNumber = parseInt(partArg, 10);
+
+      if (isNaN(partNumber) || partNumber < 1 || partNumber > 4) {
+        console.error('Error: Part number must be between 1 and 4');
+        process.exit(1);
+      }
+
+      const questions = await loadQuestions(partNumber);
+      await seedQuestions(questions, quizId, partNumber);
+
+      console.log('\nPart seeded successfully!');
+      console.log(`   - Quiz: ${QUIZ_METADATA.translations.en.title}`);
+      console.log(`   - Part ${partNumber}: ${questions.length} questions`);
+      console.log(`   - ${questions.length * 4} answers with ${LOCALES.length} translations each`);
+    }
+  } catch (error) {
+    console.error('\nError seeding quiz:', error);
+    throw error;
+  }
+}
+
+seedQuizFromJson()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/frontend/db/seed-quiz-nodejs.ts b/frontend/db/seed-quiz-nodejs.ts
new file mode 100644
index 00000000..58201836
--- /dev/null
+++ b/frontend/db/seed-quiz-nodejs.ts
@@ -0,0 +1,244 @@
+import { eq } from 'drizzle-orm';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { db } from './index';
+import { categories } from './schema/categories';
+import {
+  quizzes,
+  quizTranslations,
+  quizQuestions,
+  quizQuestionContent,
+  quizAnswers,
+  quizAnswerTranslations,
+  quizAttempts,
+} from './schema/quiz';
+
+type Locale = 'uk' | 'en' | 'pl';
+const LOCALES: Locale[] = ['uk', 'en', 'pl'];
+
+interface QuestionData {
+  id: string;
+  order: number;
+  difficulty: 'beginner' | 'medium' | 'advanced';
+  uk: { q: string; exp: string };
+  en: { q: string; exp: string };
+  pl: { q: string; exp: string };
+  answers: {
+    uk: string;
+    en: string;
+    pl: string;
+    correct: boolean;
+  }[];
+}
+
+interface QuizPartData {
+  questions: QuestionData[];
+}
+
+const CATEGORY_SLUG = 'node';
+
+const QUIZ_METADATA = {
+  slug: 'node-fundamentals',
+  questionsCount: 40,
+  timeLimitSeconds: 1200,
+  translations: {
+    uk: {
+      title: 'Основи Node.js',
+      description: 'Перевірте свої знання базових концепцій Node.js: event loop, модулі, асинхронність, Express.js, тестування та деплой.',
+    },
+    en: {
+      title: 'Node.js Fundamentals',
+      description: 'Test your knowledge of Node.js basics: event loop, modules, asynchronicity, Express.js, testing, and deployment.',
+    },
+    pl: {
+      title: 'Podstawy Node.js',
+      description: 'Sprawdź swoją wiedzę o podstawach Node.js: event loop, moduły, asynchroniczność, Express.js, testowanie i deployment.',
+    },
+  },
+};
+
+function createExplanation(text: string) {
+  return [{ type: 'paragraph' as const, children: [{ text }] }];
+}
+
+const projectRoot = existsSync(join(process.cwd(), 'json'))
+  ? process.cwd()
+  : join(process.cwd(), '..');
+
+async function loadQuestions(partNumber: number): Promise<QuestionData[]> {
+  const partPath = join(projectRoot, 'json', 'quizzes', 'node', 'beginner_medium', `nodejs-quiz-part${partNumber}.json`);
+  const partData: QuizPartData = JSON.parse(readFileSync(partPath, 'utf-8'));
+  return partData.questions;
+}
+
+async function ensureQuizExists(): Promise<string> {
+  console.log('Ensuring quiz exists...');
+
+  // Find category by slug
+  const [category] = await db
+    .select()
+    .from(categories)
+    .where(eq(categories.slug, CATEGORY_SLUG))
+    .limit(1);
+
+  if (!category) {
+    throw new Error(`Category "${CATEGORY_SLUG}" not found. Run seed:categories first.`);
+  }
+
+  // Clean up old quiz by slug
+  const existing = await db.query.quizzes.findFirst({
+    where: eq(quizzes.slug, QUIZ_METADATA.slug),
+  });
+  if (existing) {
+    const existingAttempt = await db.query.quizAttempts.findFirst({
+      where: eq(quizAttempts.quizId, existing.id),
+    });
+    if (existingAttempt) {
+      throw new Error(`Quiz ${QUIZ_METADATA.slug} has existing attempts. Aborting to avoid data loss.`);
+    }
+
+    await db.delete(quizQuestions).where(eq(quizQuestions.quizId, existing.id));
+    await db.delete(quizTranslations).where(eq(quizTranslations.quizId, existing.id));
+    await db.update(quizzes).set({
+      categoryId: category.id,
+      slug: QUIZ_METADATA.slug,
+      displayOrder: 1,
+      questionsCount: QUIZ_METADATA.questionsCount,
+      timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+      isActive: true,
+    }).where(eq(quizzes.id, existing.id));
+
+    const quizId = existing.id;
+    for (const locale of LOCALES) {
+      await db.insert(quizTranslations).values({
+        quizId,
+        locale,
+        title: QUIZ_METADATA.translations[locale].title,
+        description: QUIZ_METADATA.translations[locale].description,
+      });
+    }
+
+    return quizId;
+  }
+
+  const [quiz] = await db.insert(quizzes).values({
+    categoryId: category.id,
+    slug: QUIZ_METADATA.slug,
+    displayOrder: 1,
+    questionsCount: QUIZ_METADATA.questionsCount,
+    timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+    isActive: true,
+  }).returning();
+
+  for (const locale of LOCALES) {
+    await db.insert(quizTranslations).values({
+      quizId: quiz.id,
+      locale,
+      title: QUIZ_METADATA.translations[locale].title,
+      description: QUIZ_METADATA.translations[locale].description,
+    });
+  }
+
+  return quiz.id;
+}
+
+async function seedQuestions(questions: QuestionData[], quizId: string, partNumber: number) {
+  console.log(`Seeding ${questions.length} questions from part ${partNumber}...`);
+
+  for (const question of questions) {
+    const [q] = await db.insert(quizQuestions).values({
+      quizId,
+      displayOrder: question.order,
+      difficulty: question.difficulty,
+    }).returning();
+
+    for (const locale of LOCALES) {
+      await db.insert(quizQuestionContent).values({
+        quizQuestionId: q.id,
+        locale,
+        questionText: question[locale].q,
+        explanation: createExplanation(question[locale].exp),
+      });
+    }
+
+    for (let i = 0; i < question.answers.length; i++) {
+      const answer = question.answers[i];
+      
+      const [a] = await db.insert(quizAnswers).values({
+        quizQuestionId: q.id,
+        displayOrder: i + 1,
+        isCorrect: answer.correct,
+      }).returning();
+
+      for (const locale of LOCALES) {
+        await db.insert(quizAnswerTranslations).values({
+          quizAnswerId: a.id,
+          locale,
+          answerText: answer[locale],
+        });
+      }
+    }
+  }
+
+  console.log(`Part ${partNumber} completed (${questions.length} questions)`);
+}
+
+async function seedQuizFromJson() {
+  const args = process.argv.slice(2);
+  const partArg = args[0];
+
+  if (!partArg) {
+    console.error('Error: Please specify which part to upload');
+    console.log('Usage: npx tsx db/seeds/seed-quiz-nodejs-fundamentals.ts <part-number>');
+    console.log('Example: npx tsx db/seeds/seed-quiz-nodejs-fundamentals.ts 1');
+    console.log('Or upload all: npx tsx db/seeds/seed-quiz-nodejs-fundamentals.ts all');
+    process.exit(1);
+  }
+
+  console.log('Starting Node.js Fundamentals quiz seed...\n');
+
+  try {
+    const quizId = await ensureQuizExists();
+
+    if (partArg.toLowerCase() === 'all') {
+      console.log('Uploading all parts...\n');
+      let totalQuestions = 0;
+
+      for (let i = 1; i <= 4; i++) {
+        const questions = await loadQuestions(i);
+        await seedQuestions(questions, quizId, i);
+        totalQuestions += questions.length;
+      }
+
+      console.log('\nAll parts seeded successfully!');
+      console.log(`   - 1 quiz with ${LOCALES.length} translations`);
+      console.log(`   - ${totalQuestions} questions total`);
+      console.log(`   - ${totalQuestions * 4} answers with ${LOCALES.length} translations each`);
+    } else {
+      const partNumber = parseInt(partArg, 10);
+
+      if (isNaN(partNumber) || partNumber < 1 || partNumber > 4) {
+        console.error('Error: Part number must be between 1 and 4');
+        process.exit(1);
+      }
+
+      const questions = await loadQuestions(partNumber);
+      await seedQuestions(questions, quizId, partNumber);
+
+      console.log('\nPart seeded successfully!');
+      console.log(`   - Quiz: ${QUIZ_METADATA.translations.en.title}`);
+      console.log(`   - Part ${partNumber}: ${questions.length} questions`);
+      console.log(`   - ${questions.length * 4} answers with ${LOCALES.length} translations each`);
+    }
+  } catch (error) {
+    console.error('\nError seeding quiz:', error);
+    throw error;
+  }
+}
+
+seedQuizFromJson()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/frontend/db/seed-quiz-vue.ts b/frontend/db/seed-quiz-vue.ts
new file mode 100644
index 00000000..ac260d00
--- /dev/null
+++ b/frontend/db/seed-quiz-vue.ts
@@ -0,0 +1,243 @@
+import { eq } from 'drizzle-orm';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { db } from './index';
+import { categories } from './schema/categories';
+import {
+  quizzes,
+  quizTranslations,
+  quizQuestions,
+  quizQuestionContent,
+  quizAnswers,
+  quizAnswerTranslations,
+  quizAttempts,
+} from './schema/quiz';
+
+type Locale = 'uk' | 'en' | 'pl';
+const LOCALES: Locale[] = ['uk', 'en', 'pl'];
+
+interface QuestionData {
+  id: string;
+  order: number;
+  difficulty: 'beginner' | 'medium' | 'advanced';
+  uk: { q: string; exp: string };
+  en: { q: string; exp: string };
+  pl: { q: string; exp: string };
+  answers: {
+    uk: string;
+    en: string;
+    pl: string;
+    correct: boolean;
+  }[];
+}
+
+interface QuizPartData {
+  questions: QuestionData[];
+}
+
+const CATEGORY_SLUG = 'vue';
+
+const QUIZ_METADATA = {
+  slug: 'vue-fundamentals',
+  questionsCount: 40,
+  timeLimitSeconds: 1200,
+  translations: {
+    uk: {
+      title: 'Основи Vue.js',
+      description: 'Перевірте свої знання базових концепцій Vue.js: компоненти, реактивність, директиви, Composition API, Vue Router, Pinia та життєвий цикл.',
+    },
+    en: {
+      title: 'Vue.js Fundamentals',
+      description: 'Test your knowledge of Vue.js basics: components, reactivity, directives, Composition API, Vue Router, Pinia, and lifecycle.',
+    },
+    pl: {
+      title: 'Podstawy Vue.js',
+      description: 'Sprawdź swoją wiedzę o podstawach Vue.js: komponenty, reaktywność, dyrektywy, Composition API, Vue Router, Pinia i cykl życia.',
+    },
+  },
+};
+
+function createExplanation(text: string) {
+  return [{ type: 'paragraph' as const, children: [{ text }] }];
+}
+
+const projectRoot = existsSync(join(process.cwd(), 'json'))
+  ? process.cwd()
+  : join(process.cwd(), '..');
+
+async function loadQuestions(partNumber: number): Promise<QuestionData[]> {
+  const partPath = join(projectRoot, 'json', 'quizzes', 'vue', 'beginner_medium', `vue-quiz-part${partNumber}.json`);
+  const partData: QuizPartData = JSON.parse(readFileSync(partPath, 'utf-8'));
+  return partData.questions;
+}
+
+async function ensureQuizExists(): Promise<string> {
+  console.log('Ensuring quiz exists...');
+
+  const [category] = await db
+    .select()
+    .from(categories)
+    .where(eq(categories.slug, CATEGORY_SLUG))
+    .limit(1);
+
+  if (!category) {
+    throw new Error(`Category "${CATEGORY_SLUG}" not found. Run seed:categories first.`);
+  }
+
+  const existing = await db.query.quizzes.findFirst({
+    where: eq(quizzes.slug, QUIZ_METADATA.slug),
+  });
+
+  if (existing) {
+    const existingAttempt = await db.query.quizAttempts.findFirst({
+      where: eq(quizAttempts.quizId, existing.id),
+    });
+    if (existingAttempt) {
+      throw new Error(`Quiz ${QUIZ_METADATA.slug} has existing attempts. Aborting to avoid data loss.`);
+    }
+
+    await db.delete(quizQuestions).where(eq(quizQuestions.quizId, existing.id));
+    await db.delete(quizTranslations).where(eq(quizTranslations.quizId, existing.id));
+    await db.update(quizzes).set({
+      categoryId: category.id,
+      slug: QUIZ_METADATA.slug,
+      displayOrder: 1,
+      questionsCount: QUIZ_METADATA.questionsCount,
+      timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+      isActive: true,
+    }).where(eq(quizzes.id, existing.id));
+
+    const quizId = existing.id;
+    for (const locale of LOCALES) {
+      await db.insert(quizTranslations).values({
+        quizId,
+        locale,
+        title: QUIZ_METADATA.translations[locale].title,
+        description: QUIZ_METADATA.translations[locale].description,
+      });
+    }
+
+    return quizId;
+  }
+
+  const [quiz] = await db.insert(quizzes).values({
+    categoryId: category.id,
+    slug: QUIZ_METADATA.slug,
+    displayOrder: 1,
+    questionsCount: QUIZ_METADATA.questionsCount,
+    timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+    isActive: true,
+  }).returning();
+
+  for (const locale of LOCALES) {
+    await db.insert(quizTranslations).values({
+      quizId: quiz.id,
+      locale,
+      title: QUIZ_METADATA.translations[locale].title,
+      description: QUIZ_METADATA.translations[locale].description,
+    });
+  }
+
+  return quiz.id;
+}
+
+async function seedQuestions(questions: QuestionData[], quizId: string, partNumber: number) {
+  console.log(`Seeding ${questions.length} questions from part ${partNumber}...`);
+
+  for (const question of questions) {
+    const [q] = await db.insert(quizQuestions).values({
+      quizId,
+      displayOrder: question.order,
+      difficulty: question.difficulty,
+    }).returning();
+
+    for (const locale of LOCALES) {
+      await db.insert(quizQuestionContent).values({
+        quizQuestionId: q.id,
+        locale,
+        questionText: question[locale].q,
+        explanation: createExplanation(question[locale].exp),
+      });
+    }
+
+    for (let i = 0; i < question.answers.length; i++) {
+      const answer = question.answers[i];
+      
+      const [a] = await db.insert(quizAnswers).values({
+        quizQuestionId: q.id,
+        displayOrder: i + 1,
+        isCorrect: answer.correct,
+      }).returning();
+
+      for (const locale of LOCALES) {
+        await db.insert(quizAnswerTranslations).values({
+          quizAnswerId: a.id,
+          locale,
+          answerText: answer[locale],
+        });
+      }
+    }
+  }
+
+  console.log(`Part ${partNumber} completed (${questions.length} questions)`);
+}
+
+async function seedQuizFromJson() {
+  const args = process.argv.slice(2);
+  const partArg = args[0];
+
+  if (!partArg) {
+    console.error('Error: Please specify which part to upload');
+    console.log('Usage: npx tsx db/seeds/seed-quiz-vue.ts <part-number>');
+    console.log('Example: npx tsx db/seeds/seed-quiz-vue.ts 1');
+    console.log('Or upload all: npx tsx db/seeds/seed-quiz-vue.ts all');
+    process.exit(1);
+  }
+
+  console.log('Starting Vue.js quiz seed...\n');
+
+  try {
+    const quizId = await ensureQuizExists();
+
+    if (partArg.toLowerCase() === 'all') {
+      console.log('Uploading all parts...\n');
+      let totalQuestions = 0;
+
+      for (let i = 1; i <= 4; i++) {
+        const questions = await loadQuestions(i);
+        await seedQuestions(questions, quizId, i);
+        totalQuestions += questions.length;
+      }
+
+      console.log('\nAll parts seeded successfully!');
+      console.log(`   - 1 quiz with ${LOCALES.length} translations`);
+      console.log(`   - ${totalQuestions} questions total`);
+      console.log(`   - ${totalQuestions * 4} answers with ${LOCALES.length} translations each`);
+    } else {
+      const partNumber = parseInt(partArg, 10);
+
+      if (isNaN(partNumber) || partNumber < 1 || partNumber > 4) {
+        console.error('Error: Part number must be between 1 and 4');
+        process.exit(1);
+      }
+
+      const questions = await loadQuestions(partNumber);
+      await seedQuestions(questions, quizId, partNumber);
+
+      console.log('\nPart seeded successfully!');
+      console.log(`   - Quiz: ${QUIZ_METADATA.translations.en.title}`);
+      console.log(`   - Part ${partNumber}: ${questions.length} questions`);
+      console.log(`   - ${questions.length * 4} answers with ${LOCALES.length} translations each`);
+    }
+  } catch (error) {
+    console.error('\nError seeding quiz:', error);
+    throw error;
+  }
+}
+
+seedQuizFromJson()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index 84f96cf5..cd8cb5f0 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -96,7 +96,9 @@
         "description": "We recommend reviewing this topic after completing the quiz"
       },
       "loading": "Loading...",
-      "nextButton": "Next"
+      "nextButton": "Next",
+      "verifyRetry": "Retrying answer verification...",
+      "verifyFailed": "Failed to verify the answer. Please try again."
     },
     "progress": {
       "label": "Question {current} / {total}"
diff --git a/frontend/messages/pl.json b/frontend/messages/pl.json
index 607404b5..fec2827b 100644
--- a/frontend/messages/pl.json
+++ b/frontend/messages/pl.json
@@ -96,7 +96,9 @@
         "description": "Zalecamy przejrzenie tego tematu po ukończeniu quizu"
       },
       "loading": "Ładowanie...",
-      "nextButton": "Dalej"
+      "nextButton": "Dalej",
+      "verifyRetry": "Ponawiamy weryfikację odpowiedzi...",
+      "verifyFailed": "Nie udało się zweryfikować odpowiedzi. Spróbuj ponownie."
     },
     "progress": {
       "label": "Pytanie {current} / {total}"
@@ -157,7 +159,7 @@
   "confirm": "Wyjdź",
   "cancel": "Kontynuuj"
 }
-  },
+},
   "blog": {
     "title": "Wszystkie Wpisy na Blogu",
     "metaTitle": "Blog | DevLovers",
diff --git a/frontend/messages/uk.json b/frontend/messages/uk.json
index 64829d2e..44613053 100644
--- a/frontend/messages/uk.json
+++ b/frontend/messages/uk.json
@@ -96,7 +96,9 @@
         "description": "Рекомендуємо повторити цю тему після завершення квізу"
       },
       "loading": "Завантаження...",
-      "nextButton": "Далі"
+      "nextButton": "Далі",
+      "verifyRetry": "Повторюємо перевірку відповіді...",
+      "verifyFailed": "Не вдалося перевірити відповідь. Спробуйте ще раз."
     },
     "progress": {
       "label": "Питання {current} / {total}"
diff --git a/json/quizzes/angular/advanced/angular-advanced-quiz-part1.json b/json/quizzes/angular/advanced/angular-advanced-quiz-part1.json
new file mode 100644
index 00000000..ee06901c
--- /dev/null
+++ b/json/quizzes/angular/advanced/angular-advanced-quiz-part1.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "angular-adv-q01",
+      "order": 1,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Який lifecycle hook викликається при кожній зміні @Input властивостей?",
+        "exp": "ngOnChanges() викликається кожного разу, коли змінюються @Input властивості. Отримує об'єкт SimpleChanges з попередніми та поточними значеннями."
+      },
+      "en": {
+        "q": "Which lifecycle hook is called on every @Input property change?",
+        "exp": "ngOnChanges() is called every time @Input properties change. It receives a SimpleChanges object with previous and current values."
+      },
+      "pl": {
+        "q": "Który lifecycle hook jest wywoływany przy każdej zmianie właściwości @Input?",
+        "exp": "ngOnChanges() jest wywoływany za każdym razem, gdy zmieniają się właściwości @Input. Otrzymuje obiekt SimpleChanges z poprzednimi i aktualnymi wartościami."
+      },
+      "answers": [
+        {
+          "uk": "ngOnInit()",
+          "en": "ngOnInit()",
+          "pl": "ngOnInit()",
+          "correct": false
+        },
+        {
+          "uk": "ngOnChanges()",
+          "en": "ngOnChanges()",
+          "pl": "ngOnChanges()",
+          "correct": true
+        },
+        {
+          "uk": "ngDoCheck()",
+          "en": "ngDoCheck()",
+          "pl": "ngDoCheck()",
+          "correct": false
+        },
+        {
+          "uk": "ngAfterViewInit()",
+          "en": "ngAfterViewInit()",
+          "pl": "ngAfterViewInit()",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q02",
+      "order": 2,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Коли використовується ngAfterViewInit()?",
+        "exp": "ngAfterViewInit() викликається один раз після ініціалізації view компонента. Використовується для доступу до елементів через @ViewChild/@ViewChildren."
+      },
+      "en": {
+        "q": "When is ngAfterViewInit() used?",
+        "exp": "ngAfterViewInit() is called once after the component's view is initialized. Used for accessing elements via @ViewChild/@ViewChildren."
+      },
+      "pl": {
+        "q": "Kiedy używa się ngAfterViewInit()?",
+        "exp": "ngAfterViewInit() jest wywoływany raz po inicjalizacji widoku komponentu. Używany do dostępu do elementów przez @ViewChild/@ViewChildren."
+      },
+      "answers": [
+        {
+          "uk": "Перед ініціалізацією компонента",
+          "en": "Before component initialization",
+          "pl": "Przed inicjalizacją komponentu",
+          "correct": false
+        },
+        {
+          "uk": "Після ініціалізації view для доступу до @ViewChild",
+          "en": "After view initialization for @ViewChild access",
+          "pl": "Po inicjalizacji widoku dla dostępu do @ViewChild",
+          "correct": true
+        },
+        {
+          "uk": "При кожній зміні даних",
+          "en": "On every data change",
+          "pl": "Przy każdej zmianie danych",
+          "correct": false
+        },
+        {
+          "uk": "Перед знищенням компонента",
+          "en": "Before component destruction",
+          "pl": "Przed zniszczeniem komponentu",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q03",
+      "order": 3,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Для чого використовується @ViewChild?",
+        "exp": "@ViewChild дає доступ до дочірнього компонента, директиви або DOM-елемента з власного шаблону компонента. Доступний після ngAfterViewInit()."
+      },
+      "en": {
+        "q": "What is @ViewChild used for?",
+        "exp": "@ViewChild provides access to a child component, directive, or DOM element from the component's own template. Available after ngAfterViewInit()."
+      },
+      "pl": {
+        "q": "Do czego służy @ViewChild?",
+        "exp": "@ViewChild zapewnia dostęp do komponentu dziecka, dyrektywy lub elementu DOM z własnego szablonu komponentu. Dostępny po ngAfterViewInit()."
+      },
+      "answers": [
+        {
+          "uk": "Для передачі даних батьківському компоненту",
+          "en": "For passing data to parent component",
+          "pl": "Do przekazywania danych do komponentu rodzica",
+          "correct": false
+        },
+        {
+          "uk": "Для доступу до елементів власного шаблону",
+          "en": "For accessing elements in own template",
+          "pl": "Do dostępu do elementów własnego szablonu",
+          "correct": true
+        },
+        {
+          "uk": "Для підписки на HTTP-запити",
+          "en": "For subscribing to HTTP requests",
+          "pl": "Do subskrypcji żądań HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Для валідації форм",
+          "en": "For form validation",
+          "pl": "Do walidacji formularzy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q04",
+      "order": 4,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка різниця між @ViewChild та @ContentChild?",
+        "exp": "@ViewChild звертається до елементів власного шаблону компонента. @ContentChild — до проєктованого контенту (ng-content), переданого ззовні."
+      },
+      "en": {
+        "q": "What is the difference between @ViewChild and @ContentChild?",
+        "exp": "@ViewChild accesses elements in the component's own template. @ContentChild accesses projected content (ng-content) passed from outside."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między @ViewChild a @ContentChild?",
+        "exp": "@ViewChild dostęp do elementów własnego szablonu komponentu. @ContentChild dostęp do projektowanej zawartości (ng-content) przekazanej z zewnątrz."
+      },
+      "answers": [
+        {
+          "uk": "@ViewChild — для сервісів, @ContentChild — для компонентів",
+          "en": "@ViewChild for services, @ContentChild for components",
+          "pl": "@ViewChild dla serwisów, @ContentChild dla komponentów",
+          "correct": false
+        },
+        {
+          "uk": "@ViewChild — для власного шаблону, @ContentChild — для проєктованого контенту",
+          "en": "@ViewChild for own template, @ContentChild for projected content",
+          "pl": "@ViewChild dla własnego szablonu, @ContentChild dla projektowanej zawartości",
+          "correct": true
+        },
+        {
+          "uk": "Різниці немає",
+          "en": "No difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        },
+        {
+          "uk": "@ContentChild працює тільки з формами",
+          "en": "@ContentChild only works with forms",
+          "pl": "@ContentChild działa tylko z formularzami",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q05",
+      "order": 5,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке ng-content і для чого він використовується?",
+        "exp": "ng-content — це механізм проєкції контенту, що дозволяє передавати HTML-вміст у компонент ззовні. Аналог slots у Web Components."
+      },
+      "en": {
+        "q": "What is ng-content and what is it used for?",
+        "exp": "ng-content is a content projection mechanism that allows passing HTML content into a component from outside. Similar to slots in Web Components."
+      },
+      "pl": {
+        "q": "Czym jest ng-content i do czego służy?",
+        "exp": "ng-content to mechanizm projekcji zawartości pozwalający przekazywać zawartość HTML do komponentu z zewnątrz. Podobny do slots w Web Components."
+      },
+      "answers": [
+        {
+          "uk": "Директива для умовного рендерингу",
+          "en": "A directive for conditional rendering",
+          "pl": "Dyrektywa do warunkowego renderowania",
+          "correct": false
+        },
+        {
+          "uk": "Механізм проєкції контенту для передачі HTML у компонент ззовні",
+          "en": "A content projection mechanism for passing HTML into a component from outside",
+          "pl": "Mechanizm projekcji zawartości do przekazywania HTML do komponentu z zewnątrz",
+          "correct": true
+        },
+        {
+          "uk": "Сервіс для роботи з DOM",
+          "en": "A service for working with DOM",
+          "pl": "Serwis do pracy z DOM",
+          "correct": false
+        },
+        {
+          "uk": "Pipe для форматування тексту",
+          "en": "A pipe for text formatting",
+          "pl": "Pipe do formatowania tekstu",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q06",
+      "order": 6,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Як створити синхронний кастомний валідатор для Reactive Forms?",
+        "exp": "Кастомний валідатор — це функція, що приймає AbstractControl і повертає об'єкт помилки { errorKey: true } або null, якщо валідація пройшла."
+      },
+      "en": {
+        "q": "How do you create a synchronous custom validator for Reactive Forms?",
+        "exp": "A custom validator is a function that takes AbstractControl and returns an error object { errorKey: true } or null if validation passed."
+      },
+      "pl": {
+        "q": "Jak stworzyć synchroniczny niestandardowy walidator dla Reactive Forms?",
+        "exp": "Niestandardowy walidator to funkcja przyjmująca AbstractControl i zwracająca obiekt błędu { errorKey: true } lub null, jeśli walidacja przeszła."
+      },
+      "answers": [
+        {
+          "uk": "Створити клас, що розширює Validators",
+          "en": "Create a class extending Validators",
+          "pl": "Stworzyć klasę rozszerzającą Validators",
+          "correct": false
+        },
+        {
+          "uk": "Створити функцію, що повертає { errorKey: true } або null",
+          "en": "Create a function returning { errorKey: true } or null",
+          "pl": "Stworzyć funkcję zwracającą { errorKey: true } lub null",
+          "correct": true
+        },
+        {
+          "uk": "Використати декоратор @Validator",
+          "en": "Use @Validator decorator",
+          "pl": "Użyć dekoratora @Validator",
+          "correct": false
+        },
+        {
+          "uk": "Кастомні валідатори неможливі в Angular",
+          "en": "Custom validators are not possible in Angular",
+          "pl": "Niestandardowe walidatory nie są możliwe w Angular",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q07",
+      "order": 7,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Чим асинхронний валідатор відрізняється від синхронного?",
+        "exp": "Асинхронний валідатор повертає Observable або Promise замість звичайного значення. Використовується для перевірок, що потребують HTTP-запитів (наприклад, унікальність email)."
+      },
+      "en": {
+        "q": "How does an async validator differ from a sync validator?",
+        "exp": "An async validator returns Observable or Promise instead of a plain value. Used for checks requiring HTTP requests (e.g., email uniqueness)."
+      },
+      "pl": {
+        "q": "Czym różni się walidator asynchroniczny od synchronicznego?",
+        "exp": "Walidator asynchroniczny zwraca Observable lub Promise zamiast zwykłej wartości. Używany do sprawdzeń wymagających żądań HTTP (np. unikalność emaila)."
+      },
+      "answers": [
+        {
+          "uk": "Асинхронний працює швидше",
+          "en": "Async works faster",
+          "pl": "Asynchroniczny działa szybciej",
+          "correct": false
+        },
+        {
+          "uk": "Асинхронний повертає Observable/Promise для перевірок з HTTP-запитами",
+          "en": "Async returns Observable/Promise for checks with HTTP requests",
+          "pl": "Asynchroniczny zwraca Observable/Promise dla sprawdzeń z żądaniami HTTP",
+          "correct": true
+        },
+        {
+          "uk": "Асинхронний не підтримує кастомні помилки",
+          "en": "Async doesn't support custom errors",
+          "pl": "Asynchroniczny nie wspiera niestandardowych błędów",
+          "correct": false
+        },
+        {
+          "uk": "Різниці немає",
+          "en": "No difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q08",
+      "order": 8,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Який lifecycle hook викликається один раз після вставлення проєктованого контенту (ng-content)?",
+        "exp": "ngAfterContentInit() викликається один раз після того, як Angular проєктує зовнішній контент у компонент через ng-content."
+      },
+      "en": {
+        "q": "Which lifecycle hook is called once after projected content (ng-content) is inserted?",
+        "exp": "ngAfterContentInit() is called once after Angular projects external content into the component via ng-content."
+      },
+      "pl": {
+        "q": "Który lifecycle hook jest wywoływany raz po wstawieniu projektowanej zawartości (ng-content)?",
+        "exp": "ngAfterContentInit() jest wywoływany raz po tym, jak Angular projektuje zewnętrzną zawartość do komponentu przez ng-content."
+      },
+      "answers": [
+        {
+          "uk": "ngOnInit()",
+          "en": "ngOnInit()",
+          "pl": "ngOnInit()",
+          "correct": false
+        },
+        {
+          "uk": "ngAfterViewInit()",
+          "en": "ngAfterViewInit()",
+          "pl": "ngAfterViewInit()",
+          "correct": false
+        },
+        {
+          "uk": "ngAfterContentInit()",
+          "en": "ngAfterContentInit()",
+          "pl": "ngAfterContentInit()",
+          "correct": true
+        },
+        {
+          "uk": "ngDoCheck()",
+          "en": "ngDoCheck()",
+          "pl": "ngDoCheck()",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q09",
+      "order": 9,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Для чого використовується ngDoCheck()?",
+        "exp": "ngDoCheck() викликається на кожному циклі change detection. Використовується для кастомної логіки виявлення змін, коли стандартний механізм не підходить."
+      },
+      "en": {
+        "q": "What is ngDoCheck() used for?",
+        "exp": "ngDoCheck() is called on every change detection cycle. Used for custom change detection logic when the standard mechanism isn't sufficient."
+      },
+      "pl": {
+        "q": "Do czego służy ngDoCheck()?",
+        "exp": "ngDoCheck() jest wywoływany przy każdym cyklu change detection. Używany do niestandardowej logiki wykrywania zmian, gdy standardowy mechanizm nie wystarcza."
+      },
+      "answers": [
+        {
+          "uk": "Для ініціалізації компонента",
+          "en": "For component initialization",
+          "pl": "Do inicjalizacji komponentu",
+          "correct": false
+        },
+        {
+          "uk": "Для кастомної логіки виявлення змін на кожному CD-циклі",
+          "en": "For custom change detection logic on every CD cycle",
+          "pl": "Do niestandardowej logiki wykrywania zmian przy każdym cyklu CD",
+          "correct": true
+        },
+        {
+          "uk": "Для очищення ресурсів",
+          "en": "For resource cleanup",
+          "pl": "Do czyszczenia zasobów",
+          "correct": false
+        },
+        {
+          "uk": "Для HTTP-запитів",
+          "en": "For HTTP requests",
+          "pl": "Do żądań HTTP",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q10",
+      "order": 10,
+      "difficulty": "medium",
+      "uk": {
+        "q": "В якому порядку викликаються lifecycle hooks: ngOnInit, ngOnChanges, ngAfterViewInit?",
+        "exp": "Порядок: ngOnChanges (перший, якщо є @Input) → ngOnInit → ngAfterContentInit → ngAfterViewInit. ngOnChanges викликається перед ngOnInit."
+      },
+      "en": {
+        "q": "In what order are lifecycle hooks called: ngOnInit, ngOnChanges, ngAfterViewInit?",
+        "exp": "Order: ngOnChanges (first if @Input exists) → ngOnInit → ngAfterContentInit → ngAfterViewInit. ngOnChanges is called before ngOnInit."
+      },
+      "pl": {
+        "q": "W jakiej kolejności wywoływane są lifecycle hooks: ngOnInit, ngOnChanges, ngAfterViewInit?",
+        "exp": "Kolejność: ngOnChanges (pierwszy jeśli istnieje @Input) → ngOnInit → ngAfterContentInit → ngAfterViewInit. ngOnChanges wywoływany przed ngOnInit."
+      },
+      "answers": [
+        {
+          "uk": "ngOnInit → ngOnChanges → ngAfterViewInit",
+          "en": "ngOnInit → ngOnChanges → ngAfterViewInit",
+          "pl": "ngOnInit → ngOnChanges → ngAfterViewInit",
+          "correct": false
+        },
+        {
+          "uk": "ngOnChanges → ngOnInit → ngAfterViewInit",
+          "en": "ngOnChanges → ngOnInit → ngAfterViewInit",
+          "pl": "ngOnChanges → ngOnInit → ngAfterViewInit",
+          "correct": true
+        },
+        {
+          "uk": "ngAfterViewInit → ngOnInit → ngOnChanges",
+          "en": "ngAfterViewInit → ngOnInit → ngOnChanges",
+          "pl": "ngAfterViewInit → ngOnInit → ngOnChanges",
+          "correct": false
+        },
+        {
+          "uk": "Порядок випадковий",
+          "en": "Order is random",
+          "pl": "Kolejność jest losowa",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/angular/advanced/angular-advanced-quiz-part2.json b/json/quizzes/angular/advanced/angular-advanced-quiz-part2.json
new file mode 100644
index 00000000..33cf1b95
--- /dev/null
+++ b/json/quizzes/angular/advanced/angular-advanced-quiz-part2.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "angular-adv-q11",
+      "order": 11,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Для чого використовується декоратор @Optional() у DI?",
+        "exp": "@Optional() позначає залежність як необов'язкову. Якщо Angular не знайде провайдера, він поверне null замість викидання помилки."
+      },
+      "en": {
+        "q": "What is the @Optional() decorator used for in DI?",
+        "exp": "@Optional() marks a dependency as optional. If Angular can't find a provider, it returns null instead of throwing an error."
+      },
+      "pl": {
+        "q": "Do czego służy dekorator @Optional() w DI?",
+        "exp": "@Optional() oznacza zależność jako opcjonalną. Jeśli Angular nie znajdzie providera, zwróci null zamiast rzucać błąd."
+      },
+      "answers": [
+        {
+          "uk": "Для створення singleton-сервісу",
+          "en": "For creating a singleton service",
+          "pl": "Do tworzenia serwisu singleton",
+          "correct": false
+        },
+        {
+          "uk": "Для позначення залежності як необов'язкової (null якщо не знайдено)",
+          "en": "For marking a dependency as optional (null if not found)",
+          "pl": "Do oznaczenia zależności jako opcjonalnej (null jeśli nie znaleziono)",
+          "correct": true
+        },
+        {
+          "uk": "Для lazy loading сервісу",
+          "en": "For lazy loading a service",
+          "pl": "Do lazy loading serwisu",
+          "correct": false
+        },
+        {
+          "uk": "Для кешування залежності",
+          "en": "For caching a dependency",
+          "pl": "Do cache'owania zależności",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q12",
+      "order": 12,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Яка різниця між @Self() та @SkipSelf() у DI?",
+        "exp": "@Self() шукає залежність тільки в локальному інжекторі компонента. @SkipSelf() пропускає локальний інжектор і шукає в батьківських."
+      },
+      "en": {
+        "q": "What is the difference between @Self() and @SkipSelf() in DI?",
+        "exp": "@Self() looks for dependency only in the component's local injector. @SkipSelf() skips the local injector and looks in parent injectors."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między @Self() a @SkipSelf() w DI?",
+        "exp": "@Self() szuka zależności tylko w lokalnym injektorze komponentu. @SkipSelf() pomija lokalny injektor i szuka w injektorach nadrzędnych."
+      },
+      "answers": [
+        {
+          "uk": "@Self() — для сервісів, @SkipSelf() — для компонентів",
+          "en": "@Self() for services, @SkipSelf() for components",
+          "pl": "@Self() dla serwisów, @SkipSelf() dla komponentów",
+          "correct": false
+        },
+        {
+          "uk": "@Self() шукає локально, @SkipSelf() пропускає локальний і шукає в батьківських",
+          "en": "@Self() looks locally, @SkipSelf() skips local and looks in parents",
+          "pl": "@Self() szuka lokalnie, @SkipSelf() pomija lokalny i szuka w nadrzędnych",
+          "correct": true
+        },
+        {
+          "uk": "@SkipSelf() швидший за @Self()",
+          "en": "@SkipSelf() is faster than @Self()",
+          "pl": "@SkipSelf() jest szybszy niż @Self()",
+          "correct": false
+        },
+        {
+          "uk": "Різниці немає",
+          "en": "No difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q13",
+      "order": 13,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Для чого використовується декоратор @Inject()?",
+        "exp": "@Inject() дозволяє явно вказати токен для інжекції, особливо корисний для інжекції примітивних значень або InjectionToken."
+      },
+      "en": {
+        "q": "What is the @Inject() decorator used for?",
+        "exp": "@Inject() allows explicitly specifying the injection token, especially useful for injecting primitive values or InjectionToken."
+      },
+      "pl": {
+        "q": "Do czego służy dekorator @Inject()?",
+        "exp": "@Inject() pozwala jawnie określić token do iniekcji, szczególnie przydatny do wstrzykiwania wartości prymitywnych lub InjectionToken."
+      },
+      "answers": [
+        {
+          "uk": "Для створення нового сервісу",
+          "en": "For creating a new service",
+          "pl": "Do tworzenia nowego serwisu",
+          "correct": false
+        },
+        {
+          "uk": "Для явного вказання токена інжекції (примітиви, InjectionToken)",
+          "en": "For explicitly specifying injection token (primitives, InjectionToken)",
+          "pl": "Do jawnego określenia tokena iniekcji (prymitywy, InjectionToken)",
+          "correct": true
+        },
+        {
+          "uk": "Для валідації залежностей",
+          "en": "For validating dependencies",
+          "pl": "Do walidacji zależności",
+          "correct": false
+        },
+        {
+          "uk": "Для логування інжекцій",
+          "en": "For logging injections",
+          "pl": "Do logowania iniekcji",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q14",
+      "order": 14,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка різниця між Subject та BehaviorSubject?",
+        "exp": "Subject не має початкового значення і не передає останнє значення новим підписникам. BehaviorSubject зберігає останнє значення і одразу передає його новим підписникам."
+      },
+      "en": {
+        "q": "What is the difference between Subject and BehaviorSubject?",
+        "exp": "Subject has no initial value and doesn't pass the last value to new subscribers. BehaviorSubject stores the last value and immediately passes it to new subscribers."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między Subject a BehaviorSubject?",
+        "exp": "Subject nie ma wartości początkowej i nie przekazuje ostatniej wartości nowym subskrybentom. BehaviorSubject przechowuje ostatnią wartość i natychmiast przekazuje ją nowym subskrybentom."
+      },
+      "answers": [
+        {
+          "uk": "Subject швидший за BehaviorSubject",
+          "en": "Subject is faster than BehaviorSubject",
+          "pl": "Subject jest szybszy niż BehaviorSubject",
+          "correct": false
+        },
+        {
+          "uk": "BehaviorSubject зберігає та передає останнє значення новим підписникам",
+          "en": "BehaviorSubject stores and passes the last value to new subscribers",
+          "pl": "BehaviorSubject przechowuje i przekazuje ostatnią wartość nowym subskrybentom",
+          "correct": true
+        },
+        {
+          "uk": "Subject працює тільки з HTTP",
+          "en": "Subject only works with HTTP",
+          "pl": "Subject działa tylko z HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Різниці немає",
+          "en": "No difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q15",
+      "order": 15,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Коли варто використовувати ReplaySubject замість BehaviorSubject?",
+        "exp": "ReplaySubject передає новим підписникам N останніх значень (конфігурується). Корисний для історії подій або кешування кількох значень."
+      },
+      "en": {
+        "q": "When should you use ReplaySubject instead of BehaviorSubject?",
+        "exp": "ReplaySubject passes N last values to new subscribers (configurable). Useful for event history or caching multiple values."
+      },
+      "pl": {
+        "q": "Kiedy używać ReplaySubject zamiast BehaviorSubject?",
+        "exp": "ReplaySubject przekazuje N ostatnich wartości nowym subskrybentom (konfigurowalne). Przydatny dla historii zdarzeń lub cache'owania wielu wartości."
+      },
+      "answers": [
+        {
+          "uk": "Коли потрібно передати тільки перше значення",
+          "en": "When you need to pass only the first value",
+          "pl": "Kiedy trzeba przekazać tylko pierwszą wartość",
+          "correct": false
+        },
+        {
+          "uk": "Коли потрібно передати N останніх значень новим підписникам",
+          "en": "When you need to pass N last values to new subscribers",
+          "pl": "Kiedy trzeba przekazać N ostatnich wartości nowym subskrybentom",
+          "correct": true
+        },
+        {
+          "uk": "Коли працюєте з формами",
+          "en": "When working with forms",
+          "pl": "Kiedy pracujesz z formularzami",
+          "correct": false
+        },
+        {
+          "uk": "ReplaySubject застарілий",
+          "en": "ReplaySubject is deprecated",
+          "pl": "ReplaySubject jest przestarzały",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q16",
+      "order": 16,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Як створити кастомну структурну директиву?",
+        "exp": "Структурна директива створюється через @Directive з інжекцією TemplateRef та ViewContainerRef. ViewContainerRef керує вставкою/видаленням шаблону."
+      },
+      "en": {
+        "q": "How do you create a custom structural directive?",
+        "exp": "A structural directive is created via @Directive with TemplateRef and ViewContainerRef injection. ViewContainerRef manages template insertion/removal."
+      },
+      "pl": {
+        "q": "Jak stworzyć niestandardową dyrektywę strukturalną?",
+        "exp": "Dyrektywa strukturalna tworzona jest przez @Directive z iniekcją TemplateRef i ViewContainerRef. ViewContainerRef zarządza wstawianiem/usuwaniem szablonu."
+      },
+      "answers": [
+        {
+          "uk": "Через @Component з порожнім шаблоном",
+          "en": "Via @Component with empty template",
+          "pl": "Przez @Component z pustym szablonem",
+          "correct": false
+        },
+        {
+          "uk": "Через @Directive з TemplateRef та ViewContainerRef",
+          "en": "Via @Directive with TemplateRef and ViewContainerRef",
+          "pl": "Przez @Directive z TemplateRef i ViewContainerRef",
+          "correct": true
+        },
+        {
+          "uk": "Через спеціальний @StructuralDirective декоратор",
+          "en": "Via special @StructuralDirective decorator",
+          "pl": "Przez specjalny dekorator @StructuralDirective",
+          "correct": false
+        },
+        {
+          "uk": "Кастомні структурні директиви неможливі",
+          "en": "Custom structural directives are not possible",
+          "pl": "Niestandardowe dyrektywy strukturalne nie są możliwe",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q17",
+      "order": 17,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Для чого використовується ViewContainerRef у структурних директивах?",
+        "exp": "ViewContainerRef — це контейнер, який керує створенням та видаленням views. Методи createEmbeddedView() та clear() контролюють DOM."
+      },
+      "en": {
+        "q": "What is ViewContainerRef used for in structural directives?",
+        "exp": "ViewContainerRef is a container that manages view creation and removal. Methods createEmbeddedView() and clear() control the DOM."
+      },
+      "pl": {
+        "q": "Do czego służy ViewContainerRef w dyrektywach strukturalnych?",
+        "exp": "ViewContainerRef to kontener zarządzający tworzeniem i usuwaniem widoków. Metody createEmbeddedView() i clear() kontrolują DOM."
+      },
+      "answers": [
+        {
+          "uk": "Для стилізації елементів",
+          "en": "For styling elements",
+          "pl": "Do stylizacji elementów",
+          "correct": false
+        },
+        {
+          "uk": "Для керування створенням та видаленням views у DOM",
+          "en": "For managing view creation and removal in DOM",
+          "pl": "Do zarządzania tworzeniem i usuwaniem widoków w DOM",
+          "correct": true
+        },
+        {
+          "uk": "Для валідації форм",
+          "en": "For form validation",
+          "pl": "Do walidacji formularzy",
+          "correct": false
+        },
+        {
+          "uk": "Для HTTP-запитів",
+          "en": "For HTTP requests",
+          "pl": "Do żądań HTTP",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q18",
+      "order": 18,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Route Resolver і коли його використовувати?",
+        "exp": "Route Resolver завантажує дані перед активацією маршруту. Angular чекає завершення resolve і передає дані в компонент через ActivatedRoute.data."
+      },
+      "en": {
+        "q": "What is a Route Resolver and when should you use it?",
+        "exp": "Route Resolver loads data before route activation. Angular waits for resolve completion and passes data to the component via ActivatedRoute.data."
+      },
+      "pl": {
+        "q": "Czym jest Route Resolver i kiedy go używać?",
+        "exp": "Route Resolver ładuje dane przed aktywacją trasy. Angular czeka na zakończenie resolve i przekazuje dane do komponentu przez ActivatedRoute.data."
+      },
+      "answers": [
+        {
+          "uk": "Для валідації URL",
+          "en": "For URL validation",
+          "pl": "Do walidacji URL",
+          "correct": false
+        },
+        {
+          "uk": "Для завантаження даних перед активацією маршруту",
+          "en": "For loading data before route activation",
+          "pl": "Do ładowania danych przed aktywacją trasy",
+          "correct": true
+        },
+        {
+          "uk": "Для кешування маршрутів",
+          "en": "For caching routes",
+          "pl": "Do cache'owania tras",
+          "correct": false
+        },
+        {
+          "uk": "Для анімації переходів",
+          "en": "For transition animations",
+          "pl": "Do animacji przejść",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q19",
+      "order": 19,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка різниця між canActivate та canLoad guards?",
+        "exp": "canActivate перевіряє доступ до маршруту (код вже завантажено). canLoad запобігає завантаженню lazy-loaded модуля взагалі."
+      },
+      "en": {
+        "q": "What is the difference between canActivate and canLoad guards?",
+        "exp": "canActivate checks route access (code already loaded). canLoad prevents lazy-loaded module from loading at all."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między canActivate a canLoad guards?",
+        "exp": "canActivate sprawdza dostęp do trasy (kod już załadowany). canLoad zapobiega ładowaniu lazy-loaded modułu w ogóle."
+      },
+      "answers": [
+        {
+          "uk": "canActivate швидший",
+          "en": "canActivate is faster",
+          "pl": "canActivate jest szybszy",
+          "correct": false
+        },
+        {
+          "uk": "canActivate перевіряє доступ, canLoad запобігає завантаженню lazy-модуля",
+          "en": "canActivate checks access, canLoad prevents lazy module loading",
+          "pl": "canActivate sprawdza dostęp, canLoad zapobiega ładowaniu lazy modułu",
+          "correct": true
+        },
+        {
+          "uk": "canLoad працює тільки з SSR",
+          "en": "canLoad only works with SSR",
+          "pl": "canLoad działa tylko z SSR",
+          "correct": false
+        },
+        {
+          "uk": "Різниці немає",
+          "en": "No difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q20",
+      "order": 20,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Для чого використовується canDeactivate guard?",
+        "exp": "canDeactivate перевіряє, чи можна покинути поточний маршрут. Типове використання — попередження про незбережені зміни у формі."
+      },
+      "en": {
+        "q": "What is the canDeactivate guard used for?",
+        "exp": "canDeactivate checks if the current route can be left. Typical use — warning about unsaved form changes."
+      },
+      "pl": {
+        "q": "Do czego służy guard canDeactivate?",
+        "exp": "canDeactivate sprawdza, czy można opuścić bieżącą trasę. Typowe użycie — ostrzeżenie o niezapisanych zmianach w formularzu."
+      },
+      "answers": [
+        {
+          "uk": "Для перевірки авторизації",
+          "en": "For authorization check",
+          "pl": "Do sprawdzenia autoryzacji",
+          "correct": false
+        },
+        {
+          "uk": "Для перевірки, чи можна покинути маршрут (незбережені зміни)",
+          "en": "For checking if route can be left (unsaved changes)",
+          "pl": "Do sprawdzenia czy można opuścić trasę (niezapisane zmiany)",
+          "correct": true
+        },
+        {
+          "uk": "Для lazy loading",
+          "en": "For lazy loading",
+          "pl": "Do lazy loading",
+          "correct": false
+        },
+        {
+          "uk": "Для кешування даних",
+          "en": "For data caching",
+          "pl": "Do cache'owania danych",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/angular/advanced/angular-advanced-quiz-part3.json b/json/quizzes/angular/advanced/angular-advanced-quiz-part3.json
new file mode 100644
index 00000000..35c37f88
--- /dev/null
+++ b/json/quizzes/angular/advanced/angular-advanced-quiz-part3.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "angular-adv-q21",
+      "order": 21,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Що таке Actions у NgRx?",
+        "exp": "Actions — це об'єкти, що описують події в застосунку (\"що сталося\"). Мають обов'язкове поле type і опціональний payload через props<>()."
+      },
+      "en": {
+        "q": "What are Actions in NgRx?",
+        "exp": "Actions are objects describing events in the application (\"what happened\"). They have a required type field and optional payload via props<>()."
+      },
+      "pl": {
+        "q": "Czym są Actions w NgRx?",
+        "exp": "Actions to obiekty opisujące zdarzenia w aplikacji (\"co się stało\"). Mają wymagane pole type i opcjonalny payload przez props<>()."
+      },
+      "answers": [
+        {
+          "uk": "Функції для HTTP-запитів",
+          "en": "Functions for HTTP requests",
+          "pl": "Funkcje do żądań HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Об'єкти, що описують події (\"що сталося\") з типом і payload",
+          "en": "Objects describing events (\"what happened\") with type and payload",
+          "pl": "Obiekty opisujące zdarzenia (\"co się stało\") z type i payload",
+          "correct": true
+        },
+        {
+          "uk": "Компоненти для відображення даних",
+          "en": "Components for displaying data",
+          "pl": "Komponenty do wyświetlania danych",
+          "correct": false
+        },
+        {
+          "uk": "Валідатори форм",
+          "en": "Form validators",
+          "pl": "Walidatory formularzy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q22",
+      "order": 22,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Що таке Reducers у NgRx і які їх ключові правила?",
+        "exp": "Reducers — чисті функції, що визначають як змінюється стан у відповідь на action. Правила: без side-effects, без мутацій, повертають новий immutable-стан."
+      },
+      "en": {
+        "q": "What are Reducers in NgRx and what are their key rules?",
+        "exp": "Reducers are pure functions defining how state changes in response to actions. Rules: no side effects, no mutations, return new immutable state."
+      },
+      "pl": {
+        "q": "Czym są Reducers w NgRx i jakie są ich kluczowe zasady?",
+        "exp": "Reducers to czyste funkcje określające jak zmienia się stan w odpowiedzi na akcje. Zasady: bez efektów ubocznych, bez mutacji, zwracają nowy niemutowalny stan."
+      },
+      "answers": [
+        {
+          "uk": "Асинхронні функції для API-запитів",
+          "en": "Async functions for API requests",
+          "pl": "Asynchroniczne funkcje do żądań API",
+          "correct": false
+        },
+        {
+          "uk": "Чисті функції без side-effects, що повертають новий immutable-стан",
+          "en": "Pure functions without side effects returning new immutable state",
+          "pl": "Czyste funkcje bez efektów ubocznych zwracające nowy niemutowalny stan",
+          "correct": true
+        },
+        {
+          "uk": "Класи для валідації даних",
+          "en": "Classes for data validation",
+          "pl": "Klasy do walidacji danych",
+          "correct": false
+        },
+        {
+          "uk": "Директиви для шаблонів",
+          "en": "Template directives",
+          "pl": "Dyrektywy dla szablonów",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q23",
+      "order": 23,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Для чого використовуються Effects у NgRx?",
+        "exp": "Effects обробляють side-effects (HTTP, storage, navigation) поза reducer. Слухають actions через ofType() і можуть dispatch нові actions."
+      },
+      "en": {
+        "q": "What are Effects used for in NgRx?",
+        "exp": "Effects handle side effects (HTTP, storage, navigation) outside reducers. They listen to actions via ofType() and can dispatch new actions."
+      },
+      "pl": {
+        "q": "Do czego służą Effects w NgRx?",
+        "exp": "Effects obsługują efekty uboczne (HTTP, storage, nawigacja) poza reducerami. Nasłuchują akcji przez ofType() i mogą dispatch'ować nowe akcje."
+      },
+      "answers": [
+        {
+          "uk": "Для стилізації компонентів",
+          "en": "For styling components",
+          "pl": "Do stylizacji komponentów",
+          "correct": false
+        },
+        {
+          "uk": "Для обробки side-effects (HTTP, storage) поза reducer",
+          "en": "For handling side effects (HTTP, storage) outside reducer",
+          "pl": "Do obsługi efektów ubocznych (HTTP, storage) poza reducerem",
+          "correct": true
+        },
+        {
+          "uk": "Для валідації форм",
+          "en": "For form validation",
+          "pl": "Do walidacji formularzy",
+          "correct": false
+        },
+        {
+          "uk": "Для анімацій",
+          "en": "For animations",
+          "pl": "Do animacji",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q24",
+      "order": 24,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Що таке Selectors у NgRx і навіщо вони потрібні?",
+        "exp": "Selectors — чисті функції для ефективного отримання даних зі Store. createSelector() мемоізує результати, уникаючи зайвих обчислень."
+      },
+      "en": {
+        "q": "What are Selectors in NgRx and why are they needed?",
+        "exp": "Selectors are pure functions for efficient data retrieval from Store. createSelector() memoizes results, avoiding unnecessary computations."
+      },
+      "pl": {
+        "q": "Czym są Selectors w NgRx i po co są potrzebne?",
+        "exp": "Selectors to czyste funkcje do efektywnego pobierania danych ze Store. createSelector() memoizuje wyniki, unikając niepotrzebnych obliczeń."
+      },
+      "answers": [
+        {
+          "uk": "CSS-селектори для компонентів",
+          "en": "CSS selectors for components",
+          "pl": "Selektory CSS dla komponentów",
+          "correct": false
+        },
+        {
+          "uk": "Мемоізовані функції для ефективного отримання даних зі Store",
+          "en": "Memoized functions for efficient data retrieval from Store",
+          "pl": "Memoizowane funkcje do efektywnego pobierania danych ze Store",
+          "correct": true
+        },
+        {
+          "uk": "Методи для фільтрації масивів",
+          "en": "Methods for filtering arrays",
+          "pl": "Metody do filtrowania tablic",
+          "correct": false
+        },
+        {
+          "uk": "Декоратори для сервісів",
+          "en": "Decorators for services",
+          "pl": "Dekoratory dla serwisów",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q25",
+      "order": 25,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що робить ChangeDetectionStrategy.OnPush?",
+        "exp": "OnPush оптимізує change detection: компонент перевіряється тільки коли змінюються @Input (за посиланням), або викликається async pipe, або вручну markForCheck()."
+      },
+      "en": {
+        "q": "What does ChangeDetectionStrategy.OnPush do?",
+        "exp": "OnPush optimizes change detection: component is checked only when @Input changes (by reference), async pipe fires, or markForCheck() is called manually."
+      },
+      "pl": {
+        "q": "Co robi ChangeDetectionStrategy.OnPush?",
+        "exp": "OnPush optymalizuje change detection: komponent sprawdzany tylko gdy zmienia się @Input (przez referencję), odpala async pipe, lub ręcznie markForCheck()."
+      },
+      "answers": [
+        {
+          "uk": "Вимикає change detection повністю",
+          "en": "Disables change detection completely",
+          "pl": "Wyłącza change detection całkowicie",
+          "correct": false
+        },
+        {
+          "uk": "Перевіряє компонент тільки при зміні @Input за посиланням або async pipe",
+          "en": "Checks component only on @Input reference change or async pipe",
+          "pl": "Sprawdza komponent tylko przy zmianie @Input przez referencję lub async pipe",
+          "correct": true
+        },
+        {
+          "uk": "Запускає change detection кожну секунду",
+          "en": "Runs change detection every second",
+          "pl": "Uruchamia change detection co sekundę",
+          "correct": false
+        },
+        {
+          "uk": "Використовується тільки для форм",
+          "en": "Used only for forms",
+          "pl": "Używany tylko dla formularzy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q26",
+      "order": 26,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як вручну запустити change detection при OnPush?",
+        "exp": "Використовується ChangeDetectorRef: markForCheck() позначає компонент для перевірки, detectChanges() запускає CD негайно для компонента і нащадків."
+      },
+      "en": {
+        "q": "How do you manually trigger change detection with OnPush?",
+        "exp": "Use ChangeDetectorRef: markForCheck() marks component for check, detectChanges() runs CD immediately for component and descendants."
+      },
+      "pl": {
+        "q": "Jak ręcznie uruchomić change detection przy OnPush?",
+        "exp": "Używa się ChangeDetectorRef: markForCheck() oznacza komponent do sprawdzenia, detectChanges() uruchamia CD natychmiast dla komponentu i potomków."
+      },
+      "answers": [
+        {
+          "uk": "Викликати this.update()",
+          "en": "Call this.update()",
+          "pl": "Wywołać this.update()",
+          "correct": false
+        },
+        {
+          "uk": "Через ChangeDetectorRef.markForCheck() або detectChanges()",
+          "en": "Via ChangeDetectorRef.markForCheck() or detectChanges()",
+          "pl": "Przez ChangeDetectorRef.markForCheck() lub detectChanges()",
+          "correct": true
+        },
+        {
+          "uk": "Перезавантажити сторінку",
+          "en": "Reload the page",
+          "pl": "Przeładować stronę",
+          "correct": false
+        },
+        {
+          "uk": "Неможливо при OnPush",
+          "en": "Not possible with OnPush",
+          "pl": "Niemożliwe przy OnPush",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q27",
+      "order": 27,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Які основні функції використовуються для створення анімацій в Angular?",
+        "exp": "Основні функції з @angular/animations: trigger(), state(), style(), transition(), animate(). trigger() визначає ім'я анімації для шаблону."
+      },
+      "en": {
+        "q": "What are the main functions used for creating animations in Angular?",
+        "exp": "Main functions from @angular/animations: trigger(), state(), style(), transition(), animate(). trigger() defines the animation name for template."
+      },
+      "pl": {
+        "q": "Jakie są główne funkcje do tworzenia animacji w Angular?",
+        "exp": "Główne funkcje z @angular/animations: trigger(), state(), style(), transition(), animate(). trigger() definiuje nazwę animacji dla szablonu."
+      },
+      "answers": [
+        {
+          "uk": "animate(), move(), scale()",
+          "en": "animate(), move(), scale()",
+          "pl": "animate(), move(), scale()",
+          "correct": false
+        },
+        {
+          "uk": "trigger(), state(), style(), transition(), animate()",
+          "en": "trigger(), state(), style(), transition(), animate()",
+          "pl": "trigger(), state(), style(), transition(), animate()",
+          "correct": true
+        },
+        {
+          "uk": "start(), stop(), pause()",
+          "en": "start(), stop(), pause()",
+          "pl": "start(), stop(), pause()",
+          "correct": false
+        },
+        {
+          "uk": "Angular не підтримує анімації",
+          "en": "Angular doesn't support animations",
+          "pl": "Angular nie wspiera animacji",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q28",
+      "order": 28,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Що робить функція stagger() в анімаціях Angular?",
+        "exp": "stagger() створює затримку між анімаціями елементів у списку. Наприклад, stagger(100, animate(...)) додає 100ms затримки між кожним елементом."
+      },
+      "en": {
+        "q": "What does the stagger() function do in Angular animations?",
+        "exp": "stagger() creates a delay between animations of list elements. For example, stagger(100, animate(...)) adds 100ms delay between each element."
+      },
+      "pl": {
+        "q": "Co robi funkcja stagger() w animacjach Angular?",
+        "exp": "stagger() tworzy opóźnienie między animacjami elementów listy. Na przykład stagger(100, animate(...)) dodaje 100ms opóźnienia między każdym elementem."
+      },
+      "answers": [
+        {
+          "uk": "Зупиняє анімацію",
+          "en": "Stops the animation",
+          "pl": "Zatrzymuje animację",
+          "correct": false
+        },
+        {
+          "uk": "Створює затримку між анімаціями елементів списку",
+          "en": "Creates delay between list element animations",
+          "pl": "Tworzy opóźnienie między animacjami elementów listy",
+          "correct": true
+        },
+        {
+          "uk": "Прискорює анімацію",
+          "en": "Speeds up animation",
+          "pl": "Przyspiesza animację",
+          "correct": false
+        },
+        {
+          "uk": "Повторює анімацію",
+          "en": "Repeats animation",
+          "pl": "Powtarza animację",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q29",
+      "order": 29,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як створити pipe з параметрами?",
+        "exp": "Метод transform() приймає додаткові параметри після основного значення. У шаблоні: {{ value | pipeName:param1:param2 }}."
+      },
+      "en": {
+        "q": "How do you create a pipe with parameters?",
+        "exp": "The transform() method accepts additional parameters after the main value. In template: {{ value | pipeName:param1:param2 }}."
+      },
+      "pl": {
+        "q": "Jak stworzyć pipe z parametrami?",
+        "exp": "Metoda transform() przyjmuje dodatkowe parametry po głównej wartości. W szablonie: {{ value | pipeName:param1:param2 }}."
+      },
+      "answers": [
+        {
+          "uk": "Через декоратор @Param()",
+          "en": "Via @Param() decorator",
+          "pl": "Przez dekorator @Param()",
+          "correct": false
+        },
+        {
+          "uk": "Додаткові параметри в transform() і {{ value | pipe:param1:param2 }}",
+          "en": "Additional parameters in transform() and {{ value | pipe:param1:param2 }}",
+          "pl": "Dodatkowe parametry w transform() i {{ value | pipe:param1:param2 }}",
+          "correct": true
+        },
+        {
+          "uk": "Pipes не підтримують параметри",
+          "en": "Pipes don't support parameters",
+          "pl": "Pipes nie wspierają parametrów",
+          "correct": false
+        },
+        {
+          "uk": "Через окремий конфігураційний файл",
+          "en": "Via separate configuration file",
+          "pl": "Przez osobny plik konfiguracyjny",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q30",
+      "order": 30,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що означає providedIn: 'any' у @Injectable?",
+        "exp": "providedIn: 'any' створює окремий екземпляр сервісу для кожного lazy-loaded модуля. Корисно для ізоляції стану між незалежними частинами застосунку."
+      },
+      "en": {
+        "q": "What does providedIn: 'any' mean in @Injectable?",
+        "exp": "providedIn: 'any' creates a separate service instance for each lazy-loaded module. Useful for isolating state between independent app parts."
+      },
+      "pl": {
+        "q": "Co oznacza providedIn: 'any' w @Injectable?",
+        "exp": "providedIn: 'any' tworzy osobną instancję serwisu dla każdego lazy-loaded modułu. Przydatne do izolacji stanu między niezależnymi częściami aplikacji."
+      },
+      "answers": [
+        {
+          "uk": "Сервіс доступний тільки в тестах",
+          "en": "Service is only available in tests",
+          "pl": "Serwis dostępny tylko w testach",
+          "correct": false
+        },
+        {
+          "uk": "Окремий екземпляр сервісу для кожного lazy-loaded модуля",
+          "en": "Separate service instance for each lazy-loaded module",
+          "pl": "Osobna instancja serwisu dla każdego lazy-loaded modułu",
+          "correct": true
+        },
+        {
+          "uk": "Сервіс не використовує DI",
+          "en": "Service doesn't use DI",
+          "pl": "Serwis nie używa DI",
+          "correct": false
+        },
+        {
+          "uk": "Те саме, що providedIn: 'root'",
+          "en": "Same as providedIn: 'root'",
+          "pl": "To samo co providedIn: 'root'",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/angular/advanced/angular-advanced-quiz-part4.json b/json/quizzes/angular/advanced/angular-advanced-quiz-part4.json
new file mode 100644
index 00000000..3eef69a5
--- /dev/null
+++ b/json/quizzes/angular/advanced/angular-advanced-quiz-part4.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "angular-adv-q31",
+      "order": 31,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Що таке Hydration у контексті Angular SSR?",
+        "exp": "Hydration — процес, коли Angular \"підхоплює\" серверний HTML і робить його інтерактивним без повного перерендеру. provideClientHydration() активує цю функцію."
+      },
+      "en": {
+        "q": "What is Hydration in the context of Angular SSR?",
+        "exp": "Hydration is the process where Angular 'picks up' server-rendered HTML and makes it interactive without full re-render. provideClientHydration() enables this."
+      },
+      "pl": {
+        "q": "Czym jest Hydration w kontekście Angular SSR?",
+        "exp": "Hydration to proces, gdzie Angular 'podchwytuje' HTML wyrenderowany na serwerze i czyni go interaktywnym bez pełnego re-renderu. provideClientHydration() włącza tę funkcję."
+      },
+      "answers": [
+        {
+          "uk": "Процес завантаження CSS",
+          "en": "CSS loading process",
+          "pl": "Proces ładowania CSS",
+          "correct": false
+        },
+        {
+          "uk": "Підхоплення серверного HTML без повного перерендеру",
+          "en": "Picking up server HTML without full re-render",
+          "pl": "Podchwytywanie serwerowego HTML bez pełnego re-renderu",
+          "correct": true
+        },
+        {
+          "uk": "Кешування даних",
+          "en": "Data caching",
+          "pl": "Cache'owanie danych",
+          "correct": false
+        },
+        {
+          "uk": "Стиснення зображень",
+          "en": "Image compression",
+          "pl": "Kompresja obrazów",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q32",
+      "order": 32,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Для чого використовується TransferState у SSR?",
+        "exp": "TransferState передає дані з сервера в браузер, уникаючи повторних API-запитів. Сервер зберігає дані в state, браузер їх читає при hydration."
+      },
+      "en": {
+        "q": "What is TransferState used for in SSR?",
+        "exp": "TransferState passes data from server to browser, avoiding duplicate API calls. Server stores data in state, browser reads it during hydration."
+      },
+      "pl": {
+        "q": "Do czego służy TransferState w SSR?",
+        "exp": "TransferState przekazuje dane z serwera do przeglądarki, unikając duplikacji żądań API. Serwer zapisuje dane w state, przeglądarka czyta je podczas hydration."
+      },
+      "answers": [
+        {
+          "uk": "Для анімації переходів між сторінками",
+          "en": "For page transition animations",
+          "pl": "Do animacji przejść między stronami",
+          "correct": false
+        },
+        {
+          "uk": "Для передачі даних з сервера в браузер без повторних API-запитів",
+          "en": "For passing data from server to browser without duplicate API calls",
+          "pl": "Do przekazywania danych z serwera do przeglądarki bez duplikacji żądań API",
+          "correct": true
+        },
+        {
+          "uk": "Для стилізації компонентів",
+          "en": "For component styling",
+          "pl": "Do stylizacji komponentów",
+          "correct": false
+        },
+        {
+          "uk": "Для валідації форм",
+          "en": "For form validation",
+          "pl": "Do walidacji formularzy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q33",
+      "order": 33,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як перевірити, чи код виконується в браузері чи на сервері при SSR?",
+        "exp": "Використовується функція isPlatformBrowser(platformId) або isPlatformServer(platformId). PLATFORM_ID інжектується через DI."
+      },
+      "en": {
+        "q": "How do you check if code runs in browser or server during SSR?",
+        "exp": "Use isPlatformBrowser(platformId) or isPlatformServer(platformId) functions. PLATFORM_ID is injected via DI."
+      },
+      "pl": {
+        "q": "Jak sprawdzić czy kod działa w przeglądarce czy na serwerze przy SSR?",
+        "exp": "Używa się funkcji isPlatformBrowser(platformId) lub isPlatformServer(platformId). PLATFORM_ID jest wstrzykiwany przez DI."
+      },
+      "answers": [
+        {
+          "uk": "Через window !== undefined",
+          "en": "Via window !== undefined",
+          "pl": "Przez window !== undefined",
+          "correct": false
+        },
+        {
+          "uk": "Через isPlatformBrowser(platformId) або isPlatformServer(platformId)",
+          "en": "Via isPlatformBrowser(platformId) or isPlatformServer(platformId)",
+          "pl": "Przez isPlatformBrowser(platformId) lub isPlatformServer(platformId)",
+          "correct": true
+        },
+        {
+          "uk": "Angular робить це автоматично",
+          "en": "Angular does this automatically",
+          "pl": "Angular robi to automatycznie",
+          "correct": false
+        },
+        {
+          "uk": "Неможливо перевірити",
+          "en": "Not possible to check",
+          "pl": "Niemożliwe do sprawdzenia",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q34",
+      "order": 34,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Чому не можна напряму використовувати window або document при SSR?",
+        "exp": "На сервері немає браузерних API (window, document, localStorage). Прямий доступ викличе помилку. Потрібно перевіряти платформу або використовувати Renderer2."
+      },
+      "en": {
+        "q": "Why can't you directly use window or document in SSR?",
+        "exp": "Server doesn't have browser APIs (window, document, localStorage). Direct access causes errors. Check platform or use Renderer2."
+      },
+      "pl": {
+        "q": "Dlaczego nie można bezpośrednio używać window lub document w SSR?",
+        "exp": "Serwer nie ma API przeglądarki (window, document, localStorage). Bezpośredni dostęp powoduje błędy. Sprawdzaj platformę lub używaj Renderer2."
+      },
+      "answers": [
+        {
+          "uk": "Вони працюють повільно",
+          "en": "They work slowly",
+          "pl": "Działają wolno",
+          "correct": false
+        },
+        {
+          "uk": "На сервері немає браузерних API — буде помилка",
+          "en": "Server doesn't have browser APIs — will cause error",
+          "pl": "Serwer nie ma API przeglądarki — będzie błąd",
+          "correct": true
+        },
+        {
+          "uk": "Angular забороняє їх використання",
+          "en": "Angular forbids their use",
+          "pl": "Angular zabrania ich użycia",
+          "correct": false
+        },
+        {
+          "uk": "Вони застарілі",
+          "en": "They are deprecated",
+          "pl": "Są przestarzałe",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q35",
+      "order": 35,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка різниця між route parameters та query parameters?",
+        "exp": "Route parameters (/user/:id) — частина шляху, обов'язкові. Query parameters (?sort=asc) — опціональні, передаються після ?. Доступ через paramMap та queryParamMap."
+      },
+      "en": {
+        "q": "What is the difference between route parameters and query parameters?",
+        "exp": "Route parameters (/user/:id) are path parts, required. Query parameters (?sort=asc) are optional, after ?. Access via paramMap and queryParamMap."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między route parameters a query parameters?",
+        "exp": "Route parameters (/user/:id) to części ścieżki, wymagane. Query parameters (?sort=asc) są opcjonalne, po ?. Dostęp przez paramMap i queryParamMap."
+      },
+      "answers": [
+        {
+          "uk": "Різниці немає",
+          "en": "No difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        },
+        {
+          "uk": "Route params — частина шляху, query params — опціональні після ?",
+          "en": "Route params are path parts, query params are optional after ?",
+          "pl": "Route params to części ścieżki, query params są opcjonalne po ?",
+          "correct": true
+        },
+        {
+          "uk": "Query parameters швидші",
+          "en": "Query parameters are faster",
+          "pl": "Query parameters są szybsze",
+          "correct": false
+        },
+        {
+          "uk": "Route parameters працюють тільки з SSR",
+          "en": "Route parameters only work with SSR",
+          "pl": "Route parameters działają tylko z SSR",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q36",
+      "order": 36,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як отримати query parameters з URL в Angular?",
+        "exp": "Через ActivatedRoute.queryParamMap (Observable) або snapshot.queryParamMap. Метод get('paramName') повертає значення параметра."
+      },
+      "en": {
+        "q": "How do you get query parameters from URL in Angular?",
+        "exp": "Via ActivatedRoute.queryParamMap (Observable) or snapshot.queryParamMap. The get('paramName') method returns the parameter value."
+      },
+      "pl": {
+        "q": "Jak pobrać query parameters z URL w Angular?",
+        "exp": "Przez ActivatedRoute.queryParamMap (Observable) lub snapshot.queryParamMap. Metoda get('paramName') zwraca wartość parametru."
+      },
+      "answers": [
+        {
+          "uk": "Через window.location.search",
+          "en": "Via window.location.search",
+          "pl": "Przez window.location.search",
+          "correct": false
+        },
+        {
+          "uk": "Через ActivatedRoute.queryParamMap",
+          "en": "Via ActivatedRoute.queryParamMap",
+          "pl": "Przez ActivatedRoute.queryParamMap",
+          "correct": true
+        },
+        {
+          "uk": "Через Router.params",
+          "en": "Via Router.params",
+          "pl": "Przez Router.params",
+          "correct": false
+        },
+        {
+          "uk": "Query parameters недоступні в Angular",
+          "en": "Query parameters are not available in Angular",
+          "pl": "Query parameters nie są dostępne w Angular",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q37",
+      "order": 37,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Preloading Strategy і для чого вона потрібна?",
+        "exp": "Preloading Strategy визначає, які lazy-loaded модулі завантажити заздалегідь. PreloadAllModules завантажує всі після старту, можна створити custom strategy."
+      },
+      "en": {
+        "q": "What is Preloading Strategy and what is it for?",
+        "exp": "Preloading Strategy determines which lazy-loaded modules to load in advance. PreloadAllModules loads all after startup, can create custom strategy."
+      },
+      "pl": {
+        "q": "Czym jest Preloading Strategy i do czego służy?",
+        "exp": "Preloading Strategy określa, które lazy-loaded moduły załadować z wyprzedzeniem. PreloadAllModules ładuje wszystkie po starcie, można stworzyć custom strategy."
+      },
+      "answers": [
+        {
+          "uk": "Стратегія кешування даних",
+          "en": "Data caching strategy",
+          "pl": "Strategia cache'owania danych",
+          "correct": false
+        },
+        {
+          "uk": "Визначає, які lazy-модулі завантажити заздалегідь",
+          "en": "Determines which lazy modules to preload",
+          "pl": "Określa które lazy moduły załadować z wyprzedzeniem",
+          "correct": true
+        },
+        {
+          "uk": "Стратегія валідації форм",
+          "en": "Form validation strategy",
+          "pl": "Strategia walidacji formularzy",
+          "correct": false
+        },
+        {
+          "uk": "Метод стилізації компонентів",
+          "en": "Component styling method",
+          "pl": "Metoda stylizacji komponentów",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q38",
+      "order": 38,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке inject() функція і чим вона краща за constructor injection?",
+        "exp": "inject() — функціональний спосіб DI без constructor. Працює в функціях, guards, resolvers. Чистіший код, менше boilerplate, краща типізація."
+      },
+      "en": {
+        "q": "What is the inject() function and how is it better than constructor injection?",
+        "exp": "inject() is a functional DI approach without constructor. Works in functions, guards, resolvers. Cleaner code, less boilerplate, better typing."
+      },
+      "pl": {
+        "q": "Czym jest funkcja inject() i czym jest lepsza od constructor injection?",
+        "exp": "inject() to funkcjonalne podejście do DI bez konstruktora. Działa w funkcjach, guards, resolvers. Czystszy kod, mniej boilerplate, lepsza typizacja."
+      },
+      "answers": [
+        {
+          "uk": "inject() швидша за constructor",
+          "en": "inject() is faster than constructor",
+          "pl": "inject() jest szybsze niż konstruktor",
+          "correct": false
+        },
+        {
+          "uk": "Функціональний DI без constructor, працює в guards/resolvers",
+          "en": "Functional DI without constructor, works in guards/resolvers",
+          "pl": "Funkcjonalne DI bez konstruktora, działa w guards/resolvers",
+          "correct": true
+        },
+        {
+          "uk": "inject() працює тільки з HTTP",
+          "en": "inject() only works with HTTP",
+          "pl": "inject() działa tylko z HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Різниці немає",
+          "en": "No difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q39",
+      "order": 39,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Коли використовувати effect() з Signals?",
+        "exp": "effect() виконує side-effects при зміні сигналів (логування, DOM-операції, синхронізація). Автоматично відстежує залежності та реагує на зміни."
+      },
+      "en": {
+        "q": "When should you use effect() with Signals?",
+        "exp": "effect() performs side effects when signals change (logging, DOM operations, sync). Automatically tracks dependencies and reacts to changes."
+      },
+      "pl": {
+        "q": "Kiedy używać effect() z Signals?",
+        "exp": "effect() wykonuje efekty uboczne przy zmianie sygnałów (logowanie, operacje DOM, synchronizacja). Automatycznie śledzi zależności i reaguje na zmiany."
+      },
+      "answers": [
+        {
+          "uk": "Для HTTP-запитів",
+          "en": "For HTTP requests",
+          "pl": "Do żądań HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Для виконання side-effects при зміні сигналів",
+          "en": "For executing side effects when signals change",
+          "pl": "Do wykonywania efektów ubocznych przy zmianie sygnałów",
+          "correct": true
+        },
+        {
+          "uk": "Для валідації форм",
+          "en": "For form validation",
+          "pl": "Do walidacji formularzy",
+          "correct": false
+        },
+        {
+          "uk": "effect() застарілий",
+          "en": "effect() is deprecated",
+          "pl": "effect() jest przestarzały",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-adv-q40",
+      "order": 40,
+      "difficulty": "advanced",
+      "uk": {
+        "q": "Що таке computed() у Signals і чим він відрізняється від звичайного signal()?",
+        "exp": "computed() створює похідний сигнал, що автоматично перераховується при зміні залежностей. На відміну від signal(), не можна встановити значення напряму — воно завжди обчислюється."
+      },
+      "en": {
+        "q": "What is computed() in Signals and how does it differ from signal()?",
+        "exp": "computed() creates a derived signal that auto-recalculates when dependencies change. Unlike signal(), you can't set value directly — it's always calculated."
+      },
+      "pl": {
+        "q": "Czym jest computed() w Signals i czym różni się od signal()?",
+        "exp": "computed() tworzy pochodny sygnał, który automatycznie przelicza się przy zmianie zależności. W przeciwieństwie do signal(), nie można ustawić wartości bezpośrednio — jest zawsze obliczana."
+      },
+      "answers": [
+        {
+          "uk": "computed() швидший за signal()",
+          "en": "computed() is faster than signal()",
+          "pl": "computed() jest szybszy niż signal()",
+          "correct": false
+        },
+        {
+          "uk": "computed() — похідний сигнал, що автоматично перераховується",
+          "en": "computed() is a derived signal that auto-recalculates",
+          "pl": "computed() to pochodny sygnał, który automatycznie się przelicza",
+          "correct": true
+        },
+        {
+          "uk": "computed() працює тільки з HTTP",
+          "en": "computed() only works with HTTP",
+          "pl": "computed() działa tylko z HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Різниці немає",
+          "en": "No difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/angular/advanced/seed-quiz-angular-advanced.ts b/json/quizzes/angular/advanced/seed-quiz-angular-advanced.ts
new file mode 100644
index 00000000..c23fc390
--- /dev/null
+++ b/json/quizzes/angular/advanced/seed-quiz-angular-advanced.ts
@@ -0,0 +1,240 @@
+import { eq } from 'drizzle-orm';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { db } from './index';
+import { categories } from './schema/categories';
+import {
+  quizzes,
+  quizTranslations,
+  quizQuestions,
+  quizQuestionContent,
+  quizAnswers,
+  quizAnswerTranslations,
+  quizAttempts,
+} from './schema/quiz';
+
+type Locale = 'uk' | 'en' | 'pl';
+const LOCALES: Locale[] = ['uk', 'en', 'pl'];
+
+interface QuestionData {
+  id: string;
+  order: number;
+  difficulty: 'beginner' | 'medium' | 'advanced';
+  uk: { q: string; exp: string };
+  en: { q: string; exp: string };
+  pl: { q: string; exp: string };
+  answers: {
+    uk: string;
+    en: string;
+    pl: string;
+    correct: boolean;
+  }[];
+}
+
+interface QuizPartData {
+  questions: QuestionData[];
+}
+
+const CATEGORY_SLUG = 'angular';
+
+const QUIZ_METADATA = {
+  slug: 'angular-advanced',
+  questionsCount: 40,
+  timeLimitSeconds: 2400,
+  translations: {
+    uk: {
+      title: 'Angular Advanced',
+      description: 'Поглиблені концепції Angular: lifecycle hooks, DI декоратори, NgRx, кастомні директиви, SSR, Signals, OnPush та оптимізація продуктивності.',
+    },
+    en: {
+      title: 'Angular Advanced',
+      description: 'Advanced Angular concepts: lifecycle hooks, DI decorators, NgRx, custom directives, SSR, Signals, OnPush and performance optimization.',
+    },
+    pl: {
+      title: 'Angular Advanced',
+      description: 'Zaawansowane koncepcje Angular: lifecycle hooks, dekoratory DI, NgRx, niestandardowe dyrektywy, SSR, Signals, OnPush i optymalizacja wydajności.',
+    },
+  },
+};
+
+function createExplanation(text: string) {
+  return [{ type: 'paragraph' as const, children: [{ text }] }];
+}
+
+async function loadQuestions(partNumber: number): Promise<QuestionData[]> {
+  const partPath = join(process.cwd(), 'data', `angular-advanced-quiz-part${partNumber}.json`);
+  const partData: QuizPartData = JSON.parse(readFileSync(partPath, 'utf-8'));
+  return partData.questions;
+}
+
+async function ensureQuizExists(): Promise<string> {
+  console.log('Ensuring quiz exists...');
+
+  // Find category by slug
+  const [category] = await db
+    .select()
+    .from(categories)
+    .where(eq(categories.slug, CATEGORY_SLUG))
+    .limit(1);
+
+  if (!category) {
+    throw new Error(`Category "${CATEGORY_SLUG}" not found. Run seed:categories first.`);
+  }
+
+  // Clean up old quiz by slug
+  const existing = await db.query.quizzes.findFirst({
+    where: eq(quizzes.slug, QUIZ_METADATA.slug),
+  });
+  if (existing) {
+    const existingAttempt = await db.query.quizAttempts.findFirst({
+      where: eq(quizAttempts.quizId, existing.id),
+    });
+    if (existingAttempt) {
+      throw new Error(`Quiz ${QUIZ_METADATA.slug} has existing attempts. Aborting to avoid data loss.`);
+    }
+
+    await db.delete(quizQuestions).where(eq(quizQuestions.quizId, existing.id));
+    await db.delete(quizTranslations).where(eq(quizTranslations.quizId, existing.id));
+    await db.update(quizzes).set({
+      categoryId: category.id,
+      slug: QUIZ_METADATA.slug,
+      displayOrder: 2,
+      questionsCount: QUIZ_METADATA.questionsCount,
+      timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+      isActive: true,
+    }).where(eq(quizzes.id, existing.id));
+
+    const quizId = existing.id;
+    for (const locale of LOCALES) {
+      await db.insert(quizTranslations).values({
+        quizId,
+        locale,
+        title: QUIZ_METADATA.translations[locale].title,
+        description: QUIZ_METADATA.translations[locale].description,
+      });
+    }
+
+    return quizId;
+  }
+
+  const [quiz] = await db.insert(quizzes).values({
+    categoryId: category.id,
+    slug: QUIZ_METADATA.slug,
+    displayOrder: 2,
+    questionsCount: QUIZ_METADATA.questionsCount,
+    timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+    isActive: true,
+  }).returning();
+
+  for (const locale of LOCALES) {
+    await db.insert(quizTranslations).values({
+      quizId: quiz.id,
+      locale,
+      title: QUIZ_METADATA.translations[locale].title,
+      description: QUIZ_METADATA.translations[locale].description,
+    });
+  }
+
+  return quiz.id;
+}
+
+async function seedQuestions(questions: QuestionData[], quizId: string, partNumber: number) {
+  console.log(`Seeding ${questions.length} questions from part ${partNumber}...`);
+
+  for (const question of questions) {
+    const [q] = await db.insert(quizQuestions).values({
+      quizId,
+      displayOrder: question.order,
+      difficulty: question.difficulty,
+    }).returning();
+
+    for (const locale of LOCALES) {
+      await db.insert(quizQuestionContent).values({
+        quizQuestionId: q.id,
+        locale,
+        questionText: question[locale].q,
+        explanation: createExplanation(question[locale].exp),
+      });
+    }
+
+    for (let i = 0; i < question.answers.length; i++) {
+      const answer = question.answers[i];
+      
+      const [a] = await db.insert(quizAnswers).values({
+        quizQuestionId: q.id,
+        displayOrder: i + 1,
+        isCorrect: answer.correct,
+      }).returning();
+
+      for (const locale of LOCALES) {
+        await db.insert(quizAnswerTranslations).values({
+          quizAnswerId: a.id,
+          locale,
+          answerText: answer[locale],
+        });
+      }
+    }
+  }
+
+  console.log(`Part ${partNumber} completed (${questions.length} questions)`);
+}
+
+async function seedQuizFromJson() {
+  const args = process.argv.slice(2);
+  const partArg = args[0];
+
+  if (!partArg) {
+    console.error('Error: Please specify which part to upload');
+    console.log('Usage: npx tsx db/seeds/seed-quiz-angular-advanced.ts <part-number>');
+    console.log('Example: npx tsx db/seeds/seed-quiz-angular-advanced.ts 1');
+    console.log('Or upload all: npx tsx db/seeds/seed-quiz-angular-advanced.ts all');
+    process.exit(1);
+  }
+
+  console.log('Starting Angular Advanced quiz seed...\n');
+
+  try {
+    const quizId = await ensureQuizExists();
+
+    if (partArg.toLowerCase() === 'all') {
+      console.log('Uploading all parts...\n');
+      let totalQuestions = 0;
+
+      for (let i = 1; i <= 4; i++) {
+        const questions = await loadQuestions(i);
+        await seedQuestions(questions, quizId, i);
+        totalQuestions += questions.length;
+      }
+
+      console.log('\nAll parts seeded successfully!');
+      console.log(`   - 1 quiz with ${LOCALES.length} translations`);
+      console.log(`   - ${totalQuestions} questions total`);
+      console.log(`   - ${totalQuestions * 4} answers with ${LOCALES.length} translations each`);
+    } else {
+      const partNumber = parseInt(partArg, 10);
+
+      if (isNaN(partNumber) || partNumber < 1 || partNumber > 4) {
+        console.error('Error: Part number must be between 1 and 4');
+        process.exit(1);
+      }
+
+      const questions = await loadQuestions(partNumber);
+      await seedQuestions(questions, quizId, partNumber);
+
+      console.log('\nPart seeded successfully!');
+      console.log(`   - Quiz: ${QUIZ_METADATA.translations.en.title}`);
+      console.log(`   - Part ${partNumber}: ${questions.length} questions`);
+      console.log(`   - ${questions.length * 4} answers with ${LOCALES.length} translations each`);
+    }
+  } catch (error) {
+    console.error('\nError seeding quiz:', error);
+    throw error;
+  }
+}
+
+seedQuizFromJson()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/json/quizzes/angular/beginner_medium/angular-quiz-part1.json b/json/quizzes/angular/beginner_medium/angular-quiz-part1.json
new file mode 100644
index 00000000..81f7a26e
--- /dev/null
+++ b/json/quizzes/angular/beginner_medium/angular-quiz-part1.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "angular-q01",
+      "order": 1,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Що таке Angular?",
+        "exp": "Angular — це фронтенд-фреймворк від Google для побудови SPA (Single Page Applications) та масштабованих веб-додатків із вбудованими інструментами."
+      },
+      "en": {
+        "q": "What is Angular?",
+        "exp": "Angular is a frontend framework by Google for building SPAs (Single Page Applications) and scalable web applications with built-in tools."
+      },
+      "pl": {
+        "q": "Czym jest Angular?",
+        "exp": "Angular to framework frontendowy od Google do budowania SPA (Single Page Applications) i skalowalnych aplikacji webowych z wbudowanymi narzędziami."
+      },
+      "answers": [
+        {
+          "uk": "Бібліотека для роботи з базами даних",
+          "en": "A library for working with databases",
+          "pl": "Biblioteka do pracy z bazami danych",
+          "correct": false
+        },
+        {
+          "uk": "Фронтенд-фреймворк від Google для побудови SPA та масштабованих веб-додатків",
+          "en": "A frontend framework by Google for building SPAs and scalable web applications",
+          "pl": "Framework frontendowy od Google do budowania SPA i skalowalnych aplikacji webowych",
+          "correct": true
+        },
+        {
+          "uk": "Мова програмування для мобільних додатків",
+          "en": "A programming language for mobile applications",
+          "pl": "Język programowania dla aplikacji mobilnych",
+          "correct": false
+        },
+        {
+          "uk": "Інструмент для тестування бекенду",
+          "en": "A tool for backend testing",
+          "pl": "Narzędzie do testowania backendu",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q02",
+      "order": 2,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Що таке компонент в Angular?",
+        "exp": "Компонент — це основний будівельний блок Angular-додатку, що складається з класу (логіка), шаблону HTML та стилів."
+      },
+      "en": {
+        "q": "What is a component in Angular?",
+        "exp": "A component is the main building block of an Angular application, consisting of a class (logic), HTML template, and styles."
+      },
+      "pl": {
+        "q": "Czym jest komponent w Angular?",
+        "exp": "Komponent to główny blok budulcowy aplikacji Angular, składający się z klasy (logika), szablonu HTML i stylów."
+      },
+      "answers": [
+        {
+          "uk": "Функція для обробки HTTP-запитів",
+          "en": "A function for handling HTTP requests",
+          "pl": "Funkcja do obsługi żądań HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Основний будівельний блок, що містить клас, шаблон і стилі",
+          "en": "A main building block containing a class, template, and styles",
+          "pl": "Główny blok budulcowy zawierający klasę, szablon i style",
+          "correct": true
+        },
+        {
+          "uk": "Файл конфігурації для маршрутизації",
+          "en": "A configuration file for routing",
+          "pl": "Plik konfiguracyjny dla routingu",
+          "correct": false
+        },
+        {
+          "uk": "Тип змінної в TypeScript",
+          "en": "A variable type in TypeScript",
+          "pl": "Typ zmiennej w TypeScript",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q03",
+      "order": 3,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Скільки основних типів data-binding існує в Angular?",
+        "exp": "В Angular є 4 типи: interpolation ({{ }}), property binding ([]), event binding (()), та two-way binding ([()])."
+      },
+      "en": {
+        "q": "How many main types of data binding exist in Angular?",
+        "exp": "Angular has 4 types: interpolation ({{ }}), property binding ([]), event binding (()), and two-way binding ([()])"
+      },
+      "pl": {
+        "q": "Ile głównych typów data binding istnieje w Angular?",
+        "exp": "Angular ma 4 typy: interpolation ({{ }}), property binding ([]), event binding (()), oraz two-way binding ([()])"
+      },
+      "answers": [
+        {
+          "uk": "2",
+          "en": "2",
+          "pl": "2",
+          "correct": false
+        },
+        {
+          "uk": "3",
+          "en": "3",
+          "pl": "3",
+          "correct": false
+        },
+        {
+          "uk": "4",
+          "en": "4",
+          "pl": "4",
+          "correct": true
+        },
+        {
+          "uk": "5",
+          "en": "5",
+          "pl": "5",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q04",
+      "order": 4,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Який синтаксис використовується для interpolation в Angular?",
+        "exp": "Interpolation використовує подвійні фігурні дужки {{ value }} для відображення даних із компонента в шаблоні."
+      },
+      "en": {
+        "q": "What syntax is used for interpolation in Angular?",
+        "exp": "Interpolation uses double curly braces {{ value }} to display component data in the template."
+      },
+      "pl": {
+        "q": "Jakiej składni używa się do interpolacji w Angular?",
+        "exp": "Interpolacja używa podwójnych nawiasów klamrowych {{ value }} do wyświetlania danych komponentu w szablonie."
+      },
+      "answers": [
+        {
+          "uk": "[value]",
+          "en": "[value]",
+          "pl": "[value]",
+          "correct": false
+        },
+        {
+          "uk": "(value)",
+          "en": "(value)",
+          "pl": "(value)",
+          "correct": false
+        },
+        {
+          "uk": "{{ value }}",
+          "en": "{{ value }}",
+          "pl": "{{ value }}",
+          "correct": true
+        },
+        {
+          "uk": "*value",
+          "en": "*value",
+          "pl": "*value",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q05",
+      "order": 5,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Як реалізувати двостороннє зв'язування (two-way binding) у Angular?",
+        "exp": "Two-way binding реалізується через [(ngModel)] або комбінацію property binding і event binding. Синтаксис [()] називають \"banana in a box\"."
+      },
+      "en": {
+        "q": "How do you implement two-way binding in Angular?",
+        "exp": "Two-way binding is implemented via [(ngModel)] or a combination of property and event binding. The [()] syntax is called 'banana in a box'."
+      },
+      "pl": {
+        "q": "Jak zaimplementować dwukierunkowe wiązanie (two-way binding) w Angular?",
+        "exp": "Two-way binding implementuje się przez [(ngModel)] lub kombinację property binding i event binding. Składnia [()] nazywana jest 'banana in a box'."
+      },
+      "answers": [
+        {
+          "uk": "Через синтаксис {{ value }}",
+          "en": "Using {{ value }} syntax",
+          "pl": "Przez składnię {{ value }}",
+          "correct": false
+        },
+        {
+          "uk": "Через синтаксис [(ngModel)]=\"value\"",
+          "en": "Using [(ngModel)]=\"value\" syntax",
+          "pl": "Przez składnię [(ngModel)]=\"value\"",
+          "correct": true
+        },
+        {
+          "uk": "Через синтаксис [value]",
+          "en": "Using [value] syntax",
+          "pl": "Przez składnię [value]",
+          "correct": false
+        },
+        {
+          "uk": "Two-way binding неможливий в Angular",
+          "en": "Two-way binding is not possible in Angular",
+          "pl": "Two-way binding nie jest możliwy w Angular",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q06",
+      "order": 6,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Яка основна різниця між структурними та атрибутними директивами?",
+        "exp": "Структурні директиви (@if, @for) змінюють структуру DOM (додають/видаляють елементи), атрибутні (ngClass, ngStyle) змінюють лише вигляд чи поведінку елемента."
+      },
+      "en": {
+        "q": "What is the main difference between structural and attribute directives?",
+        "exp": "Structural directives (@if, @for) change DOM structure (add/remove elements), attribute directives (ngClass, ngStyle) only change element appearance or behavior."
+      },
+      "pl": {
+        "q": "Jaka jest główna różnica między dyrektywami strukturalnymi a atrybutowymi?",
+        "exp": "Dyrektywy strukturalne (@if, @for) zmieniają strukturę DOM (dodają/usuwają elementy), dyrektywy atrybutowe (ngClass, ngStyle) zmieniają tylko wygląd lub zachowanie elementu."
+      },
+      "answers": [
+        {
+          "uk": "Структурні змінюють стилі, атрибутні — структуру DOM",
+          "en": "Structural change styles, attribute change DOM structure",
+          "pl": "Strukturalne zmieniają style, atrybutowe — strukturę DOM",
+          "correct": false
+        },
+        {
+          "uk": "Структурні змінюють структуру DOM, атрибутні — вигляд або поведінку",
+          "en": "Structural change DOM structure, attribute change appearance or behavior",
+          "pl": "Strukturalne zmieniają strukturę DOM, atrybutowe — wygląd lub zachowanie",
+          "correct": true
+        },
+        {
+          "uk": "Різниці немає, це синоніми",
+          "en": "No difference, they are synonyms",
+          "pl": "Nie ma różnicy, to synonimy",
+          "correct": false
+        },
+        {
+          "uk": "Атрибутні можуть видаляти елементи, структурні — ні",
+          "en": "Attribute can remove elements, structural cannot",
+          "pl": "Atrybutowe mogą usuwać elementy, strukturalne — nie",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q07",
+      "order": 7,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Що таке standalone components в Angular?",
+        "exp": "Standalone components — це компоненти, які не потребують NgModule для свого оголошення. Вони імпортують залежності напряму через властивість imports."
+      },
+      "en": {
+        "q": "What are standalone components in Angular?",
+        "exp": "Standalone components are components that don't require NgModule for their declaration. They import dependencies directly via the imports property."
+      },
+      "pl": {
+        "q": "Czym są standalone components w Angular?",
+        "exp": "Standalone components to komponenty, które nie wymagają NgModule do ich deklaracji. Importują zależności bezpośrednio przez właściwość imports."
+      },
+      "answers": [
+        {
+          "uk": "Компоненти, які працюють тільки на сервері",
+          "en": "Components that only work on the server",
+          "pl": "Komponenty, które działają tylko na serwerze",
+          "correct": false
+        },
+        {
+          "uk": "Компоненти без шаблону",
+          "en": "Components without a template",
+          "pl": "Komponenty bez szablonu",
+          "correct": false
+        },
+        {
+          "uk": "Компоненти, які не потребують NgModule",
+          "en": "Components that don't require NgModule",
+          "pl": "Komponenty, które nie wymagają NgModule",
+          "correct": true
+        },
+        {
+          "uk": "Компоненти з глобальними стилями",
+          "en": "Components with global styles",
+          "pl": "Komponenty z globalnymi stylami",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q08",
+      "order": 8,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Яка директива використовується для динамічного керування CSS-класами?",
+        "exp": "Директива ngClass дозволяє динамічно додавати або видаляти CSS-класи на елементі залежно від умов у компоненті."
+      },
+      "en": {
+        "q": "Which directive is used for dynamic CSS class management?",
+        "exp": "The ngClass directive allows dynamically adding or removing CSS classes on an element based on conditions in the component."
+      },
+      "pl": {
+        "q": "Która dyrektywa służy do dynamicznego zarządzania klasami CSS?",
+        "exp": "Dyrektywa ngClass pozwala dynamicznie dodawać lub usuwać klasy CSS na elemencie w zależności od warunków w komponencie."
+      },
+      "answers": [
+        {
+          "uk": "ngStyle",
+          "en": "ngStyle",
+          "pl": "ngStyle",
+          "correct": false
+        },
+        {
+          "uk": "ngClass",
+          "en": "ngClass",
+          "pl": "ngClass",
+          "correct": true
+        },
+        {
+          "uk": "@if",
+          "en": "@if",
+          "pl": "@if",
+          "correct": false
+        },
+        {
+          "uk": "ngModel",
+          "en": "ngModel",
+          "pl": "ngModel",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q09",
+      "order": 9,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Як обробити подію click на кнопці в Angular?",
+        "exp": "Події обробляються через event binding з синтаксисом (eventName). Для click: <button (click)=\"onClick()\">."
+      },
+      "en": {
+        "q": "How do you handle a click event on a button in Angular?",
+        "exp": "Events are handled via event binding with (eventName) syntax. For click: <button (click)=\"onClick()\">."
+      },
+      "pl": {
+        "q": "Jak obsłużyć zdarzenie click na przycisku w Angular?",
+        "exp": "Zdarzenia obsługuje się przez event binding ze składnią (eventName). Dla click: <button (click)=\"onClick()\">."
+      },
+      "answers": [
+        {
+          "uk": "<button [click]=\"onClick()\">",
+          "en": "<button [click]=\"onClick()\">",
+          "pl": "<button [click]=\"onClick()\">",
+          "correct": false
+        },
+        {
+          "uk": "<button (click)=\"onClick()\">",
+          "en": "<button (click)=\"onClick()\">",
+          "pl": "<button (click)=\"onClick()\">",
+          "correct": true
+        },
+        {
+          "uk": "<button {{click}}=\"onClick()\">",
+          "en": "<button {{click}}=\"onClick()\">",
+          "pl": "<button {{click}}=\"onClick()\">",
+          "correct": false
+        },
+        {
+          "uk": "<button click=\"onClick()\">",
+          "en": "<button click=\"onClick()\">",
+          "pl": "<button click=\"onClick()\">",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q10",
+      "order": 10,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Який декоратор використовується для передачі даних з батьківського компонента в дочірній?",
+        "exp": "Декоратор @Input() позначає властивість, яка може отримувати дані від батьківського компонента через property binding."
+      },
+      "en": {
+        "q": "Which decorator is used to pass data from a parent component to a child?",
+        "exp": "The @Input() decorator marks a property that can receive data from a parent component via property binding."
+      },
+      "pl": {
+        "q": "Który dekorator służy do przekazywania danych z komponentu rodzica do dziecka?",
+        "exp": "Dekorator @Input() oznacza właściwość, która może otrzymywać dane od komponentu rodzica przez property binding."
+      },
+      "answers": [
+        {
+          "uk": "@Output()",
+          "en": "@Output()",
+          "pl": "@Output()",
+          "correct": false
+        },
+        {
+          "uk": "@Input()",
+          "en": "@Input()",
+          "pl": "@Input()",
+          "correct": true
+        },
+        {
+          "uk": "@ViewChild()",
+          "en": "@ViewChild()",
+          "pl": "@ViewChild()",
+          "correct": false
+        },
+        {
+          "uk": "@Injectable()",
+          "en": "@Injectable()",
+          "pl": "@Injectable()",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/angular/beginner_medium/angular-quiz-part2.json b/json/quizzes/angular/beginner_medium/angular-quiz-part2.json
new file mode 100644
index 00000000..28222d08
--- /dev/null
+++ b/json/quizzes/angular/beginner_medium/angular-quiz-part2.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "angular-q11",
+      "order": 11,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Який декоратор використовується для передачі подій з дочірнього компонента в батьківський?",
+        "exp": "@Output() разом з EventEmitter дозволяє дочірньому компоненту емітити події, на які батьківський компонент може підписатися."
+      },
+      "en": {
+        "q": "Which decorator is used to emit events from a child component to a parent?",
+        "exp": "@Output() together with EventEmitter allows a child component to emit events that the parent component can subscribe to."
+      },
+      "pl": {
+        "q": "Który dekorator służy do emitowania zdarzeń z komponentu dziecka do rodzica?",
+        "exp": "@Output() wraz z EventEmitter pozwala komponentowi dziecka emitować zdarzenia, na które komponent rodzica może się subskrybować."
+      },
+      "answers": [
+        {
+          "uk": "@Input()",
+          "en": "@Input()",
+          "pl": "@Input()",
+          "correct": false
+        },
+        {
+          "uk": "@Output()",
+          "en": "@Output()",
+          "pl": "@Output()",
+          "correct": true
+        },
+        {
+          "uk": "@Emit()",
+          "en": "@Emit()",
+          "pl": "@Emit()",
+          "correct": false
+        },
+        {
+          "uk": "@Event()",
+          "en": "@Event()",
+          "pl": "@Event()",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q12",
+      "order": 12,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Що таке сервіс в Angular і для чого він використовується?",
+        "exp": "Сервіс — це клас з бізнес-логікою, який не пов'язаний напряму з UI. Використовується для роботи з API, керування станом та повторного використання коду."
+      },
+      "en": {
+        "q": "What is a service in Angular and what is it used for?",
+        "exp": "A service is a class with business logic not directly tied to UI. It's used for API calls, state management, and code reusability."
+      },
+      "pl": {
+        "q": "Czym jest serwis w Angular i do czego służy?",
+        "exp": "Serwis to klasa z logiką biznesową niezwiązana bezpośrednio z UI. Służy do wywołań API, zarządzania stanem i ponownego wykorzystania kodu."
+      },
+      "answers": [
+        {
+          "uk": "Компонент для відображення даних",
+          "en": "A component for displaying data",
+          "pl": "Komponent do wyświetlania danych",
+          "correct": false
+        },
+        {
+          "uk": "Клас з бізнес-логікою для роботи з API та керування станом",
+          "en": "A class with business logic for API calls and state management",
+          "pl": "Klasa z logiką biznesową do wywołań API i zarządzania stanem",
+          "correct": true
+        },
+        {
+          "uk": "Файл конфігурації маршрутів",
+          "en": "A route configuration file",
+          "pl": "Plik konfiguracji tras",
+          "correct": false
+        },
+        {
+          "uk": "Директива для стилізації",
+          "en": "A directive for styling",
+          "pl": "Dyrektywa do stylizacji",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q13",
+      "order": 13,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що означає providedIn: 'root' у декораторі @Injectable?",
+        "exp": "providedIn: 'root' реєструє сервіс у головному інжекторі як singleton — один екземпляр на весь застосунок з оптимізацією tree-shaking."
+      },
+      "en": {
+        "q": "What does providedIn: 'root' mean in the @Injectable decorator?",
+        "exp": "providedIn: 'root' registers the service in the root injector as a singleton — one instance for the entire app with tree-shaking optimization."
+      },
+      "pl": {
+        "q": "Co oznacza providedIn: 'root' w dekoratorze @Injectable?",
+        "exp": "providedIn: 'root' rejestruje serwis w głównym injektorze jako singleton — jedna instancja dla całej aplikacji z optymalizacją tree-shaking."
+      },
+      "answers": [
+        {
+          "uk": "Сервіс доступний тільки в кореневому компоненті",
+          "en": "Service is only available in the root component",
+          "pl": "Serwis jest dostępny tylko w głównym komponencie",
+          "correct": false
+        },
+        {
+          "uk": "Сервіс є singleton на рівні всього застосунку",
+          "en": "Service is a singleton for the entire application",
+          "pl": "Serwis jest singletonem dla całej aplikacji",
+          "correct": true
+        },
+        {
+          "uk": "Сервіс створюється для кожного компонента окремо",
+          "en": "Service is created separately for each component",
+          "pl": "Serwis jest tworzony oddzielnie dla każdego komponentu",
+          "correct": false
+        },
+        {
+          "uk": "Сервіс працює тільки на сервері",
+          "en": "Service only works on the server",
+          "pl": "Serwis działa tylko na serwerze",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q14",
+      "order": 14,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Dependency Injection (DI) в Angular?",
+        "exp": "DI — це механізм, який автоматично створює та надає об'єкти (сервіси) компонентам замість ручного створення через new. Спрощує тестування та керує життєвим циклом об'єктів."
+      },
+      "en": {
+        "q": "What is Dependency Injection (DI) in Angular?",
+        "exp": "DI is a mechanism that automatically creates and provides objects (services) to components instead of manual creation via new. It simplifies testing and manages object lifecycles."
+      },
+      "pl": {
+        "q": "Czym jest Dependency Injection (DI) w Angular?",
+        "exp": "DI to mechanizm automatycznego tworzenia i dostarczania obiektów (serwisów) do komponentów zamiast ręcznego tworzenia przez new. Upraszcza testowanie i zarządza cyklem życia obiektów."
+      },
+      "answers": [
+        {
+          "uk": "Спосіб додавання CSS-залежностей",
+          "en": "A way to add CSS dependencies",
+          "pl": "Sposób dodawania zależności CSS",
+          "correct": false
+        },
+        {
+          "uk": "Механізм автоматичного надання залежностей компонентам",
+          "en": "A mechanism for automatically providing dependencies to components",
+          "pl": "Mechanizm automatycznego dostarczania zależności do komponentów",
+          "correct": true
+        },
+        {
+          "uk": "Процес збірки застосунку",
+          "en": "The application build process",
+          "pl": "Proces budowania aplikacji",
+          "correct": false
+        },
+        {
+          "uk": "Метод шифрування даних",
+          "en": "A data encryption method",
+          "pl": "Metoda szyfrowania danych",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q15",
+      "order": 15,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Який lifecycle hook викликається один раз після ініціалізації компонента?",
+        "exp": "ngOnInit() викликається один раз після ініціалізації компонента. Використовується для початкового завантаження даних та налаштування."
+      },
+      "en": {
+        "q": "Which lifecycle hook is called once after component initialization?",
+        "exp": "ngOnInit() is called once after component initialization. It's used for initial data loading and setup."
+      },
+      "pl": {
+        "q": "Który lifecycle hook jest wywoływany raz po inicjalizacji komponentu?",
+        "exp": "ngOnInit() jest wywoływany raz po inicjalizacji komponentu. Służy do początkowego ładowania danych i konfiguracji."
+      },
+      "answers": [
+        {
+          "uk": "ngOnChanges()",
+          "en": "ngOnChanges()",
+          "pl": "ngOnChanges()",
+          "correct": false
+        },
+        {
+          "uk": "ngOnInit()",
+          "en": "ngOnInit()",
+          "pl": "ngOnInit()",
+          "correct": true
+        },
+        {
+          "uk": "ngOnDestroy()",
+          "en": "ngOnDestroy()",
+          "pl": "ngOnDestroy()",
+          "correct": false
+        },
+        {
+          "uk": "ngAfterViewInit()",
+          "en": "ngAfterViewInit()",
+          "pl": "ngAfterViewInit()",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q16",
+      "order": 16,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Який lifecycle hook використовується для очищення ресурсів перед знищенням компонента?",
+        "exp": "ngOnDestroy() викликається перед знищенням компонента. Тут потрібно відписуватися від Observable, очищати таймери та інші ресурси."
+      },
+      "en": {
+        "q": "Which lifecycle hook is used for cleanup before component destruction?",
+        "exp": "ngOnDestroy() is called before component destruction. Use it to unsubscribe from Observables, clear timers, and release other resources."
+      },
+      "pl": {
+        "q": "Który lifecycle hook służy do czyszczenia zasobów przed zniszczeniem komponentu?",
+        "exp": "ngOnDestroy() jest wywoływany przed zniszczeniem komponentu. Służy do odsubskrybowania Observable, czyszczenia timerów i innych zasobów."
+      },
+      "answers": [
+        {
+          "uk": "ngOnInit()",
+          "en": "ngOnInit()",
+          "pl": "ngOnInit()",
+          "correct": false
+        },
+        {
+          "uk": "ngAfterViewInit()",
+          "en": "ngAfterViewInit()",
+          "pl": "ngAfterViewInit()",
+          "correct": false
+        },
+        {
+          "uk": "ngOnDestroy()",
+          "en": "ngOnDestroy()",
+          "pl": "ngOnDestroy()",
+          "correct": true
+        },
+        {
+          "uk": "ngDoCheck()",
+          "en": "ngDoCheck()",
+          "pl": "ngDoCheck()",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q17",
+      "order": 17,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Що таке pipe в Angular?",
+        "exp": "Pipe — це клас для трансформації даних у шаблоні без зміни оригінального значення. Наприклад: date, currency, uppercase."
+      },
+      "en": {
+        "q": "What is a pipe in Angular?",
+        "exp": "A pipe is a class for transforming data in templates without changing the original value. For example: date, currency, uppercase."
+      },
+      "pl": {
+        "q": "Czym jest pipe w Angular?",
+        "exp": "Pipe to klasa do transformacji danych w szablonach bez zmiany oryginalnej wartości. Na przykład: date, currency, uppercase."
+      },
+      "answers": [
+        {
+          "uk": "Інструмент для роботи з HTTP",
+          "en": "A tool for working with HTTP",
+          "pl": "Narzędzie do pracy z HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Клас для трансформації даних у шаблоні",
+          "en": "A class for transforming data in templates",
+          "pl": "Klasa do transformacji danych w szablonach",
+          "correct": true
+        },
+        {
+          "uk": "Метод маршрутизації",
+          "en": "A routing method",
+          "pl": "Metoda routingu",
+          "correct": false
+        },
+        {
+          "uk": "Декоратор для сервісів",
+          "en": "A decorator for services",
+          "pl": "Dekorator dla serwisów",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q18",
+      "order": 18,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка різниця між pure та impure pipes?",
+        "exp": "Pure pipes викликаються тільки при зміні вхідних даних (за замовчуванням), impure — на кожен цикл change detection. Pure pipes продуктивніші."
+      },
+      "en": {
+        "q": "What is the difference between pure and impure pipes?",
+        "exp": "Pure pipes are called only when input changes (default), impure pipes run on every change detection cycle. Pure pipes are more performant."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między pipe'ami pure i impure?",
+        "exp": "Pure pipes wywoływane są tylko przy zmianie danych wejściowych (domyślnie), impure — przy każdym cyklu change detection. Pure pipes są wydajniejsze."
+      },
+      "answers": [
+        {
+          "uk": "Pure працюють на сервері, impure — в браузері",
+          "en": "Pure work on server, impure work in browser",
+          "pl": "Pure działają na serwerze, impure — w przeglądarce",
+          "correct": false
+        },
+        {
+          "uk": "Pure викликаються тільки при зміні input, impure — на кожен change detection",
+          "en": "Pure are called only on input change, impure on every change detection",
+          "pl": "Pure wywoływane tylko przy zmianie input, impure — przy każdym change detection",
+          "correct": true
+        },
+        {
+          "uk": "Impure швидші за pure",
+          "en": "Impure are faster than pure",
+          "pl": "Impure są szybsze niż pure",
+          "correct": false
+        },
+        {
+          "uk": "Різниці немає",
+          "en": "There is no difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q19",
+      "order": 19,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Яка основна різниця між Template-driven та Reactive формами?",
+        "exp": "Template-driven форми будуються в HTML через директиви (ngModel), Reactive — в TypeScript через FormGroup/FormControl. Reactive дають більше контролю."
+      },
+      "en": {
+        "q": "What is the main difference between Template-driven and Reactive forms?",
+        "exp": "Template-driven forms are built in HTML via directives (ngModel), Reactive forms in TypeScript via FormGroup/FormControl. Reactive forms give more control."
+      },
+      "pl": {
+        "q": "Jaka jest główna różnica między formularzami Template-driven a Reactive?",
+        "exp": "Formularze Template-driven budowane są w HTML przez dyrektywy (ngModel), Reactive — w TypeScript przez FormGroup/FormControl. Reactive dają więcej kontroli."
+      },
+      "answers": [
+        {
+          "uk": "Template-driven швидші за Reactive",
+          "en": "Template-driven are faster than Reactive",
+          "pl": "Template-driven są szybsze niż Reactive",
+          "correct": false
+        },
+        {
+          "uk": "Template-driven будуються в HTML, Reactive — в TypeScript коді",
+          "en": "Template-driven are built in HTML, Reactive in TypeScript code",
+          "pl": "Template-driven budowane są w HTML, Reactive — w kodzie TypeScript",
+          "correct": true
+        },
+        {
+          "uk": "Reactive працюють тільки з ngModel",
+          "en": "Reactive only work with ngModel",
+          "pl": "Reactive działają tylko z ngModel",
+          "correct": false
+        },
+        {
+          "uk": "Template-driven не підтримують валідацію",
+          "en": "Template-driven don't support validation",
+          "pl": "Template-driven nie wspierają walidacji",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q20",
+      "order": 20,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке FormGroup у Reactive Forms?",
+        "exp": "FormGroup — це контейнер, що об'єднує кілька FormControl у єдину структуру для керування станом, валідацією та значеннями всієї групи полів."
+      },
+      "en": {
+        "q": "What is FormGroup in Reactive Forms?",
+        "exp": "FormGroup is a container that combines multiple FormControls into a single structure for managing state, validation, and values of the entire field group."
+      },
+      "pl": {
+        "q": "Czym jest FormGroup w Reactive Forms?",
+        "exp": "FormGroup to kontener łączący wiele FormControl w jedną strukturę do zarządzania stanem, walidacją i wartościami całej grupy pól."
+      },
+      "answers": [
+        {
+          "uk": "Окреме поле форми",
+          "en": "A single form field",
+          "pl": "Pojedyncze pole formularza",
+          "correct": false
+        },
+        {
+          "uk": "Контейнер, що об'єднує кілька FormControl",
+          "en": "A container that combines multiple FormControls",
+          "pl": "Kontener łączący wiele FormControl",
+          "correct": true
+        },
+        {
+          "uk": "Валідатор форми",
+          "en": "A form validator",
+          "pl": "Walidator formularza",
+          "correct": false
+        },
+        {
+          "uk": "Декоратор для шаблону",
+          "en": "A template decorator",
+          "pl": "Dekorator dla szablonu",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/angular/beginner_medium/angular-quiz-part3.json b/json/quizzes/angular/beginner_medium/angular-quiz-part3.json
new file mode 100644
index 00000000..cfa8c5c7
--- /dev/null
+++ b/json/quizzes/angular/beginner_medium/angular-quiz-part3.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "angular-q21",
+      "order": 21,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке FormArray і коли його використовують?",
+        "exp": "FormArray — це масив FormControl або FormGroup для динамічних форм, де кількість полів може змінюватися (наприклад, список телефонів)."
+      },
+      "en": {
+        "q": "What is FormArray and when is it used?",
+        "exp": "FormArray is an array of FormControls or FormGroups for dynamic forms where the number of fields can change (e.g., a list of phone numbers)."
+      },
+      "pl": {
+        "q": "Czym jest FormArray i kiedy się go używa?",
+        "exp": "FormArray to tablica FormControl lub FormGroup dla dynamicznych formularzy, gdzie liczba pól może się zmieniać (np. lista numerów telefonów)."
+      },
+      "answers": [
+        {
+          "uk": "Масив валідаторів",
+          "en": "An array of validators",
+          "pl": "Tablica walidatorów",
+          "correct": false
+        },
+        {
+          "uk": "Масив FormControl для динамічних форм зі змінною кількістю полів",
+          "en": "An array of FormControls for dynamic forms with variable field count",
+          "pl": "Tablica FormControl dla dynamicznych formularzy ze zmienną liczbą pól",
+          "correct": true
+        },
+        {
+          "uk": "Стилізований список полів",
+          "en": "A styled list of fields",
+          "pl": "Stylizowana lista pól",
+          "correct": false
+        },
+        {
+          "uk": "Групування валідаційних помилок",
+          "en": "A grouping of validation errors",
+          "pl": "Grupowanie błędów walidacji",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q22",
+      "order": 22,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Для чого використовується <router-outlet> в Angular?",
+        "exp": "<router-outlet> — це директива, яка визначає місце в шаблоні, куди Angular підставляє компонент відповідно до активного маршруту."
+      },
+      "en": {
+        "q": "What is <router-outlet> used for in Angular?",
+        "exp": "<router-outlet> is a directive that defines where in the template Angular inserts the component matching the active route."
+      },
+      "pl": {
+        "q": "Do czego służy <router-outlet> w Angular?",
+        "exp": "<router-outlet> to dyrektywa określająca miejsce w szablonie, gdzie Angular wstawia komponent odpowiadający aktywnej trasie."
+      },
+      "answers": [
+        {
+          "uk": "Контейнер для форм",
+          "en": "A container for forms",
+          "pl": "Kontener dla formularzy",
+          "correct": false
+        },
+        {
+          "uk": "Місце для відображення компонента активного маршруту",
+          "en": "A place to display the active route's component",
+          "pl": "Miejsce do wyświetlania komponentu aktywnej trasy",
+          "correct": true
+        },
+        {
+          "uk": "Елемент для стилізації навігації",
+          "en": "An element for styling navigation",
+          "pl": "Element do stylizacji nawigacji",
+          "correct": false
+        },
+        {
+          "uk": "Метод переходу між сторінками",
+          "en": "A method for navigating between pages",
+          "pl": "Metoda nawigacji między stronami",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q23",
+      "order": 23,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке lazy loading в контексті маршрутизації Angular?",
+        "exp": "Lazy loading — це завантаження модуля або компонента тільки при переході на відповідний маршрут, що зменшує початковий розмір бандлу."
+      },
+      "en": {
+        "q": "What is lazy loading in the context of Angular routing?",
+        "exp": "Lazy loading is loading a module or component only when navigating to its route, which reduces the initial bundle size."
+      },
+      "pl": {
+        "q": "Czym jest lazy loading w kontekście routingu Angular?",
+        "exp": "Lazy loading to ładowanie modułu lub komponentu tylko przy nawigacji do jego trasy, co zmniejsza początkowy rozmiar paczki."
+      },
+      "answers": [
+        {
+          "uk": "Завантаження всіх компонентів при старті",
+          "en": "Loading all components at startup",
+          "pl": "Ładowanie wszystkich komponentów przy starcie",
+          "correct": false
+        },
+        {
+          "uk": "Завантаження модуля/компонента тільки при переході на маршрут",
+          "en": "Loading module/component only when navigating to the route",
+          "pl": "Ładowanie modułu/komponentu tylko przy nawigacji do trasy",
+          "correct": true
+        },
+        {
+          "uk": "Кешування даних маршруту",
+          "en": "Caching route data",
+          "pl": "Cache'owanie danych trasy",
+          "correct": false
+        },
+        {
+          "uk": "Попереднє завантаження зображень",
+          "en": "Preloading images",
+          "pl": "Wstępne ładowanie obrazów",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q24",
+      "order": 24,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Для чого використовуються Route Guards?",
+        "exp": "Route Guards (canActivate, canDeactivate, canLoad) контролюють доступ до маршрутів — наприклад, перевіряють авторизацію перед переходом."
+      },
+      "en": {
+        "q": "What are Route Guards used for?",
+        "exp": "Route Guards (canActivate, canDeactivate, canLoad) control access to routes — for example, checking authorization before navigation."
+      },
+      "pl": {
+        "q": "Do czego służą Route Guards?",
+        "exp": "Route Guards (canActivate, canDeactivate, canLoad) kontrolują dostęp do tras — na przykład sprawdzają autoryzację przed nawigacją."
+      },
+      "answers": [
+        {
+          "uk": "Стилізація навігаційних посилань",
+          "en": "Styling navigation links",
+          "pl": "Stylizacja linków nawigacyjnych",
+          "correct": false
+        },
+        {
+          "uk": "Кешування даних маршруту",
+          "en": "Caching route data",
+          "pl": "Cache'owanie danych trasy",
+          "correct": false
+        },
+        {
+          "uk": "Контроль доступу до маршрутів",
+          "en": "Controlling access to routes",
+          "pl": "Kontrola dostępu do tras",
+          "correct": true
+        },
+        {
+          "uk": "Анімація переходів між сторінками",
+          "en": "Animating transitions between pages",
+          "pl": "Animacja przejść między stronami",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q25",
+      "order": 25,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке ActivatedRoute і для чого він використовується?",
+        "exp": "ActivatedRoute надає доступ до інформації про активний маршрут: параметри, query-параметри, дані з resolve та інше."
+      },
+      "en": {
+        "q": "What is ActivatedRoute and what is it used for?",
+        "exp": "ActivatedRoute provides access to information about the active route: parameters, query parameters, resolve data, and more."
+      },
+      "pl": {
+        "q": "Czym jest ActivatedRoute i do czego służy?",
+        "exp": "ActivatedRoute zapewnia dostęp do informacji o aktywnej trasie: parametry, query parameters, dane z resolve i więcej."
+      },
+      "answers": [
+        {
+          "uk": "Сервіс для HTTP-запитів",
+          "en": "A service for HTTP requests",
+          "pl": "Serwis do żądań HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Сервіс для доступу до параметрів та даних активного маршруту",
+          "en": "A service for accessing parameters and data of the active route",
+          "pl": "Serwis do dostępu do parametrów i danych aktywnej trasy",
+          "correct": true
+        },
+        {
+          "uk": "Декоратор для компонентів",
+          "en": "A decorator for components",
+          "pl": "Dekorator dla komponentów",
+          "correct": false
+        },
+        {
+          "uk": "Метод для зміни маршруту",
+          "en": "A method for changing routes",
+          "pl": "Metoda do zmiany tras",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q26",
+      "order": 26,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Який сервіс використовується для HTTP-запитів в Angular?",
+        "exp": "HttpClient — це сервіс для виконання HTTP-запитів. Він автоматично парсить JSON і повертає Observable."
+      },
+      "en": {
+        "q": "Which service is used for HTTP requests in Angular?",
+        "exp": "HttpClient is a service for making HTTP requests. It automatically parses JSON and returns Observables."
+      },
+      "pl": {
+        "q": "Który serwis służy do żądań HTTP w Angular?",
+        "exp": "HttpClient to serwis do wykonywania żądań HTTP. Automatycznie parsuje JSON i zwraca Observable."
+      },
+      "answers": [
+        {
+          "uk": "HttpService",
+          "en": "HttpService",
+          "pl": "HttpService",
+          "correct": false
+        },
+        {
+          "uk": "HttpClient",
+          "en": "HttpClient",
+          "pl": "HttpClient",
+          "correct": true
+        },
+        {
+          "uk": "RequestService",
+          "en": "RequestService",
+          "pl": "RequestService",
+          "correct": false
+        },
+        {
+          "uk": "ApiClient",
+          "en": "ApiClient",
+          "pl": "ApiClient",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q27",
+      "order": 27,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як обробити помилки HTTP-запитів в Angular?",
+        "exp": "Помилки обробляються через RxJS оператор catchError у pipe(). Це дозволяє перехопити помилку та повернути альтернативне значення або логувати."
+      },
+      "en": {
+        "q": "How do you handle HTTP request errors in Angular?",
+        "exp": "Errors are handled via the RxJS catchError operator in pipe(). This allows intercepting errors and returning alternative values or logging."
+      },
+      "pl": {
+        "q": "Jak obsługiwać błędy żądań HTTP w Angular?",
+        "exp": "Błędy obsługuje się przez operator RxJS catchError w pipe(). Pozwala to przechwycić błąd i zwrócić alternatywną wartość lub logować."
+      },
+      "answers": [
+        {
+          "uk": "Через try-catch блок",
+          "en": "Using try-catch block",
+          "pl": "Przez blok try-catch",
+          "correct": false
+        },
+        {
+          "uk": "Через оператор catchError у pipe()",
+          "en": "Using catchError operator in pipe()",
+          "pl": "Przez operator catchError w pipe()",
+          "correct": true
+        },
+        {
+          "uk": "Angular автоматично обробляє всі помилки",
+          "en": "Angular automatically handles all errors",
+          "pl": "Angular automatycznie obsługuje wszystkie błędy",
+          "correct": false
+        },
+        {
+          "uk": "Через декоратор @ErrorHandler",
+          "en": "Using @ErrorHandler decorator",
+          "pl": "Przez dekorator @ErrorHandler",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q28",
+      "order": 28,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке async pipe і яку проблему він вирішує?",
+        "exp": "async pipe автоматично підписується на Observable/Promise, оновлює шаблон при нових значеннях і відписується при знищенні — запобігає memory leaks."
+      },
+      "en": {
+        "q": "What is async pipe and what problem does it solve?",
+        "exp": "async pipe automatically subscribes to Observable/Promise, updates template on new values, and unsubscribes on destroy — prevents memory leaks."
+      },
+      "pl": {
+        "q": "Czym jest async pipe i jaki problem rozwiązuje?",
+        "exp": "async pipe automatycznie subskrybuje Observable/Promise, aktualizuje szablon przy nowych wartościach i odsubskrybowuje przy zniszczeniu — zapobiega wyciekom pamięci."
+      },
+      "answers": [
+        {
+          "uk": "Pipe для форматування дат",
+          "en": "A pipe for formatting dates",
+          "pl": "Pipe do formatowania dat",
+          "correct": false
+        },
+        {
+          "uk": "Pipe для асинхронної валідації",
+          "en": "A pipe for async validation",
+          "pl": "Pipe do asynchronicznej walidacji",
+          "correct": false
+        },
+        {
+          "uk": "Pipe для автоматичної підписки на Observable з авто-відпискою",
+          "en": "A pipe for automatic Observable subscription with auto-unsubscribe",
+          "pl": "Pipe do automatycznej subskrypcji Observable z auto-odsubskrypcją",
+          "correct": true
+        },
+        {
+          "uk": "Pipe для шифрування даних",
+          "en": "A pipe for encrypting data",
+          "pl": "Pipe do szyfrowania danych",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q29",
+      "order": 29,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Signals в Angular?",
+        "exp": "Signals — це новий реактивний примітив для керування станом. На відміну від Zone.js, вони забезпечують точкове оновлення UI без глобального change detection."
+      },
+      "en": {
+        "q": "What are Signals in Angular?",
+        "exp": "Signals are a new reactive primitive for state management. Unlike Zone.js, they enable fine-grained UI updates without global change detection."
+      },
+      "pl": {
+        "q": "Czym są Signals w Angular?",
+        "exp": "Signals to nowy reaktywny prymityw do zarządzania stanem. W przeciwieństwie do Zone.js, umożliwiają precyzyjne aktualizacje UI bez globalnego change detection."
+      },
+      "answers": [
+        {
+          "uk": "Система сповіщень для користувачів",
+          "en": "A notification system for users",
+          "pl": "System powiadomień dla użytkowników",
+          "correct": false
+        },
+        {
+          "uk": "Реактивний примітив для керування станом з точковим оновленням UI",
+          "en": "A reactive primitive for state management with fine-grained UI updates",
+          "pl": "Reaktywny prymityw do zarządzania stanem z precyzyjnymi aktualizacjami UI",
+          "correct": true
+        },
+        {
+          "uk": "Метод відправки HTTP-запитів",
+          "en": "A method for sending HTTP requests",
+          "pl": "Metoda wysyłania żądań HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Декоратор для подій",
+          "en": "A decorator for events",
+          "pl": "Dekorator dla zdarzeń",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q30",
+      "order": 30,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке change detection в Angular?",
+        "exp": "Change detection — це процес, яким Angular визначає зміни даних у компонентах і оновлює відповідні частини UI. Може використовувати Zone.js або Signals."
+      },
+      "en": {
+        "q": "What is change detection in Angular?",
+        "exp": "Change detection is the process Angular uses to detect data changes in components and update corresponding UI parts. Can use Zone.js or Signals."
+      },
+      "pl": {
+        "q": "Czym jest change detection w Angular?",
+        "exp": "Change detection to proces, którym Angular wykrywa zmiany danych w komponentach i aktualizuje odpowiednie części UI. Może używać Zone.js lub Signals."
+      },
+      "answers": [
+        {
+          "uk": "Процес виявлення помилок у коді",
+          "en": "A process for detecting code errors",
+          "pl": "Proces wykrywania błędów w kodzie",
+          "correct": false
+        },
+        {
+          "uk": "Процес виявлення змін даних і оновлення UI",
+          "en": "A process for detecting data changes and updating UI",
+          "pl": "Proces wykrywania zmian danych i aktualizacji UI",
+          "correct": true
+        },
+        {
+          "uk": "Метод валідації форм",
+          "en": "A form validation method",
+          "pl": "Metoda walidacji formularzy",
+          "correct": false
+        },
+        {
+          "uk": "Система керування версіями",
+          "en": "A version control system",
+          "pl": "System kontroli wersji",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/angular/beginner_medium/angular-quiz-part4.json b/json/quizzes/angular/beginner_medium/angular-quiz-part4.json
new file mode 100644
index 00000000..85bfae88
--- /dev/null
+++ b/json/quizzes/angular/beginner_medium/angular-quiz-part4.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "angular-q31",
+      "order": 31,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яке значення ViewEncapsulation використовується за замовчуванням?",
+        "exp": "За замовчуванням використовується ViewEncapsulation.Emulated — Angular імітує Shadow DOM, додаючи унікальні атрибути до елементів для ізоляції стилів."
+      },
+      "en": {
+        "q": "Which ViewEncapsulation value is used by default?",
+        "exp": "By default, ViewEncapsulation.Emulated is used — Angular emulates Shadow DOM by adding unique attributes to elements for style isolation."
+      },
+      "pl": {
+        "q": "Która wartość ViewEncapsulation jest używana domyślnie?",
+        "exp": "Domyślnie używane jest ViewEncapsulation.Emulated — Angular emuluje Shadow DOM, dodając unikalne atrybuty do elementów dla izolacji stylów."
+      },
+      "answers": [
+        {
+          "uk": "ViewEncapsulation.None",
+          "en": "ViewEncapsulation.None",
+          "pl": "ViewEncapsulation.None",
+          "correct": false
+        },
+        {
+          "uk": "ViewEncapsulation.ShadowDom",
+          "en": "ViewEncapsulation.ShadowDom",
+          "pl": "ViewEncapsulation.ShadowDom",
+          "correct": false
+        },
+        {
+          "uk": "ViewEncapsulation.Emulated",
+          "en": "ViewEncapsulation.Emulated",
+          "pl": "ViewEncapsulation.Emulated",
+          "correct": true
+        },
+        {
+          "uk": "ViewEncapsulation.Global",
+          "en": "ViewEncapsulation.Global",
+          "pl": "ViewEncapsulation.Global",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q32",
+      "order": 32,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Для чого використовується BehaviorSubject у сервісах Angular?",
+        "exp": "BehaviorSubject зберігає останнє значення і автоматично надає його новим підписникам. Ідеально підходить для поточного стану (авторизація, вибраний користувач)."
+      },
+      "en": {
+        "q": "What is BehaviorSubject used for in Angular services?",
+        "exp": "BehaviorSubject stores the latest value and automatically provides it to new subscribers. Ideal for current state (auth, selected user)."
+      },
+      "pl": {
+        "q": "Do czego służy BehaviorSubject w serwisach Angular?",
+        "exp": "BehaviorSubject przechowuje ostatnią wartość i automatycznie przekazuje ją nowym subskrybentom. Idealny do bieżącego stanu (autoryzacja, wybrany użytkownik)."
+      },
+      "answers": [
+        {
+          "uk": "Для одноразової передачі даних",
+          "en": "For one-time data transmission",
+          "pl": "Do jednorazowej transmisji danych",
+          "correct": false
+        },
+        {
+          "uk": "Для зберігання та передачі останнього значення новим підписникам",
+          "en": "For storing and providing the latest value to new subscribers",
+          "pl": "Do przechowywania i przekazywania ostatniej wartości nowym subskrybentom",
+          "correct": true
+        },
+        {
+          "uk": "Для валідації форм",
+          "en": "For form validation",
+          "pl": "Do walidacji formularzy",
+          "correct": false
+        },
+        {
+          "uk": "Для HTTP-запитів",
+          "en": "For HTTP requests",
+          "pl": "Do żądań HTTP",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q33",
+      "order": 33,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Zone.js і яку роль він відіграє в Angular?",
+        "exp": "Zone.js перехоплює асинхронні операції (події, таймери, проміси) і автоматично запускає change detection. У нових версіях замінюється на Signals."
+      },
+      "en": {
+        "q": "What is Zone.js and what role does it play in Angular?",
+        "exp": "Zone.js intercepts async operations (events, timers, promises) and automatically triggers change detection. Being replaced by Signals in newer versions."
+      },
+      "pl": {
+        "q": "Czym jest Zone.js i jaką rolę pełni w Angular?",
+        "exp": "Zone.js przechwytuje operacje asynchroniczne (zdarzenia, timery, promisy) i automatycznie wyzwala change detection. W nowszych wersjach zastępowany przez Signals."
+      },
+      "answers": [
+        {
+          "uk": "Бібліотека для роботи з часовими зонами",
+          "en": "A library for working with time zones",
+          "pl": "Biblioteka do pracy ze strefami czasowymi",
+          "correct": false
+        },
+        {
+          "uk": "Механізм перехоплення асинхронних операцій для автозапуску change detection",
+          "en": "A mechanism for intercepting async operations to auto-trigger change detection",
+          "pl": "Mechanizm przechwytywania operacji asynchronicznych do automatycznego wyzwalania change detection",
+          "correct": true
+        },
+        {
+          "uk": "Інструмент для тестування",
+          "en": "A testing tool",
+          "pl": "Narzędzie do testowania",
+          "correct": false
+        },
+        {
+          "uk": "CSS-фреймворк",
+          "en": "A CSS framework",
+          "pl": "Framework CSS",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q34",
+      "order": 34,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка різниця між AOT та JIT компіляцією?",
+        "exp": "AOT компілює шаблони під час збірки (швидший старт, менший бандл). JIT компілює в браузері під час виконання (зручно для розробки)."
+      },
+      "en": {
+        "q": "What is the difference between AOT and JIT compilation?",
+        "exp": "AOT compiles templates during build (faster startup, smaller bundle). JIT compiles in browser at runtime (convenient for development)."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między kompilacją AOT i JIT?",
+        "exp": "AOT kompiluje szablony podczas budowania (szybszy start, mniejszy bundle). JIT kompiluje w przeglądarce w czasie wykonania (wygodne do rozwoju)."
+      },
+      "answers": [
+        {
+          "uk": "AOT швидше компілює, JIT дає менший бандл",
+          "en": "AOT compiles faster, JIT gives smaller bundle",
+          "pl": "AOT kompiluje szybciej, JIT daje mniejszy bundle",
+          "correct": false
+        },
+        {
+          "uk": "AOT компілює при збірці (production), JIT — у браузері (development)",
+          "en": "AOT compiles at build (production), JIT in browser (development)",
+          "pl": "AOT kompiluje przy budowaniu (production), JIT — w przeglądarce (development)",
+          "correct": true
+        },
+        {
+          "uk": "JIT використовується тільки для тестування",
+          "en": "JIT is only used for testing",
+          "pl": "JIT jest używany tylko do testowania",
+          "correct": false
+        },
+        {
+          "uk": "Різниці немає",
+          "en": "There is no difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q35",
+      "order": 35,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Яка команда Angular CLI використовується для створення нового компонента?",
+        "exp": "Команда ng generate component (або ng g c) створює новий компонент з усіма необхідними файлами: клас, шаблон, стилі, тест."
+      },
+      "en": {
+        "q": "Which Angular CLI command is used to create a new component?",
+        "exp": "The ng generate component (or ng g c) command creates a new component with all necessary files: class, template, styles, test."
+      },
+      "pl": {
+        "q": "Która komenda Angular CLI służy do tworzenia nowego komponentu?",
+        "exp": "Komenda ng generate component (lub ng g c) tworzy nowy komponent ze wszystkimi niezbędnymi plikami: klasa, szablon, style, test."
+      },
+      "answers": [
+        {
+          "uk": "ng new component",
+          "en": "ng new component",
+          "pl": "ng new component",
+          "correct": false
+        },
+        {
+          "uk": "ng create component",
+          "en": "ng create component",
+          "pl": "ng create component",
+          "correct": false
+        },
+        {
+          "uk": "ng generate component",
+          "en": "ng generate component",
+          "pl": "ng generate component",
+          "correct": true
+        },
+        {
+          "uk": "ng add component",
+          "en": "ng add component",
+          "pl": "ng add component",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q36",
+      "order": 36,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Для чого використовується Renderer2 замість прямого доступу до DOM?",
+        "exp": "Renderer2 — безпечна абстракція над DOM. Він захищає від XSS, працює з SSR і є кросплатформенним, на відміну від прямого nativeElement."
+      },
+      "en": {
+        "q": "Why use Renderer2 instead of direct DOM access?",
+        "exp": "Renderer2 is a safe DOM abstraction. It protects against XSS, works with SSR, and is cross-platform, unlike direct nativeElement access."
+      },
+      "pl": {
+        "q": "Dlaczego używać Renderer2 zamiast bezpośredniego dostępu do DOM?",
+        "exp": "Renderer2 to bezpieczna abstrakcja nad DOM. Chroni przed XSS, działa z SSR i jest wieloplatformowy, w przeciwieństwie do bezpośredniego nativeElement."
+      },
+      "answers": [
+        {
+          "uk": "Renderer2 швидший",
+          "en": "Renderer2 is faster",
+          "pl": "Renderer2 jest szybszy",
+          "correct": false
+        },
+        {
+          "uk": "Для безпеки (XSS), SSR-сумісності та кросплатформенності",
+          "en": "For security (XSS), SSR compatibility, and cross-platform support",
+          "pl": "Dla bezpieczeństwa (XSS), kompatybilności z SSR i wieloplatformowości",
+          "correct": true
+        },
+        {
+          "uk": "Renderer2 простіший у використанні",
+          "en": "Renderer2 is easier to use",
+          "pl": "Renderer2 jest łatwiejszy w użyciu",
+          "correct": false
+        },
+        {
+          "uk": "Прямий доступ до DOM заборонений в Angular",
+          "en": "Direct DOM access is forbidden in Angular",
+          "pl": "Bezpośredni dostęp do DOM jest zabroniony w Angular",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q37",
+      "order": 37,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке NgRx і коли його варто використовувати?",
+        "exp": "NgRx — бібліотека для управління станом на основі Redux та RxJS. Підходить для великих застосунків зі складним shared-state та багатьма асинхронними операціями."
+      },
+      "en": {
+        "q": "What is NgRx and when should it be used?",
+        "exp": "NgRx is a state management library based on Redux and RxJS. Suitable for large applications with complex shared state and many async operations."
+      },
+      "pl": {
+        "q": "Czym jest NgRx i kiedy należy go używać?",
+        "exp": "NgRx to biblioteka do zarządzania stanem oparta na Redux i RxJS. Nadaje się do dużych aplikacji ze złożonym współdzielonym stanem i wieloma operacjami asynchronicznymi."
+      },
+      "answers": [
+        {
+          "uk": "CSS-фреймворк для Angular",
+          "en": "A CSS framework for Angular",
+          "pl": "Framework CSS dla Angular",
+          "correct": false
+        },
+        {
+          "uk": "Бібліотека для управління станом у великих застосунках",
+          "en": "A state management library for large applications",
+          "pl": "Biblioteka do zarządzania stanem w dużych aplikacjach",
+          "correct": true
+        },
+        {
+          "uk": "Інструмент для тестування",
+          "en": "A testing tool",
+          "pl": "Narzędzie do testowania",
+          "correct": false
+        },
+        {
+          "uk": "Система маршрутизації",
+          "en": "A routing system",
+          "pl": "System routingu",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q38",
+      "order": 38,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як trackBy оптимізує роботу @for (ngFor)?",
+        "exp": "trackBy дозволяє Angular ідентифікувати елементи за унікальним ключем, запобігаючи повному перерендеру списку при змінах — оновлюються тільки змінені елементи."
+      },
+      "en": {
+        "q": "How does trackBy optimize @for (ngFor) performance?",
+        "exp": "trackBy allows Angular to identify elements by unique key, preventing full list re-render on changes — only changed elements are updated."
+      },
+      "pl": {
+        "q": "Jak trackBy optymalizuje działanie @for (ngFor)?",
+        "exp": "trackBy pozwala Angular identyfikować elementy przez unikalny klucz, zapobiegając pełnemu re-renderowi listy przy zmianach — aktualizowane są tylko zmienione elementy."
+      },
+      "answers": [
+        {
+          "uk": "Сортує елементи автоматично",
+          "en": "Sorts elements automatically",
+          "pl": "Sortuje elementy automatycznie",
+          "correct": false
+        },
+        {
+          "uk": "Кешує дані списку",
+          "en": "Caches list data",
+          "pl": "Cache'uje dane listy",
+          "correct": false
+        },
+        {
+          "uk": "Ідентифікує елементи за ключем для точкового оновлення",
+          "en": "Identifies elements by key for targeted updates",
+          "pl": "Identyfikuje elementy po kluczu dla punktowych aktualizacji",
+          "correct": true
+        },
+        {
+          "uk": "Завантажує елементи асинхронно",
+          "en": "Loads elements asynchronously",
+          "pl": "Ładuje elementy asynchronicznie",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q39",
+      "order": 39,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке @HostBinding та @HostListener?",
+        "exp": "@HostBinding прив'язує властивість до host-елемента (наприклад, клас). @HostListener підписується на події host-елемента. Використовуються в директивах."
+      },
+      "en": {
+        "q": "What are @HostBinding and @HostListener?",
+        "exp": "@HostBinding binds a property to the host element (e.g., class). @HostListener subscribes to host element events. Used in directives."
+      },
+      "pl": {
+        "q": "Czym są @HostBinding i @HostListener?",
+        "exp": "@HostBinding wiąże właściwość z elementem host (np. klasę). @HostListener subskrybuje zdarzenia elementu host. Używane w dyrektywach."
+      },
+      "answers": [
+        {
+          "uk": "Декоратори для HTTP-запитів",
+          "en": "Decorators for HTTP requests",
+          "pl": "Dekoratory do żądań HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Декоратори для прив'язки властивостей та подій до host-елемента",
+          "en": "Decorators for binding properties and events to host element",
+          "pl": "Dekoratory do wiązania właściwości i zdarzeń z elementem host",
+          "correct": true
+        },
+        {
+          "uk": "Декоратори для роботи з формами",
+          "en": "Decorators for working with forms",
+          "pl": "Dekoratory do pracy z formularzami",
+          "correct": false
+        },
+        {
+          "uk": "Декоратори для маршрутизації",
+          "en": "Decorators for routing",
+          "pl": "Dekoratory do routingu",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "angular-q40",
+      "order": 40,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як увімкнути SSR в Angular за допомогою Angular Universal?",
+        "exp": "SSR вмикається командою ng add @angular/ssr, яка автоматично налаштовує сервер, bootstrap і hydration для серверного рендерингу."
+      },
+      "en": {
+        "q": "How do you enable SSR in Angular using Angular Universal?",
+        "exp": "SSR is enabled with ng add @angular/ssr command, which automatically configures server, bootstrap, and hydration for server-side rendering."
+      },
+      "pl": {
+        "q": "Jak włączyć SSR w Angular używając Angular Universal?",
+        "exp": "SSR włącza się komendą ng add @angular/ssr, która automatycznie konfiguruje serwer, bootstrap i hydration do renderowania po stronie serwera."
+      },
+      "answers": [
+        {
+          "uk": "ng add @angular/http",
+          "en": "ng add @angular/http",
+          "pl": "ng add @angular/http",
+          "correct": false
+        },
+        {
+          "uk": "ng add @angular/ssr",
+          "en": "ng add @angular/ssr",
+          "pl": "ng add @angular/ssr",
+          "correct": true
+        },
+        {
+          "uk": "ng generate ssr",
+          "en": "ng generate ssr",
+          "pl": "ng generate ssr",
+          "correct": false
+        },
+        {
+          "uk": "SSR налаштовується тільки вручну",
+          "en": "SSR is only configured manually",
+          "pl": "SSR konfiguruje się tylko ręcznie",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/angular/beginner_medium/seed-quiz-angular.ts b/json/quizzes/angular/beginner_medium/seed-quiz-angular.ts
new file mode 100644
index 00000000..26c0cf9b
--- /dev/null
+++ b/json/quizzes/angular/beginner_medium/seed-quiz-angular.ts
@@ -0,0 +1,240 @@
+import { eq } from 'drizzle-orm';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { db } from './index';
+import { categories } from './schema/categories';
+import {
+  quizzes,
+  quizTranslations,
+  quizQuestions,
+  quizQuestionContent,
+  quizAnswers,
+  quizAnswerTranslations,
+  quizAttempts,
+} from './schema/quiz';
+
+type Locale = 'uk' | 'en' | 'pl';
+const LOCALES: Locale[] = ['uk', 'en', 'pl'];
+
+interface QuestionData {
+  id: string;
+  order: number;
+  difficulty: 'beginner' | 'medium' | 'advanced';
+  uk: { q: string; exp: string };
+  en: { q: string; exp: string };
+  pl: { q: string; exp: string };
+  answers: {
+    uk: string;
+    en: string;
+    pl: string;
+    correct: boolean;
+  }[];
+}
+
+interface QuizPartData {
+  questions: QuestionData[];
+}
+
+const CATEGORY_SLUG = 'angular';
+
+const QUIZ_METADATA = {
+  slug: 'angular-fundamentals',
+  questionsCount: 40,
+  timeLimitSeconds: 1800,
+  translations: {
+    uk: {
+      title: 'Основи Angular',
+      description: 'Перевірте свої знання базових концепцій Angular: компоненти, директиви, сервіси, DI, маршрутизація, форми, Signals та RxJS.',
+    },
+    en: {
+      title: 'Angular Fundamentals',
+      description: 'Test your knowledge of Angular basics: components, directives, services, DI, routing, forms, Signals, and RxJS.',
+    },
+    pl: {
+      title: 'Podstawy Angular',
+      description: 'Sprawdź swoją wiedzę o podstawach Angular: komponenty, dyrektywy, serwisy, DI, routing, formularze, Signals i RxJS.',
+    },
+  },
+};
+
+function createExplanation(text: string) {
+  return [{ type: 'paragraph' as const, children: [{ text }] }];
+}
+
+async function loadQuestions(partNumber: number): Promise<QuestionData[]> {
+  const partPath = join(process.cwd(), 'data', `angular-quiz-part${partNumber}.json`);
+  const partData: QuizPartData = JSON.parse(readFileSync(partPath, 'utf-8'));
+  return partData.questions;
+}
+
+async function ensureQuizExists(): Promise<string> {
+  console.log('Ensuring quiz exists...');
+
+  // Find category by slug
+  const [category] = await db
+    .select()
+    .from(categories)
+    .where(eq(categories.slug, CATEGORY_SLUG))
+    .limit(1);
+
+  if (!category) {
+    throw new Error(`Category "${CATEGORY_SLUG}" not found. Run seed:categories first.`);
+  }
+
+  // Clean up old quiz by slug
+  const existing = await db.query.quizzes.findFirst({
+    where: eq(quizzes.slug, QUIZ_METADATA.slug),
+  });
+  if (existing) {
+    const existingAttempt = await db.query.quizAttempts.findFirst({
+      where: eq(quizAttempts.quizId, existing.id),
+    });
+    if (existingAttempt) {
+      throw new Error(`Quiz ${QUIZ_METADATA.slug} has existing attempts. Aborting to avoid data loss.`);
+    }
+
+    await db.delete(quizQuestions).where(eq(quizQuestions.quizId, existing.id));
+    await db.delete(quizTranslations).where(eq(quizTranslations.quizId, existing.id));
+    await db.update(quizzes).set({
+      categoryId: category.id,
+      slug: QUIZ_METADATA.slug,
+      displayOrder: 1,
+      questionsCount: QUIZ_METADATA.questionsCount,
+      timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+      isActive: true,
+    }).where(eq(quizzes.id, existing.id));
+
+    const quizId = existing.id;
+    for (const locale of LOCALES) {
+      await db.insert(quizTranslations).values({
+        quizId,
+        locale,
+        title: QUIZ_METADATA.translations[locale].title,
+        description: QUIZ_METADATA.translations[locale].description,
+      });
+    }
+
+    return quizId;
+  }
+
+  const [quiz] = await db.insert(quizzes).values({
+    categoryId: category.id,
+    slug: QUIZ_METADATA.slug,
+    displayOrder: 1,
+    questionsCount: QUIZ_METADATA.questionsCount,
+    timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+    isActive: true,
+  }).returning();
+
+  for (const locale of LOCALES) {
+    await db.insert(quizTranslations).values({
+      quizId: quiz.id,
+      locale,
+      title: QUIZ_METADATA.translations[locale].title,
+      description: QUIZ_METADATA.translations[locale].description,
+    });
+  }
+
+  return quiz.id;
+}
+
+async function seedQuestions(questions: QuestionData[], quizId: string, partNumber: number) {
+  console.log(`Seeding ${questions.length} questions from part ${partNumber}...`);
+
+  for (const question of questions) {
+    const [q] = await db.insert(quizQuestions).values({
+      quizId,
+      displayOrder: question.order,
+      difficulty: question.difficulty,
+    }).returning();
+
+    for (const locale of LOCALES) {
+      await db.insert(quizQuestionContent).values({
+        quizQuestionId: q.id,
+        locale,
+        questionText: question[locale].q,
+        explanation: createExplanation(question[locale].exp),
+      });
+    }
+
+    for (let i = 0; i < question.answers.length; i++) {
+      const answer = question.answers[i];
+      
+      const [a] = await db.insert(quizAnswers).values({
+        quizQuestionId: q.id,
+        displayOrder: i + 1,
+        isCorrect: answer.correct,
+      }).returning();
+
+      for (const locale of LOCALES) {
+        await db.insert(quizAnswerTranslations).values({
+          quizAnswerId: a.id,
+          locale,
+          answerText: answer[locale],
+        });
+      }
+    }
+  }
+
+  console.log(`Part ${partNumber} completed (${questions.length} questions)`);
+}
+
+async function seedQuizFromJson() {
+  const args = process.argv.slice(2);
+  const partArg = args[0];
+
+  if (!partArg) {
+    console.error('Error: Please specify which part to upload');
+    console.log('Usage: npx tsx db/seeds/seed-quiz-angular.ts <part-number>');
+    console.log('Example: npx tsx db/seeds/seed-quiz-angular.ts 1');
+    console.log('Or upload all: npx tsx db/seeds/seed-quiz-angular.ts all');
+    process.exit(1);
+  }
+
+  console.log('Starting Angular quiz seed...\n');
+
+  try {
+    const quizId = await ensureQuizExists();
+
+    if (partArg.toLowerCase() === 'all') {
+      console.log('Uploading all parts...\n');
+      let totalQuestions = 0;
+
+      for (let i = 1; i <= 4; i++) {
+        const questions = await loadQuestions(i);
+        await seedQuestions(questions, quizId, i);
+        totalQuestions += questions.length;
+      }
+
+      console.log('\nAll parts seeded successfully!');
+      console.log(`   - 1 quiz with ${LOCALES.length} translations`);
+      console.log(`   - ${totalQuestions} questions total`);
+      console.log(`   - ${totalQuestions * 4} answers with ${LOCALES.length} translations each`);
+    } else {
+      const partNumber = parseInt(partArg, 10);
+
+      if (isNaN(partNumber) || partNumber < 1 || partNumber > 4) {
+        console.error('Error: Part number must be between 1 and 4');
+        process.exit(1);
+      }
+
+      const questions = await loadQuestions(partNumber);
+      await seedQuestions(questions, quizId, partNumber);
+
+      console.log('\nPart seeded successfully!');
+      console.log(`   - Quiz: ${QUIZ_METADATA.translations.en.title}`);
+      console.log(`   - Part ${partNumber}: ${questions.length} questions`);
+      console.log(`   - ${questions.length * 4} answers with ${LOCALES.length} translations each`);
+    }
+  } catch (error) {
+    console.error('\nError seeding quiz:', error);
+    throw error;
+  }
+}
+
+seedQuizFromJson()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/json/quizzes/node/advanced/nodejs-advanced-quiz-part1.json b/json/quizzes/node/advanced/nodejs-advanced-quiz-part1.json
new file mode 100644
index 00000000..4e0df7e5
--- /dev/null
+++ b/json/quizzes/node/advanced/nodejs-advanced-quiz-part1.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "node-adv-q01",
+      "order": 1,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке BFF (Backend For Frontend) у контексті мікросервісної архітектури Node.js?",
+        "exp": "BFF — це легкий API-шар на Node.js, який агрегує запити до різних мікросервісів і надає оптимізований інтерфейс для конкретного клієнта (web, mobile)."
+      },
+      "en": {
+        "q": "What is BFF (Backend For Frontend) in the context of Node.js microservices architecture?",
+        "exp": "BFF is a lightweight API layer on Node.js that aggregates requests to various microservices and provides an optimized interface for a specific client (web, mobile)."
+      },
+      "pl": {
+        "q": "Czym jest BFF (Backend For Frontend) w kontekście architektury mikroserwisów Node.js?",
+        "exp": "BFF to lekka warstwa API na Node.js, która agreguje żądania do różnych mikroserwisów i zapewnia zoptymalizowany interfejs dla konkretnego klienta (web, mobile)."
+      },
+      "answers": [
+        {
+          "uk": "База даних для фронтенд-застосунків",
+          "en": "A database for frontend applications",
+          "pl": "Baza danych dla aplikacji frontendowych",
+          "correct": false
+        },
+        {
+          "uk": "API-шар, що агрегує запити до мікросервісів для конкретного клієнта",
+          "en": "An API layer that aggregates requests to microservices for a specific client",
+          "pl": "Warstwa API agregująca żądania do mikroserwisów dla konkretnego klienta",
+          "correct": true
+        },
+        {
+          "uk": "Протокол для передачі даних між сервісами",
+          "en": "A protocol for data transfer between services",
+          "pl": "Protokół do przesyłania danych między usługami",
+          "correct": false
+        },
+        {
+          "uk": "Фреймворк для розробки фронтенду",
+          "en": "A framework for frontend development",
+          "pl": "Framework do rozwoju frontendu",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q02",
+      "order": 2,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка перевага gRPC над REST для комунікації між мікросервісами?",
+        "exp": "gRPC використовує бінарний протокол Protocol Buffers, що забезпечує швидшу серіалізацію, менший розмір повідомлень та автогенерацію клієнтів."
+      },
+      "en": {
+        "q": "What is the advantage of gRPC over REST for microservice communication?",
+        "exp": "gRPC uses the binary Protocol Buffers protocol, which provides faster serialization, smaller message sizes, and auto-generated clients."
+      },
+      "pl": {
+        "q": "Jaka jest zaleta gRPC nad REST do komunikacji między mikroserwisami?",
+        "exp": "gRPC używa binarnego protokołu Protocol Buffers, który zapewnia szybszą serializację, mniejszy rozmiar wiadomości i automatycznie generowanych klientów."
+      },
+      "answers": [
+        {
+          "uk": "gRPC простіший у налагодженні через браузер",
+          "en": "gRPC is easier to debug through a browser",
+          "pl": "gRPC jest łatwiejszy do debugowania przez przeglądarkę",
+          "correct": false
+        },
+        {
+          "uk": "Бінарний протокол, швидша серіалізація, менший розмір повідомлень",
+          "en": "Binary protocol, faster serialization, smaller message sizes",
+          "pl": "Protokół binarny, szybsza serializacja, mniejszy rozmiar wiadomości",
+          "correct": true
+        },
+        {
+          "uk": "gRPC не потребує визначення схеми",
+          "en": "gRPC doesn't require schema definition",
+          "pl": "gRPC nie wymaga definicji schematu",
+          "correct": false
+        },
+        {
+          "uk": "gRPC працює тільки з JavaScript",
+          "en": "gRPC works only with JavaScript",
+          "pl": "gRPC działa tylko z JavaScript",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q03",
+      "order": 3,
+      "difficulty": "medium",
+      "uk": {
+        "q": "У чому різниця між child_process та worker_threads у Node.js?",
+        "exp": "child_process створює окремі процеси з власною пам'яттю (fork, spawn), а worker_threads — потоки в межах одного процесу з можливістю обміну пам'яттю через SharedArrayBuffer."
+      },
+      "en": {
+        "q": "What is the difference between child_process and worker_threads in Node.js?",
+        "exp": "child_process creates separate processes with their own memory (fork, spawn), while worker_threads creates threads within one process with shared memory via SharedArrayBuffer."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między child_process a worker_threads w Node.js?",
+        "exp": "child_process tworzy oddzielne procesy z własną pamięcią (fork, spawn), a worker_threads tworzy wątki w ramach jednego procesu z współdzieloną pamięcią przez SharedArrayBuffer."
+      },
+      "answers": [
+        {
+          "uk": "child_process — окремі процеси з власною пам'яттю; worker_threads — потоки з можливістю обміну пам'яттю",
+          "en": "child_process — separate processes with own memory; worker_threads — threads with possible shared memory",
+          "pl": "child_process — oddzielne procesy z własną pamięcią; worker_threads — wątki z możliwą współdzieloną pamięcią",
+          "correct": true
+        },
+        {
+          "uk": "Різниці немає, це синоніми",
+          "en": "No difference, they are synonyms",
+          "pl": "Nie ma różnicy, to synonimy",
+          "correct": false
+        },
+        {
+          "uk": "worker_threads працює тільки на Linux",
+          "en": "worker_threads works only on Linux",
+          "pl": "worker_threads działa tylko na Linux",
+          "correct": false
+        },
+        {
+          "uk": "child_process швидший для всіх задач",
+          "en": "child_process is faster for all tasks",
+          "pl": "child_process jest szybszy dla wszystkich zadań",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q04",
+      "order": 4,
+      "difficulty": "medium",
+      "uk": {
+        "q": "У чому різниця між process.nextTick() та setImmediate() у Node.js?",
+        "exp": "process.nextTick() виконується перед переходом до наступної фази event loop, а setImmediate() — на початку наступної ітерації (check phase)."
+      },
+      "en": {
+        "q": "What is the difference between process.nextTick() and setImmediate() in Node.js?",
+        "exp": "process.nextTick() executes before moving to the next event loop phase, while setImmediate() executes at the start of the next iteration (check phase)."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między process.nextTick() a setImmediate() w Node.js?",
+        "exp": "process.nextTick() wykonuje się przed przejściem do następnej fazy event loop, a setImmediate() wykonuje się na początku następnej iteracji (check phase)."
+      },
+      "answers": [
+        {
+          "uk": "Вони виконуються однаково",
+          "en": "They execute the same way",
+          "pl": "Wykonują się tak samo",
+          "correct": false
+        },
+        {
+          "uk": "nextTick — перед наступною фазою event loop; setImmediate — на check phase наступної ітерації",
+          "en": "nextTick — before next event loop phase; setImmediate — at check phase of next iteration",
+          "pl": "nextTick — przed następną fazą event loop; setImmediate — na check phase następnej iteracji",
+          "correct": true
+        },
+        {
+          "uk": "setImmediate швидший за nextTick завжди",
+          "en": "setImmediate is always faster than nextTick",
+          "pl": "setImmediate jest zawsze szybszy niż nextTick",
+          "correct": false
+        },
+        {
+          "uk": "nextTick застарів і не рекомендується",
+          "en": "nextTick is deprecated and not recommended",
+          "pl": "nextTick jest przestarzały i nie zalecany",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q05",
+      "order": 5,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Який інструмент рекомендується для перевірки вразливостей у залежностях Node.js проєкту?",
+        "exp": "npm audit вбудований у npm і перевіряє залежності на відомі вразливості. Також використовують Snyk для більш детального аналізу."
+      },
+      "en": {
+        "q": "Which tool is recommended for checking vulnerabilities in Node.js project dependencies?",
+        "exp": "npm audit is built into npm and checks dependencies for known vulnerabilities. Snyk is also used for more detailed analysis."
+      },
+      "pl": {
+        "q": "Które narzędzie jest zalecane do sprawdzania podatności w zależnościach projektu Node.js?",
+        "exp": "npm audit jest wbudowany w npm i sprawdza zależności pod kątem znanych podatności. Snyk jest również używany do bardziej szczegółowej analizy."
+      },
+      "answers": [
+        {
+          "uk": "ESLint",
+          "en": "ESLint",
+          "pl": "ESLint",
+          "correct": false
+        },
+        {
+          "uk": "npm audit або Snyk",
+          "en": "npm audit or Snyk",
+          "pl": "npm audit lub Snyk",
+          "correct": true
+        },
+        {
+          "uk": "Prettier",
+          "en": "Prettier",
+          "pl": "Prettier",
+          "correct": false
+        },
+        {
+          "uk": "Webpack",
+          "en": "Webpack",
+          "pl": "Webpack",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q06",
+      "order": 6,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Content Security Policy (CSP) і як вона захищає Node.js застосунок?",
+        "exp": "CSP — це HTTP-заголовок, який визначає дозволені джерела скриптів, стилів та інших ресурсів, захищаючи від XSS-атак через заборону inline-скриптів."
+      },
+      "en": {
+        "q": "What is Content Security Policy (CSP) and how does it protect a Node.js application?",
+        "exp": "CSP is an HTTP header that defines allowed sources for scripts, styles, and other resources, protecting against XSS attacks by blocking inline scripts."
+      },
+      "pl": {
+        "q": "Czym jest Content Security Policy (CSP) i jak chroni aplikację Node.js?",
+        "exp": "CSP to nagłówek HTTP określający dozwolone źródła skryptów, stylów i innych zasobów, chroniący przed atakami XSS przez blokowanie skryptów inline."
+      },
+      "answers": [
+        {
+          "uk": "Протокол шифрування даних у базі",
+          "en": "A protocol for encrypting database data",
+          "pl": "Protokół szyfrowania danych w bazie",
+          "correct": false
+        },
+        {
+          "uk": "HTTP-заголовок, що визначає дозволені джерела ресурсів для захисту від XSS",
+          "en": "HTTP header that defines allowed resource sources for XSS protection",
+          "pl": "Nagłówek HTTP określający dozwolone źródła zasobów dla ochrony przed XSS",
+          "correct": true
+        },
+        {
+          "uk": "Бібліотека для валідації форм",
+          "en": "A library for form validation",
+          "pl": "Biblioteka do walidacji formularzy",
+          "correct": false
+        },
+        {
+          "uk": "Менеджер сесій користувачів",
+          "en": "A user session manager",
+          "pl": "Menedżer sesji użytkowników",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q07",
+      "order": 7,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як захистити Node.js API від brute-force атак?",
+        "exp": "Використовувати rate limiting (express-rate-limit), slow-down для уповільнення запитів, CAPTCHA та блокування IP після багатьох невдалих спроб."
+      },
+      "en": {
+        "q": "How to protect a Node.js API from brute-force attacks?",
+        "exp": "Use rate limiting (express-rate-limit), slow-down to slow down requests, CAPTCHA, and IP blocking after many failed attempts."
+      },
+      "pl": {
+        "q": "Jak chronić API Node.js przed atakami brute-force?",
+        "exp": "Używać rate limiting (express-rate-limit), slow-down do spowalniania żądań, CAPTCHA i blokowania IP po wielu nieudanych próbach."
+      },
+      "answers": [
+        {
+          "uk": "Збільшити потужність сервера",
+          "en": "Increase server capacity",
+          "pl": "Zwiększyć moc serwera",
+          "correct": false
+        },
+        {
+          "uk": "Rate limiting, slow-down, CAPTCHA, блокування IP",
+          "en": "Rate limiting, slow-down, CAPTCHA, IP blocking",
+          "pl": "Rate limiting, slow-down, CAPTCHA, blokowanie IP",
+          "correct": true
+        },
+        {
+          "uk": "Використовувати тільки POST-запити",
+          "en": "Use only POST requests",
+          "pl": "Używać tylko żądań POST",
+          "correct": false
+        },
+        {
+          "uk": "Відключити логування",
+          "en": "Disable logging",
+          "pl": "Wyłączyć logowanie",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q08",
+      "order": 8,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке loosely coupled архітектура у контексті мікросервісів?",
+        "exp": "Loosely coupled означає, що сервіси взаємодіють через асинхронні повідомлення (message broker), не залежать один від одного напряму і можуть змінюватися незалежно."
+      },
+      "en": {
+        "q": "What is loosely coupled architecture in the context of microservices?",
+        "exp": "Loosely coupled means services communicate through async messages (message broker), don't depend directly on each other, and can change independently."
+      },
+      "pl": {
+        "q": "Czym jest architektura loosely coupled w kontekście mikroserwisów?",
+        "exp": "Loosely coupled oznacza, że usługi komunikują się przez asynchroniczne wiadomości (message broker), nie zależą bezpośrednio od siebie i mogą zmieniać się niezależnie."
+      },
+      "answers": [
+        {
+          "uk": "Усі сервіси в одному репозиторії",
+          "en": "All services in one repository",
+          "pl": "Wszystkie usługi w jednym repozytorium",
+          "correct": false
+        },
+        {
+          "uk": "Сервіси не залежать напряму один від одного, спілкуються через message broker",
+          "en": "Services don't depend directly on each other, communicate via message broker",
+          "pl": "Usługi nie zależą bezpośrednio od siebie, komunikują się przez message broker",
+          "correct": true
+        },
+        {
+          "uk": "Сервіси використовують одну базу даних",
+          "en": "Services use one database",
+          "pl": "Usługi używają jednej bazy danych",
+          "correct": false
+        },
+        {
+          "uk": "Сервіси завжди синхронно викликають один одного",
+          "en": "Services always call each other synchronously",
+          "pl": "Usługi zawsze wywołują się synchronicznie",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q09",
+      "order": 9,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка різниця між RabbitMQ та Kafka для Node.js мікросервісів?",
+        "exp": "RabbitMQ — традиційний message broker з чергами, підходить для task queues. Kafka — distributed log для high-throughput streaming з persistence та replay."
+      },
+      "en": {
+        "q": "What is the difference between RabbitMQ and Kafka for Node.js microservices?",
+        "exp": "RabbitMQ is a traditional message broker with queues, suitable for task queues. Kafka is a distributed log for high-throughput streaming with persistence and replay."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między RabbitMQ a Kafka dla mikroserwisów Node.js?",
+        "exp": "RabbitMQ to tradycyjny message broker z kolejkami, odpowiedni dla task queues. Kafka to distributed log dla high-throughput streaming z persistence i replay."
+      },
+      "answers": [
+        {
+          "uk": "Вони однакові, різниця лише в назві",
+          "en": "They are the same, only the name differs",
+          "pl": "Są takie same, różni się tylko nazwa",
+          "correct": false
+        },
+        {
+          "uk": "RabbitMQ — черги для tasks; Kafka — distributed log для streaming з persistence",
+          "en": "RabbitMQ — queues for tasks; Kafka — distributed log for streaming with persistence",
+          "pl": "RabbitMQ — kolejki dla tasks; Kafka — distributed log dla streaming z persistence",
+          "correct": true
+        },
+        {
+          "uk": "Kafka працює тільки з Java",
+          "en": "Kafka works only with Java",
+          "pl": "Kafka działa tylko z Java",
+          "correct": false
+        },
+        {
+          "uk": "RabbitMQ швидший за Kafka завжди",
+          "en": "RabbitMQ is always faster than Kafka",
+          "pl": "RabbitMQ jest zawsze szybszy niż Kafka",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q10",
+      "order": 10,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке ZeroMQ і коли його варто використовувати замість RabbitMQ?",
+        "exp": "ZeroMQ — бібліотека для P2P комунікації без центрального брокера. Підходить, коли потрібна низька затримка і немає потреби у гарантованій доставці повідомлень."
+      },
+      "en": {
+        "q": "What is ZeroMQ and when should it be used instead of RabbitMQ?",
+        "exp": "ZeroMQ is a library for P2P communication without a central broker. Suitable when low latency is needed and guaranteed message delivery is not required."
+      },
+      "pl": {
+        "q": "Czym jest ZeroMQ i kiedy należy go używać zamiast RabbitMQ?",
+        "exp": "ZeroMQ to biblioteka do komunikacji P2P bez centralnego brokera. Odpowiednia gdy potrzebne jest niskie opóźnienie i nie wymaga gwarantowanego dostarczenia wiadomości."
+      },
+      "answers": [
+        {
+          "uk": "ZeroMQ — база даних для повідомлень",
+          "en": "ZeroMQ is a database for messages",
+          "pl": "ZeroMQ to baza danych dla wiadomości",
+          "correct": false
+        },
+        {
+          "uk": "P2P бібліотека без брокера для низької затримки",
+          "en": "P2P library without broker for low latency",
+          "pl": "Biblioteka P2P bez brokera dla niskiego opóźnienia",
+          "correct": true
+        },
+        {
+          "uk": "ZeroMQ замінює HTTP протокол",
+          "en": "ZeroMQ replaces the HTTP protocol",
+          "pl": "ZeroMQ zastępuje protokół HTTP",
+          "correct": false
+        },
+        {
+          "uk": "ZeroMQ працює тільки локально",
+          "en": "ZeroMQ works only locally",
+          "pl": "ZeroMQ działa tylko lokalnie",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/node/advanced/nodejs-advanced-quiz-part2.json b/json/quizzes/node/advanced/nodejs-advanced-quiz-part2.json
new file mode 100644
index 00000000..dce9f148
--- /dev/null
+++ b/json/quizzes/node/advanced/nodejs-advanced-quiz-part2.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "node-adv-q11",
+      "order": 11,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Які основні архітектурні концепції використовує NestJS?",
+        "exp": "NestJS базується на модулях, контролерах, сервісах, декораторах та Dependency Injection (DI), подібно до Angular."
+      },
+      "en": {
+        "q": "What are the main architectural concepts used by NestJS?",
+        "exp": "NestJS is based on modules, controllers, services, decorators, and Dependency Injection (DI), similar to Angular."
+      },
+      "pl": {
+        "q": "Jakie są główne koncepcje architektoniczne używane przez NestJS?",
+        "exp": "NestJS opiera się na modułach, kontrolerach, serwisach, dekoratorach i Dependency Injection (DI), podobnie jak Angular."
+      },
+      "answers": [
+        {
+          "uk": "Тільки middleware та роути",
+          "en": "Only middleware and routes",
+          "pl": "Tylko middleware i routy",
+          "correct": false
+        },
+        {
+          "uk": "Модулі, контролери, сервіси, декоратори, Dependency Injection",
+          "en": "Modules, controllers, services, decorators, Dependency Injection",
+          "pl": "Moduły, kontrolery, serwisy, dekoratory, Dependency Injection",
+          "correct": true
+        },
+        {
+          "uk": "MVC без dependency injection",
+          "en": "MVC without dependency injection",
+          "pl": "MVC bez dependency injection",
+          "correct": false
+        },
+        {
+          "uk": "Функціональний підхід без класів",
+          "en": "Functional approach without classes",
+          "pl": "Podejście funkcyjne bez klas",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q12",
+      "order": 12,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Чим Koa.js відрізняється від Express.js у роботі з middleware?",
+        "exp": "Koa використовує onion model — middleware виконується до і після наступного через async/await, тоді як Express передає керування тільки вперед через next()."
+      },
+      "en": {
+        "q": "How does Koa.js differ from Express.js in middleware handling?",
+        "exp": "Koa uses an onion model — middleware executes before and after the next via async/await, while Express passes control only forward via next()."
+      },
+      "pl": {
+        "q": "Czym Koa.js różni się od Express.js w obsłudze middleware?",
+        "exp": "Koa używa modelu cebuli — middleware wykonuje się przed i po następnym przez async/await, podczas gdy Express przekazuje sterowanie tylko do przodu przez next()."
+      },
+      "answers": [
+        {
+          "uk": "Різниці немає",
+          "en": "No difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        },
+        {
+          "uk": "Koa — onion model з async/await (до і після); Express — тільки вперед через next()",
+          "en": "Koa — onion model with async/await (before and after); Express — only forward via next()",
+          "pl": "Koa — model cebuli z async/await (przed i po); Express — tylko do przodu przez next()",
+          "correct": true
+        },
+        {
+          "uk": "Koa не підтримує middleware",
+          "en": "Koa doesn't support middleware",
+          "pl": "Koa nie obsługuje middleware",
+          "correct": false
+        },
+        {
+          "uk": "Express швидший за Koa",
+          "en": "Express is faster than Koa",
+          "pl": "Express jest szybszy niż Koa",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q13",
+      "order": 13,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка перевага GraphQL над REST API у Node.js?",
+        "exp": "GraphQL дозволяє клієнту запитувати тільки потрібні поля, уникаючи over-fetching та under-fetching, і надає єдину точку входу замість множини ендпоінтів."
+      },
+      "en": {
+        "q": "What is the advantage of GraphQL over REST API in Node.js?",
+        "exp": "GraphQL allows the client to request only needed fields, avoiding over-fetching and under-fetching, and provides a single entry point instead of multiple endpoints."
+      },
+      "pl": {
+        "q": "Jaka jest zaleta GraphQL nad REST API w Node.js?",
+        "exp": "GraphQL pozwala klientowi żądać tylko potrzebnych pól, unikając over-fetching i under-fetching, i zapewnia jeden punkt wejścia zamiast wielu endpointów."
+      },
+      "answers": [
+        {
+          "uk": "GraphQL працює швидше за мережею",
+          "en": "GraphQL works faster over the network",
+          "pl": "GraphQL działa szybciej przez sieć",
+          "correct": false
+        },
+        {
+          "uk": "Клієнт запитує лише потрібні поля, єдина точка входу",
+          "en": "Client requests only needed fields, single entry point",
+          "pl": "Klient żąda tylko potrzebnych pól, pojedynczy punkt wejścia",
+          "correct": true
+        },
+        {
+          "uk": "GraphQL не потребує серверної частини",
+          "en": "GraphQL doesn't need a server part",
+          "pl": "GraphQL nie wymaga części serwerowej",
+          "correct": false
+        },
+        {
+          "uk": "GraphQL автоматично кешує всі запити",
+          "en": "GraphQL automatically caches all requests",
+          "pl": "GraphQL automatycznie cachuje wszystkie żądania",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q14",
+      "order": 14,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке резолвери (resolvers) у GraphQL?",
+        "exp": "Резолвери — це функції, які виконуються для кожного поля у GraphQL-запиті та повертають дані з бази, API або іншого джерела."
+      },
+      "en": {
+        "q": "What are resolvers in GraphQL?",
+        "exp": "Resolvers are functions that execute for each field in a GraphQL query and return data from a database, API, or other source."
+      },
+      "pl": {
+        "q": "Czym są resolvery w GraphQL?",
+        "exp": "Resolvery to funkcje wykonywane dla każdego pola w zapytaniu GraphQL, które zwracają dane z bazy danych, API lub innego źródła."
+      },
+      "answers": [
+        {
+          "uk": "Валідатори вхідних даних",
+          "en": "Input data validators",
+          "pl": "Walidatory danych wejściowych",
+          "correct": false
+        },
+        {
+          "uk": "Функції, що повертають дані для кожного поля запиту",
+          "en": "Functions that return data for each query field",
+          "pl": "Funkcje zwracające dane dla każdego pola zapytania",
+          "correct": true
+        },
+        {
+          "uk": "Middleware для авторизації",
+          "en": "Middleware for authorization",
+          "pl": "Middleware do autoryzacji",
+          "correct": false
+        },
+        {
+          "uk": "Схеми бази даних",
+          "en": "Database schemas",
+          "pl": "Schematy bazy danych",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q15",
+      "order": 15,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Server-Side Rendering (SSR) і яку бібліотеку використовують для React SSR у Node.js?",
+        "exp": "SSR — генерація HTML на сервері для покращення SEO та швидкості завантаження. Для React використовують Next.js або ReactDOMServer.renderToString()."
+      },
+      "en": {
+        "q": "What is Server-Side Rendering (SSR) and which library is used for React SSR in Node.js?",
+        "exp": "SSR is generating HTML on the server to improve SEO and loading speed. For React, Next.js or ReactDOMServer.renderToString() is used."
+      },
+      "pl": {
+        "q": "Czym jest Server-Side Rendering (SSR) i jakiej biblioteki używa się do React SSR w Node.js?",
+        "exp": "SSR to generowanie HTML na serwerze dla poprawy SEO i szybkości ładowania. Dla React używa się Next.js lub ReactDOMServer.renderToString()."
+      },
+      "answers": [
+        {
+          "uk": "Рендеринг CSS на сервері; використовують Sass",
+          "en": "Rendering CSS on server; Sass is used",
+          "pl": "Renderowanie CSS na serwerze; używa się Sass",
+          "correct": false
+        },
+        {
+          "uk": "Генерація HTML на сервері для SEO; Next.js або ReactDOMServer",
+          "en": "Generating HTML on server for SEO; Next.js or ReactDOMServer",
+          "pl": "Generowanie HTML na serwerze dla SEO; Next.js lub ReactDOMServer",
+          "correct": true
+        },
+        {
+          "uk": "Компіляція JavaScript у WebAssembly",
+          "en": "Compiling JavaScript to WebAssembly",
+          "pl": "Kompilacja JavaScript do WebAssembly",
+          "correct": false
+        },
+        {
+          "uk": "Кешування сторінок у Redis",
+          "en": "Caching pages in Redis",
+          "pl": "Cachowanie stron w Redis",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q16",
+      "order": 16,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке гідрація (hydration) у контексті SSR?",
+        "exp": "Гідрація — процес, коли React на клієнті приєднує event listeners до HTML, згенерованого на сервері, роблячи сторінку інтерактивною."
+      },
+      "en": {
+        "q": "What is hydration in the context of SSR?",
+        "exp": "Hydration is the process where React on the client attaches event listeners to HTML generated on the server, making the page interactive."
+      },
+      "pl": {
+        "q": "Czym jest hydration w kontekście SSR?",
+        "exp": "Hydration to proces, w którym React na kliencie dołącza event listenery do HTML wygenerowanego na serwerze, czyniąc stronę interaktywną."
+      },
+      "answers": [
+        {
+          "uk": "Стиснення HTML для передачі",
+          "en": "Compressing HTML for transfer",
+          "pl": "Kompresja HTML do transferu",
+          "correct": false
+        },
+        {
+          "uk": "Приєднання event listeners до серверного HTML для інтерактивності",
+          "en": "Attaching event listeners to server HTML for interactivity",
+          "pl": "Dołączanie event listenerów do serwerowego HTML dla interaktywności",
+          "correct": true
+        },
+        {
+          "uk": "Завантаження зображень",
+          "en": "Loading images",
+          "pl": "Ładowanie obrazów",
+          "correct": false
+        },
+        {
+          "uk": "Шифрування даних",
+          "en": "Encrypting data",
+          "pl": "Szyfrowanie danych",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q17",
+      "order": 17,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка основна перевага TypeScript для великих Node.js проєктів?",
+        "exp": "Статична типізація дозволяє ловити помилки на етапі компіляції, покращує автодоповнення в IDE, спрощує рефакторинг та підвищує читабельність коду."
+      },
+      "en": {
+        "q": "What is the main advantage of TypeScript for large Node.js projects?",
+        "exp": "Static typing allows catching errors at compile time, improves IDE autocompletion, simplifies refactoring, and increases code readability."
+      },
+      "pl": {
+        "q": "Jaka jest główna zaleta TypeScript dla dużych projektów Node.js?",
+        "exp": "Statyczne typowanie pozwala łapać błędy na etapie kompilacji, poprawia autouzupełnianie w IDE, upraszcza refaktoryzację i zwiększa czytelność kodu."
+      },
+      "answers": [
+        {
+          "uk": "TypeScript працює швидше за JavaScript",
+          "en": "TypeScript runs faster than JavaScript",
+          "pl": "TypeScript działa szybciej niż JavaScript",
+          "correct": false
+        },
+        {
+          "uk": "Статична типізація, помилки на етапі компіляції, кращий рефакторинг",
+          "en": "Static typing, compile-time errors, better refactoring",
+          "pl": "Statyczne typowanie, błędy na etapie kompilacji, lepszy refaktoring",
+          "correct": true
+        },
+        {
+          "uk": "TypeScript не потребує транспіляції",
+          "en": "TypeScript doesn't need transpilation",
+          "pl": "TypeScript nie wymaga transpilacji",
+          "correct": false
+        },
+        {
+          "uk": "TypeScript замінює всі npm-пакети",
+          "en": "TypeScript replaces all npm packages",
+          "pl": "TypeScript zastępuje wszystkie pakiety npm",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q18",
+      "order": 18,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Який принцип Twelve-Factor App відповідає за зберігання конфігурації?",
+        "exp": "Принцип Config вимагає зберігати конфігурацію у змінних середовища (process.env), а не в коді, для безпеки та гнучкості."
+      },
+      "en": {
+        "q": "Which Twelve-Factor App principle is responsible for configuration storage?",
+        "exp": "The Config principle requires storing configuration in environment variables (process.env), not in code, for security and flexibility."
+      },
+      "pl": {
+        "q": "Która zasada Twelve-Factor App odpowiada za przechowywanie konfiguracji?",
+        "exp": "Zasada Config wymaga przechowywania konfiguracji w zmiennych środowiskowych (process.env), nie w kodzie, dla bezpieczeństwa i elastyczności."
+      },
+      "answers": [
+        {
+          "uk": "Codebase",
+          "en": "Codebase",
+          "pl": "Codebase",
+          "correct": false
+        },
+        {
+          "uk": "Config — конфігурація через змінні середовища",
+          "en": "Config — configuration through environment variables",
+          "pl": "Config — konfiguracja przez zmienne środowiskowe",
+          "correct": true
+        },
+        {
+          "uk": "Logs",
+          "en": "Logs",
+          "pl": "Logs",
+          "correct": false
+        },
+        {
+          "uk": "Dependencies",
+          "en": "Dependencies",
+          "pl": "Dependencies",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q19",
+      "order": 19,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що означає принцип Disposability у Twelve-Factor App?",
+        "exp": "Disposability означає швидкий старт та graceful shutdown застосунку — процес має коректно завершувати активні запити та з'єднання перед зупинкою."
+      },
+      "en": {
+        "q": "What does the Disposability principle mean in Twelve-Factor App?",
+        "exp": "Disposability means fast startup and graceful shutdown — the process should correctly complete active requests and connections before stopping."
+      },
+      "pl": {
+        "q": "Co oznacza zasada Disposability w Twelve-Factor App?",
+        "exp": "Disposability oznacza szybki start i graceful shutdown — proces powinien poprawnie zakończyć aktywne żądania i połączenia przed zatrzymaniem."
+      },
+      "answers": [
+        {
+          "uk": "Код має бути одноразовим і видалятися після використання",
+          "en": "Code should be disposable and deleted after use",
+          "pl": "Kod powinien być jednorazowy i usuwany po użyciu",
+          "correct": false
+        },
+        {
+          "uk": "Швидкий старт та graceful shutdown з коректним завершенням запитів",
+          "en": "Fast startup and graceful shutdown with proper request completion",
+          "pl": "Szybki start i graceful shutdown z poprawnym zakończeniem żądań",
+          "correct": true
+        },
+        {
+          "uk": "Використання тимчасових файлів",
+          "en": "Using temporary files",
+          "pl": "Używanie plików tymczasowych",
+          "correct": false
+        },
+        {
+          "uk": "Автоматичне видалення логів",
+          "en": "Automatic log deletion",
+          "pl": "Automatyczne usuwanie logów",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q20",
+      "order": 20,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як реалізувати graceful shutdown у Node.js застосунку?",
+        "exp": "Слухати сигнали SIGTERM/SIGINT, зупинити прийом нових з'єднань, дочекатися завершення активних запитів, закрити з'єднання з БД і вийти."
+      },
+      "en": {
+        "q": "How to implement graceful shutdown in a Node.js application?",
+        "exp": "Listen for SIGTERM/SIGINT signals, stop accepting new connections, wait for active requests to complete, close DB connections, and exit."
+      },
+      "pl": {
+        "q": "Jak zaimplementować graceful shutdown w aplikacji Node.js?",
+        "exp": "Nasłuchiwać sygnałów SIGTERM/SIGINT, przestać przyjmować nowe połączenia, poczekać na zakończenie aktywnych żądań, zamknąć połączenia z BD i wyjść."
+      },
+      "answers": [
+        {
+          "uk": "Просто викликати process.exit(0)",
+          "en": "Just call process.exit(0)",
+          "pl": "Po prostu wywołać process.exit(0)",
+          "correct": false
+        },
+        {
+          "uk": "Слухати SIGTERM/SIGINT, завершити активні запити, закрити з'єднання з БД",
+          "en": "Listen for SIGTERM/SIGINT, complete active requests, close DB connections",
+          "pl": "Nasłuchiwać SIGTERM/SIGINT, zakończyć aktywne żądania, zamknąć połączenia z BD",
+          "correct": true
+        },
+        {
+          "uk": "Перезапустити сервер автоматично",
+          "en": "Restart the server automatically",
+          "pl": "Zrestartować serwer automatycznie",
+          "correct": false
+        },
+        {
+          "uk": "Зберегти стан у файл",
+          "en": "Save state to a file",
+          "pl": "Zapisać stan do pliku",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/node/advanced/nodejs-advanced-quiz-part3.json b/json/quizzes/node/advanced/nodejs-advanced-quiz-part3.json
new file mode 100644
index 00000000..1751251c
--- /dev/null
+++ b/json/quizzes/node/advanced/nodejs-advanced-quiz-part3.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "node-adv-q21",
+      "order": 21,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке serverless архітектура і які її переваги для Node.js?",
+        "exp": "Serverless — модель, де код виконується по запиту без управління серверами. Платиш тільки за час виконання, автоматичне масштабування."
+      },
+      "en": {
+        "q": "What is serverless architecture and what are its advantages for Node.js?",
+        "exp": "Serverless is a model where code runs on demand without server management. You pay only for execution time, automatic scaling."
+      },
+      "pl": {
+        "q": "Czym jest architektura serverless i jakie są jej zalety dla Node.js?",
+        "exp": "Serverless to model, w którym kod uruchamia się na żądanie bez zarządzania serwerami. Płacisz tylko za czas wykonania, automatyczne skalowanie."
+      },
+      "answers": [
+        {
+          "uk": "Код виконується без JavaScript",
+          "en": "Code runs without JavaScript",
+          "pl": "Kod działa bez JavaScript",
+          "correct": false
+        },
+        {
+          "uk": "Виконання по запиту без управління серверами, оплата за час виконання",
+          "en": "On-demand execution without server management, pay for execution time",
+          "pl": "Wykonywanie na żądanie bez zarządzania serwerami, płatność za czas wykonania",
+          "correct": true
+        },
+        {
+          "uk": "Сервери працюють без електрики",
+          "en": "Servers work without electricity",
+          "pl": "Serwery działają bez elektryczności",
+          "correct": false
+        },
+        {
+          "uk": "Тільки для статичних сайтів",
+          "en": "Only for static sites",
+          "pl": "Tylko dla stron statycznych",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q22",
+      "order": 22,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка проблема cold start у serverless і як її мінімізувати?",
+        "exp": "Cold start — затримка при першому виклику функції через ініціалізацію контейнера. Мінімізують через provisioned concurrency, менший розмір пакета, lazy loading."
+      },
+      "en": {
+        "q": "What is the cold start problem in serverless and how to minimize it?",
+        "exp": "Cold start is a delay on the first function call due to container initialization. Minimize via provisioned concurrency, smaller package size, lazy loading."
+      },
+      "pl": {
+        "q": "Czym jest problem cold start w serverless i jak go zminimalizować?",
+        "exp": "Cold start to opóźnienie przy pierwszym wywołaniu funkcji przez inicjalizację kontenera. Minimalizuje się przez provisioned concurrency, mniejszy rozmiar pakietu, lazy loading."
+      },
+      "answers": [
+        {
+          "uk": "Проблема з температурою серверів",
+          "en": "Server temperature problem",
+          "pl": "Problem z temperaturą serwerów",
+          "correct": false
+        },
+        {
+          "uk": "Затримка при першому виклику; мінімізують через provisioned concurrency та менший пакет",
+          "en": "Delay on first call; minimize via provisioned concurrency and smaller package",
+          "pl": "Opóźnienie przy pierwszym wywołaniu; minimalizuje się przez provisioned concurrency i mniejszy pakiet",
+          "correct": true
+        },
+        {
+          "uk": "Помилка у конфігурації",
+          "en": "Configuration error",
+          "pl": "Błąd konfiguracji",
+          "correct": false
+        },
+        {
+          "uk": "Обмеження на кількість функцій",
+          "en": "Limit on number of functions",
+          "pl": "Limit liczby funkcji",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q23",
+      "order": 23,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що включає Continuous Integration (CI) для Node.js проєкту?",
+        "exp": "CI включає автоматичну установку залежностей (npm install), запуск тестів (npm test), перевірку коду лінтером (ESLint) при кожному push/PR."
+      },
+      "en": {
+        "q": "What does Continuous Integration (CI) include for a Node.js project?",
+        "exp": "CI includes automatic dependency installation (npm install), running tests (npm test), code linting (ESLint) on every push/PR."
+      },
+      "pl": {
+        "q": "Co obejmuje Continuous Integration (CI) dla projektu Node.js?",
+        "exp": "CI obejmuje automatyczną instalację zależności (npm install), uruchamianie testów (npm test), sprawdzanie kodu linterem (ESLint) przy każdym push/PR."
+      },
+      "answers": [
+        {
+          "uk": "Тільки деплой на продакшн",
+          "en": "Only deployment to production",
+          "pl": "Tylko deployment na produkcję",
+          "correct": false
+        },
+        {
+          "uk": "Автоматична установка залежностей, тести, лінтинг при кожному push/PR",
+          "en": "Automatic dependency installation, tests, linting on every push/PR",
+          "pl": "Automatyczna instalacja zależności, testy, linting przy każdym push/PR",
+          "correct": true
+        },
+        {
+          "uk": "Ручне тестування перед релізом",
+          "en": "Manual testing before release",
+          "pl": "Ręczne testowanie przed wydaniem",
+          "correct": false
+        },
+        {
+          "uk": "Написання документації",
+          "en": "Writing documentation",
+          "pl": "Pisanie dokumentacji",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q24",
+      "order": 24,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як керувати сесіями у масштабованому Node.js застосунку з кількома інстансами?",
+        "exp": "Використовувати централізоване сховище сесій (Redis, Memcached) або JWT-токени, які зберігаються на клієнті і не потребують серверного стану."
+      },
+      "en": {
+        "q": "How to manage sessions in a scalable Node.js app with multiple instances?",
+        "exp": "Use centralized session storage (Redis, Memcached) or JWT tokens that are stored on the client and don't require server state."
+      },
+      "pl": {
+        "q": "Jak zarządzać sesjami w skalowalnej aplikacji Node.js z wieloma instancjami?",
+        "exp": "Używać scentralizowanego storage sesji (Redis, Memcached) lub tokenów JWT przechowywanych na kliencie i nie wymagających stanu serwera."
+      },
+      "answers": [
+        {
+          "uk": "Зберігати сесії в пам'яті кожного інстансу",
+          "en": "Store sessions in memory of each instance",
+          "pl": "Przechowywać sesje w pamięci każdej instancji",
+          "correct": false
+        },
+        {
+          "uk": "Централізоване сховище (Redis) або JWT-токени на клієнті",
+          "en": "Centralized storage (Redis) or JWT tokens on client",
+          "pl": "Scentralizowane storage (Redis) lub tokeny JWT na kliencie",
+          "correct": true
+        },
+        {
+          "uk": "Використовувати cookies без шифрування",
+          "en": "Use cookies without encryption",
+          "pl": "Używać cookies bez szyfrowania",
+          "correct": false
+        },
+        {
+          "uk": "Завжди направляти користувача на один сервер",
+          "en": "Always direct user to one server",
+          "pl": "Zawsze kierować użytkownika na jeden serwer",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q25",
+      "order": 25,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке connection pooling і чому він важливий для Node.js з базами даних?",
+        "exp": "Connection pooling — повторне використання відкритих з'єднань до БД замість створення нових. Зменшує overhead та покращує продуктивність."
+      },
+      "en": {
+        "q": "What is connection pooling and why is it important for Node.js with databases?",
+        "exp": "Connection pooling is reusing open database connections instead of creating new ones. Reduces overhead and improves performance."
+      },
+      "pl": {
+        "q": "Czym jest connection pooling i dlaczego jest ważny dla Node.js z bazami danych?",
+        "exp": "Connection pooling to ponowne wykorzystywanie otwartych połączeń do BD zamiast tworzenia nowych. Zmniejsza overhead i poprawia wydajność."
+      },
+      "answers": [
+        {
+          "uk": "Об'єднання кількох баз даних в одну",
+          "en": "Combining multiple databases into one",
+          "pl": "Łączenie wielu baz danych w jedną",
+          "correct": false
+        },
+        {
+          "uk": "Повторне використання з'єднань до БД для зменшення overhead",
+          "en": "Reusing DB connections to reduce overhead",
+          "pl": "Ponowne wykorzystywanie połączeń do BD dla zmniejszenia overhead",
+          "correct": true
+        },
+        {
+          "uk": "Шифрування з'єднань до бази",
+          "en": "Encrypting database connections",
+          "pl": "Szyfrowanie połączeń do bazy",
+          "correct": false
+        },
+        {
+          "uk": "Створення нового з'єднання для кожного запиту",
+          "en": "Creating a new connection for each request",
+          "pl": "Tworzenie nowego połączenia dla każdego żądania",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q26",
+      "order": 26,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Який інструмент використовують для профайлінгу CPU та пам'яті у Node.js?",
+        "exp": "node --inspect з Chrome DevTools, clinic.js (Doctor, Flame, Bubbleprof), 0x для flame graphs, perf_hooks для вбудованого профайлінгу."
+      },
+      "en": {
+        "q": "Which tool is used for CPU and memory profiling in Node.js?",
+        "exp": "node --inspect with Chrome DevTools, clinic.js (Doctor, Flame, Bubbleprof), 0x for flame graphs, perf_hooks for built-in profiling."
+      },
+      "pl": {
+        "q": "Które narzędzie jest używane do profilowania CPU i pamięci w Node.js?",
+        "exp": "node --inspect z Chrome DevTools, clinic.js (Doctor, Flame, Bubbleprof), 0x dla flame graphs, perf_hooks dla wbudowanego profilowania."
+      },
+      "answers": [
+        {
+          "uk": "npm audit",
+          "en": "npm audit",
+          "pl": "npm audit",
+          "correct": false
+        },
+        {
+          "uk": "node --inspect з Chrome DevTools, clinic.js, 0x",
+          "en": "node --inspect with Chrome DevTools, clinic.js, 0x",
+          "pl": "node --inspect z Chrome DevTools, clinic.js, 0x",
+          "correct": true
+        },
+        {
+          "uk": "ESLint",
+          "en": "ESLint",
+          "pl": "ESLint",
+          "correct": false
+        },
+        {
+          "uk": "Prettier",
+          "en": "Prettier",
+          "pl": "Prettier",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q27",
+      "order": 27,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка рекомендована стратегія логування для Node.js у продакшн?",
+        "exp": "Логування як потік у stdout/stderr, структуровані JSON логи (Winston, Pino), збір через зовнішні сервіси (ELK stack, Datadog)."
+      },
+      "en": {
+        "q": "What is the recommended logging strategy for Node.js in production?",
+        "exp": "Logging as a stream to stdout/stderr, structured JSON logs (Winston, Pino), collection via external services (ELK stack, Datadog)."
+      },
+      "pl": {
+        "q": "Jaka jest zalecana strategia logowania dla Node.js na produkcji?",
+        "exp": "Logowanie jako strumień do stdout/stderr, strukturyzowane logi JSON (Winston, Pino), zbieranie przez zewnętrzne serwisy (ELK stack, Datadog)."
+      },
+      "answers": [
+        {
+          "uk": "Записувати логи тільки у локальний файл",
+          "en": "Write logs only to a local file",
+          "pl": "Zapisywać logi tylko do lokalnego pliku",
+          "correct": false
+        },
+        {
+          "uk": "Структуровані JSON логи у stdout/stderr, збір через ELK/Datadog",
+          "en": "Structured JSON logs to stdout/stderr, collection via ELK/Datadog",
+          "pl": "Strukturyzowane logi JSON do stdout/stderr, zbieranie przez ELK/Datadog",
+          "correct": true
+        },
+        {
+          "uk": "Використовувати тільки console.log",
+          "en": "Use only console.log",
+          "pl": "Używać tylko console.log",
+          "correct": false
+        },
+        {
+          "uk": "Відключити логування для продуктивності",
+          "en": "Disable logging for performance",
+          "pl": "Wyłączyć logowanie dla wydajności",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q28",
+      "order": 28,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як використовувати Swagger/OpenAPI для документування Node.js REST API?",
+        "exp": "Визначити специфікацію API у YAML/JSON форматі, інтегрувати swagger-ui-express для візуалізації, автогенерувати клієнти та тести."
+      },
+      "en": {
+        "q": "How to use Swagger/OpenAPI for documenting Node.js REST API?",
+        "exp": "Define API specification in YAML/JSON format, integrate swagger-ui-express for visualization, auto-generate clients and tests."
+      },
+      "pl": {
+        "q": "Jak używać Swagger/OpenAPI do dokumentowania REST API Node.js?",
+        "exp": "Zdefiniować specyfikację API w formacie YAML/JSON, zintegrować swagger-ui-express dla wizualizacji, autogenerować klientów i testy."
+      },
+      "answers": [
+        {
+          "uk": "Swagger тільки для фронтенду",
+          "en": "Swagger is only for frontend",
+          "pl": "Swagger jest tylko dla frontendu",
+          "correct": false
+        },
+        {
+          "uk": "Специфікація у YAML/JSON, swagger-ui-express для візуалізації, автогенерація клієнтів",
+          "en": "Specification in YAML/JSON, swagger-ui-express for visualization, auto-generate clients",
+          "pl": "Specyfikacja w YAML/JSON, swagger-ui-express dla wizualizacji, autogeneracja klientów",
+          "correct": true
+        },
+        {
+          "uk": "Swagger замінює базу даних",
+          "en": "Swagger replaces the database",
+          "pl": "Swagger zastępuje bazę danych",
+          "correct": false
+        },
+        {
+          "uk": "Swagger працює тільки з GraphQL",
+          "en": "Swagger works only with GraphQL",
+          "pl": "Swagger działa tylko z GraphQL",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q29",
+      "order": 29,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Які хмарні сервіси AWS використовуються для Node.js serverless функцій?",
+        "exp": "AWS Lambda для виконання функцій, API Gateway для HTTP-ендпоінтів, DynamoDB для даних, SQS/SNS для повідомлень, S3 для файлів."
+      },
+      "en": {
+        "q": "Which AWS cloud services are used for Node.js serverless functions?",
+        "exp": "AWS Lambda for function execution, API Gateway for HTTP endpoints, DynamoDB for data, SQS/SNS for messages, S3 for files."
+      },
+      "pl": {
+        "q": "Które usługi chmurowe AWS są używane do funkcji serverless Node.js?",
+        "exp": "AWS Lambda do wykonywania funkcji, API Gateway dla endpointów HTTP, DynamoDB dla danych, SQS/SNS dla wiadomości, S3 dla plików."
+      },
+      "answers": [
+        {
+          "uk": "Тільки EC2",
+          "en": "Only EC2",
+          "pl": "Tylko EC2",
+          "correct": false
+        },
+        {
+          "uk": "Lambda, API Gateway, DynamoDB, SQS/SNS, S3",
+          "en": "Lambda, API Gateway, DynamoDB, SQS/SNS, S3",
+          "pl": "Lambda, API Gateway, DynamoDB, SQS/SNS, S3",
+          "correct": true
+        },
+        {
+          "uk": "Тільки S3",
+          "en": "Only S3",
+          "pl": "Tylko S3",
+          "correct": false
+        },
+        {
+          "uk": "AWS не підтримує Node.js",
+          "en": "AWS doesn't support Node.js",
+          "pl": "AWS nie obsługuje Node.js",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q30",
+      "order": 30,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке API Gateway у контексті мікросервісної архітектури?",
+        "exp": "API Gateway — єдина точка входу, яка маршрутизує запити до мікросервісів, забезпечує аутентифікацію, rate limiting, агрегацію відповідей."
+      },
+      "en": {
+        "q": "What is API Gateway in the context of microservices architecture?",
+        "exp": "API Gateway is a single entry point that routes requests to microservices, provides authentication, rate limiting, and response aggregation."
+      },
+      "pl": {
+        "q": "Czym jest API Gateway w kontekście architektury mikroserwisów?",
+        "exp": "API Gateway to pojedynczy punkt wejścia, który routuje żądania do mikroserwisów, zapewnia autentykację, rate limiting i agregację odpowiedzi."
+      },
+      "answers": [
+        {
+          "uk": "База даних для API",
+          "en": "A database for API",
+          "pl": "Baza danych dla API",
+          "correct": false
+        },
+        {
+          "uk": "Єдина точка входу для маршрутизації, аутентифікації та rate limiting",
+          "en": "Single entry point for routing, authentication, and rate limiting",
+          "pl": "Pojedynczy punkt wejścia dla routingu, autentykacji i rate limiting",
+          "correct": true
+        },
+        {
+          "uk": "Інструмент для тестування",
+          "en": "A testing tool",
+          "pl": "Narzędzie do testowania",
+          "correct": false
+        },
+        {
+          "uk": "Фреймворк для фронтенду",
+          "en": "A frontend framework",
+          "pl": "Framework frontendowy",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/node/advanced/nodejs-advanced-quiz-part4.json b/json/quizzes/node/advanced/nodejs-advanced-quiz-part4.json
new file mode 100644
index 00000000..b7a2cfb2
--- /dev/null
+++ b/json/quizzes/node/advanced/nodejs-advanced-quiz-part4.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "node-adv-q31",
+      "order": 31,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Чому Node.js підходить для IoT (Internet of Things) застосунків?",
+        "exp": "Легка вага, асинхронність та подієво-орієнтована модель дозволяють ефективно обробляти велику кількість підключень від сенсорів у реальному часі."
+      },
+      "en": {
+        "q": "Why is Node.js suitable for IoT (Internet of Things) applications?",
+        "exp": "Lightweight, async, and event-driven model allows efficient handling of many sensor connections in real-time."
+      },
+      "pl": {
+        "q": "Dlaczego Node.js nadaje się do aplikacji IoT (Internet of Things)?",
+        "exp": "Lekkość, asynchroniczność i model sterowany zdarzeniami pozwalają efektywnie obsługiwać wiele połączeń z sensorów w czasie rzeczywistym."
+      },
+      "answers": [
+        {
+          "uk": "Node.js споживає мало електрики",
+          "en": "Node.js consumes little electricity",
+          "pl": "Node.js zużywa mało elektryczności",
+          "correct": false
+        },
+        {
+          "uk": "Легкість, асинхронність та event-driven модель для обробки багатьох підключень",
+          "en": "Lightweight, async, and event-driven model for handling many connections",
+          "pl": "Lekkość, asynchroniczność i model event-driven do obsługi wielu połączeń",
+          "correct": true
+        },
+        {
+          "uk": "Node.js працює без інтернету",
+          "en": "Node.js works without internet",
+          "pl": "Node.js działa bez internetu",
+          "correct": false
+        },
+        {
+          "uk": "Node.js замінює прошивку пристроїв",
+          "en": "Node.js replaces device firmware",
+          "pl": "Node.js zastępuje firmware urządzeń",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q32",
+      "order": 32,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Який протокол часто використовують для IoT комунікації з Node.js?",
+        "exp": "MQTT — легкий протокол publish/subscribe для IoT з низьким споживанням ресурсів, підтримкою QoS та offline повідомлень."
+      },
+      "en": {
+        "q": "Which protocol is often used for IoT communication with Node.js?",
+        "exp": "MQTT is a lightweight publish/subscribe protocol for IoT with low resource consumption, QoS support, and offline messages."
+      },
+      "pl": {
+        "q": "Który protokół jest często używany do komunikacji IoT z Node.js?",
+        "exp": "MQTT to lekki protokół publish/subscribe dla IoT z niskim zużyciem zasobów, obsługą QoS i wiadomościami offline."
+      },
+      "answers": [
+        {
+          "uk": "FTP",
+          "en": "FTP",
+          "pl": "FTP",
+          "correct": false
+        },
+        {
+          "uk": "MQTT — легкий publish/subscribe протокол для IoT",
+          "en": "MQTT — lightweight publish/subscribe protocol for IoT",
+          "pl": "MQTT — lekki protokół publish/subscribe dla IoT",
+          "correct": true
+        },
+        {
+          "uk": "SMTP",
+          "en": "SMTP",
+          "pl": "SMTP",
+          "correct": false
+        },
+        {
+          "uk": "SSH",
+          "en": "SSH",
+          "pl": "SSH",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q33",
+      "order": 33,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка бібліотека використовується для машинного навчання безпосередньо у Node.js?",
+        "exp": "TensorFlow.js дозволяє тренувати та запускати ML-моделі прямо у Node.js. Також є Brain.js, ML.js для легких задач."
+      },
+      "en": {
+        "q": "Which library is used for machine learning directly in Node.js?",
+        "exp": "TensorFlow.js allows training and running ML models directly in Node.js. There's also Brain.js, ML.js for lighter tasks."
+      },
+      "pl": {
+        "q": "Która biblioteka jest używana do uczenia maszynowego bezpośrednio w Node.js?",
+        "exp": "TensorFlow.js pozwala trenować i uruchamiać modele ML bezpośrednio w Node.js. Jest też Brain.js, ML.js dla lżejszych zadań."
+      },
+      "answers": [
+        {
+          "uk": "Lodash",
+          "en": "Lodash",
+          "pl": "Lodash",
+          "correct": false
+        },
+        {
+          "uk": "TensorFlow.js, Brain.js, ML.js",
+          "en": "TensorFlow.js, Brain.js, ML.js",
+          "pl": "TensorFlow.js, Brain.js, ML.js",
+          "correct": true
+        },
+        {
+          "uk": "Express.js",
+          "en": "Express.js",
+          "pl": "Express.js",
+          "correct": false
+        },
+        {
+          "uk": "Moment.js",
+          "en": "Moment.js",
+          "pl": "Moment.js",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q34",
+      "order": 34,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка перевага Socket.IO над чистим WebSocket?",
+        "exp": "Socket.IO надає автоматичний fallback на long-polling, rooms/namespaces для групування, reconnection та broadcasting з коробки."
+      },
+      "en": {
+        "q": "What is the advantage of Socket.IO over plain WebSocket?",
+        "exp": "Socket.IO provides automatic fallback to long-polling, rooms/namespaces for grouping, reconnection, and broadcasting out of the box."
+      },
+      "pl": {
+        "q": "Jaka jest zaleta Socket.IO nad czystym WebSocket?",
+        "exp": "Socket.IO zapewnia automatyczny fallback na long-polling, rooms/namespaces do grupowania, reconnection i broadcasting z pudełka."
+      },
+      "answers": [
+        {
+          "uk": "Socket.IO швидший за WebSocket",
+          "en": "Socket.IO is faster than WebSocket",
+          "pl": "Socket.IO jest szybszy niż WebSocket",
+          "correct": false
+        },
+        {
+          "uk": "Fallback на long-polling, rooms/namespaces, reconnection, broadcasting",
+          "en": "Fallback to long-polling, rooms/namespaces, reconnection, broadcasting",
+          "pl": "Fallback na long-polling, rooms/namespaces, reconnection, broadcasting",
+          "correct": true
+        },
+        {
+          "uk": "Socket.IO не потребує сервера",
+          "en": "Socket.IO doesn't need a server",
+          "pl": "Socket.IO nie potrzebuje serwera",
+          "correct": false
+        },
+        {
+          "uk": "Socket.IO працює тільки з React",
+          "en": "Socket.IO works only with React",
+          "pl": "Socket.IO działa tylko z React",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q35",
+      "order": 35,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як інтегрувати Node.js з Python ML-сервісом для великих моделей?",
+        "exp": "Запустити Python скрипт через child_process, або створити окремий Python REST API/gRPC сервіс, з яким Node.js взаємодіє через HTTP."
+      },
+      "en": {
+        "q": "How to integrate Node.js with a Python ML service for large models?",
+        "exp": "Run Python script via child_process, or create a separate Python REST API/gRPC service that Node.js interacts with via HTTP."
+      },
+      "pl": {
+        "q": "Jak zintegrować Node.js z serwisem Python ML dla dużych modeli?",
+        "exp": "Uruchomić skrypt Python przez child_process lub stworzyć osobny serwis Python REST API/gRPC, z którym Node.js komunikuje się przez HTTP."
+      },
+      "answers": [
+        {
+          "uk": "Переписати модель на JavaScript",
+          "en": "Rewrite the model in JavaScript",
+          "pl": "Przepisać model na JavaScript",
+          "correct": false
+        },
+        {
+          "uk": "child_process або окремий Python REST API/gRPC сервіс",
+          "en": "child_process or separate Python REST API/gRPC service",
+          "pl": "child_process lub osobny serwis Python REST API/gRPC",
+          "correct": true
+        },
+        {
+          "uk": "Імпортувати Python напряму в Node.js",
+          "en": "Import Python directly into Node.js",
+          "pl": "Importować Python bezpośrednio do Node.js",
+          "correct": false
+        },
+        {
+          "uk": "Python не можна інтегрувати з Node.js",
+          "en": "Python cannot be integrated with Node.js",
+          "pl": "Python nie może być zintegrowany z Node.js",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q36",
+      "order": 36,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Який інструмент використовують для load testing Node.js API?",
+        "exp": "Autocannon, Artillery, k6, Apache JMeter — для симуляції великого навантаження та вимірювання latency, throughput, error rate."
+      },
+      "en": {
+        "q": "Which tool is used for load testing Node.js API?",
+        "exp": "Autocannon, Artillery, k6, Apache JMeter — for simulating heavy load and measuring latency, throughput, error rate."
+      },
+      "pl": {
+        "q": "Które narzędzie jest używane do load testingu API Node.js?",
+        "exp": "Autocannon, Artillery, k6, Apache JMeter — do symulowania dużego obciążenia i mierzenia latency, throughput, error rate."
+      },
+      "answers": [
+        {
+          "uk": "ESLint",
+          "en": "ESLint",
+          "pl": "ESLint",
+          "correct": false
+        },
+        {
+          "uk": "Autocannon, Artillery, k6, Apache JMeter",
+          "en": "Autocannon, Artillery, k6, Apache JMeter",
+          "pl": "Autocannon, Artillery, k6, Apache JMeter",
+          "correct": true
+        },
+        {
+          "uk": "Prettier",
+          "en": "Prettier",
+          "pl": "Prettier",
+          "correct": false
+        },
+        {
+          "uk": "Webpack",
+          "en": "Webpack",
+          "pl": "Webpack",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q37",
+      "order": 37,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як безпечно зберігати секрети (API ключі, паролі) у Node.js продакшн?",
+        "exp": "Використовувати Vault, AWS Secrets Manager, Azure Key Vault або Kubernetes Secrets замість .env файлів чи хардкоду в коді."
+      },
+      "en": {
+        "q": "How to securely store secrets (API keys, passwords) in Node.js production?",
+        "exp": "Use Vault, AWS Secrets Manager, Azure Key Vault, or Kubernetes Secrets instead of .env files or hardcoding in code."
+      },
+      "pl": {
+        "q": "Jak bezpiecznie przechowywać sekrety (klucze API, hasła) w Node.js na produkcji?",
+        "exp": "Używać Vault, AWS Secrets Manager, Azure Key Vault lub Kubernetes Secrets zamiast plików .env lub hardkodowania w kodzie."
+      },
+      "answers": [
+        {
+          "uk": "Зберігати у коді для зручності",
+          "en": "Store in code for convenience",
+          "pl": "Przechowywać w kodzie dla wygody",
+          "correct": false
+        },
+        {
+          "uk": "Vault, AWS Secrets Manager, Azure Key Vault, Kubernetes Secrets",
+          "en": "Vault, AWS Secrets Manager, Azure Key Vault, Kubernetes Secrets",
+          "pl": "Vault, AWS Secrets Manager, Azure Key Vault, Kubernetes Secrets",
+          "correct": true
+        },
+        {
+          "uk": "Публікувати в README",
+          "en": "Publish in README",
+          "pl": "Publikować w README",
+          "correct": false
+        },
+        {
+          "uk": "Комітити .env у Git",
+          "en": "Commit .env to Git",
+          "pl": "Commitować .env do Git",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q38",
+      "order": 38,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як Node.js застосунок масштабується у Kubernetes?",
+        "exp": "Запускається як Pod/Deployment з кількома репліками, використовується Horizontal Pod Autoscaler (HPA) для автоматичного масштабування за CPU/пам'яттю."
+      },
+      "en": {
+        "q": "How does a Node.js application scale in Kubernetes?",
+        "exp": "Runs as Pod/Deployment with multiple replicas, uses Horizontal Pod Autoscaler (HPA) for automatic scaling by CPU/memory."
+      },
+      "pl": {
+        "q": "Jak aplikacja Node.js skaluje się w Kubernetes?",
+        "exp": "Działa jako Pod/Deployment z wieloma replikami, używa Horizontal Pod Autoscaler (HPA) do automatycznego skalowania po CPU/pamięci."
+      },
+      "answers": [
+        {
+          "uk": "Node.js не працює в Kubernetes",
+          "en": "Node.js doesn't work in Kubernetes",
+          "pl": "Node.js nie działa w Kubernetes",
+          "correct": false
+        },
+        {
+          "uk": "Pod/Deployment з репліками, Horizontal Pod Autoscaler для автоскейлінгу",
+          "en": "Pod/Deployment with replicas, Horizontal Pod Autoscaler for autoscaling",
+          "pl": "Pod/Deployment z replikami, Horizontal Pod Autoscaler do autoskalowania",
+          "correct": true
+        },
+        {
+          "uk": "Тільки один екземпляр на кластер",
+          "en": "Only one instance per cluster",
+          "pl": "Tylko jedna instancja na klaster",
+          "correct": false
+        },
+        {
+          "uk": "Kubernetes автоматично перетворює код",
+          "en": "Kubernetes automatically transforms code",
+          "pl": "Kubernetes automatycznie przekształca kod",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q39",
+      "order": 39,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке supertest і як він використовується для тестування Node.js API?",
+        "exp": "Supertest — бібліотека для integration testing HTTP-серверів у Node.js. Дозволяє робити HTTP-запити до Express/Koa app і перевіряти відповіді."
+      },
+      "en": {
+        "q": "What is supertest and how is it used for testing Node.js API?",
+        "exp": "Supertest is a library for integration testing HTTP servers in Node.js. Allows making HTTP requests to Express/Koa app and checking responses."
+      },
+      "pl": {
+        "q": "Czym jest supertest i jak jest używany do testowania API Node.js?",
+        "exp": "Supertest to biblioteka do integration testingu serwerów HTTP w Node.js. Pozwala wysyłać żądania HTTP do aplikacji Express/Koa i sprawdzać odpowiedzi."
+      },
+      "answers": [
+        {
+          "uk": "Бібліотека для UI-тестування",
+          "en": "A library for UI testing",
+          "pl": "Biblioteka do testowania UI",
+          "correct": false
+        },
+        {
+          "uk": "Бібліотека для integration testing HTTP-серверів Node.js",
+          "en": "A library for integration testing Node.js HTTP servers",
+          "pl": "Biblioteka do integration testingu serwerów HTTP Node.js",
+          "correct": true
+        },
+        {
+          "uk": "Інструмент для деплою",
+          "en": "A deployment tool",
+          "pl": "Narzędzie do deploymentu",
+          "correct": false
+        },
+        {
+          "uk": "Менеджер пакетів",
+          "en": "A package manager",
+          "pl": "Menedżer pakietów",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-adv-q40",
+      "order": 40,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що означає принцип Dev/prod parity у Twelve-Factor App?",
+        "exp": "Dev/prod parity означає, що середовище розробки має бути максимально наближеним до продакшну для уникнення проблем при деплої."
+      },
+      "en": {
+        "q": "What does the Dev/prod parity principle mean in Twelve-Factor App?",
+        "exp": "Dev/prod parity means the development environment should closely match production to avoid deployment issues."
+      },
+      "pl": {
+        "q": "Co oznacza zasada Dev/prod parity w Twelve-Factor App?",
+        "exp": "Dev/prod parity oznacza, że środowisko deweloperskie powinno być maksymalnie zbliżone do produkcji, aby uniknąć problemów przy deploymencie."
+      },
+      "answers": [
+        {
+          "uk": "Dev і prod мають різні бази даних",
+          "en": "Dev and prod have different databases",
+          "pl": "Dev i prod mają różne bazy danych",
+          "correct": false
+        },
+        {
+          "uk": "Середовище розробки максимально наближене до продакшну",
+          "en": "Development environment closely matches production",
+          "pl": "Środowisko deweloperskie maksymalnie zbliżone do produkcji",
+          "correct": true
+        },
+        {
+          "uk": "Код пишеться тільки на продакшні",
+          "en": "Code is written only in production",
+          "pl": "Kod jest pisany tylko na produkcji",
+          "correct": false
+        },
+        {
+          "uk": "Dev не потрібен взагалі",
+          "en": "Dev is not needed at all",
+          "pl": "Dev nie jest w ogóle potrzebny",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/node/advanced/seed-quiz-nodejs-advanced.ts b/json/quizzes/node/advanced/seed-quiz-nodejs-advanced.ts
new file mode 100644
index 00000000..8e9a2f2e
--- /dev/null
+++ b/json/quizzes/node/advanced/seed-quiz-nodejs-advanced.ts
@@ -0,0 +1,240 @@
+import { eq } from 'drizzle-orm';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { db } from './index';
+import { categories } from './schema/categories';
+import {
+  quizzes,
+  quizTranslations,
+  quizQuestions,
+  quizQuestionContent,
+  quizAnswers,
+  quizAnswerTranslations,
+  quizAttempts,
+} from './schema/quiz';
+
+type Locale = 'uk' | 'en' | 'pl';
+const LOCALES: Locale[] = ['uk', 'en', 'pl'];
+
+interface QuestionData {
+  id: string;
+  order: number;
+  difficulty: 'beginner' | 'medium' | 'advanced';
+  uk: { q: string; exp: string };
+  en: { q: string; exp: string };
+  pl: { q: string; exp: string };
+  answers: {
+    uk: string;
+    en: string;
+    pl: string;
+    correct: boolean;
+  }[];
+}
+
+interface QuizPartData {
+  questions: QuestionData[];
+}
+
+const CATEGORY_SLUG = 'nodejs';
+
+const QUIZ_METADATA = {
+  slug: 'nodejs-advanced',
+  questionsCount: 40,
+  timeLimitSeconds: 2400,
+  translations: {
+    uk: {
+      title: 'Node.js Advanced',
+      description: 'Поглиблені знання Node.js: мікросервіси, gRPC, GraphQL, NestJS, serverless, CI/CD, Kubernetes, безпека та масштабування.',
+    },
+    en: {
+      title: 'Node.js Advanced',
+      description: 'Advanced Node.js knowledge: microservices, gRPC, GraphQL, NestJS, serverless, CI/CD, Kubernetes, security, and scaling.',
+    },
+    pl: {
+      title: 'Node.js Advanced',
+      description: 'Zaawansowana wiedza o Node.js: mikroserwisy, gRPC, GraphQL, NestJS, serverless, CI/CD, Kubernetes, bezpieczeństwo i skalowanie.',
+    },
+  },
+};
+
+function createExplanation(text: string) {
+  return [{ type: 'paragraph' as const, children: [{ text }] }];
+}
+
+async function loadQuestions(partNumber: number): Promise<QuestionData[]> {
+  const partPath = join(process.cwd(), 'data', `nodejs-advanced-quiz-part${partNumber}.json`);
+  const partData: QuizPartData = JSON.parse(readFileSync(partPath, 'utf-8'));
+  return partData.questions;
+}
+
+async function ensureQuizExists(): Promise<string> {
+  console.log('Ensuring quiz exists...');
+
+  // Find category by slug
+  const [category] = await db
+    .select()
+    .from(categories)
+    .where(eq(categories.slug, CATEGORY_SLUG))
+    .limit(1);
+
+  if (!category) {
+    throw new Error(`Category "${CATEGORY_SLUG}" not found. Run seed:categories first.`);
+  }
+
+  // Clean up old quiz by slug
+  const existing = await db.query.quizzes.findFirst({
+    where: eq(quizzes.slug, QUIZ_METADATA.slug),
+  });
+  if (existing) {
+    const existingAttempt = await db.query.quizAttempts.findFirst({
+      where: eq(quizAttempts.quizId, existing.id),
+    });
+    if (existingAttempt) {
+      throw new Error(`Quiz ${QUIZ_METADATA.slug} has existing attempts. Aborting to avoid data loss.`);
+    }
+
+    await db.delete(quizQuestions).where(eq(quizQuestions.quizId, existing.id));
+    await db.delete(quizTranslations).where(eq(quizTranslations.quizId, existing.id));
+    await db.update(quizzes).set({
+      categoryId: category.id,
+      slug: QUIZ_METADATA.slug,
+      displayOrder: 2,
+      questionsCount: QUIZ_METADATA.questionsCount,
+      timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+      isActive: true,
+    }).where(eq(quizzes.id, existing.id));
+
+    const quizId = existing.id;
+    for (const locale of LOCALES) {
+      await db.insert(quizTranslations).values({
+        quizId,
+        locale,
+        title: QUIZ_METADATA.translations[locale].title,
+        description: QUIZ_METADATA.translations[locale].description,
+      });
+    }
+
+    return quizId;
+  }
+
+  const [quiz] = await db.insert(quizzes).values({
+    categoryId: category.id,
+    slug: QUIZ_METADATA.slug,
+    displayOrder: 2,
+    questionsCount: QUIZ_METADATA.questionsCount,
+    timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+    isActive: true,
+  }).returning();
+
+  for (const locale of LOCALES) {
+    await db.insert(quizTranslations).values({
+      quizId: quiz.id,
+      locale,
+      title: QUIZ_METADATA.translations[locale].title,
+      description: QUIZ_METADATA.translations[locale].description,
+    });
+  }
+
+  return quiz.id;
+}
+
+async function seedQuestions(questions: QuestionData[], quizId: string, partNumber: number) {
+  console.log(`Seeding ${questions.length} questions from part ${partNumber}...`);
+
+  for (const question of questions) {
+    const [q] = await db.insert(quizQuestions).values({
+      quizId,
+      displayOrder: question.order,
+      difficulty: question.difficulty,
+    }).returning();
+
+    for (const locale of LOCALES) {
+      await db.insert(quizQuestionContent).values({
+        quizQuestionId: q.id,
+        locale,
+        questionText: question[locale].q,
+        explanation: createExplanation(question[locale].exp),
+      });
+    }
+
+    for (let i = 0; i < question.answers.length; i++) {
+      const answer = question.answers[i];
+      
+      const [a] = await db.insert(quizAnswers).values({
+        quizQuestionId: q.id,
+        displayOrder: i + 1,
+        isCorrect: answer.correct,
+      }).returning();
+
+      for (const locale of LOCALES) {
+        await db.insert(quizAnswerTranslations).values({
+          quizAnswerId: a.id,
+          locale,
+          answerText: answer[locale],
+        });
+      }
+    }
+  }
+
+  console.log(`Part ${partNumber} completed (${questions.length} questions)`);
+}
+
+async function seedQuizFromJson() {
+  const args = process.argv.slice(2);
+  const partArg = args[0];
+
+  if (!partArg) {
+    console.error('Error: Please specify which part to upload');
+    console.log('Usage: npx tsx db/seeds/seed-quiz-nodejs-advanced.ts <part-number>');
+    console.log('Example: npx tsx db/seeds/seed-quiz-nodejs-advanced.ts 1');
+    console.log('Or upload all: npx tsx db/seeds/seed-quiz-nodejs-advanced.ts all');
+    process.exit(1);
+  }
+
+  console.log('Starting Node.js Advanced quiz seed...\n');
+
+  try {
+    const quizId = await ensureQuizExists();
+
+    if (partArg.toLowerCase() === 'all') {
+      console.log('Uploading all parts...\n');
+      let totalQuestions = 0;
+
+      for (let i = 1; i <= 4; i++) {
+        const questions = await loadQuestions(i);
+        await seedQuestions(questions, quizId, i);
+        totalQuestions += questions.length;
+      }
+
+      console.log('\nAll parts seeded successfully!');
+      console.log(`   - 1 quiz with ${LOCALES.length} translations`);
+      console.log(`   - ${totalQuestions} questions total`);
+      console.log(`   - ${totalQuestions * 4} answers with ${LOCALES.length} translations each`);
+    } else {
+      const partNumber = parseInt(partArg, 10);
+
+      if (isNaN(partNumber) || partNumber < 1 || partNumber > 4) {
+        console.error('Error: Part number must be between 1 and 4');
+        process.exit(1);
+      }
+
+      const questions = await loadQuestions(partNumber);
+      await seedQuestions(questions, quizId, partNumber);
+
+      console.log('\nPart seeded successfully!');
+      console.log(`   - Quiz: ${QUIZ_METADATA.translations.en.title}`);
+      console.log(`   - Part ${partNumber}: ${questions.length} questions`);
+      console.log(`   - ${questions.length * 4} answers with ${LOCALES.length} translations each`);
+    }
+  } catch (error) {
+    console.error('\nError seeding quiz:', error);
+    throw error;
+  }
+}
+
+seedQuizFromJson()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/json/quizzes/node/beginner_medium/nodejs-quiz-part1.json b/json/quizzes/node/beginner_medium/nodejs-quiz-part1.json
new file mode 100644
index 00000000..e0129b7e
--- /dev/null
+++ b/json/quizzes/node/beginner_medium/nodejs-quiz-part1.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "node-q01",
+      "order": 1,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Що таке Node.js?",
+        "exp": "Node.js — це середовище виконання JavaScript поза браузером, побудоване на движку V8. Використовується для серверної розробки, API, CLI-утиліт."
+      },
+      "en": {
+        "q": "What is Node.js?",
+        "exp": "Node.js is a JavaScript runtime environment outside the browser, built on the V8 engine. It is used for server-side development, APIs, and CLI tools."
+      },
+      "pl": {
+        "q": "Czym jest Node.js?",
+        "exp": "Node.js to środowisko uruchomieniowe JavaScript poza przeglądarką, zbudowane na silniku V8. Używane do programowania serwerowego, API i narzędzi CLI."
+      },
+      "answers": [
+        {
+          "uk": "Фреймворк для створення фронтенд-інтерфейсів",
+          "en": "A framework for building frontend interfaces",
+          "pl": "Framework do tworzenia interfejsów frontend",
+          "correct": false
+        },
+        {
+          "uk": "Середовище виконання JavaScript поза браузером, побудоване на V8",
+          "en": "A JavaScript runtime environment outside the browser, built on V8",
+          "pl": "Środowisko uruchomieniowe JavaScript poza przeglądarką, zbudowane na V8",
+          "correct": true
+        },
+        {
+          "uk": "База даних для зберігання JSON-документів",
+          "en": "A database for storing JSON documents",
+          "pl": "Baza danych do przechowywania dokumentów JSON",
+          "correct": false
+        },
+        {
+          "uk": "Компілятор JavaScript у машинний код",
+          "en": "A compiler of JavaScript to machine code",
+          "pl": "Kompilator JavaScript do kodu maszynowego",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q02",
+      "order": 2,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Що таке event loop у Node.js?",
+        "exp": "Event loop — це механізм, який керує виконанням асинхронних операцій. Він перевіряє чергу подій і виконує колбеки, коли стек викликів порожній."
+      },
+      "en": {
+        "q": "What is the event loop in Node.js?",
+        "exp": "The event loop is a mechanism that manages asynchronous operations. It checks the event queue and executes callbacks when the call stack is empty."
+      },
+      "pl": {
+        "q": "Czym jest event loop w Node.js?",
+        "exp": "Event loop to mechanizm zarządzający operacjami asynchronicznymi. Sprawdza kolejkę zdarzeń i wykonuje callbacki, gdy stos wywołań jest pusty."
+      },
+      "answers": [
+        {
+          "uk": "Цикл for для обробки масивів",
+          "en": "A for loop for processing arrays",
+          "pl": "Pętla for do przetwarzania tablic",
+          "correct": false
+        },
+        {
+          "uk": "Механізм управління асинхронними операціями та виконання колбеків",
+          "en": "A mechanism for managing async operations and executing callbacks",
+          "pl": "Mechanizm zarządzania operacjami asynchronicznymi i wykonywania callbacków",
+          "correct": true
+        },
+        {
+          "uk": "Інструмент для відлагодження коду",
+          "en": "A tool for debugging code",
+          "pl": "Narzędzie do debugowania kodu",
+          "correct": false
+        },
+        {
+          "uk": "Модуль для роботи з файловою системою",
+          "en": "A module for working with the file system",
+          "pl": "Moduł do pracy z systemem plików",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q03",
+      "order": 3,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Що означає неблокуюче (non-blocking) виконання у Node.js?",
+        "exp": "Неблокуюче означає, що Node.js не чекає завершення I/O операцій, а продовжує виконання коду, обробляючи результати через колбеки або проміси."
+      },
+      "en": {
+        "q": "What does non-blocking execution mean in Node.js?",
+        "exp": "Non-blocking means Node.js doesn't wait for I/O operations to complete but continues executing code, handling results through callbacks or promises."
+      },
+      "pl": {
+        "q": "Co oznacza nieblokujące (non-blocking) wykonanie w Node.js?",
+        "exp": "Nieblokujące oznacza, że Node.js nie czeka na zakończenie operacji I/O, lecz kontynuuje wykonywanie kodu, obsługując wyniki przez callbacki lub promise."
+      },
+      "answers": [
+        {
+          "uk": "Node.js виконує код тільки послідовно, один за одним",
+          "en": "Node.js executes code only sequentially, one after another",
+          "pl": "Node.js wykonuje kod tylko sekwencyjnie, jeden po drugim",
+          "correct": false
+        },
+        {
+          "uk": "Код не чекає завершення I/O операцій і продовжує виконання",
+          "en": "Code doesn't wait for I/O operations and continues execution",
+          "pl": "Kod nie czeka na zakończenie operacji I/O i kontynuuje wykonywanie",
+          "correct": true
+        },
+        {
+          "uk": "Усі операції виконуються в окремих потоках",
+          "en": "All operations are executed in separate threads",
+          "pl": "Wszystkie operacje są wykonywane w osobnych wątkach",
+          "correct": false
+        },
+        {
+          "uk": "Node.js блокує процесор під час мережевих запитів",
+          "en": "Node.js blocks the CPU during network requests",
+          "pl": "Node.js blokuje procesor podczas żądań sieciowych",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q04",
+      "order": 4,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Для чого використовується npm?",
+        "exp": "npm (Node Package Manager) — це менеджер пакетів для встановлення, оновлення та управління бібліотеками і залежностями у Node.js проєктах."
+      },
+      "en": {
+        "q": "What is npm used for?",
+        "exp": "npm (Node Package Manager) is a package manager for installing, updating, and managing libraries and dependencies in Node.js projects."
+      },
+      "pl": {
+        "q": "Do czego służy npm?",
+        "exp": "npm (Node Package Manager) to menedżer pakietów do instalowania, aktualizowania i zarządzania bibliotekami i zależnościami w projektach Node.js."
+      },
+      "answers": [
+        {
+          "uk": "Для компіляції TypeScript у JavaScript",
+          "en": "For compiling TypeScript to JavaScript",
+          "pl": "Do kompilowania TypeScript do JavaScript",
+          "correct": false
+        },
+        {
+          "uk": "Для встановлення, оновлення та управління залежностями проєкту",
+          "en": "For installing, updating, and managing project dependencies",
+          "pl": "Do instalowania, aktualizowania i zarządzania zależnościami projektu",
+          "correct": true
+        },
+        {
+          "uk": "Для запуску тестів автоматично",
+          "en": "For running tests automatically",
+          "pl": "Do automatycznego uruchamiania testów",
+          "correct": false
+        },
+        {
+          "uk": "Для створення Docker-контейнерів",
+          "en": "For creating Docker containers",
+          "pl": "Do tworzenia kontenerów Docker",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q05",
+      "order": 5,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Яке призначення файлу package.json?",
+        "exp": "package.json описує Node.js проєкт: назву, версію, залежності (dependencies, devDependencies), скрипти для запуску команд та метадані."
+      },
+      "en": {
+        "q": "What is the purpose of the package.json file?",
+        "exp": "package.json describes the Node.js project: name, version, dependencies (dependencies, devDependencies), scripts for running commands, and metadata."
+      },
+      "pl": {
+        "q": "Jakie jest przeznaczenie pliku package.json?",
+        "exp": "package.json opisuje projekt Node.js: nazwę, wersję, zależności (dependencies, devDependencies), skrypty do uruchamiania poleceń i metadane."
+      },
+      "answers": [
+        {
+          "uk": "Зберігає скомпільований JavaScript-код",
+          "en": "Stores compiled JavaScript code",
+          "pl": "Przechowuje skompilowany kod JavaScript",
+          "correct": false
+        },
+        {
+          "uk": "Містить конфігурацію бази даних",
+          "en": "Contains database configuration",
+          "pl": "Zawiera konfigurację bazy danych",
+          "correct": false
+        },
+        {
+          "uk": "Описує проєкт, залежності та скрипти для запуску команд",
+          "en": "Describes the project, dependencies, and scripts for running commands",
+          "pl": "Opisuje projekt, zależności i skrypty do uruchamiania poleceń",
+          "correct": true
+        },
+        {
+          "uk": "Зберігає змінні середовища для продакшну",
+          "en": "Stores environment variables for production",
+          "pl": "Przechowuje zmienne środowiskowe dla produkcji",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q06",
+      "order": 6,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Яке призначення файлу package-lock.json?",
+        "exp": "package-lock.json фіксує точні версії всіх залежностей, гарантуючи однакові версії пакетів для всіх учасників проєкту."
+      },
+      "en": {
+        "q": "What is the purpose of the package-lock.json file?",
+        "exp": "package-lock.json locks exact versions of all dependencies, ensuring the same package versions for all project contributors."
+      },
+      "pl": {
+        "q": "Jakie jest przeznaczenie pliku package-lock.json?",
+        "exp": "package-lock.json blokuje dokładne wersje wszystkich zależności, zapewniając te same wersje pakietów dla wszystkich uczestników projektu."
+      },
+      "answers": [
+        {
+          "uk": "Блокує проєкт від змін іншими розробниками",
+          "en": "Locks the project from changes by other developers",
+          "pl": "Blokuje projekt przed zmianami innych programistów",
+          "correct": false
+        },
+        {
+          "uk": "Фіксує точні версії залежностей для консистентності у команді",
+          "en": "Locks exact dependency versions for team consistency",
+          "pl": "Blokuje dokładne wersje zależności dla spójności w zespole",
+          "correct": true
+        },
+        {
+          "uk": "Зберігає паролі та секрети проєкту",
+          "en": "Stores project passwords and secrets",
+          "pl": "Przechowuje hasła i sekrety projektu",
+          "correct": false
+        },
+        {
+          "uk": "Конфігурує налаштування Git для проєкту",
+          "en": "Configures Git settings for the project",
+          "pl": "Konfiguruje ustawienia Git dla projektu",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q07",
+      "order": 7,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Чим Node.js відрізняється від традиційних вебсерверів (Apache, Tomcat)?",
+        "exp": "Node.js використовує однопотокову подієво-орієнтовану модель, тоді як традиційні сервери створюють окремий потік для кожного запиту."
+      },
+      "en": {
+        "q": "How does Node.js differ from traditional web servers (Apache, Tomcat)?",
+        "exp": "Node.js uses a single-threaded event-driven model, while traditional servers create a separate thread for each request."
+      },
+      "pl": {
+        "q": "Czym Node.js różni się od tradycyjnych serwerów webowych (Apache, Tomcat)?",
+        "exp": "Node.js używa jednowątkowego modelu sterowanego zdarzeniami, podczas gdy tradycyjne serwery tworzą osobny wątek dla każdego żądania."
+      },
+      "answers": [
+        {
+          "uk": "Node.js використовує однопотокову подієво-орієнтовану модель",
+          "en": "Node.js uses a single-threaded event-driven model",
+          "pl": "Node.js używa jednowątkowego modelu sterowanego zdarzeniami",
+          "correct": true
+        },
+        {
+          "uk": "Node.js не підтримує HTTP-протокол",
+          "en": "Node.js doesn't support the HTTP protocol",
+          "pl": "Node.js nie obsługuje protokołu HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Node.js працює тільки на Windows",
+          "en": "Node.js works only on Windows",
+          "pl": "Node.js działa tylko na Windows",
+          "correct": false
+        },
+        {
+          "uk": "Node.js не підтримує роботу з базами даних",
+          "en": "Node.js doesn't support database operations",
+          "pl": "Node.js nie obsługuje operacji na bazach danych",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q08",
+      "order": 8,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Який інструмент найкраще підходить для керування кількома версіями Node.js на одній машині?",
+        "exp": "nvm (Node Version Manager) дозволяє встановлювати та перемикатися між різними версіями Node.js без конфліктів."
+      },
+      "en": {
+        "q": "Which tool is best for managing multiple Node.js versions on one machine?",
+        "exp": "nvm (Node Version Manager) allows installing and switching between different Node.js versions without conflicts."
+      },
+      "pl": {
+        "q": "Które narzędzie najlepiej nadaje się do zarządzania wieloma wersjami Node.js na jednej maszynie?",
+        "exp": "nvm (Node Version Manager) pozwala instalować i przełączać się między różnymi wersjami Node.js bez konfliktów."
+      },
+      "answers": [
+        {
+          "uk": "Docker",
+          "en": "Docker",
+          "pl": "Docker",
+          "correct": false
+        },
+        {
+          "uk": "nvm (Node Version Manager)",
+          "en": "nvm (Node Version Manager)",
+          "pl": "nvm (Node Version Manager)",
+          "correct": true
+        },
+        {
+          "uk": "npm",
+          "en": "npm",
+          "pl": "npm",
+          "correct": false
+        },
+        {
+          "uk": "Git",
+          "en": "Git",
+          "pl": "Git",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q09",
+      "order": 9,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка роль libuv у Node.js?",
+        "exp": "libuv — це бібліотека, яка забезпечує асинхронний I/O та пул потоків для виконання важких операцій без блокування основного потоку."
+      },
+      "en": {
+        "q": "What role does libuv play in Node.js?",
+        "exp": "libuv is a library that provides asynchronous I/O and a thread pool for executing heavy operations without blocking the main thread."
+      },
+      "pl": {
+        "q": "Jaką rolę pełni libuv w Node.js?",
+        "exp": "libuv to biblioteka zapewniająca asynchroniczne I/O i pulę wątków do wykonywania ciężkich operacji bez blokowania głównego wątku."
+      },
+      "answers": [
+        {
+          "uk": "Компілює JavaScript у машинний код",
+          "en": "Compiles JavaScript to machine code",
+          "pl": "Kompiluje JavaScript do kodu maszynowego",
+          "correct": false
+        },
+        {
+          "uk": "Забезпечує асинхронний I/O та пул потоків для важких операцій",
+          "en": "Provides async I/O and thread pool for heavy operations",
+          "pl": "Zapewnia asynchroniczne I/O i pulę wątków dla ciężkich operacji",
+          "correct": true
+        },
+        {
+          "uk": "Керує залежностями проєкту",
+          "en": "Manages project dependencies",
+          "pl": "Zarządza zależnościami projektu",
+          "correct": false
+        },
+        {
+          "uk": "Відповідає за рендеринг HTML-сторінок",
+          "en": "Responsible for rendering HTML pages",
+          "pl": "Odpowiada za renderowanie stron HTML",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q10",
+      "order": 10,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке event-driven програмування у Node.js?",
+        "exp": "Event-driven програмування означає, що застосунок реагує на події (I/O, мережеві запити, таймери) через колбеки, проміси або async/await."
+      },
+      "en": {
+        "q": "What is event-driven programming in Node.js?",
+        "exp": "Event-driven programming means the application reacts to events (I/O, network requests, timers) through callbacks, promises, or async/await."
+      },
+      "pl": {
+        "q": "Czym jest programowanie sterowane zdarzeniami w Node.js?",
+        "exp": "Programowanie sterowane zdarzeniami oznacza, że aplikacja reaguje na zdarzenia (I/O, żądania sieciowe, timery) przez callbacki, promise lub async/await."
+      },
+      "answers": [
+        {
+          "uk": "Програмування, де весь код виконується синхронно",
+          "en": "Programming where all code executes synchronously",
+          "pl": "Programowanie, gdzie cały kod wykonuje się synchronicznie",
+          "correct": false
+        },
+        {
+          "uk": "Модель, де застосунок реагує на події через колбеки або проміси",
+          "en": "Model where the app reacts to events through callbacks or promises",
+          "pl": "Model, w którym aplikacja reaguje na zdarzenia przez callbacki lub promise",
+          "correct": true
+        },
+        {
+          "uk": "Підхід, де кожна функція створює новий потік",
+          "en": "Approach where each function creates a new thread",
+          "pl": "Podejście, gdzie każda funkcja tworzy nowy wątek",
+          "correct": false
+        },
+        {
+          "uk": "Спосіб організації CSS-стилів",
+          "en": "A way of organizing CSS styles",
+          "pl": "Sposób organizacji stylów CSS",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/node/beginner_medium/nodejs-quiz-part2.json b/json/quizzes/node/beginner_medium/nodejs-quiz-part2.json
new file mode 100644
index 00000000..e32d5842
--- /dev/null
+++ b/json/quizzes/node/beginner_medium/nodejs-quiz-part2.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "node-q11",
+      "order": 11,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Який модуль використовується для роботи з файловою системою у Node.js?",
+        "exp": "Модуль fs (File System) дозволяє читати, записувати, створювати та видаляти файли як синхронно, так і асинхронно."
+      },
+      "en": {
+        "q": "Which module is used for working with the file system in Node.js?",
+        "exp": "The fs (File System) module allows reading, writing, creating, and deleting files both synchronously and asynchronously."
+      },
+      "pl": {
+        "q": "Który moduł służy do pracy z systemem plików w Node.js?",
+        "exp": "Moduł fs (File System) pozwala na odczytywanie, zapisywanie, tworzenie i usuwanie plików zarówno synchronicznie, jak i asynchronicznie."
+      },
+      "answers": [
+        {
+          "uk": "path",
+          "en": "path",
+          "pl": "path",
+          "correct": false
+        },
+        {
+          "uk": "fs",
+          "en": "fs",
+          "pl": "fs",
+          "correct": true
+        },
+        {
+          "uk": "http",
+          "en": "http",
+          "pl": "http",
+          "correct": false
+        },
+        {
+          "uk": "os",
+          "en": "os",
+          "pl": "os",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q12",
+      "order": 12,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Для чого використовується модуль path у Node.js?",
+        "exp": "Модуль path забезпечує кросплатформену роботу з файловими шляхами: об'єднання, отримання імені файлу, директорії, розширення."
+      },
+      "en": {
+        "q": "What is the path module used for in Node.js?",
+        "exp": "The path module provides cross-platform handling of file paths: joining, getting filename, directory, and extension."
+      },
+      "pl": {
+        "q": "Do czego służy moduł path w Node.js?",
+        "exp": "Moduł path zapewnia wieloplatformową obsługę ścieżek plików: łączenie, pobieranie nazwy pliku, katalogu i rozszerzenia."
+      },
+      "answers": [
+        {
+          "uk": "Для роботи з HTTP-запитами",
+          "en": "For handling HTTP requests",
+          "pl": "Do obsługi żądań HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Для кросплатформної роботи з файловими шляхами",
+          "en": "For cross-platform handling of file paths",
+          "pl": "Do wieloplatformowej obsługi ścieżek plików",
+          "correct": true
+        },
+        {
+          "uk": "Для шифрування даних",
+          "en": "For encrypting data",
+          "pl": "Do szyfrowania danych",
+          "correct": false
+        },
+        {
+          "uk": "Для роботи з базою даних",
+          "en": "For working with databases",
+          "pl": "Do pracy z bazą danych",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q13",
+      "order": 13,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Buffer у Node.js?",
+        "exp": "Buffer — це клас для роботи з двійковими даними (raw data). Використовується для обробки файлів, мережевих потоків, зображень."
+      },
+      "en": {
+        "q": "What is Buffer in Node.js?",
+        "exp": "Buffer is a class for working with binary data (raw data). It is used for processing files, network streams, and images."
+      },
+      "pl": {
+        "q": "Czym jest Buffer w Node.js?",
+        "exp": "Buffer to klasa do pracy z danymi binarnymi (raw data). Używana do przetwarzania plików, strumieni sieciowych i obrazów."
+      },
+      "answers": [
+        {
+          "uk": "Тимчасове сховище для кешування HTTP-запитів",
+          "en": "Temporary storage for caching HTTP requests",
+          "pl": "Tymczasowe miejsce do cachowania żądań HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Клас для роботи з двійковими даними поза V8 heap",
+          "en": "A class for working with binary data outside V8 heap",
+          "pl": "Klasa do pracy z danymi binarnymi poza V8 heap",
+          "correct": true
+        },
+        {
+          "uk": "Модуль для буферизації виводу в консоль",
+          "en": "A module for buffering console output",
+          "pl": "Moduł do buforowania wyjścia do konsoli",
+          "correct": false
+        },
+        {
+          "uk": "Функція для затримки виконання коду",
+          "en": "A function for delaying code execution",
+          "pl": "Funkcja do opóźniania wykonywania kodu",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q14",
+      "order": 14,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Які типи стрімів існують у Node.js?",
+        "exp": "У Node.js є 4 типи стрімів: Readable (читання), Writable (запис), Duplex (читання і запис), Transform (трансформація даних)."
+      },
+      "en": {
+        "q": "What types of streams exist in Node.js?",
+        "exp": "Node.js has 4 stream types: Readable (reading), Writable (writing), Duplex (reading and writing), Transform (data transformation)."
+      },
+      "pl": {
+        "q": "Jakie typy strumieni istnieją w Node.js?",
+        "exp": "Node.js ma 4 typy strumieni: Readable (odczyt), Writable (zapis), Duplex (odczyt i zapis), Transform (transformacja danych)."
+      },
+      "answers": [
+        {
+          "uk": "Input, Output, Mixed",
+          "en": "Input, Output, Mixed",
+          "pl": "Input, Output, Mixed",
+          "correct": false
+        },
+        {
+          "uk": "Readable, Writable, Duplex, Transform",
+          "en": "Readable, Writable, Duplex, Transform",
+          "pl": "Readable, Writable, Duplex, Transform",
+          "correct": true
+        },
+        {
+          "uk": "Sync, Async, Hybrid",
+          "en": "Sync, Async, Hybrid",
+          "pl": "Sync, Async, Hybrid",
+          "correct": false
+        },
+        {
+          "uk": "File, Network, Memory",
+          "en": "File, Network, Memory",
+          "pl": "File, Network, Memory",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q15",
+      "order": 15,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка перевага використання стрімів для роботи з великими файлами?",
+        "exp": "Стріми обробляють дані по частинах (chunks), не завантажуючи весь файл у пам'ять, що економить ресурси та прискорює обробку."
+      },
+      "en": {
+        "q": "What is the advantage of using streams for large files?",
+        "exp": "Streams process data in chunks without loading the entire file into memory, which saves resources and speeds up processing."
+      },
+      "pl": {
+        "q": "Jaka jest zaleta używania strumieni do dużych plików?",
+        "exp": "Strumienie przetwarzają dane w kawałkach bez ładowania całego pliku do pamięci, co oszczędza zasoby i przyspiesza przetwarzanie."
+      },
+      "answers": [
+        {
+          "uk": "Стріми автоматично стискають файли",
+          "en": "Streams automatically compress files",
+          "pl": "Strumienie automatycznie kompresują pliki",
+          "correct": false
+        },
+        {
+          "uk": "Обробка по частинах без завантаження всього файлу в пам'ять",
+          "en": "Processing in chunks without loading the entire file into memory",
+          "pl": "Przetwarzanie w kawałkach bez ładowania całego pliku do pamięci",
+          "correct": true
+        },
+        {
+          "uk": "Стріми працюють тільки з текстовими файлами",
+          "en": "Streams only work with text files",
+          "pl": "Strumienie działają tylko z plikami tekstowymi",
+          "correct": false
+        },
+        {
+          "uk": "Стріми шифрують дані автоматично",
+          "en": "Streams automatically encrypt data",
+          "pl": "Strumienie automatycznie szyfrują dane",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q16",
+      "order": 16,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Що таке error-first callback у Node.js?",
+        "exp": "Error-first callback — це патерн, де перший аргумент колбека завжди призначений для помилки, а другий — для результату."
+      },
+      "en": {
+        "q": "What is an error-first callback in Node.js?",
+        "exp": "Error-first callback is a pattern where the first callback argument is always for the error, and the second is for the result."
+      },
+      "pl": {
+        "q": "Czym jest error-first callback w Node.js?",
+        "exp": "Error-first callback to wzorzec, gdzie pierwszy argument callbacka jest zawsze dla błędu, a drugi dla wyniku."
+      },
+      "answers": [
+        {
+          "uk": "Колбек, який викликається тільки при помилці",
+          "en": "A callback that is called only on error",
+          "pl": "Callback wywoływany tylko przy błędzie",
+          "correct": false
+        },
+        {
+          "uk": "Патерн, де перший аргумент — помилка, другий — результат",
+          "en": "Pattern where first argument is error, second is result",
+          "pl": "Wzorzec, gdzie pierwszy argument to błąd, drugi to wynik",
+          "correct": true
+        },
+        {
+          "uk": "Функція для логування помилок",
+          "en": "A function for logging errors",
+          "pl": "Funkcja do logowania błędów",
+          "correct": false
+        },
+        {
+          "uk": "Метод для перехоплення всіх помилок",
+          "en": "A method for catching all errors",
+          "pl": "Metoda do przechwytywania wszystkich błędów",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q17",
+      "order": 17,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке callback hell і як його уникнути?",
+        "exp": "Callback hell — це вкладені колбеки, що ускладнюють код. Уникають через Promises, async/await або розбиття на функції."
+      },
+      "en": {
+        "q": "What is callback hell and how to avoid it?",
+        "exp": "Callback hell is nested callbacks that make code complex. Avoid it using Promises, async/await, or splitting into functions."
+      },
+      "pl": {
+        "q": "Czym jest callback hell i jak go uniknąć?",
+        "exp": "Callback hell to zagnieżdżone callbacki utrudniające kod. Unika się go przez Promise, async/await lub dzielenie na funkcje."
+      },
+      "answers": [
+        {
+          "uk": "Помилка сервера при великому навантаженні",
+          "en": "Server error under heavy load",
+          "pl": "Błąd serwera przy dużym obciążeniu",
+          "correct": false
+        },
+        {
+          "uk": "Вкладені колбеки, що ускладнюють код; уникають через Promises або async/await",
+          "en": "Nested callbacks making code complex; avoid with Promises or async/await",
+          "pl": "Zagnieżdżone callbacki utrudniające kod; unika się przez Promise lub async/await",
+          "correct": true
+        },
+        {
+          "uk": "Втрата даних при асинхронних операціях",
+          "en": "Data loss during async operations",
+          "pl": "Utrata danych podczas operacji asynchronicznych",
+          "correct": false
+        },
+        {
+          "uk": "Переповнення стеку викликів",
+          "en": "Call stack overflow",
+          "pl": "Przepełnienie stosu wywołań",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q18",
+      "order": 18,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Які стани має Promise у JavaScript/Node.js?",
+        "exp": "Promise має три стани: pending (очікування), fulfilled (успішно виконано), rejected (помилка)."
+      },
+      "en": {
+        "q": "What states does a Promise have in JavaScript/Node.js?",
+        "exp": "A Promise has three states: pending (waiting), fulfilled (successfully completed), rejected (error)."
+      },
+      "pl": {
+        "q": "Jakie stany ma Promise w JavaScript/Node.js?",
+        "exp": "Promise ma trzy stany: pending (oczekiwanie), fulfilled (pomyślnie zakończony), rejected (błąd)."
+      },
+      "answers": [
+        {
+          "uk": "start, process, end",
+          "en": "start, process, end",
+          "pl": "start, process, end",
+          "correct": false
+        },
+        {
+          "uk": "pending, fulfilled, rejected",
+          "en": "pending, fulfilled, rejected",
+          "pl": "pending, fulfilled, rejected",
+          "correct": true
+        },
+        {
+          "uk": "waiting, running, completed",
+          "en": "waiting, running, completed",
+          "pl": "waiting, running, completed",
+          "correct": false
+        },
+        {
+          "uk": "open, closed, error",
+          "en": "open, closed, error",
+          "pl": "open, closed, error",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q19",
+      "order": 19,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Яка перевага async/await над ланцюжками .then()?",
+        "exp": "async/await робить асинхронний код схожим на синхронний, що спрощує читання, написання та відлагодження."
+      },
+      "en": {
+        "q": "What is the advantage of async/await over .then() chains?",
+        "exp": "async/await makes async code look like synchronous code, which simplifies reading, writing, and debugging."
+      },
+      "pl": {
+        "q": "Jaka jest zaleta async/await nad łańcuchami .then()?",
+        "exp": "async/await sprawia, że kod asynchroniczny wygląda jak synchroniczny, co ułatwia czytanie, pisanie i debugowanie."
+      },
+      "answers": [
+        {
+          "uk": "async/await працює швидше",
+          "en": "async/await works faster",
+          "pl": "async/await działa szybciej",
+          "correct": false
+        },
+        {
+          "uk": "Код виглядає як синхронний, легше читати та відлагоджувати",
+          "en": "Code looks synchronous, easier to read and debug",
+          "pl": "Kod wygląda jak synchroniczny, łatwiejszy do czytania i debugowania",
+          "correct": true
+        },
+        {
+          "uk": "async/await не потребує обробки помилок",
+          "en": "async/await doesn't require error handling",
+          "pl": "async/await nie wymaga obsługi błędów",
+          "correct": false
+        },
+        {
+          "uk": "async/await автоматично кешує результати",
+          "en": "async/await automatically caches results",
+          "pl": "async/await automatycznie cachuje wyniki",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q20",
+      "order": 20,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Чому синхронні методи fs (наприклад, readFileSync) не рекомендуються у продакшн-серверах?",
+        "exp": "Синхронні методи блокують event loop, що зупиняє обробку інших запитів і знижує продуктивність сервера."
+      },
+      "en": {
+        "q": "Why are synchronous fs methods (e.g., readFileSync) not recommended in production servers?",
+        "exp": "Synchronous methods block the event loop, which stops processing other requests and reduces server performance."
+      },
+      "pl": {
+        "q": "Dlaczego synchroniczne metody fs (np. readFileSync) nie są zalecane na serwerach produkcyjnych?",
+        "exp": "Metody synchroniczne blokują event loop, co zatrzymuje przetwarzanie innych żądań i obniża wydajność serwera."
+      },
+      "answers": [
+        {
+          "uk": "Вони споживають більше пам'яті",
+          "en": "They consume more memory",
+          "pl": "Zużywają więcej pamięci",
+          "correct": false
+        },
+        {
+          "uk": "Вони блокують event loop і зупиняють обробку інших запитів",
+          "en": "They block the event loop and stop processing other requests",
+          "pl": "Blokują event loop i zatrzymują przetwarzanie innych żądań",
+          "correct": true
+        },
+        {
+          "uk": "Вони не підтримують великі файли",
+          "en": "They don't support large files",
+          "pl": "Nie obsługują dużych plików",
+          "correct": false
+        },
+        {
+          "uk": "Вони застарілі та скоро будуть видалені",
+          "en": "They are deprecated and will be removed soon",
+          "pl": "Są przestarzałe i wkrótce zostaną usunięte",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/node/beginner_medium/nodejs-quiz-part3.json b/json/quizzes/node/beginner_medium/nodejs-quiz-part3.json
new file mode 100644
index 00000000..eca5b173
--- /dev/null
+++ b/json/quizzes/node/beginner_medium/nodejs-quiz-part3.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "node-q21",
+      "order": 21,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Що таке Express.js і чому він популярний?",
+        "exp": "Express.js — це мінімалістичний веб-фреймворк для Node.js, який спрощує маршрутизацію, middleware та розробку REST API."
+      },
+      "en": {
+        "q": "What is Express.js and why is it popular?",
+        "exp": "Express.js is a minimalist web framework for Node.js that simplifies routing, middleware, and REST API development."
+      },
+      "pl": {
+        "q": "Czym jest Express.js i dlaczego jest popularny?",
+        "exp": "Express.js to minimalistyczny framework webowy dla Node.js, który upraszcza routing, middleware i tworzenie REST API."
+      },
+      "answers": [
+        {
+          "uk": "База даних для Node.js",
+          "en": "A database for Node.js",
+          "pl": "Baza danych dla Node.js",
+          "correct": false
+        },
+        {
+          "uk": "Мінімалістичний веб-фреймворк для створення серверів та API",
+          "en": "A minimalist web framework for building servers and APIs",
+          "pl": "Minimalistyczny framework webowy do tworzenia serwerów i API",
+          "correct": true
+        },
+        {
+          "uk": "Інструмент для тестування JavaScript",
+          "en": "A tool for testing JavaScript",
+          "pl": "Narzędzie do testowania JavaScript",
+          "correct": false
+        },
+        {
+          "uk": "Компілятор TypeScript",
+          "en": "A TypeScript compiler",
+          "pl": "Kompilator TypeScript",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q22",
+      "order": 22,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке middleware у Express.js?",
+        "exp": "Middleware — це функція, яка виконується між отриманням запиту та відправкою відповіді. Вона може змінювати req/res та викликати next()."
+      },
+      "en": {
+        "q": "What is middleware in Express.js?",
+        "exp": "Middleware is a function that executes between receiving a request and sending a response. It can modify req/res and call next()."
+      },
+      "pl": {
+        "q": "Czym jest middleware w Express.js?",
+        "exp": "Middleware to funkcja wykonywana między otrzymaniem żądania a wysłaniem odpowiedzi. Może modyfikować req/res i wywoływać next()."
+      },
+      "answers": [
+        {
+          "uk": "Функція між отриманням запиту та відправкою відповіді",
+          "en": "A function between receiving request and sending response",
+          "pl": "Funkcja między otrzymaniem żądania a wysłaniem odpowiedzi",
+          "correct": true
+        },
+        {
+          "uk": "База даних для зберігання сесій",
+          "en": "A database for storing sessions",
+          "pl": "Baza danych do przechowywania sesji",
+          "correct": false
+        },
+        {
+          "uk": "Протокол для передачі даних",
+          "en": "A protocol for data transmission",
+          "pl": "Protokół do transmisji danych",
+          "correct": false
+        },
+        {
+          "uk": "Інструмент для мінімізації JavaScript",
+          "en": "A tool for minifying JavaScript",
+          "pl": "Narzędzie do minifikacji JavaScript",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q23",
+      "order": 23,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Який пакет рекомендується для захисту HTTP-заголовків у Express.js?",
+        "exp": "helmet — це middleware, який автоматично додає безпечні HTTP-заголовки для захисту від XSS, clickjacking та інших атак."
+      },
+      "en": {
+        "q": "Which package is recommended for securing HTTP headers in Express.js?",
+        "exp": "helmet is a middleware that automatically adds secure HTTP headers for protection against XSS, clickjacking, and other attacks."
+      },
+      "pl": {
+        "q": "Który pakiet jest zalecany do zabezpieczania nagłówków HTTP w Express.js?",
+        "exp": "helmet to middleware, który automatycznie dodaje bezpieczne nagłówki HTTP dla ochrony przed XSS, clickjacking i innymi atakami."
+      },
+      "answers": [
+        {
+          "uk": "cors",
+          "en": "cors",
+          "pl": "cors",
+          "correct": false
+        },
+        {
+          "uk": "helmet",
+          "en": "helmet",
+          "pl": "helmet",
+          "correct": true
+        },
+        {
+          "uk": "morgan",
+          "en": "morgan",
+          "pl": "morgan",
+          "correct": false
+        },
+        {
+          "uk": "body-parser",
+          "en": "body-parser",
+          "pl": "body-parser",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q24",
+      "order": 24,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як обробити невловлені помилки у Node.js застосунку?",
+        "exp": "Використовуються process.on('uncaughtException') для синхронних помилок і process.on('unhandledRejection') для відхилених промісів."
+      },
+      "en": {
+        "q": "How to handle uncaught errors in a Node.js application?",
+        "exp": "Use process.on('uncaughtException') for synchronous errors and process.on('unhandledRejection') for rejected promises."
+      },
+      "pl": {
+        "q": "Jak obsłużyć nieprzechwycone błędy w aplikacji Node.js?",
+        "exp": "Używa się process.on('uncaughtException') dla błędów synchronicznych i process.on('unhandledRejection') dla odrzuconych promisów."
+      },
+      "answers": [
+        {
+          "uk": "Тільки через try/catch у кожній функції",
+          "en": "Only through try/catch in every function",
+          "pl": "Tylko przez try/catch w każdej funkcji",
+          "correct": false
+        },
+        {
+          "uk": "Через process.on('uncaughtException') та process.on('unhandledRejection')",
+          "en": "Through process.on('uncaughtException') and process.on('unhandledRejection')",
+          "pl": "Przez process.on('uncaughtException') i process.on('unhandledRejection')",
+          "correct": true
+        },
+        {
+          "uk": "Node.js автоматично логує всі помилки",
+          "en": "Node.js automatically logs all errors",
+          "pl": "Node.js automatycznie loguje wszystkie błędy",
+          "correct": false
+        },
+        {
+          "uk": "Невловлені помилки неможливо обробити",
+          "en": "Uncaught errors cannot be handled",
+          "pl": "Nieprzechwyconych błędów nie można obsłużyć",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q25",
+      "order": 25,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке ORM і яку роль він виконує у Node.js?",
+        "exp": "ORM (Object-Relational Mapping) дозволяє працювати з базою даних через JavaScript-об'єкти замість SQL-запитів."
+      },
+      "en": {
+        "q": "What is ORM and what role does it play in Node.js?",
+        "exp": "ORM (Object-Relational Mapping) allows working with databases through JavaScript objects instead of SQL queries."
+      },
+      "pl": {
+        "q": "Czym jest ORM i jaką rolę pełni w Node.js?",
+        "exp": "ORM (Object-Relational Mapping) pozwala pracować z bazą danych przez obiekty JavaScript zamiast zapytań SQL."
+      },
+      "answers": [
+        {
+          "uk": "Протокол для передачі даних між серверами",
+          "en": "A protocol for data transfer between servers",
+          "pl": "Protokół do przesyłania danych między serwerami",
+          "correct": false
+        },
+        {
+          "uk": "Шар абстракції для роботи з БД через JavaScript-об'єкти",
+          "en": "An abstraction layer for working with DB through JavaScript objects",
+          "pl": "Warstwa abstrakcji do pracy z BD przez obiekty JavaScript",
+          "correct": true
+        },
+        {
+          "uk": "Інструмент для оптимізації запитів до API",
+          "en": "A tool for optimizing API requests",
+          "pl": "Narzędzie do optymalizacji żądań API",
+          "correct": false
+        },
+        {
+          "uk": "Система кешування для Node.js",
+          "en": "A caching system for Node.js",
+          "pl": "System cachowania dla Node.js",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q26",
+      "order": 26,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Який популярний ODM використовується для роботи з MongoDB у Node.js?",
+        "exp": "Mongoose — це ODM (Object Data Modeling), який додає схеми, валідацію та зручні методи для роботи з MongoDB."
+      },
+      "en": {
+        "q": "Which popular ODM is used for working with MongoDB in Node.js?",
+        "exp": "Mongoose is an ODM (Object Data Modeling) that adds schemas, validation, and convenient methods for working with MongoDB."
+      },
+      "pl": {
+        "q": "Który popularny ODM jest używany do pracy z MongoDB w Node.js?",
+        "exp": "Mongoose to ODM (Object Data Modeling), który dodaje schematy, walidację i wygodne metody do pracy z MongoDB."
+      },
+      "answers": [
+        {
+          "uk": "Sequelize",
+          "en": "Sequelize",
+          "pl": "Sequelize",
+          "correct": false
+        },
+        {
+          "uk": "Mongoose",
+          "en": "Mongoose",
+          "pl": "Mongoose",
+          "correct": true
+        },
+        {
+          "uk": "Prisma",
+          "en": "Prisma",
+          "pl": "Prisma",
+          "correct": false
+        },
+        {
+          "uk": "TypeORM",
+          "en": "TypeORM",
+          "pl": "TypeORM",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q27",
+      "order": 27,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Для чого використовуються змінні оточення (environment variables) у Node.js?",
+        "exp": "Змінні оточення зберігають конфігурацію (порти, ключі API, URL бази даних) окремо від коду для безпеки та гнучкості."
+      },
+      "en": {
+        "q": "What are environment variables used for in Node.js?",
+        "exp": "Environment variables store configuration (ports, API keys, database URLs) separately from code for security and flexibility."
+      },
+      "pl": {
+        "q": "Do czego służą zmienne środowiskowe w Node.js?",
+        "exp": "Zmienne środowiskowe przechowują konfigurację (porty, klucze API, URL bazy danych) oddzielnie od kodu dla bezpieczeństwa i elastyczności."
+      },
+      "answers": [
+        {
+          "uk": "Для прискорення виконання коду",
+          "en": "For speeding up code execution",
+          "pl": "Do przyspieszania wykonywania kodu",
+          "correct": false
+        },
+        {
+          "uk": "Для зберігання конфігурації окремо від коду",
+          "en": "For storing configuration separately from code",
+          "pl": "Do przechowywania konfiguracji oddzielnie od kodu",
+          "correct": true
+        },
+        {
+          "uk": "Для логування помилок",
+          "en": "For logging errors",
+          "pl": "Do logowania błędów",
+          "correct": false
+        },
+        {
+          "uk": "Для компіляції TypeScript",
+          "en": "For compiling TypeScript",
+          "pl": "Do kompilowania TypeScript",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q28",
+      "order": 28,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Який пакет найчастіше використовують для завантаження .env файлів у Node.js?",
+        "exp": "dotenv — це популярний пакет, який завантажує змінні середовища з .env файлу в process.env."
+      },
+      "en": {
+        "q": "Which package is most commonly used for loading .env files in Node.js?",
+        "exp": "dotenv is a popular package that loads environment variables from a .env file into process.env."
+      },
+      "pl": {
+        "q": "Który pakiet jest najczęściej używany do ładowania plików .env w Node.js?",
+        "exp": "dotenv to popularny pakiet, który ładuje zmienne środowiskowe z pliku .env do process.env."
+      },
+      "answers": [
+        {
+          "uk": "config",
+          "en": "config",
+          "pl": "config",
+          "correct": false
+        },
+        {
+          "uk": "dotenv",
+          "en": "dotenv",
+          "pl": "dotenv",
+          "correct": true
+        },
+        {
+          "uk": "env-loader",
+          "en": "env-loader",
+          "pl": "env-loader",
+          "correct": false
+        },
+        {
+          "uk": "process-env",
+          "en": "process-env",
+          "pl": "process-env",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q29",
+      "order": 29,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке JWT і як він використовується для аутентифікації?",
+        "exp": "JWT (JSON Web Token) — це токен, що зберігає інформацію про користувача і перевіряється сервером без звернення до бази даних."
+      },
+      "en": {
+        "q": "What is JWT and how is it used for authentication?",
+        "exp": "JWT (JSON Web Token) is a token that stores user information and is verified by the server without database queries."
+      },
+      "pl": {
+        "q": "Czym jest JWT i jak jest używany do uwierzytelniania?",
+        "exp": "JWT (JSON Web Token) to token przechowujący informacje o użytkowniku i weryfikowany przez serwer bez zapytań do bazy danych."
+      },
+      "answers": [
+        {
+          "uk": "Протокол для шифрування паролів",
+          "en": "A protocol for encrypting passwords",
+          "pl": "Protokół do szyfrowania haseł",
+          "correct": false
+        },
+        {
+          "uk": "Токен з інформацією про користувача, що перевіряється без БД",
+          "en": "A token with user info that is verified without DB",
+          "pl": "Token z informacjami o użytkowniku weryfikowany bez BD",
+          "correct": true
+        },
+        {
+          "uk": "Бібліотека для хешування даних",
+          "en": "A library for hashing data",
+          "pl": "Biblioteka do hashowania danych",
+          "correct": false
+        },
+        {
+          "uk": "Менеджер сесій у Express.js",
+          "en": "A session manager in Express.js",
+          "pl": "Menedżer sesji w Express.js",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q30",
+      "order": 30,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке EventEmitter у Node.js?",
+        "exp": "EventEmitter — це клас з модуля events, який дозволяє створювати власні події та підписників (listeners) для реалізації подієвої моделі."
+      },
+      "en": {
+        "q": "What is EventEmitter in Node.js?",
+        "exp": "EventEmitter is a class from the events module that allows creating custom events and listeners for implementing the event model."
+      },
+      "pl": {
+        "q": "Czym jest EventEmitter w Node.js?",
+        "exp": "EventEmitter to klasa z modułu events, która pozwala tworzyć własne zdarzenia i listenerów do implementacji modelu zdarzeń."
+      },
+      "answers": [
+        {
+          "uk": "Модуль для відправки email",
+          "en": "A module for sending emails",
+          "pl": "Moduł do wysyłania emaili",
+          "correct": false
+        },
+        {
+          "uk": "Клас для створення власних подій та підписників",
+          "en": "A class for creating custom events and listeners",
+          "pl": "Klasa do tworzenia własnych zdarzeń i listenerów",
+          "correct": true
+        },
+        {
+          "uk": "Функція для запуску таймерів",
+          "en": "A function for starting timers",
+          "pl": "Funkcja do uruchamiania timerów",
+          "correct": false
+        },
+        {
+          "uk": "Інструмент для логування подій у файл",
+          "en": "A tool for logging events to a file",
+          "pl": "Narzędzie do logowania zdarzeń do pliku",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/node/beginner_medium/nodejs-quiz-part4.json b/json/quizzes/node/beginner_medium/nodejs-quiz-part4.json
new file mode 100644
index 00000000..fa512845
--- /dev/null
+++ b/json/quizzes/node/beginner_medium/nodejs-quiz-part4.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "node-q31",
+      "order": 31,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Який тестовий фреймворк найчастіше використовується у Node.js проєктах?",
+        "exp": "Jest — це all-in-one фреймворк від Facebook з вбудованими асертами, мокінгом та coverage, що робить його популярним вибором."
+      },
+      "en": {
+        "q": "Which testing framework is most commonly used in Node.js projects?",
+        "exp": "Jest is an all-in-one framework from Facebook with built-in assertions, mocking, and coverage, making it a popular choice."
+      },
+      "pl": {
+        "q": "Który framework testowy jest najczęściej używany w projektach Node.js?",
+        "exp": "Jest to framework all-in-one od Facebooka z wbudowanymi asercjami, mockingiem i coverage, co czyni go popularnym wyborem."
+      },
+      "answers": [
+        {
+          "uk": "Webpack",
+          "en": "Webpack",
+          "pl": "Webpack",
+          "correct": false
+        },
+        {
+          "uk": "Jest",
+          "en": "Jest",
+          "pl": "Jest",
+          "correct": true
+        },
+        {
+          "uk": "Babel",
+          "en": "Babel",
+          "pl": "Babel",
+          "correct": false
+        },
+        {
+          "uk": "ESLint",
+          "en": "ESLint",
+          "pl": "ESLint",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q32",
+      "order": 32,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке mocking у контексті тестування Node.js?",
+        "exp": "Mocking — це техніка імітації залежностей (БД, API) для ізольованого тестування модулів без реальних зовнішніх сервісів."
+      },
+      "en": {
+        "q": "What is mocking in the context of Node.js testing?",
+        "exp": "Mocking is a technique for simulating dependencies (DB, API) to test modules in isolation without real external services."
+      },
+      "pl": {
+        "q": "Czym jest mocking w kontekście testowania Node.js?",
+        "exp": "Mocking to technika symulowania zależności (BD, API) do izolowanego testowania modułów bez rzeczywistych usług zewnętrznych."
+      },
+      "answers": [
+        {
+          "uk": "Техніка прискорення виконання тестів",
+          "en": "A technique for speeding up test execution",
+          "pl": "Technika przyspieszania wykonywania testów",
+          "correct": false
+        },
+        {
+          "uk": "Імітація залежностей для ізольованого тестування модулів",
+          "en": "Simulating dependencies for isolated module testing",
+          "pl": "Symulowanie zależności do izolowanego testowania modułów",
+          "correct": true
+        },
+        {
+          "uk": "Генерація випадкових тестових даних",
+          "en": "Generating random test data",
+          "pl": "Generowanie losowych danych testowych",
+          "correct": false
+        },
+        {
+          "uk": "Автоматичне виправлення помилок у коді",
+          "en": "Automatic code error fixing",
+          "pl": "Automatyczne poprawianie błędów w kodzie",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q33",
+      "order": 33,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке PM2 і для чого він використовується?",
+        "exp": "PM2 — це менеджер процесів для Node.js у продакшн. Забезпечує автоматичний рестарт, кластеризацію, моніторинг та логування."
+      },
+      "en": {
+        "q": "What is PM2 and what is it used for?",
+        "exp": "PM2 is a process manager for Node.js in production. It provides auto-restart, clustering, monitoring, and logging."
+      },
+      "pl": {
+        "q": "Czym jest PM2 i do czego jest używany?",
+        "exp": "PM2 to menedżer procesów dla Node.js na produkcji. Zapewnia auto-restart, klasteryzację, monitoring i logowanie."
+      },
+      "answers": [
+        {
+          "uk": "Пакетний менеджер для Node.js",
+          "en": "A package manager for Node.js",
+          "pl": "Menedżer pakietów dla Node.js",
+          "correct": false
+        },
+        {
+          "uk": "Менеджер процесів з авто-рестартом, кластеризацією та моніторингом",
+          "en": "A process manager with auto-restart, clustering, and monitoring",
+          "pl": "Menedżer procesów z auto-restartem, klasteryzacją i monitoringiem",
+          "correct": true
+        },
+        {
+          "uk": "Інструмент для мінімізації JavaScript",
+          "en": "A tool for minifying JavaScript",
+          "pl": "Narzędzie do minifikacji JavaScript",
+          "correct": false
+        },
+        {
+          "uk": "Фреймворк для створення API",
+          "en": "A framework for building APIs",
+          "pl": "Framework do tworzenia API",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q34",
+      "order": 34,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як кластеризація допомагає масштабувати Node.js застосунок?",
+        "exp": "Модуль cluster створює кілька воркер-процесів, що використовують усі ядра CPU, розподіляючи навантаження між ними."
+      },
+      "en": {
+        "q": "How does clustering help scale a Node.js application?",
+        "exp": "The cluster module creates multiple worker processes that utilize all CPU cores, distributing the load among them."
+      },
+      "pl": {
+        "q": "Jak klasteryzacja pomaga skalować aplikację Node.js?",
+        "exp": "Moduł cluster tworzy wiele procesów workerów wykorzystujących wszystkie rdzenie CPU, rozdzielając obciążenie między nimi."
+      },
+      "answers": [
+        {
+          "uk": "Стискає JavaScript-код для швидшого завантаження",
+          "en": "Compresses JavaScript code for faster loading",
+          "pl": "Kompresuje kod JavaScript dla szybszego ładowania",
+          "correct": false
+        },
+        {
+          "uk": "Створює воркер-процеси для використання всіх ядер CPU",
+          "en": "Creates worker processes to utilize all CPU cores",
+          "pl": "Tworzy procesy workerów do wykorzystania wszystkich rdzeni CPU",
+          "correct": true
+        },
+        {
+          "uk": "Кешує відповіді сервера автоматично",
+          "en": "Automatically caches server responses",
+          "pl": "Automatycznie cachuje odpowiedzi serwera",
+          "correct": false
+        },
+        {
+          "uk": "Об'єднує кілька серверів в один",
+          "en": "Combines multiple servers into one",
+          "pl": "Łączy wiele serwerów w jeden",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q35",
+      "order": 35,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке WebSocket і чим він відрізняється від HTTP?",
+        "exp": "WebSocket — це протокол для постійного двонаправленого з'єднання між клієнтом і сервером, на відміну від HTTP з окремими запитами."
+      },
+      "en": {
+        "q": "What is WebSocket and how does it differ from HTTP?",
+        "exp": "WebSocket is a protocol for persistent bidirectional connection between client and server, unlike HTTP with separate requests."
+      },
+      "pl": {
+        "q": "Czym jest WebSocket i czym różni się od HTTP?",
+        "exp": "WebSocket to protokół dla trwałego dwukierunkowego połączenia między klientem a serwerem, w przeciwieństwie do HTTP z osobnymi żądaniami."
+      },
+      "answers": [
+        {
+          "uk": "WebSocket працює тільки на localhost",
+          "en": "WebSocket only works on localhost",
+          "pl": "WebSocket działa tylko na localhost",
+          "correct": false
+        },
+        {
+          "uk": "Протокол для постійного двонаправленого з'єднання",
+          "en": "A protocol for persistent bidirectional connection",
+          "pl": "Protokół dla trwałego dwukierunkowego połączenia",
+          "correct": true
+        },
+        {
+          "uk": "Спосіб стиснення HTTP-відповідей",
+          "en": "A way to compress HTTP responses",
+          "pl": "Sposób kompresji odpowiedzi HTTP",
+          "correct": false
+        },
+        {
+          "uk": "Альтернативний порт для HTTP-запитів",
+          "en": "An alternative port for HTTP requests",
+          "pl": "Alternatywny port dla żądań HTTP",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q36",
+      "order": 36,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка основна перевага контейнеризації (Docker) для Node.js застосунків?",
+        "exp": "Docker забезпечує ізоляцію середовища та однакову роботу застосунку на dev, staging і production, спрощуючи деплой."
+      },
+      "en": {
+        "q": "What is the main advantage of containerization (Docker) for Node.js apps?",
+        "exp": "Docker provides environment isolation and consistent app behavior across dev, staging, and production, simplifying deployment."
+      },
+      "pl": {
+        "q": "Jaka jest główna zaleta konteneryzacji (Docker) dla aplikacji Node.js?",
+        "exp": "Docker zapewnia izolację środowiska i spójne działanie aplikacji na dev, staging i produkcji, upraszczając deployment."
+      },
+      "answers": [
+        {
+          "uk": "Прискорює виконання JavaScript-коду",
+          "en": "Speeds up JavaScript code execution",
+          "pl": "Przyspiesza wykonywanie kodu JavaScript",
+          "correct": false
+        },
+        {
+          "uk": "Ізоляція середовища та однакова робота на всіх оточеннях",
+          "en": "Environment isolation and consistent behavior across all environments",
+          "pl": "Izolacja środowiska i spójne działanie we wszystkich środowiskach",
+          "correct": true
+        },
+        {
+          "uk": "Автоматичне тестування коду",
+          "en": "Automatic code testing",
+          "pl": "Automatyczne testowanie kodu",
+          "correct": false
+        },
+        {
+          "uk": "Заміна npm для управління залежностями",
+          "en": "Replacement for npm for dependency management",
+          "pl": "Zamiennik npm do zarządzania zależnościami",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q37",
+      "order": 37,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Worker Threads у Node.js?",
+        "exp": "Worker Threads дозволяють виконувати JavaScript у паралельних потоках для CPU-інтенсивних задач, не блокуючи основний потік."
+      },
+      "en": {
+        "q": "What are Worker Threads in Node.js?",
+        "exp": "Worker Threads allow executing JavaScript in parallel threads for CPU-intensive tasks without blocking the main thread."
+      },
+      "pl": {
+        "q": "Czym są Worker Threads w Node.js?",
+        "exp": "Worker Threads pozwalają wykonywać JavaScript w równoległych wątkach dla zadań intensywnych CPU bez blokowania głównego wątku."
+      },
+      "answers": [
+        {
+          "uk": "Модуль для роботи з базою даних",
+          "en": "A module for database operations",
+          "pl": "Moduł do operacji na bazie danych",
+          "correct": false
+        },
+        {
+          "uk": "Паралельні потоки для CPU-інтенсивних задач без блокування main thread",
+          "en": "Parallel threads for CPU-intensive tasks without blocking main thread",
+          "pl": "Równoległe wątki dla zadań intensywnych CPU bez blokowania main thread",
+          "correct": true
+        },
+        {
+          "uk": "Інструмент для логування у фоновому режимі",
+          "en": "A tool for background logging",
+          "pl": "Narzędzie do logowania w tle",
+          "correct": false
+        },
+        {
+          "uk": "Механізм для обробки HTTP-запитів",
+          "en": "A mechanism for handling HTTP requests",
+          "pl": "Mechanizm do obsługi żądań HTTP",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q38",
+      "order": 38,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке reverse proxy і яку роль він виконує для Node.js?",
+        "exp": "Reverse proxy (наприклад, Nginx) стоїть перед Node.js, забезпечуючи SSL-термінацію, балансування, кешування та безпеку."
+      },
+      "en": {
+        "q": "What is a reverse proxy and what role does it play for Node.js?",
+        "exp": "A reverse proxy (e.g., Nginx) sits in front of Node.js, providing SSL termination, load balancing, caching, and security."
+      },
+      "pl": {
+        "q": "Czym jest reverse proxy i jaką rolę pełni dla Node.js?",
+        "exp": "Reverse proxy (np. Nginx) stoi przed Node.js, zapewniając terminację SSL, balansowanie obciążenia, cachowanie i bezpieczeństwo."
+      },
+      "answers": [
+        {
+          "uk": "Бібліотека для шифрування даних",
+          "en": "A library for encrypting data",
+          "pl": "Biblioteka do szyfrowania danych",
+          "correct": false
+        },
+        {
+          "uk": "Посередник для SSL, балансування, кешування та безпеки",
+          "en": "An intermediary for SSL, load balancing, caching, and security",
+          "pl": "Pośrednik dla SSL, balansowania obciążenia, cachowania i bezpieczeństwa",
+          "correct": true
+        },
+        {
+          "uk": "Інструмент для тестування API",
+          "en": "A tool for API testing",
+          "pl": "Narzędzie do testowania API",
+          "correct": false
+        },
+        {
+          "uk": "Модуль Node.js для маршрутизації",
+          "en": "A Node.js module for routing",
+          "pl": "Moduł Node.js do routingu",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q39",
+      "order": 39,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке message queue і як вона використовується з Node.js?",
+        "exp": "Message queue (RabbitMQ, Kafka) — система для асинхронної обробки завдань через передачу повідомлень між сервісами."
+      },
+      "en": {
+        "q": "What is a message queue and how is it used with Node.js?",
+        "exp": "A message queue (RabbitMQ, Kafka) is a system for async task processing through message passing between services."
+      },
+      "pl": {
+        "q": "Czym jest kolejka wiadomości i jak jest używana z Node.js?",
+        "exp": "Kolejka wiadomości (RabbitMQ, Kafka) to system do asynchronicznego przetwarzania zadań przez przekazywanie wiadomości między usługami."
+      },
+      "answers": [
+        {
+          "uk": "База даних для зберігання повідомлень чату",
+          "en": "A database for storing chat messages",
+          "pl": "Baza danych do przechowywania wiadomości czatu",
+          "correct": false
+        },
+        {
+          "uk": "Система для асинхронної обробки завдань через передачу повідомлень",
+          "en": "A system for async task processing through message passing",
+          "pl": "System do asynchronicznego przetwarzania zadań przez przekazywanie wiadomości",
+          "correct": true
+        },
+        {
+          "uk": "Протокол для відправки email",
+          "en": "A protocol for sending emails",
+          "pl": "Protokół do wysyłania emaili",
+          "correct": false
+        },
+        {
+          "uk": "Метод сортування масивів у JavaScript",
+          "en": "A method for sorting arrays in JavaScript",
+          "pl": "Metoda sortowania tablic w JavaScript",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "node-q40",
+      "order": 40,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як запобігти витокам пам'яті (memory leaks) у Node.js?",
+        "exp": "Видаляти listeners, очищати таймери, обмежувати кешування, використовувати стріми для великих даних та профайлити heap."
+      },
+      "en": {
+        "q": "How to prevent memory leaks in Node.js?",
+        "exp": "Remove listeners, clear timers, limit caching, use streams for large data, and profile the heap."
+      },
+      "pl": {
+        "q": "Jak zapobiegać wyciekom pamięci w Node.js?",
+        "exp": "Usuwać listenery, czyścić timery, ograniczać cachowanie, używać strumieni dla dużych danych i profilować heap."
+      },
+      "answers": [
+        {
+          "uk": "Збільшити обсяг оперативної пам'яті сервера",
+          "en": "Increase server RAM",
+          "pl": "Zwiększyć RAM serwera",
+          "correct": false
+        },
+        {
+          "uk": "Видаляти listeners, очищати таймери, обмежувати кеш, профайлити heap",
+          "en": "Remove listeners, clear timers, limit cache, profile heap",
+          "pl": "Usuwać listenery, czyścić timery, ograniczać cache, profilować heap",
+          "correct": true
+        },
+        {
+          "uk": "Перезапускати сервер кожну годину",
+          "en": "Restart the server every hour",
+          "pl": "Restartować serwer co godzinę",
+          "correct": false
+        },
+        {
+          "uk": "Використовувати тільки синхронні методи",
+          "en": "Use only synchronous methods",
+          "pl": "Używać tylko metod synchronicznych",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/node/beginner_medium/seed-quiz-nodejs-fundamentals.ts b/json/quizzes/node/beginner_medium/seed-quiz-nodejs-fundamentals.ts
new file mode 100644
index 00000000..e155081f
--- /dev/null
+++ b/json/quizzes/node/beginner_medium/seed-quiz-nodejs-fundamentals.ts
@@ -0,0 +1,240 @@
+import { eq } from 'drizzle-orm';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { db } from './index';
+import { categories } from './schema/categories';
+import {
+  quizzes,
+  quizTranslations,
+  quizQuestions,
+  quizQuestionContent,
+  quizAnswers,
+  quizAnswerTranslations,
+  quizAttempts,
+} from './schema/quiz';
+
+type Locale = 'uk' | 'en' | 'pl';
+const LOCALES: Locale[] = ['uk', 'en', 'pl'];
+
+interface QuestionData {
+  id: string;
+  order: number;
+  difficulty: 'beginner' | 'medium' | 'advanced';
+  uk: { q: string; exp: string };
+  en: { q: string; exp: string };
+  pl: { q: string; exp: string };
+  answers: {
+    uk: string;
+    en: string;
+    pl: string;
+    correct: boolean;
+  }[];
+}
+
+interface QuizPartData {
+  questions: QuestionData[];
+}
+
+const CATEGORY_SLUG = 'nodejs';
+
+const QUIZ_METADATA = {
+  slug: 'nodejs-fundamentals',
+  questionsCount: 40,
+  timeLimitSeconds: 1800,
+  translations: {
+    uk: {
+      title: 'Основи Node.js',
+      description: 'Перевірте свої знання базових концепцій Node.js: event loop, модулі, асинхронність, Express.js, тестування та деплой.',
+    },
+    en: {
+      title: 'Node.js Fundamentals',
+      description: 'Test your knowledge of Node.js basics: event loop, modules, asynchronicity, Express.js, testing, and deployment.',
+    },
+    pl: {
+      title: 'Podstawy Node.js',
+      description: 'Sprawdź swoją wiedzę o podstawach Node.js: event loop, moduły, asynchroniczność, Express.js, testowanie i deployment.',
+    },
+  },
+};
+
+function createExplanation(text: string) {
+  return [{ type: 'paragraph' as const, children: [{ text }] }];
+}
+
+async function loadQuestions(partNumber: number): Promise<QuestionData[]> {
+  const partPath = join(process.cwd(), 'data', `nodejs-quiz-part${partNumber}.json`);
+  const partData: QuizPartData = JSON.parse(readFileSync(partPath, 'utf-8'));
+  return partData.questions;
+}
+
+async function ensureQuizExists(): Promise<string> {
+  console.log('Ensuring quiz exists...');
+
+  // Find category by slug
+  const [category] = await db
+    .select()
+    .from(categories)
+    .where(eq(categories.slug, CATEGORY_SLUG))
+    .limit(1);
+
+  if (!category) {
+    throw new Error(`Category "${CATEGORY_SLUG}" not found. Run seed:categories first.`);
+  }
+
+  // Clean up old quiz by slug
+  const existing = await db.query.quizzes.findFirst({
+    where: eq(quizzes.slug, QUIZ_METADATA.slug),
+  });
+  if (existing) {
+    const existingAttempt = await db.query.quizAttempts.findFirst({
+      where: eq(quizAttempts.quizId, existing.id),
+    });
+    if (existingAttempt) {
+      throw new Error(`Quiz ${QUIZ_METADATA.slug} has existing attempts. Aborting to avoid data loss.`);
+    }
+
+    await db.delete(quizQuestions).where(eq(quizQuestions.quizId, existing.id));
+    await db.delete(quizTranslations).where(eq(quizTranslations.quizId, existing.id));
+    await db.update(quizzes).set({
+      categoryId: category.id,
+      slug: QUIZ_METADATA.slug,
+      displayOrder: 1,
+      questionsCount: QUIZ_METADATA.questionsCount,
+      timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+      isActive: true,
+    }).where(eq(quizzes.id, existing.id));
+
+    const quizId = existing.id;
+    for (const locale of LOCALES) {
+      await db.insert(quizTranslations).values({
+        quizId,
+        locale,
+        title: QUIZ_METADATA.translations[locale].title,
+        description: QUIZ_METADATA.translations[locale].description,
+      });
+    }
+
+    return quizId;
+  }
+
+  const [quiz] = await db.insert(quizzes).values({
+    categoryId: category.id,
+    slug: QUIZ_METADATA.slug,
+    displayOrder: 1,
+    questionsCount: QUIZ_METADATA.questionsCount,
+    timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+    isActive: true,
+  }).returning();
+
+  for (const locale of LOCALES) {
+    await db.insert(quizTranslations).values({
+      quizId: quiz.id,
+      locale,
+      title: QUIZ_METADATA.translations[locale].title,
+      description: QUIZ_METADATA.translations[locale].description,
+    });
+  }
+
+  return quiz.id;
+}
+
+async function seedQuestions(questions: QuestionData[], quizId: string, partNumber: number) {
+  console.log(`Seeding ${questions.length} questions from part ${partNumber}...`);
+
+  for (const question of questions) {
+    const [q] = await db.insert(quizQuestions).values({
+      quizId,
+      displayOrder: question.order,
+      difficulty: question.difficulty,
+    }).returning();
+
+    for (const locale of LOCALES) {
+      await db.insert(quizQuestionContent).values({
+        quizQuestionId: q.id,
+        locale,
+        questionText: question[locale].q,
+        explanation: createExplanation(question[locale].exp),
+      });
+    }
+
+    for (let i = 0; i < question.answers.length; i++) {
+      const answer = question.answers[i];
+      
+      const [a] = await db.insert(quizAnswers).values({
+        quizQuestionId: q.id,
+        displayOrder: i + 1,
+        isCorrect: answer.correct,
+      }).returning();
+
+      for (const locale of LOCALES) {
+        await db.insert(quizAnswerTranslations).values({
+          quizAnswerId: a.id,
+          locale,
+          answerText: answer[locale],
+        });
+      }
+    }
+  }
+
+  console.log(`Part ${partNumber} completed (${questions.length} questions)`);
+}
+
+async function seedQuizFromJson() {
+  const args = process.argv.slice(2);
+  const partArg = args[0];
+
+  if (!partArg) {
+    console.error('Error: Please specify which part to upload');
+    console.log('Usage: npx tsx db/seeds/seed-quiz-nodejs-fundamentals.ts <part-number>');
+    console.log('Example: npx tsx db/seeds/seed-quiz-nodejs-fundamentals.ts 1');
+    console.log('Or upload all: npx tsx db/seeds/seed-quiz-nodejs-fundamentals.ts all');
+    process.exit(1);
+  }
+
+  console.log('Starting Node.js Fundamentals quiz seed...\n');
+
+  try {
+    const quizId = await ensureQuizExists();
+
+    if (partArg.toLowerCase() === 'all') {
+      console.log('Uploading all parts...\n');
+      let totalQuestions = 0;
+
+      for (let i = 1; i <= 4; i++) {
+        const questions = await loadQuestions(i);
+        await seedQuestions(questions, quizId, i);
+        totalQuestions += questions.length;
+      }
+
+      console.log('\nAll parts seeded successfully!');
+      console.log(`   - 1 quiz with ${LOCALES.length} translations`);
+      console.log(`   - ${totalQuestions} questions total`);
+      console.log(`   - ${totalQuestions * 4} answers with ${LOCALES.length} translations each`);
+    } else {
+      const partNumber = parseInt(partArg, 10);
+
+      if (isNaN(partNumber) || partNumber < 1 || partNumber > 4) {
+        console.error('Error: Part number must be between 1 and 4');
+        process.exit(1);
+      }
+
+      const questions = await loadQuestions(partNumber);
+      await seedQuestions(questions, quizId, partNumber);
+
+      console.log('\nPart seeded successfully!');
+      console.log(`   - Quiz: ${QUIZ_METADATA.translations.en.title}`);
+      console.log(`   - Part ${partNumber}: ${questions.length} questions`);
+      console.log(`   - ${questions.length * 4} answers with ${LOCALES.length} translations each`);
+    }
+  } catch (error) {
+    console.error('\nError seeding quiz:', error);
+    throw error;
+  }
+}
+
+seedQuizFromJson()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/json/quizzes/vue/beginner_medium/seed-quiz-vue.ts b/json/quizzes/vue/beginner_medium/seed-quiz-vue.ts
new file mode 100644
index 00000000..0758e189
--- /dev/null
+++ b/json/quizzes/vue/beginner_medium/seed-quiz-vue.ts
@@ -0,0 +1,239 @@
+import { eq } from 'drizzle-orm';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { db } from './index';
+import { categories } from './schema/categories';
+import {
+  quizzes,
+  quizTranslations,
+  quizQuestions,
+  quizQuestionContent,
+  quizAnswers,
+  quizAnswerTranslations,
+  quizAttempts,
+} from './schema/quiz';
+
+type Locale = 'uk' | 'en' | 'pl';
+const LOCALES: Locale[] = ['uk', 'en', 'pl'];
+
+interface QuestionData {
+  id: string;
+  order: number;
+  difficulty: 'beginner' | 'medium' | 'advanced';
+  uk: { q: string; exp: string };
+  en: { q: string; exp: string };
+  pl: { q: string; exp: string };
+  answers: {
+    uk: string;
+    en: string;
+    pl: string;
+    correct: boolean;
+  }[];
+}
+
+interface QuizPartData {
+  questions: QuestionData[];
+}
+
+const CATEGORY_SLUG = 'vue';
+
+const QUIZ_METADATA = {
+  slug: 'vue-fundamentals',
+  questionsCount: 40,
+  timeLimitSeconds: 1800,
+  translations: {
+    uk: {
+      title: 'Основи Vue.js',
+      description: 'Перевірте свої знання базових концепцій Vue.js: компоненти, реактивність, директиви, Composition API, Vue Router, Pinia та життєвий цикл.',
+    },
+    en: {
+      title: 'Vue.js Fundamentals',
+      description: 'Test your knowledge of Vue.js basics: components, reactivity, directives, Composition API, Vue Router, Pinia, and lifecycle.',
+    },
+    pl: {
+      title: 'Podstawy Vue.js',
+      description: 'Sprawdź swoją wiedzę o podstawach Vue.js: komponenty, reaktywność, dyrektywy, Composition API, Vue Router, Pinia i cykl życia.',
+    },
+  },
+};
+
+function createExplanation(text: string) {
+  return [{ type: 'paragraph' as const, children: [{ text }] }];
+}
+
+async function loadQuestions(partNumber: number): Promise<QuestionData[]> {
+  const partPath = join(process.cwd(), 'data', `vue-quiz-part${partNumber}.json`);
+  const partData: QuizPartData = JSON.parse(readFileSync(partPath, 'utf-8'));
+  return partData.questions;
+}
+
+async function ensureQuizExists(): Promise<string> {
+  console.log('Ensuring quiz exists...');
+
+  const [category] = await db
+    .select()
+    .from(categories)
+    .where(eq(categories.slug, CATEGORY_SLUG))
+    .limit(1);
+
+  if (!category) {
+    throw new Error(`Category "${CATEGORY_SLUG}" not found. Run seed:categories first.`);
+  }
+
+  const existing = await db.query.quizzes.findFirst({
+    where: eq(quizzes.slug, QUIZ_METADATA.slug),
+  });
+
+  if (existing) {
+    const existingAttempt = await db.query.quizAttempts.findFirst({
+      where: eq(quizAttempts.quizId, existing.id),
+    });
+    if (existingAttempt) {
+      throw new Error(`Quiz ${QUIZ_METADATA.slug} has existing attempts. Aborting to avoid data loss.`);
+    }
+
+    await db.delete(quizQuestions).where(eq(quizQuestions.quizId, existing.id));
+    await db.delete(quizTranslations).where(eq(quizTranslations.quizId, existing.id));
+    await db.update(quizzes).set({
+      categoryId: category.id,
+      slug: QUIZ_METADATA.slug,
+      displayOrder: 1,
+      questionsCount: QUIZ_METADATA.questionsCount,
+      timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+      isActive: true,
+    }).where(eq(quizzes.id, existing.id));
+
+    const quizId = existing.id;
+    for (const locale of LOCALES) {
+      await db.insert(quizTranslations).values({
+        quizId,
+        locale,
+        title: QUIZ_METADATA.translations[locale].title,
+        description: QUIZ_METADATA.translations[locale].description,
+      });
+    }
+
+    return quizId;
+  }
+
+  const [quiz] = await db.insert(quizzes).values({
+    categoryId: category.id,
+    slug: QUIZ_METADATA.slug,
+    displayOrder: 1,
+    questionsCount: QUIZ_METADATA.questionsCount,
+    timeLimitSeconds: QUIZ_METADATA.timeLimitSeconds,
+    isActive: true,
+  }).returning();
+
+  for (const locale of LOCALES) {
+    await db.insert(quizTranslations).values({
+      quizId: quiz.id,
+      locale,
+      title: QUIZ_METADATA.translations[locale].title,
+      description: QUIZ_METADATA.translations[locale].description,
+    });
+  }
+
+  return quiz.id;
+}
+
+async function seedQuestions(questions: QuestionData[], quizId: string, partNumber: number) {
+  console.log(`Seeding ${questions.length} questions from part ${partNumber}...`);
+
+  for (const question of questions) {
+    const [q] = await db.insert(quizQuestions).values({
+      quizId,
+      displayOrder: question.order,
+      difficulty: question.difficulty,
+    }).returning();
+
+    for (const locale of LOCALES) {
+      await db.insert(quizQuestionContent).values({
+        quizQuestionId: q.id,
+        locale,
+        questionText: question[locale].q,
+        explanation: createExplanation(question[locale].exp),
+      });
+    }
+
+    for (let i = 0; i < question.answers.length; i++) {
+      const answer = question.answers[i];
+      
+      const [a] = await db.insert(quizAnswers).values({
+        quizQuestionId: q.id,
+        displayOrder: i + 1,
+        isCorrect: answer.correct,
+      }).returning();
+
+      for (const locale of LOCALES) {
+        await db.insert(quizAnswerTranslations).values({
+          quizAnswerId: a.id,
+          locale,
+          answerText: answer[locale],
+        });
+      }
+    }
+  }
+
+  console.log(`Part ${partNumber} completed (${questions.length} questions)`);
+}
+
+async function seedQuizFromJson() {
+  const args = process.argv.slice(2);
+  const partArg = args[0];
+
+  if (!partArg) {
+    console.error('Error: Please specify which part to upload');
+    console.log('Usage: npx tsx db/seeds/seed-quiz-vue.ts <part-number>');
+    console.log('Example: npx tsx db/seeds/seed-quiz-vue.ts 1');
+    console.log('Or upload all: npx tsx db/seeds/seed-quiz-vue.ts all');
+    process.exit(1);
+  }
+
+  console.log('Starting Vue.js quiz seed...\n');
+
+  try {
+    const quizId = await ensureQuizExists();
+
+    if (partArg.toLowerCase() === 'all') {
+      console.log('Uploading all parts...\n');
+      let totalQuestions = 0;
+
+      for (let i = 1; i <= 4; i++) {
+        const questions = await loadQuestions(i);
+        await seedQuestions(questions, quizId, i);
+        totalQuestions += questions.length;
+      }
+
+      console.log('\nAll parts seeded successfully!');
+      console.log(`   - 1 quiz with ${LOCALES.length} translations`);
+      console.log(`   - ${totalQuestions} questions total`);
+      console.log(`   - ${totalQuestions * 4} answers with ${LOCALES.length} translations each`);
+    } else {
+      const partNumber = parseInt(partArg, 10);
+
+      if (isNaN(partNumber) || partNumber < 1 || partNumber > 4) {
+        console.error('Error: Part number must be between 1 and 4');
+        process.exit(1);
+      }
+
+      const questions = await loadQuestions(partNumber);
+      await seedQuestions(questions, quizId, partNumber);
+
+      console.log('\nPart seeded successfully!');
+      console.log(`   - Quiz: ${QUIZ_METADATA.translations.en.title}`);
+      console.log(`   - Part ${partNumber}: ${questions.length} questions`);
+      console.log(`   - ${questions.length * 4} answers with ${LOCALES.length} translations each`);
+    }
+  } catch (error) {
+    console.error('\nError seeding quiz:', error);
+    throw error;
+  }
+}
+
+seedQuizFromJson()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
diff --git a/json/quizzes/vue/beginner_medium/vue-quiz-part1.json b/json/quizzes/vue/beginner_medium/vue-quiz-part1.json
new file mode 100644
index 00000000..ff54f5b8
--- /dev/null
+++ b/json/quizzes/vue/beginner_medium/vue-quiz-part1.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "vue-q01",
+      "order": 1,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Що таке Vue.js?",
+        "exp": "Vue.js — це прогресивний JavaScript-фреймворк для створення інтерфейсів користувача з реактивністю, легкою інтеграцією та потужною екосистемою."
+      },
+      "en": {
+        "q": "What is Vue.js?",
+        "exp": "Vue.js is a progressive JavaScript framework for building user interfaces with reactivity, easy integration, and a powerful ecosystem."
+      },
+      "pl": {
+        "q": "Czym jest Vue.js?",
+        "exp": "Vue.js to progresywny framework JavaScript do tworzenia interfejsów użytkownika z reaktywnością, łatwą integracją i potężnym ekosystemem."
+      },
+      "answers": [
+        {
+          "uk": "Бібліотека для роботи з базами даних",
+          "en": "A library for working with databases",
+          "pl": "Biblioteka do pracy z bazami danych",
+          "correct": false
+        },
+        {
+          "uk": "Прогресивний JavaScript-фреймворк для створення інтерфейсів користувача",
+          "en": "A progressive JavaScript framework for building user interfaces",
+          "pl": "Progresywny framework JavaScript do tworzenia interfejsów użytkownika",
+          "correct": true
+        },
+        {
+          "uk": "Серверна мова програмування",
+          "en": "A server-side programming language",
+          "pl": "Serwerowy język programowania",
+          "correct": false
+        },
+        {
+          "uk": "CSS-препроцесор для стилізації",
+          "en": "A CSS preprocessor for styling",
+          "pl": "Preprocesor CSS do stylizacji",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q02",
+      "order": 2,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Яка команда використовується для створення нового Vue.js проєкту з офіційним CLI?",
+        "exp": "Команда npm create vue@latest запускає офіційний CLI create-vue для створення нового проєкту з можливістю обрати TypeScript, Router, Pinia тощо."
+      },
+      "en": {
+        "q": "Which command is used to create a new Vue.js project with the official CLI?",
+        "exp": "The command npm create vue@latest runs the official create-vue CLI to create a new project with options for TypeScript, Router, Pinia, etc."
+      },
+      "pl": {
+        "q": "Jakiego polecenia używa się do utworzenia nowego projektu Vue.js za pomocą oficjalnego CLI?",
+        "exp": "Polecenie npm create vue@latest uruchamia oficjalne CLI create-vue do tworzenia nowego projektu z opcjami TypeScript, Router, Pinia itp."
+      },
+      "answers": [
+        {
+          "uk": "vue init app",
+          "en": "vue init app",
+          "pl": "vue init app",
+          "correct": false
+        },
+        {
+          "uk": "npm create vue@latest",
+          "en": "npm create vue@latest",
+          "pl": "npm create vue@latest",
+          "correct": true
+        },
+        {
+          "uk": "npx create-react-app",
+          "en": "npx create-react-app",
+          "pl": "npx create-react-app",
+          "correct": false
+        },
+        {
+          "uk": "npm start vue",
+          "en": "npm start vue",
+          "pl": "npm start vue",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q03",
+      "order": 3,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Який хук життєвого циклу викликається після того, як компонент вставлено в DOM?",
+        "exp": "Хук onMounted (або mounted в Options API) викликається після монтування компонента в DOM і дозволяє виконувати операції з DOM або запити до API."
+      },
+      "en": {
+        "q": "Which lifecycle hook is called after the component is inserted into the DOM?",
+        "exp": "The onMounted hook (or mounted in Options API) is called after the component is mounted to the DOM and allows DOM operations or API requests."
+      },
+      "pl": {
+        "q": "Który hook cyklu życia jest wywoływany po wstawieniu komponentu do DOM?",
+        "exp": "Hook onMounted (lub mounted w Options API) jest wywoływany po zamontowaniu komponentu w DOM i pozwala na operacje DOM lub żądania API."
+      },
+      "answers": [
+        {
+          "uk": "onBeforeMount",
+          "en": "onBeforeMount",
+          "pl": "onBeforeMount",
+          "correct": false
+        },
+        {
+          "uk": "onMounted",
+          "en": "onMounted",
+          "pl": "onMounted",
+          "correct": true
+        },
+        {
+          "uk": "onCreated",
+          "en": "onCreated",
+          "pl": "onCreated",
+          "correct": false
+        },
+        {
+          "uk": "onUpdated",
+          "en": "onUpdated",
+          "pl": "onUpdated",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q04",
+      "order": 4,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Що таке компоненти у Vue.js?",
+        "exp": "Компоненти — це повторно використовувані ізольовані блоки інтерфейсу з власною логікою, шаблоном і стилями, які можна реєструвати локально або глобально."
+      },
+      "en": {
+        "q": "What are components in Vue.js?",
+        "exp": "Components are reusable isolated UI blocks with their own logic, template, and styles that can be registered locally or globally."
+      },
+      "pl": {
+        "q": "Czym są komponenty w Vue.js?",
+        "exp": "Komponenty to wielokrotnie używane, izolowane bloki UI z własną logiką, szablonem i stylami, które można rejestrować lokalnie lub globalnie."
+      },
+      "answers": [
+        {
+          "uk": "Глобальні змінні для зберігання стану",
+          "en": "Global variables for storing state",
+          "pl": "Zmienne globalne do przechowywania stanu",
+          "correct": false
+        },
+        {
+          "uk": "Повторно використовувані ізольовані блоки інтерфейсу з логікою, шаблоном і стилями",
+          "en": "Reusable isolated UI blocks with logic, template, and styles",
+          "pl": "Wielokrotnie używane izolowane bloki UI z logiką, szablonem i stylami",
+          "correct": true
+        },
+        {
+          "uk": "Функції для обробки HTTP-запитів",
+          "en": "Functions for handling HTTP requests",
+          "pl": "Funkcje do obsługi żądań HTTP",
+          "correct": false
+        },
+        {
+          "uk": "CSS-класи для стилізації елементів",
+          "en": "CSS classes for styling elements",
+          "pl": "Klasy CSS do stylizacji elementów",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q05",
+      "order": 5,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Яка директива використовується для двосторонньої прив'язки даних у Vue.js?",
+        "exp": "Директива v-model створює двосторонню прив'язку між станом компонента та елементом форми, автоматично синхронізуючи дані."
+      },
+      "en": {
+        "q": "Which directive is used for two-way data binding in Vue.js?",
+        "exp": "The v-model directive creates two-way binding between component state and form elements, automatically synchronizing data."
+      },
+      "pl": {
+        "q": "Której dyrektywy używa się do dwukierunkowego wiązania danych w Vue.js?",
+        "exp": "Dyrektywa v-model tworzy dwukierunkowe wiązanie między stanem komponentu a elementami formularza, automatycznie synchronizując dane."
+      },
+      "answers": [
+        {
+          "uk": "v-bind",
+          "en": "v-bind",
+          "pl": "v-bind",
+          "correct": false
+        },
+        {
+          "uk": "v-on",
+          "en": "v-on",
+          "pl": "v-on",
+          "correct": false
+        },
+        {
+          "uk": "v-model",
+          "en": "v-model",
+          "pl": "v-model",
+          "correct": true
+        },
+        {
+          "uk": "v-for",
+          "en": "v-for",
+          "pl": "v-for",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q06",
+      "order": 6,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Як створюється екземпляр Vue у Vue 3?",
+        "exp": "У Vue 3 екземпляр створюється через функцію createApp(), яка є коренем застосунку і керує реактивними даними, методами та рендерингом."
+      },
+      "en": {
+        "q": "How is a Vue instance created in Vue 3?",
+        "exp": "In Vue 3, an instance is created using the createApp() function, which is the root of the application and manages reactive data, methods, and rendering."
+      },
+      "pl": {
+        "q": "Jak tworzy się instancję Vue w Vue 3?",
+        "exp": "W Vue 3 instancję tworzy się za pomocą funkcji createApp(), która jest korzeniem aplikacji i zarządza reaktywnymi danymi, metodami i renderowaniem."
+      },
+      "answers": [
+        {
+          "uk": "new Vue()",
+          "en": "new Vue()",
+          "pl": "new Vue()",
+          "correct": false
+        },
+        {
+          "uk": "createApp()",
+          "en": "createApp()",
+          "pl": "createApp()",
+          "correct": true
+        },
+        {
+          "uk": "Vue.init()",
+          "en": "Vue.init()",
+          "pl": "Vue.init()",
+          "correct": false
+        },
+        {
+          "uk": "initVue()",
+          "en": "initVue()",
+          "pl": "initVue()",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q07",
+      "order": 7,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке віртуальний DOM у Vue.js і навіщо він потрібен?",
+        "exp": "Віртуальний DOM — це легка копія реального DOM, яку Vue використовує для порівняння (diffing) і мінімального оновлення тільки змінених частин."
+      },
+      "en": {
+        "q": "What is the Virtual DOM in Vue.js and why is it needed?",
+        "exp": "The Virtual DOM is a lightweight copy of the real DOM that Vue uses for diffing and minimally updating only the changed parts."
+      },
+      "pl": {
+        "q": "Czym jest wirtualny DOM w Vue.js i po co jest potrzebny?",
+        "exp": "Wirtualny DOM to lekka kopia prawdziwego DOM, którą Vue używa do porównywania (diffing) i minimalnej aktualizacji tylko zmienionych części."
+      },
+      "answers": [
+        {
+          "uk": "Це база даних для зберігання стану компонентів",
+          "en": "It's a database for storing component state",
+          "pl": "To baza danych do przechowywania stanu komponentów",
+          "correct": false
+        },
+        {
+          "uk": "Це легка копія DOM для порівняння і мінімального оновлення змінених частин",
+          "en": "It's a lightweight DOM copy for diffing and minimally updating changed parts",
+          "pl": "To lekka kopia DOM do porównywania i minimalnej aktualizacji zmienionych części",
+          "correct": true
+        },
+        {
+          "uk": "Це окремий браузерний рушій",
+          "en": "It's a separate browser engine",
+          "pl": "To oddzielny silnik przeglądarki",
+          "correct": false
+        },
+        {
+          "uk": "Це CSS-фреймворк для стилізації",
+          "en": "It's a CSS framework for styling",
+          "pl": "To framework CSS do stylizacji",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q08",
+      "order": 8,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Яка директива використовується для умовного рендерингу в Vue.js?",
+        "exp": "Директива v-if додає або видаляє елемент з DOM залежно від умови. Також існують v-else-if та v-else для складніших умов."
+      },
+      "en": {
+        "q": "Which directive is used for conditional rendering in Vue.js?",
+        "exp": "The v-if directive adds or removes an element from the DOM based on a condition. There are also v-else-if and v-else for more complex conditions."
+      },
+      "pl": {
+        "q": "Której dyrektywy używa się do warunkowego renderowania w Vue.js?",
+        "exp": "Dyrektywa v-if dodaje lub usuwa element z DOM na podstawie warunku. Istnieją również v-else-if i v-else dla bardziej złożonych warunków."
+      },
+      "answers": [
+        {
+          "uk": "v-show",
+          "en": "v-show",
+          "pl": "v-show",
+          "correct": false
+        },
+        {
+          "uk": "v-if",
+          "en": "v-if",
+          "pl": "v-if",
+          "correct": true
+        },
+        {
+          "uk": "v-for",
+          "en": "v-for",
+          "pl": "v-for",
+          "correct": false
+        },
+        {
+          "uk": "v-render",
+          "en": "v-render",
+          "pl": "v-render",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q09",
+      "order": 9,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Як прив'язати обробник кліку до кнопки у Vue.js?",
+        "exp": "Директива v-on:click або скорочено @click прив'язує обробник події до елемента. Наприклад: @click=\"handleClick\"."
+      },
+      "en": {
+        "q": "How do you bind a click handler to a button in Vue.js?",
+        "exp": "The v-on:click directive or shorthand @click binds an event handler to an element. For example: @click=\"handleClick\"."
+      },
+      "pl": {
+        "q": "Jak powiązać handler kliknięcia z przyciskiem w Vue.js?",
+        "exp": "Dyrektywa v-on:click lub skrót @click wiąże handler zdarzenia z elementem. Na przykład: @click=\"handleClick\"."
+      },
+      "answers": [
+        {
+          "uk": "onclick=\"handleClick\"",
+          "en": "onclick=\"handleClick\"",
+          "pl": "onclick=\"handleClick\"",
+          "correct": false
+        },
+        {
+          "uk": "@click=\"handleClick\" або v-on:click=\"handleClick\"",
+          "en": "@click=\"handleClick\" or v-on:click=\"handleClick\"",
+          "pl": "@click=\"handleClick\" lub v-on:click=\"handleClick\"",
+          "correct": true
+        },
+        {
+          "uk": "v-bind:click=\"handleClick\"",
+          "en": "v-bind:click=\"handleClick\"",
+          "pl": "v-bind:click=\"handleClick\"",
+          "correct": false
+        },
+        {
+          "uk": ":click=\"handleClick\"",
+          "en": ":click=\"handleClick\"",
+          "pl": ":click=\"handleClick\"",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q10",
+      "order": 10,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Де визначаються функції для обробки подій у Options API?",
+        "exp": "У Options API функції визначаються в об'єкті methods компонента. Вони мають доступ до this для взаємодії зі станом."
+      },
+      "en": {
+        "q": "Where are event handling functions defined in the Options API?",
+        "exp": "In the Options API, functions are defined in the methods object of the component. They have access to this for interacting with state."
+      },
+      "pl": {
+        "q": "Gdzie definiuje się funkcje obsługi zdarzeń w Options API?",
+        "exp": "W Options API funkcje definiuje się w obiekcie methods komponentu. Mają dostęp do this do interakcji ze stanem."
+      },
+      "answers": [
+        {
+          "uk": "В об'єкті data",
+          "en": "In the data object",
+          "pl": "W obiekcie data",
+          "correct": false
+        },
+        {
+          "uk": "В об'єкті methods",
+          "en": "In the methods object",
+          "pl": "W obiekcie methods",
+          "correct": true
+        },
+        {
+          "uk": "В об'єкті computed",
+          "en": "In the computed object",
+          "pl": "W obiekcie computed",
+          "correct": false
+        },
+        {
+          "uk": "В об'єкті watch",
+          "en": "In the watch object",
+          "pl": "W obiekcie watch",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/vue/beginner_medium/vue-quiz-part2.json b/json/quizzes/vue/beginner_medium/vue-quiz-part2.json
new file mode 100644
index 00000000..621228ba
--- /dev/null
+++ b/json/quizzes/vue/beginner_medium/vue-quiz-part2.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "vue-q11",
+      "order": 11,
+      "difficulty": "medium",
+      "uk": {
+        "q": "У чому різниця між v-bind і v-model у Vue.js?",
+        "exp": "v-bind — одностороння прив'язка даних до атрибутів чи пропсів, v-model — двостороння прив'язка, яка синхронізує дані між станом і елементом форми."
+      },
+      "en": {
+        "q": "What is the difference between v-bind and v-model in Vue.js?",
+        "exp": "v-bind is one-way binding of data to attributes or props, v-model is two-way binding that synchronizes data between state and form elements."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między v-bind a v-model w Vue.js?",
+        "exp": "v-bind to jednokierunkowe wiązanie danych z atrybutami lub propsami, v-model to dwukierunkowe wiązanie synchronizujące dane między stanem a elementami formularza."
+      },
+      "answers": [
+        {
+          "uk": "v-bind працює тільки з компонентами, v-model — тільки з HTML",
+          "en": "v-bind only works with components, v-model only with HTML",
+          "pl": "v-bind działa tylko z komponentami, v-model tylko z HTML",
+          "correct": false
+        },
+        {
+          "uk": "v-bind — одностороння прив'язка, v-model — двостороння прив'язка",
+          "en": "v-bind is one-way binding, v-model is two-way binding",
+          "pl": "v-bind to wiązanie jednokierunkowe, v-model to wiązanie dwukierunkowe",
+          "correct": true
+        },
+        {
+          "uk": "Це синоніми з однаковою функціональністю",
+          "en": "They are synonyms with the same functionality",
+          "pl": "To synonimy o tej samej funkcjonalności",
+          "correct": false
+        },
+        {
+          "uk": "v-model швидший за v-bind",
+          "en": "v-model is faster than v-bind",
+          "pl": "v-model jest szybszy niż v-bind",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q12",
+      "order": 12,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке computed властивості у Vue.js?",
+        "exp": "Computed — це властивості, які обчислюються на основі реактивних даних і кешуються, доки їхні залежності не зміняться."
+      },
+      "en": {
+        "q": "What are computed properties in Vue.js?",
+        "exp": "Computed properties are calculated based on reactive data and cached until their dependencies change."
+      },
+      "pl": {
+        "q": "Czym są właściwości computed w Vue.js?",
+        "exp": "Właściwości computed są obliczane na podstawie reaktywnych danych i cachowane, dopóki ich zależności się nie zmienią."
+      },
+      "answers": [
+        {
+          "uk": "Функції, які виконуються при кожному рендері",
+          "en": "Functions that execute on every render",
+          "pl": "Funkcje wykonywane przy każdym renderze",
+          "correct": false
+        },
+        {
+          "uk": "Властивості, що обчислюються на основі реактивних даних і кешуються",
+          "en": "Properties calculated based on reactive data and cached",
+          "pl": "Właściwości obliczane na podstawie reaktywnych danych i cachowane",
+          "correct": true
+        },
+        {
+          "uk": "Статичні константи компонента",
+          "en": "Static component constants",
+          "pl": "Statyczne stałe komponentu",
+          "correct": false
+        },
+        {
+          "uk": "Методи для асинхронних операцій",
+          "en": "Methods for asynchronous operations",
+          "pl": "Metody do operacji asynchronicznych",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q13",
+      "order": 13,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка основна відмінність між computed і methods у Vue.js?",
+        "exp": "Computed кешуються і перевираховуються тільки при зміні залежностей, methods виконуються щоразу при виклику."
+      },
+      "en": {
+        "q": "What is the main difference between computed and methods in Vue.js?",
+        "exp": "Computed properties are cached and recalculated only when dependencies change, methods execute every time they are called."
+      },
+      "pl": {
+        "q": "Jaka jest główna różnica między computed a methods w Vue.js?",
+        "exp": "Właściwości computed są cachowane i przeliczane tylko przy zmianie zależności, methods wykonują się za każdym wywołaniem."
+      },
+      "answers": [
+        {
+          "uk": "computed можуть приймати аргументи, methods — ні",
+          "en": "computed can accept arguments, methods cannot",
+          "pl": "computed mogą przyjmować argumenty, methods nie",
+          "correct": false
+        },
+        {
+          "uk": "computed кешуються і перевираховуються при зміні залежностей, methods виконуються щоразу",
+          "en": "computed are cached and recalculate on dependency change, methods execute every time",
+          "pl": "computed są cachowane i przeliczane przy zmianie zależności, methods wykonują się za każdym razem",
+          "correct": true
+        },
+        {
+          "uk": "methods швидші за computed",
+          "en": "methods are faster than computed",
+          "pl": "methods są szybsze niż computed",
+          "correct": false
+        },
+        {
+          "uk": "Різниці немає",
+          "en": "There is no difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q14",
+      "order": 14,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Для чого використовуються watchers (спостерігачі) у Vue.js?",
+        "exp": "Watch використовується для відстеження змін у реактивних даних і виконання побічних ефектів, як-от API-запити або збереження у localStorage."
+      },
+      "en": {
+        "q": "What are watchers used for in Vue.js?",
+        "exp": "Watch is used to track changes in reactive data and perform side effects like API requests or saving to localStorage."
+      },
+      "pl": {
+        "q": "Do czego służą watchery (obserwatorzy) w Vue.js?",
+        "exp": "Watch służy do śledzenia zmian w reaktywnych danych i wykonywania efektów ubocznych, jak żądania API czy zapis do localStorage."
+      },
+      "answers": [
+        {
+          "uk": "Для кешування обчислених значень",
+          "en": "For caching computed values",
+          "pl": "Do cachowania obliczonych wartości",
+          "correct": false
+        },
+        {
+          "uk": "Для відстеження змін у даних і виконання побічних ефектів",
+          "en": "For tracking data changes and performing side effects",
+          "pl": "Do śledzenia zmian w danych i wykonywania efektów ubocznych",
+          "correct": true
+        },
+        {
+          "uk": "Для реєстрації глобальних компонентів",
+          "en": "For registering global components",
+          "pl": "Do rejestracji globalnych komponentów",
+          "correct": false
+        },
+        {
+          "uk": "Для стилізації компонентів",
+          "en": "For styling components",
+          "pl": "Do stylizacji komponentów",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q15",
+      "order": 15,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Як передати дані від батьківського компонента до дочірнього у Vue.js?",
+        "exp": "Дані передаються через props — властивості, які оголошуються у дочірньому компоненті і передаються як атрибути з батьківського."
+      },
+      "en": {
+        "q": "How do you pass data from a parent component to a child in Vue.js?",
+        "exp": "Data is passed through props — properties declared in the child component and passed as attributes from the parent."
+      },
+      "pl": {
+        "q": "Jak przekazać dane z komponentu nadrzędnego do potomnego w Vue.js?",
+        "exp": "Dane przekazuje się przez props — właściwości deklarowane w komponencie potomnym i przekazywane jako atrybuty z nadrzędnego."
+      },
+      "answers": [
+        {
+          "uk": "Через глобальні змінні",
+          "en": "Through global variables",
+          "pl": "Przez zmienne globalne",
+          "correct": false
+        },
+        {
+          "uk": "Через props",
+          "en": "Through props",
+          "pl": "Przez props",
+          "correct": true
+        },
+        {
+          "uk": "Через localStorage",
+          "en": "Through localStorage",
+          "pl": "Przez localStorage",
+          "correct": false
+        },
+        {
+          "uk": "Через URL-параметри",
+          "en": "Through URL parameters",
+          "pl": "Przez parametry URL",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q16",
+      "order": 16,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке prop drilling і як його уникнути у Vue.js?",
+        "exp": "Prop drilling — це передача даних через багато рівнів компонентів. Уникнути можна через provide/inject або Pinia для глобального стану."
+      },
+      "en": {
+        "q": "What is prop drilling and how can you avoid it in Vue.js?",
+        "exp": "Prop drilling is passing data through many component levels. It can be avoided using provide/inject or Pinia for global state."
+      },
+      "pl": {
+        "q": "Czym jest prop drilling i jak go uniknąć w Vue.js?",
+        "exp": "Prop drilling to przekazywanie danych przez wiele poziomów komponentów. Można go uniknąć używając provide/inject lub Pinia dla stanu globalnego."
+      },
+      "answers": [
+        {
+          "uk": "Оптимізація рендерингу, уникають через v-memo",
+          "en": "Rendering optimization, avoided with v-memo",
+          "pl": "Optymalizacja renderingu, unikana przez v-memo",
+          "correct": false
+        },
+        {
+          "uk": "Передача даних через багато рівнів компонентів, уникають через provide/inject або Pinia",
+          "en": "Passing data through many component levels, avoided with provide/inject or Pinia",
+          "pl": "Przekazywanie danych przez wiele poziomów komponentów, unikane przez provide/inject lub Pinia",
+          "correct": true
+        },
+        {
+          "uk": "Помилка компіляції шаблону",
+          "en": "Template compilation error",
+          "pl": "Błąd kompilacji szablonu",
+          "correct": false
+        },
+        {
+          "uk": "Витік пам'яті у компонентах",
+          "en": "Memory leak in components",
+          "pl": "Wyciek pamięci w komponentach",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q17",
+      "order": 17,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке слоти (slots) у Vue.js?",
+        "exp": "Слоти дозволяють передавати вміст від батьківського компонента в дочірній у визначене місце шаблону для гнучкої композиції."
+      },
+      "en": {
+        "q": "What are slots in Vue.js?",
+        "exp": "Slots allow passing content from a parent component to a child at a designated place in the template for flexible composition."
+      },
+      "pl": {
+        "q": "Czym są sloty w Vue.js?",
+        "exp": "Sloty pozwalają przekazywać treść z komponentu nadrzędnego do potomnego w wyznaczone miejsce szablonu dla elastycznej kompozycji."
+      },
+      "answers": [
+        {
+          "uk": "Методи для обробки подій",
+          "en": "Methods for handling events",
+          "pl": "Metody do obsługi zdarzeń",
+          "correct": false
+        },
+        {
+          "uk": "Місця у шаблоні для передачі вмісту від батьківського компонента",
+          "en": "Places in the template for passing content from the parent component",
+          "pl": "Miejsca w szablonie do przekazywania treści z komponentu nadrzędnego",
+          "correct": true
+        },
+        {
+          "uk": "Хуки життєвого циклу",
+          "en": "Lifecycle hooks",
+          "pl": "Hooki cyklu życia",
+          "correct": false
+        },
+        {
+          "uk": "Директиви для анімацій",
+          "en": "Directives for animations",
+          "pl": "Dyrektywy do animacji",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q18",
+      "order": 18,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як дочірній компонент може надіслати дані батьківському у Vue.js?",
+        "exp": "Дочірній компонент використовує $emit для надсилання подій з даними, які батьківський компонент слухає через @eventName."
+      },
+      "en": {
+        "q": "How can a child component send data to its parent in Vue.js?",
+        "exp": "The child component uses $emit to send events with data that the parent listens to via @eventName."
+      },
+      "pl": {
+        "q": "Jak komponent potomny może wysłać dane do nadrzędnego w Vue.js?",
+        "exp": "Komponent potomny używa $emit do wysyłania zdarzeń z danymi, których komponent nadrzędny nasłuchuje przez @eventName."
+      },
+      "answers": [
+        {
+          "uk": "Через props",
+          "en": "Through props",
+          "pl": "Przez props",
+          "correct": false
+        },
+        {
+          "uk": "Через $emit і події",
+          "en": "Through $emit and events",
+          "pl": "Przez $emit i zdarzenia",
+          "correct": true
+        },
+        {
+          "uk": "Через глобальний store",
+          "en": "Through global store",
+          "pl": "Przez globalny store",
+          "correct": false
+        },
+        {
+          "uk": "Напряму змінюючи стан батька",
+          "en": "By directly changing parent state",
+          "pl": "Bezpośrednio zmieniając stan rodzica",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q19",
+      "order": 19,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Яка директива використовується для рендерингу списків у Vue.js?",
+        "exp": "Директива v-for ітерує по масиву або об'єкту і рендерить елемент для кожного пункту. Обов'язково використовуйте :key для оптимізації."
+      },
+      "en": {
+        "q": "Which directive is used for rendering lists in Vue.js?",
+        "exp": "The v-for directive iterates over an array or object and renders an element for each item. Always use :key for optimization."
+      },
+      "pl": {
+        "q": "Której dyrektywy używa się do renderowania list w Vue.js?",
+        "exp": "Dyrektywa v-for iteruje po tablicy lub obiekcie i renderuje element dla każdego elementu. Zawsze używaj :key do optymalizacji."
+      },
+      "answers": [
+        {
+          "uk": "v-list",
+          "en": "v-list",
+          "pl": "v-list",
+          "correct": false
+        },
+        {
+          "uk": "v-for",
+          "en": "v-for",
+          "pl": "v-for",
+          "correct": true
+        },
+        {
+          "uk": "v-each",
+          "en": "v-each",
+          "pl": "v-each",
+          "correct": false
+        },
+        {
+          "uk": "v-repeat",
+          "en": "v-repeat",
+          "pl": "v-repeat",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q20",
+      "order": 20,
+      "difficulty": "medium",
+      "uk": {
+        "q": "У чому різниця між v-if і v-show у Vue.js?",
+        "exp": "v-if додає/видаляє елемент з DOM, v-show лише змінює display: none. Використовуйте v-show для частого перемикання видимості."
+      },
+      "en": {
+        "q": "What is the difference between v-if and v-show in Vue.js?",
+        "exp": "v-if adds/removes the element from DOM, v-show only toggles display: none. Use v-show for frequent visibility toggling."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między v-if a v-show w Vue.js?",
+        "exp": "v-if dodaje/usuwa element z DOM, v-show tylko zmienia display: none. Używaj v-show do częstego przełączania widoczności."
+      },
+      "answers": [
+        {
+          "uk": "v-if працює з компонентами, v-show — з HTML",
+          "en": "v-if works with components, v-show with HTML",
+          "pl": "v-if działa z komponentami, v-show z HTML",
+          "correct": false
+        },
+        {
+          "uk": "v-if додає/видаляє елемент з DOM, v-show змінює CSS display",
+          "en": "v-if adds/removes element from DOM, v-show changes CSS display",
+          "pl": "v-if dodaje/usuwa element z DOM, v-show zmienia CSS display",
+          "correct": true
+        },
+        {
+          "uk": "v-show швидший для першого рендерингу",
+          "en": "v-show is faster for initial rendering",
+          "pl": "v-show jest szybszy dla początkowego renderowania",
+          "correct": false
+        },
+        {
+          "uk": "Різниці немає",
+          "en": "There is no difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/vue/beginner_medium/vue-quiz-part3.json b/json/quizzes/vue/beginner_medium/vue-quiz-part3.json
new file mode 100644
index 00000000..6b571daa
--- /dev/null
+++ b/json/quizzes/vue/beginner_medium/vue-quiz-part3.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "vue-q21",
+      "order": 21,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Vue Router і для чого він використовується?",
+        "exp": "Vue Router — офіційна бібліотека маршрутизації для створення SPA з багатьма сторінками без перезавантаження, з підтримкою динамічних маршрутів і guard'ів."
+      },
+      "en": {
+        "q": "What is Vue Router and what is it used for?",
+        "exp": "Vue Router is the official routing library for creating SPAs with multiple pages without reload, supporting dynamic routes and guards."
+      },
+      "pl": {
+        "q": "Czym jest Vue Router i do czego służy?",
+        "exp": "Vue Router to oficjalna biblioteka routingu do tworzenia SPA z wieloma stronami bez przeładowania, wspierająca dynamiczne trasy i guardy."
+      },
+      "answers": [
+        {
+          "uk": "Бібліотека для управління станом",
+          "en": "A state management library",
+          "pl": "Biblioteka do zarządzania stanem",
+          "correct": false
+        },
+        {
+          "uk": "Офіційна бібліотека маршрутизації для SPA",
+          "en": "The official routing library for SPAs",
+          "pl": "Oficjalna biblioteka routingu dla SPA",
+          "correct": true
+        },
+        {
+          "uk": "Фреймворк для тестування",
+          "en": "A testing framework",
+          "pl": "Framework do testowania",
+          "correct": false
+        },
+        {
+          "uk": "CSS-фреймворк",
+          "en": "A CSS framework",
+          "pl": "Framework CSS",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q22",
+      "order": 22,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як створити динамічний маршрут у Vue Router?",
+        "exp": "Динамічний маршрут створюється з параметром у шляху, наприклад: path: '/user/:id'. Доступ до параметра через route.params.id."
+      },
+      "en": {
+        "q": "How do you create a dynamic route in Vue Router?",
+        "exp": "A dynamic route is created with a parameter in the path, e.g.: path: '/user/:id'. Access the parameter via route.params.id."
+      },
+      "pl": {
+        "q": "Jak utworzyć dynamiczną trasę w Vue Router?",
+        "exp": "Dynamiczną trasę tworzy się z parametrem w ścieżce, np.: path: '/user/:id'. Dostęp do parametru przez route.params.id."
+      },
+      "answers": [
+        {
+          "uk": "path: '/user/*'",
+          "en": "path: '/user/*'",
+          "pl": "path: '/user/*'",
+          "correct": false
+        },
+        {
+          "uk": "path: '/user/:id'",
+          "en": "path: '/user/:id'",
+          "pl": "path: '/user/:id'",
+          "correct": true
+        },
+        {
+          "uk": "path: '/user/{id}'",
+          "en": "path: '/user/{id}'",
+          "pl": "path: '/user/{id}'",
+          "correct": false
+        },
+        {
+          "uk": "path: '/user/[id]'",
+          "en": "path: '/user/[id]'",
+          "pl": "path: '/user/[id]'",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q23",
+      "order": 23,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Vuex і які його основні концепції?",
+        "exp": "Vuex — бібліотека глобального стану з концепціями: state (дані), getters (обчислені), mutations (синхронні зміни), actions (асинхронна логіка), modules."
+      },
+      "en": {
+        "q": "What is Vuex and what are its core concepts?",
+        "exp": "Vuex is a global state library with concepts: state (data), getters (computed), mutations (sync changes), actions (async logic), modules."
+      },
+      "pl": {
+        "q": "Czym jest Vuex i jakie są jego podstawowe koncepcje?",
+        "exp": "Vuex to biblioteka globalnego stanu z koncepcjami: state (dane), getters (obliczone), mutations (zmiany sync), actions (logika async), modules."
+      },
+      "answers": [
+        {
+          "uk": "Бібліотека маршрутизації з концепціями routes, guards, params",
+          "en": "A routing library with routes, guards, params concepts",
+          "pl": "Biblioteka routingu z koncepcjami routes, guards, params",
+          "correct": false
+        },
+        {
+          "uk": "Бібліотека стану з концепціями state, getters, mutations, actions, modules",
+          "en": "A state library with state, getters, mutations, actions, modules concepts",
+          "pl": "Biblioteka stanu z koncepcjami state, getters, mutations, actions, modules",
+          "correct": true
+        },
+        {
+          "uk": "UI-бібліотека компонентів",
+          "en": "A UI component library",
+          "pl": "Biblioteka komponentów UI",
+          "correct": false
+        },
+        {
+          "uk": "Фреймворк для серверного рендерингу",
+          "en": "A server-side rendering framework",
+          "pl": "Framework do renderowania po stronie serwera",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q24",
+      "order": 24,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка різниця між mutations і actions у Vuex?",
+        "exp": "Mutations — синхронні методи для зміни state. Actions — асинхронна логіка (API-запити), яка в кінці викликає mutations."
+      },
+      "en": {
+        "q": "What is the difference between mutations and actions in Vuex?",
+        "exp": "Mutations are synchronous methods for changing state. Actions are async logic (API requests) that eventually call mutations."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między mutations a actions w Vuex?",
+        "exp": "Mutations to synchroniczne metody do zmiany state. Actions to logika async (żądania API), która ostatecznie wywołuje mutations."
+      },
+      "answers": [
+        {
+          "uk": "Mutations для великих змін, actions для малих",
+          "en": "Mutations for big changes, actions for small ones",
+          "pl": "Mutations do dużych zmian, actions do małych",
+          "correct": false
+        },
+        {
+          "uk": "Mutations — синхронні зміни стану, actions — асинхронна логіка",
+          "en": "Mutations are sync state changes, actions are async logic",
+          "pl": "Mutations to sync zmiany stanu, actions to logika async",
+          "correct": true
+        },
+        {
+          "uk": "Actions швидші за mutations",
+          "en": "Actions are faster than mutations",
+          "pl": "Actions są szybsze niż mutations",
+          "correct": false
+        },
+        {
+          "uk": "Різниці немає",
+          "en": "There is no difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q25",
+      "order": 25,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Pinia і як вона відрізняється від Vuex?",
+        "exp": "Pinia — офіційна заміна Vuex у Vue 3, легша, з кращою TypeScript-підтримкою, без mutations (тільки state, getters, actions)."
+      },
+      "en": {
+        "q": "What is Pinia and how does it differ from Vuex?",
+        "exp": "Pinia is the official Vuex replacement in Vue 3, lighter, with better TypeScript support, no mutations (only state, getters, actions)."
+      },
+      "pl": {
+        "q": "Czym jest Pinia i czym różni się od Vuex?",
+        "exp": "Pinia to oficjalny zamiennik Vuex w Vue 3, lżejszy, z lepszym wsparciem TypeScript, bez mutations (tylko state, getters, actions)."
+      },
+      "answers": [
+        {
+          "uk": "Pinia — це бібліотека маршрутизації",
+          "en": "Pinia is a routing library",
+          "pl": "Pinia to biblioteka routingu",
+          "correct": false
+        },
+        {
+          "uk": "Pinia — легша заміна Vuex з кращою TypeScript-підтримкою",
+          "en": "Pinia is a lighter Vuex replacement with better TypeScript support",
+          "pl": "Pinia to lżejszy zamiennik Vuex z lepszym wsparciem TypeScript",
+          "correct": true
+        },
+        {
+          "uk": "Pinia і Vuex ідентичні",
+          "en": "Pinia and Vuex are identical",
+          "pl": "Pinia i Vuex są identyczne",
+          "correct": false
+        },
+        {
+          "uk": "Pinia тільки для Vue 2",
+          "en": "Pinia is only for Vue 2",
+          "pl": "Pinia jest tylko dla Vue 2",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q26",
+      "order": 26,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке mixins у Vue.js і яка їх головна проблема?",
+        "exp": "Mixins — механізм повторного використання логіки між компонентами. Головна проблема — конфлікти імен і важко відстежити джерело логіки."
+      },
+      "en": {
+        "q": "What are mixins in Vue.js and what is their main problem?",
+        "exp": "Mixins are a mechanism for reusing logic between components. The main problem is name conflicts and difficulty tracking logic source."
+      },
+      "pl": {
+        "q": "Czym są mixiny w Vue.js i jaki jest ich główny problem?",
+        "exp": "Mixiny to mechanizm wielokrotnego użycia logiki między komponentami. Główny problem to konflikty nazw i trudność w śledzeniu źródła logiki."
+      },
+      "answers": [
+        {
+          "uk": "Стилі компонентів, проблема — важко перевизначити",
+          "en": "Component styles, problem — hard to override",
+          "pl": "Style komponentów, problem — trudne do nadpisania",
+          "correct": false
+        },
+        {
+          "uk": "Механізм повторного використання логіки, проблема — конфлікти імен",
+          "en": "Logic reuse mechanism, problem — name conflicts",
+          "pl": "Mechanizm wielokrotnego użycia logiki, problem — konflikty nazw",
+          "correct": true
+        },
+        {
+          "uk": "Хуки життєвого циклу, проблема — повільні",
+          "en": "Lifecycle hooks, problem — slow",
+          "pl": "Hooki cyklu życia, problem — wolne",
+          "correct": false
+        },
+        {
+          "uk": "Директиви Vue, проблема — несумісність",
+          "en": "Vue directives, problem — incompatibility",
+          "pl": "Dyrektywy Vue, problem — niekompatybilność",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q27",
+      "order": 27,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як створити кастомну директиву у Vue 3?",
+        "exp": "Кастомна директива створюється через app.directive('name', { mounted(el) {...} }) і використовується як v-name у шаблоні."
+      },
+      "en": {
+        "q": "How do you create a custom directive in Vue 3?",
+        "exp": "A custom directive is created via app.directive('name', { mounted(el) {...} }) and used as v-name in the template."
+      },
+      "pl": {
+        "q": "Jak utworzyć własną dyrektywę w Vue 3?",
+        "exp": "Własną dyrektywę tworzy się przez app.directive('name', { mounted(el) {...} }) i używa jako v-name w szablonie."
+      },
+      "answers": [
+        {
+          "uk": "Vue.createDirective('name', handler)",
+          "en": "Vue.createDirective('name', handler)",
+          "pl": "Vue.createDirective('name', handler)",
+          "correct": false
+        },
+        {
+          "uk": "app.directive('name', { mounted(el) {...} })",
+          "en": "app.directive('name', { mounted(el) {...} })",
+          "pl": "app.directive('name', { mounted(el) {...} })",
+          "correct": true
+        },
+        {
+          "uk": "new Directive('name', handler)",
+          "en": "new Directive('name', handler)",
+          "pl": "new Directive('name', handler)",
+          "correct": false
+        },
+        {
+          "uk": "defineDirective('name', handler)",
+          "en": "defineDirective('name', handler)",
+          "pl": "defineDirective('name', handler)",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q28",
+      "order": 28,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке provide/inject у Vue.js?",
+        "exp": "provide/inject дозволяють передавати дані від батьківського компонента до будь-якого нащадка без props, уникаючи prop drilling."
+      },
+      "en": {
+        "q": "What is provide/inject in Vue.js?",
+        "exp": "provide/inject allows passing data from a parent component to any descendant without props, avoiding prop drilling."
+      },
+      "pl": {
+        "q": "Czym jest provide/inject w Vue.js?",
+        "exp": "provide/inject pozwala przekazywać dane z komponentu nadrzędnego do dowolnego potomka bez props, unikając prop drilling."
+      },
+      "answers": [
+        {
+          "uk": "Методи для роботи з API",
+          "en": "Methods for working with API",
+          "pl": "Metody do pracy z API",
+          "correct": false
+        },
+        {
+          "uk": "Механізм передачі даних від батька до нащадків без props",
+          "en": "Mechanism for passing data from parent to descendants without props",
+          "pl": "Mechanizm przekazywania danych od rodzica do potomków bez props",
+          "correct": true
+        },
+        {
+          "uk": "Хуки для асинхронних операцій",
+          "en": "Hooks for async operations",
+          "pl": "Hooki do operacji asynchronicznych",
+          "correct": false
+        },
+        {
+          "uk": "Директиви для форм",
+          "en": "Directives for forms",
+          "pl": "Dyrektywy do formularzy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q29",
+      "order": 29,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Composition API і чим він відрізняється від Options API?",
+        "exp": "Composition API — новий спосіб організації логіки через setup() з ref, reactive, computed. Логіка однієї фічі зберігається разом, на відміну від Options API."
+      },
+      "en": {
+        "q": "What is the Composition API and how does it differ from Options API?",
+        "exp": "Composition API is a new way to organize logic via setup() with ref, reactive, computed. Logic for one feature stays together, unlike Options API."
+      },
+      "pl": {
+        "q": "Czym jest Composition API i czym różni się od Options API?",
+        "exp": "Composition API to nowy sposób organizacji logiki przez setup() z ref, reactive, computed. Logika jednej funkcji jest razem, w przeciwieństwie do Options API."
+      },
+      "answers": [
+        {
+          "uk": "Composition API — це бібліотека компонентів",
+          "en": "Composition API is a component library",
+          "pl": "Composition API to biblioteka komponentów",
+          "correct": false
+        },
+        {
+          "uk": "Composition API організує логіку через setup(), логіка фічі зберігається разом",
+          "en": "Composition API organizes logic via setup(), feature logic stays together",
+          "pl": "Composition API organizuje logikę przez setup(), logika funkcji jest razem",
+          "correct": true
+        },
+        {
+          "uk": "Options API новіший за Composition API",
+          "en": "Options API is newer than Composition API",
+          "pl": "Options API jest nowszy niż Composition API",
+          "correct": false
+        },
+        {
+          "uk": "Вони ідентичні",
+          "en": "They are identical",
+          "pl": "Są identyczne",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q30",
+      "order": 30,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка різниця між ref і reactive у Vue 3?",
+        "exp": "ref використовується для примітивів (доступ через .value), reactive — для об'єктів і масивів (прямий доступ до властивостей)."
+      },
+      "en": {
+        "q": "What is the difference between ref and reactive in Vue 3?",
+        "exp": "ref is used for primitives (access via .value), reactive is for objects and arrays (direct property access)."
+      },
+      "pl": {
+        "q": "Jaka jest różnica między ref a reactive w Vue 3?",
+        "exp": "ref używa się dla prymitywów (dostęp przez .value), reactive dla obiektów i tablic (bezpośredni dostęp do właściwości)."
+      },
+      "answers": [
+        {
+          "uk": "ref швидший за reactive",
+          "en": "ref is faster than reactive",
+          "pl": "ref jest szybszy niż reactive",
+          "correct": false
+        },
+        {
+          "uk": "ref для примітивів (через .value), reactive для об'єктів (прямий доступ)",
+          "en": "ref for primitives (via .value), reactive for objects (direct access)",
+          "pl": "ref dla prymitywów (przez .value), reactive dla obiektów (bezpośredni dostęp)",
+          "correct": true
+        },
+        {
+          "uk": "reactive тільки для масивів",
+          "en": "reactive is only for arrays",
+          "pl": "reactive jest tylko dla tablic",
+          "correct": false
+        },
+        {
+          "uk": "Різниці немає",
+          "en": "There is no difference",
+          "pl": "Nie ma różnicy",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}
diff --git a/json/quizzes/vue/beginner_medium/vue-quiz-part4.json b/json/quizzes/vue/beginner_medium/vue-quiz-part4.json
new file mode 100644
index 00000000..54bc4fa1
--- /dev/null
+++ b/json/quizzes/vue/beginner_medium/vue-quiz-part4.json
@@ -0,0 +1,434 @@
+{
+  "questions": [
+    {
+      "id": "vue-q31",
+      "order": 31,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Single File Component (SFC) у Vue.js?",
+        "exp": "SFC — це компонент у файлі .vue з трьома секціями: template (розмітка), script (логіка), style (стилі, можуть бути scoped)."
+      },
+      "en": {
+        "q": "What is a Single File Component (SFC) in Vue.js?",
+        "exp": "SFC is a component in a .vue file with three sections: template (markup), script (logic), style (styles, can be scoped)."
+      },
+      "pl": {
+        "q": "Czym jest Single File Component (SFC) w Vue.js?",
+        "exp": "SFC to komponent w pliku .vue z trzema sekcjami: template (znaczniki), script (logika), style (style, mogą być scoped)."
+      },
+      "answers": [
+        {
+          "uk": "JavaScript-модуль з експортом функцій",
+          "en": "A JavaScript module with function exports",
+          "pl": "Moduł JavaScript z eksportowanymi funkcjami",
+          "correct": false
+        },
+        {
+          "uk": "Компонент у файлі .vue з секціями template, script, style",
+          "en": "A component in a .vue file with template, script, style sections",
+          "pl": "Komponent w pliku .vue z sekcjami template, script, style",
+          "correct": true
+        },
+        {
+          "uk": "CSS-файл зі стилями компонента",
+          "en": "A CSS file with component styles",
+          "pl": "Plik CSS ze stylami komponentu",
+          "correct": false
+        },
+        {
+          "uk": "JSON-конфігурація компонента",
+          "en": "A JSON component configuration",
+          "pl": "Konfiguracja komponentu w JSON",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q32",
+      "order": 32,
+      "difficulty": "beginner",
+      "uk": {
+        "q": "Що робить атрибут scoped у тегу style у Vue SFC?",
+        "exp": "Атрибут scoped обмежує CSS-стилі тільки поточним компонентом, додаючи унікальні атрибути до елементів і селекторів."
+      },
+      "en": {
+        "q": "What does the scoped attribute do in a Vue SFC style tag?",
+        "exp": "The scoped attribute limits CSS styles to only the current component by adding unique attributes to elements and selectors."
+      },
+      "pl": {
+        "q": "Co robi atrybut scoped w tagu style w Vue SFC?",
+        "exp": "Atrybut scoped ogranicza style CSS tylko do bieżącego komponentu, dodając unikalne atrybuty do elementów i selektorów."
+      },
+      "answers": [
+        {
+          "uk": "Робить стилі глобальними",
+          "en": "Makes styles global",
+          "pl": "Czyni style globalnymi",
+          "correct": false
+        },
+        {
+          "uk": "Обмежує стилі тільки поточним компонентом",
+          "en": "Limits styles to only the current component",
+          "pl": "Ogranicza style tylko do bieżącego komponentu",
+          "correct": true
+        },
+        {
+          "uk": "Видаляє стилі при unmount",
+          "en": "Removes styles on unmount",
+          "pl": "Usuwa style przy unmount",
+          "correct": false
+        },
+        {
+          "uk": "Кешує стилі для швидкодії",
+          "en": "Caches styles for performance",
+          "pl": "Cachuje style dla wydajności",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q33",
+      "order": 33,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Які нові можливості з'явились у Vue 3?",
+        "exp": "Vue 3 додав Composition API, Teleport, Fragments (кілька кореневих елементів), Suspense, покращену TypeScript-підтримку та меншій бандл."
+      },
+      "en": {
+        "q": "What new features were added in Vue 3?",
+        "exp": "Vue 3 added Composition API, Teleport, Fragments (multiple root elements), Suspense, improved TypeScript support, and smaller bundle."
+      },
+      "pl": {
+        "q": "Jakie nowe funkcje dodano w Vue 3?",
+        "exp": "Vue 3 dodał Composition API, Teleport, Fragments (wiele elementów głównych), Suspense, ulepszone wsparcie TypeScript i mniejszy bundle."
+      },
+      "answers": [
+        {
+          "uk": "Тільки покращення продуктивності",
+          "en": "Only performance improvements",
+          "pl": "Tylko ulepszenia wydajności",
+          "correct": false
+        },
+        {
+          "uk": "Composition API, Teleport, Fragments, Suspense, краща TypeScript-підтримка",
+          "en": "Composition API, Teleport, Fragments, Suspense, better TypeScript support",
+          "pl": "Composition API, Teleport, Fragments, Suspense, lepsze wsparcie TypeScript",
+          "correct": true
+        },
+        {
+          "uk": "Vuex вбудований у ядро",
+          "en": "Vuex built into the core",
+          "pl": "Vuex wbudowany w rdzeń",
+          "correct": false
+        },
+        {
+          "uk": "Видалено реактивність",
+          "en": "Reactivity removed",
+          "pl": "Usunięto reaktywność",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q34",
+      "order": 34,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Teleport у Vue 3?",
+        "exp": "Teleport дозволяє рендерити елементи у будь-яке місце DOM поза ієрархією компонента, корисно для модальних вікон і тултіпів."
+      },
+      "en": {
+        "q": "What is Teleport in Vue 3?",
+        "exp": "Teleport allows rendering elements to any place in the DOM outside the component hierarchy, useful for modals and tooltips."
+      },
+      "pl": {
+        "q": "Czym jest Teleport w Vue 3?",
+        "exp": "Teleport pozwala renderować elementy w dowolnym miejscu DOM poza hierarchią komponentu, przydatne dla modali i tooltipów."
+      },
+      "answers": [
+        {
+          "uk": "Метод навігації між сторінками",
+          "en": "A method for page navigation",
+          "pl": "Metoda nawigacji między stronami",
+          "correct": false
+        },
+        {
+          "uk": "Компонент для рендерингу елементів у будь-яке місце DOM",
+          "en": "A component for rendering elements to any place in the DOM",
+          "pl": "Komponent do renderowania elementów w dowolnym miejscu DOM",
+          "correct": true
+        },
+        {
+          "uk": "Бібліотека анімацій",
+          "en": "An animation library",
+          "pl": "Biblioteka animacji",
+          "correct": false
+        },
+        {
+          "uk": "Інструмент для дебагу",
+          "en": "A debugging tool",
+          "pl": "Narzędzie do debugowania",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q35",
+      "order": 35,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Навіщо потрібен атрибут key при рендерингу списків у Vue.js?",
+        "exp": "key допомагає Vue ідентифікувати елементи при оновленні DOM, забезпечуючи ефективний diffing і правильне відстеження стану елементів."
+      },
+      "en": {
+        "q": "Why is the key attribute needed when rendering lists in Vue.js?",
+        "exp": "key helps Vue identify elements during DOM updates, ensuring efficient diffing and correct tracking of element state."
+      },
+      "pl": {
+        "q": "Po co potrzebny jest atrybut key przy renderowaniu list w Vue.js?",
+        "exp": "key pomaga Vue identyfikować elementy podczas aktualizacji DOM, zapewniając efektywny diffing i prawidłowe śledzenie stanu elementów."
+      },
+      "answers": [
+        {
+          "uk": "Для стилізації елементів",
+          "en": "For styling elements",
+          "pl": "Do stylizacji elementów",
+          "correct": false
+        },
+        {
+          "uk": "Для ідентифікації елементів і ефективного оновлення DOM",
+          "en": "For identifying elements and efficient DOM updates",
+          "pl": "Do identyfikacji elementów i efektywnej aktualizacji DOM",
+          "correct": true
+        },
+        {
+          "uk": "Для валідації даних",
+          "en": "For data validation",
+          "pl": "Do walidacji danych",
+          "correct": false
+        },
+        {
+          "uk": "Для сортування списку",
+          "en": "For sorting the list",
+          "pl": "Do sortowania listy",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q36",
+      "order": 36,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Vue DevTools і для чого вони використовуються?",
+        "exp": "Vue DevTools — розширення браузера для дебагу Vue-застосунків: інспекція компонентів, стану, подій, Vuex/Pinia та time-travel debugging."
+      },
+      "en": {
+        "q": "What is Vue DevTools and what is it used for?",
+        "exp": "Vue DevTools is a browser extension for debugging Vue apps: inspecting components, state, events, Vuex/Pinia, and time-travel debugging."
+      },
+      "pl": {
+        "q": "Czym jest Vue DevTools i do czego służy?",
+        "exp": "Vue DevTools to rozszerzenie przeglądarki do debugowania aplikacji Vue: inspekcja komponentów, stanu, zdarzeń, Vuex/Pinia i time-travel debugging."
+      },
+      "answers": [
+        {
+          "uk": "IDE для розробки Vue",
+          "en": "An IDE for Vue development",
+          "pl": "IDE do rozwoju Vue",
+          "correct": false
+        },
+        {
+          "uk": "Розширення браузера для дебагу Vue-застосунків",
+          "en": "A browser extension for debugging Vue apps",
+          "pl": "Rozszerzenie przeglądarki do debugowania aplikacji Vue",
+          "correct": true
+        },
+        {
+          "uk": "Фреймворк для тестування",
+          "en": "A testing framework",
+          "pl": "Framework do testowania",
+          "correct": false
+        },
+        {
+          "uk": "Бібліотека UI-компонентів",
+          "en": "A UI component library",
+          "pl": "Biblioteka komponentów UI",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q37",
+      "order": 37,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як працює компонент transition у Vue.js?",
+        "exp": "Компонент <transition> автоматично додає CSS-класи (v-enter, v-leave тощо) на різних етапах анімації при вставці/видаленні елементів."
+      },
+      "en": {
+        "q": "How does the transition component work in Vue.js?",
+        "exp": "The <transition> component automatically adds CSS classes (v-enter, v-leave, etc.) at different animation stages during element insert/removal."
+      },
+      "pl": {
+        "q": "Jak działa komponent transition w Vue.js?",
+        "exp": "Komponent <transition> automatycznie dodaje klasy CSS (v-enter, v-leave itp.) na różnych etapach animacji podczas wstawiania/usuwania elementów."
+      },
+      "answers": [
+        {
+          "uk": "Виконує JavaScript-анімації напряму",
+          "en": "Executes JavaScript animations directly",
+          "pl": "Wykonuje animacje JavaScript bezpośrednio",
+          "correct": false
+        },
+        {
+          "uk": "Автоматично додає CSS-класи на етапах анімації",
+          "en": "Automatically adds CSS classes at animation stages",
+          "pl": "Automatycznie dodaje klasy CSS na etapach animacji",
+          "correct": true
+        },
+        {
+          "uk": "Замінює елементи без анімації",
+          "en": "Replaces elements without animation",
+          "pl": "Zastępuje elementy bez animacji",
+          "correct": false
+        },
+        {
+          "uk": "Працює тільки з SVG",
+          "en": "Works only with SVG",
+          "pl": "Działa tylko z SVG",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q38",
+      "order": 38,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Що таке Nuxt.js і як він пов'язаний з Vue.js?",
+        "exp": "Nuxt.js — фреймворк на базі Vue.js для SSR (серверний рендеринг), SSG (статична генерація), з вбудованим роутингом і структурою проєкту."
+      },
+      "en": {
+        "q": "What is Nuxt.js and how is it related to Vue.js?",
+        "exp": "Nuxt.js is a Vue.js-based framework for SSR (server-side rendering), SSG (static site generation), with built-in routing and project structure."
+      },
+      "pl": {
+        "q": "Czym jest Nuxt.js i jak jest powiązany z Vue.js?",
+        "exp": "Nuxt.js to framework oparty na Vue.js dla SSR (renderowanie po stronie serwera), SSG (generacja statyczna), z wbudowanym routingiem i strukturą projektu."
+      },
+      "answers": [
+        {
+          "uk": "Альтернатива Vue.js",
+          "en": "An alternative to Vue.js",
+          "pl": "Alternatywa dla Vue.js",
+          "correct": false
+        },
+        {
+          "uk": "Фреймворк на базі Vue.js для SSR і SSG",
+          "en": "A Vue.js-based framework for SSR and SSG",
+          "pl": "Framework oparty na Vue.js dla SSR i SSG",
+          "correct": true
+        },
+        {
+          "uk": "Бібліотека для тестування Vue",
+          "en": "A testing library for Vue",
+          "pl": "Biblioteka do testowania Vue",
+          "correct": false
+        },
+        {
+          "uk": "CSS-фреймворк для Vue",
+          "en": "A CSS framework for Vue",
+          "pl": "Framework CSS dla Vue",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q39",
+      "order": 39,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Як створити computed властивість з геттером і сеттером у Vue 3?",
+        "exp": "Передайте об'єкт з методами get() і set() у функцію computed(): computed({ get() {...}, set(val) {...} })."
+      },
+      "en": {
+        "q": "How do you create a computed property with getter and setter in Vue 3?",
+        "exp": "Pass an object with get() and set() methods to the computed() function: computed({ get() {...}, set(val) {...} })."
+      },
+      "pl": {
+        "q": "Jak utworzyć właściwość computed z getterem i setterem w Vue 3?",
+        "exp": "Przekaż obiekt z metodami get() i set() do funkcji computed(): computed({ get() {...}, set(val) {...} })."
+      },
+      "answers": [
+        {
+          "uk": "computed(() => value, (val) => {...})",
+          "en": "computed(() => value, (val) => {...})",
+          "pl": "computed(() => value, (val) => {...})",
+          "correct": false
+        },
+        {
+          "uk": "computed({ get() {...}, set(val) {...} })",
+          "en": "computed({ get() {...}, set(val) {...} })",
+          "pl": "computed({ get() {...}, set(val) {...} })",
+          "correct": true
+        },
+        {
+          "uk": "computed.withSetter(() => value)",
+          "en": "computed.withSetter(() => value)",
+          "pl": "computed.withSetter(() => value)",
+          "correct": false
+        },
+        {
+          "uk": "Це неможливо у Vue 3",
+          "en": "This is not possible in Vue 3",
+          "pl": "To niemożliwe w Vue 3",
+          "correct": false
+        }
+      ]
+    },
+    {
+      "id": "vue-q40",
+      "order": 40,
+      "difficulty": "medium",
+      "uk": {
+        "q": "Яка техніка використовується для зменшення розміру бандла у Vue.js?",
+        "exp": "Lazy loading (ліниве завантаження) через динамічний import() дозволяє завантажувати компоненти та маршрути тільки коли вони потрібні."
+      },
+      "en": {
+        "q": "What technique is used to reduce bundle size in Vue.js?",
+        "exp": "Lazy loading through dynamic import() allows loading components and routes only when they are needed."
+      },
+      "pl": {
+        "q": "Jaka technika jest używana do zmniejszenia rozmiaru bundle w Vue.js?",
+        "exp": "Lazy loading (leniwe ładowanie) przez dynamiczny import() pozwala ładować komponenty i trasy tylko wtedy, gdy są potrzebne."
+      },
+      "answers": [
+        {
+          "uk": "Видалення всіх коментарів",
+          "en": "Removing all comments",
+          "pl": "Usuwanie wszystkich komentarzy",
+          "correct": false
+        },
+        {
+          "uk": "Lazy loading через динамічний import()",
+          "en": "Lazy loading through dynamic import()",
+          "pl": "Lazy loading przez dynamiczny import()",
+          "correct": true
+        },
+        {
+          "uk": "Використання тільки inline-стилів",
+          "en": "Using only inline styles",
+          "pl": "Używanie tylko stylów inline",
+          "correct": false
+        },
+        {
+          "uk": "Відмова від TypeScript",
+          "en": "Abandoning TypeScript",
+          "pl": "Rezygnacja z TypeScript",
+          "correct": false
+        }
+      ]
+    }
+  ]
+}