diff --git a/apps/marketing/public/company-logos/codeinterview.png b/apps/marketing/public/company-logos/codeinterview.png
new file mode 100644
index 0000000..1836995
Binary files /dev/null and b/apps/marketing/public/company-logos/codeinterview.png differ
diff --git a/apps/marketing/public/company-logos/coderbyte.png b/apps/marketing/public/company-logos/coderbyte.png
new file mode 100644
index 0000000..d848192
Binary files /dev/null and b/apps/marketing/public/company-logos/coderbyte.png differ
diff --git a/apps/marketing/public/company-logos/coderpad.png b/apps/marketing/public/company-logos/coderpad.png
new file mode 100644
index 0000000..d0abac5
Binary files /dev/null and b/apps/marketing/public/company-logos/coderpad.png differ
diff --git a/apps/marketing/public/company-logos/codesignal.png b/apps/marketing/public/company-logos/codesignal.png
new file mode 100644
index 0000000..72a010f
Binary files /dev/null and b/apps/marketing/public/company-logos/codesignal.png differ
diff --git a/apps/marketing/public/company-logos/codesubmit.png b/apps/marketing/public/company-logos/codesubmit.png
new file mode 100644
index 0000000..ffc22ca
Binary files /dev/null and b/apps/marketing/public/company-logos/codesubmit.png differ
diff --git a/apps/marketing/public/company-logos/hackerrank.jpg b/apps/marketing/public/company-logos/hackerrank.jpg
new file mode 100644
index 0000000..ae1e696
Binary files /dev/null and b/apps/marketing/public/company-logos/hackerrank.jpg differ
diff --git a/apps/marketing/public/company-logos/karat.png b/apps/marketing/public/company-logos/karat.png
new file mode 100644
index 0000000..b12bf44
Binary files /dev/null and b/apps/marketing/public/company-logos/karat.png differ
diff --git a/apps/marketing/public/company-logos/leetcode.png b/apps/marketing/public/company-logos/leetcode.png
new file mode 100644
index 0000000..01903aa
Binary files /dev/null and b/apps/marketing/public/company-logos/leetcode.png differ
diff --git a/apps/marketing/public/company-logos/qualified.png b/apps/marketing/public/company-logos/qualified.png
new file mode 100644
index 0000000..ec4d87b
Binary files /dev/null and b/apps/marketing/public/company-logos/qualified.png differ
diff --git a/apps/marketing/public/company-logos/testgorilla.png b/apps/marketing/public/company-logos/testgorilla.png
new file mode 100644
index 0000000..47fe517
Binary files /dev/null and b/apps/marketing/public/company-logos/testgorilla.png differ
diff --git a/apps/marketing/src/app/(alternatives)/[slug]/page.tsx b/apps/marketing/src/app/(alternatives)/[slug]/page.tsx
index 34cf3f5..2fe6d2d 100644
--- a/apps/marketing/src/app/(alternatives)/[slug]/page.tsx
+++ b/apps/marketing/src/app/(alternatives)/[slug]/page.tsx
@@ -1,13 +1,14 @@
 import { Metadata } from 'next';
 import { notFound } from 'next/navigation';
 import { AlternativePageView } from '@/components/alternative/AlternativePageView';
+import { RoundupPageView } from '@/components/alternative/roundup/RoundupPageView';
 import { competitorData } from '@/lib/alternativeConfig';
 import { buildBreadcrumbSchema } from '@/lib/breadcrumbs';
+import { roundupData } from '@/lib/roundupConfig';
 
 export function generateStaticParams() {
-  return Object.keys(competitorData).map((key) => ({
-    slug: key,
-  }));
+  const slugs = new Set([...Object.keys(competitorData), ...Object.keys(roundupData)]);
+  return Array.from(slugs).map((slug) => ({ slug }));
 }
 
 interface AlternativeCompetitorPageProps {
@@ -18,9 +19,13 @@ export async function generateMetadata({
   params,
 }: AlternativeCompetitorPageProps): Promise<Metadata> {
   const { slug } = await params;
+  const roundup = roundupData[slug];
   const competitor = competitorData[slug];
 
-  if (!competitor) {
+  // Prefer the roundup SEO when this slug has been upgraded to a roundup page.
+  const seo = roundup?.seo ?? competitor?.seo;
+
+  if (!seo) {
     return {
       title: 'Not Found',
     };
@@ -28,17 +33,22 @@ export async function generateMetadata({
 
   const siteUrl = 'https://coderscreen.com';
   const pageUrl = `${siteUrl}/${slug}`;
+  const ogAlt = roundup
+    ? roundup.seo.title
+    : competitor
+      ? `CoderScreen vs ${competitor.displayName}`
+      : 'CoderScreen';
 
   return {
-    title: competitor.seo.title,
-    description: competitor.seo.description,
-    keywords: competitor.seo.keywords,
+    title: seo.title,
+    description: seo.description,
+    keywords: seo.keywords,
     alternates: {
       canonical: pageUrl,
     },
     openGraph: {
-      title: competitor.seo.title,
-      description: competitor.seo.description,
+      title: seo.title,
+      description: seo.description,
       url: pageUrl,
       siteName: 'CoderScreen',
       type: 'website',
@@ -47,14 +57,14 @@ export async function generateMetadata({
           url: `${siteUrl}/og-image.png`,
           width: 1200,
           height: 630,
-          alt: `CoderScreen vs ${competitor.displayName}`,
+          alt: ogAlt,
         },
       ],
     },
     twitter: {
       card: 'summary_large_image',
-      title: competitor.seo.title,
-      description: competitor.seo.description,
+      title: seo.title,
+      description: seo.description,
       images: [`${siteUrl}/og-image.png`],
     },
     robots: {
@@ -76,14 +86,20 @@ export default async function AlternativeCompetitorPage({
 }: AlternativeCompetitorPageProps) {
   const { slug } = await params;
 
+  const roundup = roundupData[slug];
   const competitor = competitorData[slug];
-  if (!competitor) {
+
+  if (!roundup && !competitor) {
     notFound();
   }
 
+  const breadcrumbLabel = roundup
+    ? `${roundup.competitorName} Alternatives`
+    : `${competitor?.displayName} Alternative`;
+
   const breadcrumbSchema = buildBreadcrumbSchema([
     { name: 'Home', href: '/' },
-    { name: `${competitor.displayName} Alternative`, href: `/${slug}` },
+    { name: breadcrumbLabel, href: `/${slug}` },
   ]);
 
   return (
@@ -93,7 +109,11 @@ export default async function AlternativeCompetitorPage({
         // biome-ignore lint/security/noDangerouslySetInnerHtml: needed for SEO schema
         dangerouslySetInnerHTML={{ __html: JSON.stringify(breadcrumbSchema) }}
       />
-      <AlternativePageView competitor={competitor} />
+      {roundup ? (
+        <RoundupPageView roundup={roundup} />
+      ) : (
+        competitor && <AlternativePageView competitor={competitor} />
+      )}
     </>
   );
 }
diff --git a/apps/marketing/src/components/alternative/roundup/BuyingGuide.tsx b/apps/marketing/src/components/alternative/roundup/BuyingGuide.tsx
new file mode 100644
index 0000000..ba5e74b
--- /dev/null
+++ b/apps/marketing/src/components/alternative/roundup/BuyingGuide.tsx
@@ -0,0 +1,28 @@
+import type { RoundupPage } from '@/lib/roundupConfig';
+import { RoundupSectionHeader } from './RoundupSectionHeader';
+
+interface BuyingGuideProps {
+  roundup: RoundupPage;
+}
+
+export const BuyingGuide = ({ roundup }: BuyingGuideProps) => {
+  return (
+    <section>
+      <RoundupSectionHeader
+        title={`How to choose the right ${roundup.competitorName} alternative`}
+        subtitle='The best fit depends on your team size and how you hire. Here is where each option tends to make sense.'
+      />
+
+      <div className='px-6 pb-20'>
+        <div className='max-w-5xl mx-auto grid sm:grid-cols-2 border-l border-t'>
+          {roundup.buyingGuide.map((segment) => (
+            <div key={segment.segment} className='border-r border-b p-8'>
+              <h3 className='text-base font-semibold text-foreground mb-2'>{segment.segment}</h3>
+              <p className='text-sm text-muted-foreground leading-relaxed'>{segment.advice}</p>
+            </div>
+          ))}
+        </div>
+      </div>
+    </section>
+  );
+};
diff --git a/apps/marketing/src/components/alternative/roundup/FeaturesToLookFor.tsx b/apps/marketing/src/components/alternative/roundup/FeaturesToLookFor.tsx
new file mode 100644
index 0000000..1ba176e
--- /dev/null
+++ b/apps/marketing/src/components/alternative/roundup/FeaturesToLookFor.tsx
@@ -0,0 +1,46 @@
+import type { RoundupPage } from '@/lib/roundupConfig';
+import { RoundupSectionHeader } from './RoundupSectionHeader';
+
+interface FeaturesToLookForProps {
+  roundup: RoundupPage;
+}
+
+const TH =
+  'px-4 py-3 text-left text-xs font-semibold uppercase tracking-wider text-muted-foreground';
+const TD = 'px-4 py-4 text-sm align-top';
+
+export const FeaturesToLookFor = ({ roundup }: FeaturesToLookForProps) => {
+  return (
+    <section>
+      <RoundupSectionHeader
+        title='Features to look for when comparing providers'
+        subtitle='Not every team needs every feature. Here is what each one does and why it might matter.'
+      />
+
+      <div className='px-6 pb-20'>
+        <div className='max-w-5xl mx-auto overflow-x-auto border'>
+          <table className='w-full min-w-[640px] border-collapse'>
+            <thead>
+              <tr className='bg-gray-100 border-b'>
+                <th className={TH}>Feature</th>
+                <th className={TH}>What it does</th>
+                <th className={TH}>Why it matters</th>
+              </tr>
+            </thead>
+            <tbody>
+              {roundup.featuresToLookFor.map((row) => (
+                <tr key={row.feature} className='border-t first:border-t-0'>
+                  <td className={`${TD} font-medium text-foreground whitespace-nowrap`}>
+                    {row.feature}
+                  </td>
+                  <td className={`${TD} text-foreground`}>{row.whatItDoes}</td>
+                  <td className={`${TD} text-muted-foreground`}>{row.whyItMatters}</td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </section>
+  );
+};
diff --git a/apps/marketing/src/components/alternative/roundup/RoundupBenefits.tsx b/apps/marketing/src/components/alternative/roundup/RoundupBenefits.tsx
new file mode 100644
index 0000000..cb3aa53
--- /dev/null
+++ b/apps/marketing/src/components/alternative/roundup/RoundupBenefits.tsx
@@ -0,0 +1,27 @@
+import { RiCheckboxCircleLine } from '@remixicon/react';
+import type { RoundupPage } from '@/lib/roundupConfig';
+import { RoundupSectionHeader } from './RoundupSectionHeader';
+
+interface RoundupBenefitsProps {
+  roundup: RoundupPage;
+}
+
+export const RoundupBenefits = ({ roundup }: RoundupBenefitsProps) => {
+  return (
+    <section>
+      <RoundupSectionHeader title={roundup.benefits.title} />
+
+      <div className='px-6 pb-20'>
+        <div className='max-w-5xl mx-auto grid sm:grid-cols-2 lg:grid-cols-4 border-l border-t'>
+          {roundup.benefits.items.map((item) => (
+            <div key={item.title} className='border-r border-b p-6'>
+              <RiCheckboxCircleLine className='size-5 text-primary mb-3' aria-hidden='true' />
+              <h3 className='text-base font-semibold text-foreground mb-1.5'>{item.title}</h3>
+              <p className='text-sm text-muted-foreground leading-relaxed'>{item.description}</p>
+            </div>
+          ))}
+        </div>
+      </div>
+    </section>
+  );
+};
diff --git a/apps/marketing/src/components/alternative/roundup/RoundupFAQ.tsx b/apps/marketing/src/components/alternative/roundup/RoundupFAQ.tsx
new file mode 100644
index 0000000..11cf7e6
--- /dev/null
+++ b/apps/marketing/src/components/alternative/roundup/RoundupFAQ.tsx
@@ -0,0 +1,55 @@
+'use client';
+
+import {
+  Accordion,
+  AccordionContent,
+  AccordionItem,
+  AccordionTrigger,
+} from '@coderscreen/ui/accordion';
+import type { RoundupPage } from '@/lib/roundupConfig';
+
+interface RoundupFAQProps {
+  roundup: RoundupPage;
+}
+
+export const RoundupFAQ = ({ roundup }: RoundupFAQProps) => {
+  const faqSchema = {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: roundup.faq.map((item) => ({
+      '@type': 'Question',
+      name: item.question,
+      acceptedAnswer: {
+        '@type': 'Answer',
+        text: item.answer,
+      },
+    })),
+  };
+
+  return (
+    <section className='border-t px-6 py-20'>
+      <script
+        type='application/ld+json'
+        // biome-ignore lint/security/noDangerouslySetInnerHtml: needed for SEO schema
+        dangerouslySetInnerHTML={{ __html: JSON.stringify(faqSchema) }}
+      />
+      <div className='max-w-3xl mx-auto'>
+        <div className='flex flex-col items-center gap-2 text-center mb-10'>
+          <h2 className='text-3xl font-semibold'>Frequently asked questions</h2>
+          <p className='text-muted-foreground'>
+            Common questions about choosing a {roundup.competitorName} alternative
+          </p>
+        </div>
+
+        <Accordion type='single' collapsible className='w-full'>
+          {roundup.faq.map((item, index) => (
+            <AccordionItem key={item.question} value={`item-${index}`}>
+              <AccordionTrigger className='text-left'>{item.question}</AccordionTrigger>
+              <AccordionContent>{item.answer}</AccordionContent>
+            </AccordionItem>
+          ))}
+        </Accordion>
+      </div>
+    </section>
+  );
+};
diff --git a/apps/marketing/src/components/alternative/roundup/RoundupHero.tsx b/apps/marketing/src/components/alternative/roundup/RoundupHero.tsx
new file mode 100644
index 0000000..2461c54
--- /dev/null
+++ b/apps/marketing/src/components/alternative/roundup/RoundupHero.tsx
@@ -0,0 +1,115 @@
+import { Button } from '@coderscreen/ui/button';
+import { RiArrowRightLine, RiGithubLine, RiStarFill } from '@remixicon/react';
+import { HeroBg } from '@/components/landing/HeroBg';
+import type { RoundupPage } from '@/lib/roundupConfig';
+import { siteConfig } from '@/lib/siteConfig';
+import { toolsDatabase } from '@/lib/toolsDatabase';
+import { cx } from '@/lib/utils';
+import { ToolLogo } from './ToolLogo';
+
+interface RoundupHeroProps {
+  roundup: RoundupPage;
+}
+
+const LeaderboardCard = ({ roundup }: RoundupHeroProps) => {
+  const tools = roundup.toolSlugs.map((slug) => toolsDatabase[slug]).filter(Boolean);
+
+  return (
+    <div className='border bg-background shadow-sm'>
+      <div className='flex items-center justify-between px-5 py-3 border-b bg-gray-50'>
+        <span className='text-xs font-semibold uppercase tracking-wider text-muted-foreground'>
+          Our 2026 ranking
+        </span>
+        <span className='text-xs text-muted-foreground'>{tools.length} compared</span>
+      </div>
+
+      <ul>
+        {tools.map((tool, index) => (
+          <li
+            key={tool.slug}
+            className={cx(
+              'flex items-center gap-3 px-5 py-3 border-b last:border-b-0',
+              tool.isUs && 'bg-gray-50'
+            )}
+          >
+            <span className='w-4 text-sm font-semibold text-muted-foreground tabular-nums'>
+              {index + 1}
+            </span>
+            <ToolLogo tool={tool} className='size-8' />
+            <div className='flex-1 min-w-0'>
+              <div className='flex items-center gap-2'>
+                <span className='text-sm font-semibold text-foreground truncate'>{tool.name}</span>
+                {tool.isUs && (
+                  <span className='inline-flex items-center gap-0.5 text-[10px] font-semibold uppercase tracking-wider text-primary'>
+                    <RiStarFill className='size-2.5' />
+                    Our pick
+                  </span>
+                )}
+              </div>
+            </div>
+            <span className='text-sm font-medium text-foreground shrink-0'>
+              {tool.rating ? (
+                <>
+                  {tool.rating.score.toFixed(1)}
+                  <span className='text-muted-foreground font-normal'> / 5</span>
+                </>
+              ) : (
+                <span className='text-muted-foreground font-normal'>{tool.isUs ? 'New' : '—'}</span>
+              )}
+            </span>
+          </li>
+        ))}
+      </ul>
+    </div>
+  );
+};
+
+export const RoundupHero = ({ roundup }: RoundupHeroProps) => {
+  return (
+    <div className='relative overflow-hidden border-b'>
+      <div className='absolute inset-0 pointer-events-none'>
+        <HeroBg />
+      </div>
+
+      <section className='relative z-10 max-w-6xl mx-auto px-6 py-16 md:py-24'>
+        <div className='grid lg:grid-cols-2 gap-12 lg:gap-16 items-center'>
+          {/* Left: copy */}
+          <div>
+            <h1 className='text-4xl md:text-5xl font-bold leading-tight mb-5'>
+              {roundup.hero.title}
+            </h1>
+            <p className='text-lg text-muted-foreground leading-relaxed mb-8'>
+              {roundup.hero.intro}
+            </p>
+            <div className='flex flex-col sm:flex-row gap-4'>
+              <a href={siteConfig.external.getStarted}>
+                <Button
+                  icon={RiArrowRightLine}
+                  iconPosition='right'
+                  variant='primary'
+                  className='px-6 py-2 text-base font-semibold'
+                >
+                  Try CoderScreen for free
+                </Button>
+              </a>
+              <a href={siteConfig.external.githubRepo}>
+                <Button
+                  icon={RiGithubLine}
+                  variant='secondary'
+                  className='px-6 py-2 text-base font-semibold'
+                >
+                  Star us on GitHub
+                </Button>
+              </a>
+            </div>
+          </div>
+
+          {/* Right: ranked shortlist */}
+          <div className='lg:pl-4'>
+            <LeaderboardCard roundup={roundup} />
+          </div>
+        </div>
+      </section>
+    </div>
+  );
+};
diff --git a/apps/marketing/src/components/alternative/roundup/RoundupList.tsx b/apps/marketing/src/components/alternative/roundup/RoundupList.tsx
new file mode 100644
index 0000000..477e3ee
--- /dev/null
+++ b/apps/marketing/src/components/alternative/roundup/RoundupList.tsx
@@ -0,0 +1,29 @@
+import type { RoundupPage } from '@/lib/roundupConfig';
+import { toolsDatabase } from '@/lib/toolsDatabase';
+import { RoundupSectionHeader } from './RoundupSectionHeader';
+import { ToolCard } from './ToolCard';
+
+interface RoundupListProps {
+  roundup: RoundupPage;
+}
+
+export const RoundupList = ({ roundup }: RoundupListProps) => {
+  const tools = roundup.toolSlugs.map((slug) => toolsDatabase[slug]).filter(Boolean);
+
+  return (
+    <section>
+      <RoundupSectionHeader
+        title={`The ${tools.length} best ${roundup.competitorName} alternatives in 2026`}
+        subtitle='Ranked and reviewed, with honest pros and cons for each.'
+      />
+
+      <div className='px-6 pb-20'>
+        <div className='max-w-4xl mx-auto space-y-6'>
+          {tools.map((tool, index) => (
+            <ToolCard key={tool.slug} tool={tool} rank={index + 1} />
+          ))}
+        </div>
+      </div>
+    </section>
+  );
+};
diff --git a/apps/marketing/src/components/alternative/roundup/RoundupPageView.tsx b/apps/marketing/src/components/alternative/roundup/RoundupPageView.tsx
new file mode 100644
index 0000000..a0faf05
--- /dev/null
+++ b/apps/marketing/src/components/alternative/roundup/RoundupPageView.tsx
@@ -0,0 +1,43 @@
+import { MarketingCTA } from '@/components/common/MarketingCTA';
+import { competitorData } from '@/lib/alternativeConfig';
+import type { RoundupPage } from '@/lib/roundupConfig';
+import { AlternativeLinks } from '../AlternativeLinks';
+import { BuyingGuide } from './BuyingGuide';
+import { FeaturesToLookFor } from './FeaturesToLookFor';
+import { RoundupBenefits } from './RoundupBenefits';
+import { RoundupFAQ } from './RoundupFAQ';
+import { RoundupHero } from './RoundupHero';
+import { RoundupList } from './RoundupList';
+import { RoundupProse } from './RoundupProse';
+import { RoundupTable } from './RoundupTable';
+import { RoundupWhyUs } from './RoundupWhyUs';
+
+interface RoundupPageViewProps {
+  roundup: RoundupPage;
+}
+
+export const RoundupPageView = ({ roundup }: RoundupPageViewProps) => {
+  // Reuse the existing cross-link section when a matching competitor entry exists.
+  const competitor = competitorData[roundup.slug];
+
+  return (
+    <div className='min-h-screen max-w-6xl mx-auto border border-y-0'>
+      <RoundupHero roundup={roundup} />
+      <RoundupProse title={roundup.whatIs.title} paragraphs={roundup.whatIs.paragraphs} />
+      <RoundupTable roundup={roundup} />
+      <RoundupList roundup={roundup} />
+      <FeaturesToLookFor roundup={roundup} />
+      <BuyingGuide roundup={roundup} />
+      <RoundupBenefits roundup={roundup} />
+      <RoundupWhyUs roundup={roundup} />
+      <RoundupProse
+        title={roundup.methodology.title}
+        paragraphs={roundup.methodology.paragraphs}
+        muted
+      />
+      <RoundupFAQ roundup={roundup} />
+      {competitor && <AlternativeLinks currentCompetitor={competitor} />}
+      <MarketingCTA />
+    </div>
+  );
+};
diff --git a/apps/marketing/src/components/alternative/roundup/RoundupProse.tsx b/apps/marketing/src/components/alternative/roundup/RoundupProse.tsx
new file mode 100644
index 0000000..8a67789
--- /dev/null
+++ b/apps/marketing/src/components/alternative/roundup/RoundupProse.tsx
@@ -0,0 +1,32 @@
+import { cx } from '@/lib/utils';
+
+interface RoundupProseProps {
+  title: string;
+  paragraphs: string[];
+  muted?: boolean; // used for the methodology / transparency note
+}
+
+export const RoundupProse = ({ title, paragraphs, muted = false }: RoundupProseProps) => {
+  return (
+    <section className='border-t px-6 py-20'>
+      <div className='max-w-3xl mx-auto'>
+        <h2 className={cx('font-semibold mb-4', muted ? 'text-lg text-foreground' : 'text-3xl')}>
+          {title}
+        </h2>
+        <div className='space-y-4'>
+          {paragraphs.map((paragraph) => (
+            <p
+              key={paragraph.slice(0, 32)}
+              className={cx(
+                'leading-relaxed text-muted-foreground',
+                muted ? 'text-sm' : 'text-base'
+              )}
+            >
+              {paragraph}
+            </p>
+          ))}
+        </div>
+      </div>
+    </section>
+  );
+};
diff --git a/apps/marketing/src/components/alternative/roundup/RoundupSectionHeader.tsx b/apps/marketing/src/components/alternative/roundup/RoundupSectionHeader.tsx
new file mode 100644
index 0000000..d8d6ade
--- /dev/null
+++ b/apps/marketing/src/components/alternative/roundup/RoundupSectionHeader.tsx
@@ -0,0 +1,17 @@
+interface RoundupSectionHeaderProps {
+  title: string;
+  subtitle?: string;
+}
+
+// Matches the landing page section-header pattern: a top border, generous top
+// padding, centered title in font-semibold with a muted subtitle.
+export const RoundupSectionHeader = ({ title, subtitle }: RoundupSectionHeaderProps) => {
+  return (
+    <div className='px-6 pt-20 pb-10 border-t'>
+      <div className='flex flex-col items-center gap-2 text-center'>
+        <h2 className='text-3xl font-semibold'>{title}</h2>
+        {subtitle && <p className='text-muted-foreground max-w-2xl'>{subtitle}</p>}
+      </div>
+    </div>
+  );
+};
diff --git a/apps/marketing/src/components/alternative/roundup/RoundupTable.tsx b/apps/marketing/src/components/alternative/roundup/RoundupTable.tsx
new file mode 100644
index 0000000..349d44b
--- /dev/null
+++ b/apps/marketing/src/components/alternative/roundup/RoundupTable.tsx
@@ -0,0 +1,77 @@
+import type { RoundupPage } from '@/lib/roundupConfig';
+import { toolsDatabase } from '@/lib/toolsDatabase';
+import { cx } from '@/lib/utils';
+import { RoundupSectionHeader } from './RoundupSectionHeader';
+import { ToolLogo } from './ToolLogo';
+
+interface RoundupTableProps {
+  roundup: RoundupPage;
+}
+
+const TH =
+  'px-4 py-3 text-left text-xs font-semibold uppercase tracking-wider text-muted-foreground';
+const TD = 'px-4 py-4 text-sm text-foreground align-middle';
+
+export const RoundupTable = ({ roundup }: RoundupTableProps) => {
+  const tools = roundup.toolSlugs.map((slug) => toolsDatabase[slug]).filter(Boolean);
+
+  return (
+    <section>
+      <RoundupSectionHeader
+        title={`At a glance: the best ${roundup.competitorName} alternatives`}
+        subtitle='A quick comparison before the detailed reviews below.'
+      />
+
+      <div className='px-6 pb-20'>
+        <div className='max-w-5xl mx-auto overflow-x-auto border'>
+          <table className='w-full min-w-[720px] border-collapse'>
+            <thead>
+              <tr className='bg-gray-100 border-b'>
+                <th className={TH}>Tool</th>
+                <th className={TH}>Best for</th>
+                <th className={TH}>Rating</th>
+                <th className={TH}>Starting price</th>
+                <th className={TH}>Free option</th>
+              </tr>
+            </thead>
+            <tbody>
+              {tools.map((tool) => (
+                <tr
+                  key={tool.slug}
+                  className={cx('border-t first:border-t-0', tool.isUs && 'bg-gray-50')}
+                >
+                  <td className={TD}>
+                    <div className='flex items-center gap-3'>
+                      <ToolLogo tool={tool} className='size-9' />
+                      <div className='leading-tight'>
+                        <div className='font-semibold text-foreground'>{tool.name}</div>
+                        {tool.isUs && (
+                          <div className='text-xs font-medium uppercase tracking-wider text-primary'>
+                            Our pick
+                          </div>
+                        )}
+                      </div>
+                    </div>
+                  </td>
+                  <td className={cx(TD, 'text-muted-foreground max-w-xs')}>{tool.bestForTag}</td>
+                  <td className={TD}>
+                    {tool.rating ? (
+                      <span className='whitespace-nowrap font-medium'>
+                        {tool.rating.score.toFixed(1)}
+                        <span className='text-muted-foreground font-normal'> / 5</span>
+                      </span>
+                    ) : (
+                      <span className='text-muted-foreground'>{tool.isUs ? 'New' : '—'}</span>
+                    )}
+                  </td>
+                  <td className={cx(TD, 'whitespace-nowrap font-medium')}>{tool.startingPrice}</td>
+                  <td className={cx(TD, 'text-muted-foreground')}>{tool.freeOption}</td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </section>
+  );
+};
diff --git a/apps/marketing/src/components/alternative/roundup/RoundupWhyUs.tsx b/apps/marketing/src/components/alternative/roundup/RoundupWhyUs.tsx
new file mode 100644
index 0000000..3876f89
--- /dev/null
+++ b/apps/marketing/src/components/alternative/roundup/RoundupWhyUs.tsx
@@ -0,0 +1,49 @@
+import { Button } from '@coderscreen/ui/button';
+import { RiArrowRightLine, RiDoubleQuotesL } from '@remixicon/react';
+import type { RoundupPage } from '@/lib/roundupConfig';
+import { siteConfig } from '@/lib/siteConfig';
+
+interface RoundupWhyUsProps {
+  roundup: RoundupPage;
+}
+
+export const RoundupWhyUs = ({ roundup }: RoundupWhyUsProps) => {
+  const { caseStudy } = roundup.whyUs;
+
+  return (
+    <section className='border-t px-6 py-20'>
+      <div className='max-w-3xl mx-auto'>
+        <h2 className='text-3xl font-semibold mb-6'>{roundup.whyUs.title}</h2>
+
+        <div className='space-y-4 mb-8'>
+          {roundup.whyUs.paragraphs.map((paragraph) => (
+            <p key={paragraph.slice(0, 32)} className='text-muted-foreground leading-relaxed'>
+              {paragraph}
+            </p>
+          ))}
+        </div>
+
+        {caseStudy && (
+          <figure className='border-l-2 border-primary bg-gray-50 p-6 mb-8'>
+            <RiDoubleQuotesL className='size-7 text-gray-300 mb-2' aria-hidden='true' />
+            <blockquote className='text-foreground leading-relaxed mb-4'>
+              {caseStudy.quote}
+            </blockquote>
+            {caseStudy.metric && (
+              <div className='text-2xl font-bold text-foreground mb-2'>{caseStudy.metric}</div>
+            )}
+            <figcaption className='text-sm text-muted-foreground'>
+              {caseStudy.author}, {caseStudy.customer}
+            </figcaption>
+          </figure>
+        )}
+
+        <a href={siteConfig.external.getStarted}>
+          <Button icon={RiArrowRightLine} iconPosition='right' variant='primary'>
+            Get started with CoderScreen
+          </Button>
+        </a>
+      </div>
+    </section>
+  );
+};
diff --git a/apps/marketing/src/components/alternative/roundup/ToolCard.tsx b/apps/marketing/src/components/alternative/roundup/ToolCard.tsx
new file mode 100644
index 0000000..243175f
--- /dev/null
+++ b/apps/marketing/src/components/alternative/roundup/ToolCard.tsx
@@ -0,0 +1,134 @@
+import { Button } from '@coderscreen/ui/button';
+import {
+  RiArrowRightLine,
+  RiCheckLine,
+  RiExternalLinkLine,
+  RiStarFill,
+  RiSubtractLine,
+} from '@remixicon/react';
+import { siteConfig } from '@/lib/siteConfig';
+import type { ToolProfile } from '@/lib/toolsDatabase';
+import { cx } from '@/lib/utils';
+import { ToolLogo } from './ToolLogo';
+
+interface ToolCardProps {
+  tool: ToolProfile;
+  rank: number;
+}
+
+const Stat = ({ label, value }: { label: string; value: string }) => (
+  <div>
+    <div className='text-xs uppercase tracking-wider text-muted-foreground mb-1'>{label}</div>
+    <div className='text-sm font-medium text-foreground'>{value}</div>
+  </div>
+);
+
+export const ToolCard = ({ tool, rank }: ToolCardProps) => {
+  return (
+    <div className={cx('border p-6 md:p-8', tool.isUs ? 'border-primary' : 'border-gray-200')}>
+      {/* Header */}
+      <div className='flex items-start justify-between gap-4 mb-6'>
+        <div className='flex items-start gap-4'>
+          <ToolLogo tool={tool} className='size-12' />
+          <div>
+            <div className='flex items-center gap-2 mb-0.5'>
+              <span className='text-sm font-medium text-muted-foreground'>#{rank}</span>
+              <h3 className='text-xl font-bold text-foreground'>{tool.name}</h3>
+              {tool.isUs && (
+                <span className='inline-flex items-center gap-1 text-xs font-semibold uppercase tracking-wider text-primary'>
+                  <RiStarFill className='size-3' />
+                  Our pick
+                </span>
+              )}
+            </div>
+            <p className='text-sm text-muted-foreground'>{tool.bestForTag}</p>
+          </div>
+        </div>
+        {tool.rating && (
+          <div className='text-right shrink-0'>
+            <div className='text-xl font-bold text-foreground'>{tool.rating.score.toFixed(1)}</div>
+            <div className='text-xs text-muted-foreground'>
+              {tool.rating.source}
+              {tool.rating.count ? ` · ${tool.rating.count}+` : ''}
+            </div>
+          </div>
+        )}
+      </div>
+
+      {/* Stat row */}
+      <div className='grid grid-cols-2 sm:grid-cols-3 gap-4 py-4 border-y'>
+        <Stat label='Starting price' value={tool.startingPrice} />
+        <Stat label='Free option' value={tool.freeOption} />
+        <Stat label='Ideal for' value={tool.idealTeamSize} />
+      </div>
+
+      {/* Key features */}
+      <div className='py-6 border-b'>
+        <h4 className='text-xs font-semibold uppercase tracking-wider text-muted-foreground mb-3'>
+          Key features
+        </h4>
+        <ul className='grid sm:grid-cols-2 gap-x-6 gap-y-2'>
+          {tool.keyFeatures.map((feature) => (
+            <li key={feature} className='flex items-start gap-2 text-sm text-foreground'>
+              <RiCheckLine className='size-4 text-emerald-600 shrink-0 mt-0.5' />
+              <span>{feature}</span>
+            </li>
+          ))}
+        </ul>
+      </div>
+
+      {/* Pros / cons */}
+      <div className='grid sm:grid-cols-2 gap-x-8 gap-y-6 py-6'>
+        <div>
+          <h4 className='text-xs font-semibold uppercase tracking-wider text-muted-foreground mb-3'>
+            Pros
+          </h4>
+          <ul className='space-y-2'>
+            {tool.pros.map((pro) => (
+              <li key={pro} className='flex items-start gap-2 text-sm text-foreground'>
+                <RiCheckLine className='size-4 text-emerald-600 shrink-0 mt-0.5' />
+                <span>{pro}</span>
+              </li>
+            ))}
+          </ul>
+        </div>
+        <div>
+          <h4 className='text-xs font-semibold uppercase tracking-wider text-muted-foreground mb-3'>
+            Cons
+          </h4>
+          <ul className='space-y-2'>
+            {tool.cons.map((con) => (
+              <li key={con} className='flex items-start gap-2 text-sm text-muted-foreground'>
+                <RiSubtractLine className='size-4 text-gray-400 shrink-0 mt-0.5' />
+                <span>{con}</span>
+              </li>
+            ))}
+          </ul>
+        </div>
+      </div>
+
+      {/* Best for + CTA */}
+      <div className='pt-6 border-t'>
+        <p className='text-sm text-muted-foreground leading-relaxed mb-4'>
+          <span className='font-semibold text-foreground'>Best for: </span>
+          {tool.bestForParagraph}
+        </p>
+        {tool.isUs ? (
+          <a href={siteConfig.external.getStarted}>
+            <Button icon={RiArrowRightLine} iconPosition='right' variant='primary'>
+              Get started for free
+            </Button>
+          </a>
+        ) : (
+          tool.website && (
+            <a href={tool.website} target='_blank' rel='noopener noreferrer nofollow'>
+              <Button icon={RiExternalLinkLine} iconPosition='right' variant='secondary'>
+                Visit {tool.name}
+              </Button>
+            </a>
+          )
+        )}
+      </div>
+    </div>
+  );
+};
diff --git a/apps/marketing/src/components/alternative/roundup/ToolLogo.tsx b/apps/marketing/src/components/alternative/roundup/ToolLogo.tsx
new file mode 100644
index 0000000..37af2be
--- /dev/null
+++ b/apps/marketing/src/components/alternative/roundup/ToolLogo.tsx
@@ -0,0 +1,34 @@
+import { Logo } from '@/components/common/Logo';
+import type { ToolProfile } from '@/lib/toolsDatabase';
+import { cx } from '@/lib/utils';
+
+interface ToolLogoProps {
+  tool: ToolProfile;
+  className?: string;
+}
+
+// A consistent square tile for every tool mark. CoderScreen renders the brand
+// SVG (its own blue); competitors render their downloaded logo, contained.
+export const ToolLogo = ({ tool, className }: ToolLogoProps) => {
+  return (
+    <div
+      className={cx(
+        'flex items-center justify-center shrink-0 border bg-white overflow-hidden',
+        className
+      )}
+    >
+      {tool.isUs ? (
+        <Logo className='h-1/2 w-auto text-primary' />
+      ) : tool.logo ? (
+        <img
+          src={tool.logo}
+          alt={`${tool.name} logo`}
+          className='h-3/4 w-3/4 object-contain'
+          loading='lazy'
+        />
+      ) : (
+        <span className='text-sm font-semibold text-gray-500'>{tool.name.charAt(0)}</span>
+      )}
+    </div>
+  );
+};
diff --git a/apps/marketing/src/lib/roundupConfig.ts b/apps/marketing/src/lib/roundupConfig.ts
new file mode 100644
index 0000000..2e35e94
--- /dev/null
+++ b/apps/marketing/src/lib/roundupConfig.ts
@@ -0,0 +1,682 @@
+// Roundup ("Best [X] alternatives") pages. These reuse the existing alternative
+// URLs (e.g. /coderpad-alternative) but render the Ramp-style roundup template:
+// an at-a-glance table, a ranked list of real tools (CoderScreen first), a buying
+// guide, benefits, a transparency note, and an FAQ.
+//
+// Tool data lives in toolsDatabase.ts and is referenced here by slug so it stays
+// a single source of truth across every roundup. Sections that are the same on
+// every page (features to look for, buying guide, benefits, methodology, and the
+// default "what is" explainer) are defined once below; each page only supplies
+// its competitor-specific hero, why-us, FAQ, SEO, and tool list.
+
+export interface FeatureToLookFor {
+  feature: string;
+  whatItDoes: string;
+  whyItMatters: string;
+}
+
+export interface BuyingGuideSegment {
+  segment: string;
+  advice: string;
+}
+
+export interface RoundupFAQItem {
+  question: string;
+  answer: string;
+}
+
+export interface RoundupCaseStudy {
+  customer: string;
+  quote: string;
+  author: string;
+  metric?: string;
+}
+
+export interface RoundupBenefit {
+  title: string;
+  description: string;
+}
+
+export interface RoundupSection {
+  title: string;
+  paragraphs: string[];
+}
+
+export interface RoundupPage {
+  slug: string; // matches the existing alternative URL, e.g. 'coderpad-alternative'
+  competitorName: string;
+  seo: {
+    title: string;
+    description: string;
+    keywords: string[];
+  };
+  hero: {
+    title: string;
+    intro: string;
+  };
+  whatIs: RoundupSection;
+  toolSlugs: string[]; // ordered; CoderScreen first
+  featuresToLookFor: FeatureToLookFor[];
+  buyingGuide: BuyingGuideSegment[];
+  benefits: {
+    title: string;
+    items: RoundupBenefit[];
+  };
+  whyUs: {
+    title: string;
+    paragraphs: string[];
+    caseStudy?: RoundupCaseStudy;
+  };
+  methodology: RoundupSection;
+  faq: RoundupFAQItem[];
+}
+
+// --- Shared sections (identical on every roundup) ---------------------------
+
+const SHARED_FEATURES: FeatureToLookFor[] = [
+  {
+    feature: 'Live collaborative editor',
+    whatItDoes: 'Lets interviewer and candidate write and run code together in real time.',
+    whyItMatters:
+      'This is the core of a live interview. Latency and language support make or break the experience.',
+  },
+  {
+    feature: 'Interview playback',
+    whatItDoes: 'Records the full session so you can replay every keystroke and decision.',
+    whyItMatters: 'Lets the wider team review a candidate without having sat in, and reduces bias.',
+  },
+  {
+    feature: 'System-design whiteboard',
+    whatItDoes: 'A shared canvas for architecture and system-design rounds.',
+    whyItMatters:
+      'Senior interviews need more than code. Some tools charge extra or omit this entirely.',
+  },
+  {
+    feature: 'Take-home assessments',
+    whatItDoes: 'Candidates complete graded work asynchronously before a live round.',
+    whyItMatters: 'Filters your funnel so live time goes only to strong candidates.',
+  },
+  {
+    feature: 'AI-assisted evaluation',
+    whatItDoes: 'Summarizes sessions and helps score candidates consistently.',
+    whyItMatters: 'Saves reviewer time and makes comparisons more consistent across interviewers.',
+  },
+  {
+    feature: 'ATS integrations',
+    whatItDoes: 'Syncs candidates and results with Greenhouse, Lever, Ashby, and others.',
+    whyItMatters: 'Removes manual copy-paste. Watch for this being gated to expensive tiers.',
+  },
+  {
+    feature: 'Pricing model',
+    whatItDoes: 'Flat subscription, per-test credits, or per-seat.',
+    whyItMatters: 'Per-test and credit models can inflate real cost fast at higher volume.',
+  },
+  {
+    feature: 'Open source / self-host',
+    whatItDoes: 'Run and extend the platform on your own infrastructure.',
+    whyItMatters: 'Avoids vendor lock-in and gives full control over candidate data.',
+  },
+];
+
+const SHARED_BUYING_GUIDE: BuyingGuideSegment[] = [
+  {
+    segment: 'Startups and small teams',
+    advice:
+      'Prioritize a real free tier and low entry price so occasional hiring does not mean a big commitment. CoderScreen (free, then $50/mo) and CodeInterview (free, then ~$89/mo) fit best. Avoid tools with no free plan and high entry prices until your volume justifies them.',
+  },
+  {
+    segment: 'Mid-market engineering teams',
+    advice:
+      'You are hiring regularly and want integrations and playback without per-test surprises. Look for flat or predictable pricing and included ATS support. CoderScreen Scale and Coderbyte suit this range; HackerRank Pro works if you value the question library.',
+  },
+  {
+    segment: 'Enterprise',
+    advice:
+      'SSO/SCIM, advanced proctoring, ATS depth, and standardized scoring matter most. CodeSignal and HackerRank Enterprise are the established picks; CoderScreen Enterprise is worth a look if open source and self-hosting are requirements.',
+  },
+  {
+    segment: 'High-volume async screening',
+    advice:
+      'If you run large take-home or screening funnels, a flat unlimited plan beats per-candidate metering. Coderbyte is built for this; just budget for the add-ons it charges separately.',
+  },
+];
+
+const SHARED_BENEFITS = {
+  title: 'What a better platform should get you',
+  items: [
+    {
+      title: 'Lower, more predictable cost',
+      description:
+        'Flat pricing avoids the per-test overages and credit top-ups that make bills unpredictable at volume.',
+    },
+    {
+      title: 'A better candidate experience',
+      description:
+        'A fast, modern editor and a fair format reduce candidate drop-off and reflect well on your brand.',
+    },
+    {
+      title: 'Faster team reviews',
+      description:
+        'Playback and AI summaries let the whole panel evaluate a candidate without scheduling more calls.',
+    },
+    {
+      title: 'No lock-in',
+      description:
+        'An open-source, self-hostable platform keeps you in control of your data and your roadmap.',
+    },
+  ],
+};
+
+const SHARED_METHODOLOGY: RoundupSection = {
+  title: 'How we compared these tools',
+  paragraphs: [
+    'CoderScreen makes one of the products in this comparison, so treat our top pick with that in mind. We have tried to be fair: every competitor is listed with its genuine strengths and real limitations, and each rating comes from third-party review sites (G2 unless noted), not from us.',
+    "Pricing and features were verified against each vendor's public pricing page and review aggregators (G2, GetApp, SoftwareAdvice) in 2026. Prices change often, so confirm the current numbers on each vendor's site before you buy. If we get something wrong, tell us and we will fix it.",
+  ],
+};
+
+const DEFAULT_WHAT_IS: RoundupSection = {
+  title: 'What is a coding interview platform?',
+  paragraphs: [
+    'A coding interview platform gives hiring teams a shared, real-time coding environment to evaluate engineering candidates. Instead of screen-sharing a local editor, both sides work in the same browser-based IDE, run code, and collaborate live, while the platform records the session for later review.',
+    'The category spans two main jobs: live interviews (an interviewer and candidate coding together) and automated assessments or take-home screens (candidates complete work on their own time and the platform grades it). When you compare alternatives, the right choice depends on which of those jobs matters most to your team, and how much you want to pay for integrations, proctoring, and question libraries.',
+  ],
+};
+
+// --- Per-page specs ---------------------------------------------------------
+
+interface RoundupSpec {
+  slug: string;
+  competitorName: string;
+  toolSlugs: string[];
+  heroIntro: string;
+  whyUs: string[];
+  faq: RoundupFAQItem[];
+  seo: RoundupPage['seo'];
+  whatIs?: RoundupSection; // override the default explainer when the category differs
+  caseStudy?: RoundupCaseStudy;
+}
+
+const buildRoundup = (spec: RoundupSpec): RoundupPage => ({
+  slug: spec.slug,
+  competitorName: spec.competitorName,
+  seo: spec.seo,
+  hero: {
+    title: `Best ${spec.competitorName} alternatives in 2026`,
+    intro: spec.heroIntro,
+  },
+  whatIs: spec.whatIs ?? DEFAULT_WHAT_IS,
+  toolSlugs: spec.toolSlugs,
+  featuresToLookFor: SHARED_FEATURES,
+  buyingGuide: SHARED_BUYING_GUIDE,
+  benefits: SHARED_BENEFITS,
+  whyUs: {
+    title: `Why CoderScreen is our top ${spec.competitorName} alternative`,
+    paragraphs: spec.whyUs,
+    caseStudy: spec.caseStudy,
+  },
+  methodology: SHARED_METHODOLOGY,
+  faq: spec.faq,
+});
+
+const SPECS: RoundupSpec[] = [
+  {
+    slug: 'coderpad-alternative',
+    competitorName: 'CoderPad',
+    toolSlugs: [
+      'coderscreen',
+      'coderpad',
+      'codesignal',
+      'hackerrank',
+      'coderbyte',
+      'codeinterview',
+    ],
+    heroIntro:
+      'CoderPad is a capable live-interview tool, but its restrictive free plan, per-test overages, and integrations locked behind higher tiers send plenty of teams looking. We compared the six best CoderPad alternatives on pricing, features, and candidate experience so you can pick the right one, whether you want lower cost, deeper assessments, or an open-source platform you can self-host.',
+    whyUs: [
+      'CoderScreen is the only fully open-source platform in this comparison. You get a real-time collaborative editor with multi-file and framework support, a system-design whiteboard, and full interview playback, all standard rather than sold as add-ons. Pricing is published: free for 3 interviews a month, $50/mo for 20, and no sales call required to start.',
+      'Compared with CoderPad specifically, you swap a restrictive free plan (2 tests a month, pads that expire in 4 days) and per-test overages for a genuinely usable free tier and flat monthly pricing. And because CoderScreen is open source, you can inspect it, extend it, or self-host it, which no other tool on this list offers.',
+    ],
+    seo: {
+      title: 'Best CoderPad Alternatives in 2026 (Compared)',
+      description:
+        'Looking for a CoderPad alternative? We compare the 6 best coding interview platforms in 2026 on pricing, features, and candidate experience, including an open-source option.',
+      keywords: [
+        'coderpad alternative',
+        'coderpad alternatives',
+        'best coderpad alternative',
+        'coderpad free alternative',
+        'coderpad competitors',
+        'coding interview platform',
+        'live coding interview tool',
+      ],
+    },
+    faq: [
+      {
+        question: 'What is the best alternative to CoderPad?',
+        answer:
+          'It depends on your priority. For an open-source, transparently priced live-interview platform, CoderScreen is our top pick. For standardized scoring at scale, CodeSignal; for a large validated question library, HackerRank; for flat-price unlimited async screening, Coderbyte; and for a simple, cheap live tool, CodeInterview.',
+      },
+      {
+        question: 'Is there a free CoderPad alternative?',
+        answer:
+          "Yes. CoderScreen offers a free plan with 3 live interviews per month, and CodeInterview offers a free plan with 2 interviews per month. Both are less restrictive than CoderPad's free plan, whose interview pads expire after 4 days.",
+      },
+      {
+        question: 'Which CoderPad alternative is cheapest?',
+        answer:
+          'For live interviews, CoderScreen starts at $50/mo for 20 interviews with a free tier below that, which is the lowest predictable entry price here. Coderbyte offers flat unlimited async screening from $199/mo. HackerRank and CodeSignal are more expensive and have no free employer plan.',
+      },
+      {
+        question: 'Is there an open-source CoderPad alternative?',
+        answer:
+          'CoderScreen is the only fully open-source option in this comparison. You can inspect the code, contribute, or self-host it, which avoids vendor lock-in and gives you full control over candidate data.',
+      },
+    ],
+  },
+
+  {
+    slug: 'hackerrank-alternative',
+    competitorName: 'HackerRank',
+    toolSlugs: ['coderscreen', 'hackerrank', 'codesignal', 'coderpad', 'coderbyte', 'testgorilla'],
+    heroIntro:
+      'HackerRank is the incumbent for technical screening, but there is no free employer plan, the attempt-based pricing adds up fast, and many candidates find the timed tests stressful. We compared the best HackerRank alternatives on pricing, candidate experience, and features, including an open-source platform you can self-host.',
+    whyUs: [
+      'CoderScreen gives you live collaborative interviews, a system-design whiteboard, and full playback on published pricing that starts free and runs $50/mo for 20 interviews, with no per-attempt metering. HackerRank has no free employer plan, starts at $165/mo, and bills extra attempts at $20 each.',
+      'Where HackerRank leans on a huge auto-graded question bank and timed tests, CoderScreen focuses on how candidates actually work: real-time collaboration, multi-file and framework support, and AI-assisted review. And because it is open source, you can self-host it and keep full control of candidate data.',
+    ],
+    seo: {
+      title: 'Best HackerRank Alternatives in 2026 (Compared)',
+      description:
+        'Looking for a HackerRank alternative? We compare the best coding assessment and interview platforms in 2026 on pricing, candidate experience, and features, including an open-source option.',
+      keywords: [
+        'hackerrank alternative',
+        'hackerrank alternatives',
+        'best hackerrank alternative',
+        'hackerrank free alternative',
+        'hackerrank competitors',
+        'coding assessment platform',
+        'technical screening software',
+      ],
+    },
+    faq: [
+      {
+        question: 'What is the best alternative to HackerRank?',
+        answer:
+          'For a modern, open-source platform with live interviews and transparent pricing, CoderScreen is our top pick. CodeSignal is strong for standardized scoring, CoderPad for a polished live IDE, Coderbyte for flat-price async screening, and TestGorilla if you also hire non-technical roles.',
+      },
+      {
+        question: 'Is there a free HackerRank alternative?',
+        answer:
+          'HackerRank has no free employer plan. CoderScreen offers a free plan with 3 live interviews per month, and CodeInterview offers 2 per month, so you can run real interviews without paying upfront.',
+      },
+      {
+        question: 'Is there a cheaper alternative to HackerRank?',
+        answer:
+          'Yes. HackerRank starts at $165/mo with extra attempts at $20 each. CoderScreen starts free and is $50/mo for 20 live interviews, and Coderbyte offers flat unlimited async screening from $199/mo.',
+      },
+      {
+        question: 'Is there an open-source HackerRank alternative?',
+        answer:
+          'CoderScreen is the only fully open-source option here. You can self-host it, inspect the code, and keep full control of candidate data, which no other tool on this list offers.',
+      },
+    ],
+  },
+
+  {
+    slug: 'codesignal-alternative',
+    competitorName: 'CodeSignal',
+    toolSlugs: [
+      'coderscreen',
+      'codesignal',
+      'hackerrank',
+      'coderpad',
+      'coderbyte',
+      'codeinterview',
+    ],
+    heroIntro:
+      'CodeSignal is known for standardized scoring, but there is no free hiring tier, the credit model escalates quickly, and the jump between plans is steep. We compared the best CodeSignal alternatives on pricing, candidate experience, and features, including an open-source option you can self-host.',
+    whyUs: [
+      'CoderScreen is transparent and affordable where CodeSignal is quote-gated and premium: start free, then $50/mo for 20 live interviews, with the system-design whiteboard and interview playback included. CodeSignal has no free hiring tier and jumps from roughly $79/mo to $479/mo between its main plans.',
+      'CodeSignal centers on a standardized Coding Score for high-volume screening; CoderScreen centers on live, collaborative interviews and hands-on assessment with AI-assisted review. And as the only open-source option here, CoderScreen lets you self-host and avoid lock-in.',
+    ],
+    seo: {
+      title: 'Best CodeSignal Alternatives in 2026 (Compared)',
+      description:
+        'Looking for a CodeSignal alternative? We compare the best coding assessment and interview platforms in 2026 on pricing, features, and candidate experience, including an open-source option.',
+      keywords: [
+        'codesignal alternative',
+        'codesignal alternatives',
+        'best codesignal alternative',
+        'codesignal competitors',
+        'coding assessment platform',
+        'technical screening software',
+        'coding interview platform',
+      ],
+    },
+    faq: [
+      {
+        question: 'What is the best alternative to CodeSignal?',
+        answer:
+          'For an open-source platform with live interviews and published pricing, CoderScreen is our top pick. HackerRank offers a larger question library, CoderPad a polished live IDE, Coderbyte flat-price async screening, and CodeInterview a simple, low-cost live tool.',
+      },
+      {
+        question: 'Is there a free CodeSignal alternative?',
+        answer:
+          'CodeSignal has no free hiring tier. CoderScreen offers a free plan with 3 live interviews per month, and CodeInterview offers 2 per month, so you can evaluate candidates before paying.',
+      },
+      {
+        question: 'Is there a cheaper alternative to CodeSignal?',
+        answer:
+          'Yes. CodeSignal jumps from about $79/mo to $479/mo between plans, with $20 per overage credit. CoderScreen starts free and is $50/mo for 20 interviews with no credit metering.',
+      },
+      {
+        question: 'Is there an open-source CodeSignal alternative?',
+        answer:
+          'CoderScreen is the only fully open-source option in this comparison. You can self-host it and keep full control of your candidate data.',
+      },
+    ],
+  },
+
+  {
+    slug: 'coderbyte-alternative',
+    competitorName: 'Coderbyte',
+    toolSlugs: ['coderscreen', 'coderbyte', 'hackerrank', 'codesignal', 'coderpad', 'codesubmit'],
+    heroIntro:
+      'Coderbyte offers flat, unlimited-usage pricing, but many of the features you actually need (ATS, SSO, branding, proctoring) are paid add-ons on top. We compared the best Coderbyte alternatives on total cost, candidate experience, and features, including an open-source platform you can self-host.',
+    whyUs: [
+      "CoderScreen keeps the essentials in the box: live collaborative interviews, a system-design whiteboard, playback, and (on Scale) ATS integrations, on published pricing from free to $50/mo. Coderbyte's flat price looks low until you add the ATS, SSO, branding, and proctoring add-ons it charges separately.",
+      'Coderbyte is built around asynchronous screening and take-homes; CoderScreen adds first-class live interviews and AI-assisted review, and as the only open-source tool here you can self-host and extend it.',
+    ],
+    seo: {
+      title: 'Best Coderbyte Alternatives in 2026 (Compared)',
+      description:
+        'Looking for a Coderbyte alternative? We compare the best coding assessment and interview platforms in 2026 on total cost, features, and candidate experience, including an open-source option.',
+      keywords: [
+        'coderbyte alternative',
+        'coderbyte alternatives',
+        'best coderbyte alternative',
+        'coderbyte competitors',
+        'coding assessment platform',
+        'take home coding test',
+        'coding interview platform',
+      ],
+    },
+    faq: [
+      {
+        question: 'What is the best alternative to Coderbyte?',
+        answer:
+          'For an open-source platform with live interviews and no add-on fees, CoderScreen is our top pick. HackerRank and CodeSignal are strong for large-scale assessment, CoderPad for live interviews, and CodeSubmit for friendly take-home assignments.',
+      },
+      {
+        question: 'Is there a free Coderbyte alternative?',
+        answer:
+          'Coderbyte offers a 14-day trial rather than a free plan. CoderScreen offers a genuinely free tier with 3 live interviews per month, and CodeInterview offers 2 per month.',
+      },
+      {
+        question: 'Is Coderbyte actually cheap once you add everything?',
+        answer:
+          "Coderbyte's headline price starts around $199/mo, but ATS integrations, SSO, custom branding, and advanced proctoring are each paid add-ons. CoderScreen includes those categories in its plans (ATS on Scale, SSO on Enterprise) with published pricing.",
+      },
+      {
+        question: 'Is there an open-source Coderbyte alternative?',
+        answer:
+          'CoderScreen is the only fully open-source option here. You can self-host it, extend it, and keep full control of candidate data.',
+      },
+    ],
+  },
+
+  {
+    slug: 'leetcode-alternative',
+    competitorName: 'LeetCode',
+    toolSlugs: ['coderscreen', 'leetcode', 'hackerrank', 'codesignal', 'coderpad', 'coderbyte'],
+    heroIntro:
+      'LeetCode is where candidates practice algorithm questions, but it was built for interview prep, not for employers running interviews or scored assessments. If you are hiring, these are the platforms to look at instead, including an open-source option you can self-host.',
+    whyUs: [
+      'If your goal is to evaluate candidates rather than help them practice, CoderScreen is purpose-built for it: run live collaborative interviews, use a system-design whiteboard, and review full playback, starting free and $50/mo for 20 interviews.',
+      'You can still use algorithm-style questions inside CoderScreen if you want them, but you also get real-time collaboration, multi-file and framework support, and AI-assisted review, on an open-source platform you can self-host.',
+    ],
+    whatIs: {
+      title: "LeetCode vs a hiring platform: what's the difference?",
+      paragraphs: [
+        'LeetCode is a practice platform. Candidates use it to grind algorithm problems and prepare for interviews, and its problem library is the best in the business for that. It is not designed for employers to run interviews or score candidates.',
+        'A hiring platform, by contrast, is built for the interviewer: a shared live editor, take-home assessments, playback, scoring, and ATS integrations. If you want to evaluate candidates rather than help them study, you want one of the hiring-focused tools below.',
+      ],
+    },
+    seo: {
+      title: 'Best LeetCode Alternatives for Hiring in 2026',
+      description:
+        'LeetCode is built for practice, not hiring. We compare the best LeetCode alternatives for employers who need to run coding interviews and assessments, including an open-source option.',
+      keywords: [
+        'leetcode alternative',
+        'leetcode alternatives',
+        'best leetcode alternative',
+        'free leetcode alternative',
+        'leetcode alternative for employers',
+        'coding interview platform',
+      ],
+    },
+    faq: [
+      {
+        question: 'Is LeetCode good for employers hiring candidates?',
+        answer:
+          'LeetCode is built for candidate practice, not for running interviews or scoring candidates. Employers who want to evaluate candidates are better served by a hiring platform like CoderScreen, HackerRank, or CodeSignal.',
+      },
+      {
+        question: 'What is the best LeetCode alternative for hiring?',
+        answer:
+          'CoderScreen is our top pick for employers: an open-source platform with live interviews, assessments, a whiteboard, and playback, from free to $50/mo. HackerRank and CodeSignal are strong for large-scale assessment.',
+      },
+      {
+        question: 'Can I use LeetCode-style questions in CoderScreen?',
+        answer:
+          'Yes. You can run algorithm-style questions inside CoderScreen, and add your own, while also getting live collaboration, take-home assessments, playback, and AI-assisted review that LeetCode does not provide to hiring teams.',
+      },
+      {
+        question: 'Is there a free LeetCode alternative for interviews?',
+        answer:
+          'CoderScreen has a free plan with 3 live interviews per month, purpose-built for hiring. CodeInterview also offers a free tier of 2 interviews per month.',
+      },
+    ],
+  },
+
+  {
+    slug: 'karat-alternative',
+    competitorName: 'Karat',
+    toolSlugs: ['coderscreen', 'karat', 'hackerrank', 'codesignal', 'coderpad', 'codeinterview'],
+    heroIntro:
+      'Karat runs your first-round technical interviews for you using external interviewers, which is powerful at enterprise scale but expensive per interview and out of reach for most teams. We compared the best Karat alternatives for teams that would rather run great interviews themselves, including an open-source platform you can self-host.',
+    whyUs: [
+      'Instead of paying $200-450 per outsourced interview, CoderScreen lets your own team run interviews on published pricing: free to start, $50/mo for 20 live interviews, with a whiteboard and full playback included so any interviewer stays calibrated.',
+      "Karat's value is offloading interviews; CoderScreen's is making your own interviews fast, consistent, and reviewable, with AI-assisted summaries and playback so the whole panel can evaluate a candidate. And it is open source, so you can self-host and own your data.",
+    ],
+    whatIs: {
+      title: 'What is interview-as-a-service, and what is the alternative?',
+      paragraphs: [
+        'Karat is interview-as-a-service: instead of your engineers running first-round technical screens, Karat provides trained external interviewers who conduct them for you and return a scorecard. It is priced per interview and aimed at enterprises with high volume.',
+        'The alternative is to run your own interviews on a platform built for it, keeping your engineers close to the signal while still getting structure, recordings, and scoring. That is far cheaper for most teams, and it is what the tools below provide.',
+      ],
+    },
+    seo: {
+      title: 'Best Karat Alternatives in 2026 (Compared)',
+      description:
+        'Looking for a Karat alternative? We compare the best platforms for running your own technical interviews in 2026 on pricing, features, and candidate experience, including an open-source option.',
+      keywords: [
+        'karat alternative',
+        'karat alternatives',
+        'best karat alternative',
+        'karat competitors',
+        'karat pricing',
+        'technical interview platform',
+      ],
+    },
+    faq: [
+      {
+        question: 'What is the best alternative to Karat?',
+        answer:
+          'For teams that want to run their own interviews instead of outsourcing them, CoderScreen is our top pick: open source, live interviews, whiteboard, and playback from free to $50/mo. HackerRank and CodeSignal add large assessment libraries.',
+      },
+      {
+        question: 'How much does Karat cost, and are alternatives cheaper?',
+        answer:
+          'Karat does not publish pricing and typically charges $200-450 per interview with minimum volume commitments. Running interviews yourself on CoderScreen ($50/mo for 20) or CodeInterview is dramatically cheaper for most teams.',
+      },
+      {
+        question: 'Can I run technical interviews myself instead of using Karat?',
+        answer:
+          'Yes. Platforms like CoderScreen give you a live collaborative editor, structured rubrics, recordings, and AI-assisted summaries so your own team can run consistent, reviewable interviews without outsourcing them.',
+      },
+      {
+        question: 'Is there an open-source Karat alternative?',
+        answer:
+          'CoderScreen is open source and self-hostable, so you can run interviews on your own infrastructure and keep full control of candidate data.',
+      },
+    ],
+  },
+
+  {
+    slug: 'testgorilla-alternative',
+    competitorName: 'TestGorilla',
+    toolSlugs: ['coderscreen', 'testgorilla', 'hackerrank', 'codesignal', 'coderbyte', 'coderpad'],
+    heroIntro:
+      'TestGorilla is a broad skills-testing platform, but paid plans lock you into a 12-month commitment and the coding assessments are shallower than dedicated developer tools. We compared the best TestGorilla alternatives, especially for technical hiring, including an open-source platform you can self-host.',
+    whyUs: [
+      'For engineering hiring specifically, CoderScreen gives you deeper technical signal than a general skills-test library: live collaborative coding, multi-file and framework support, a system-design whiteboard, and full playback, on month-to-month published pricing from free to $50/mo, with no annual lock-in.',
+      "TestGorilla is a fit when you screen many non-technical roles too; if your focus is developers, CoderScreen's hands-on interviews and assessments tell you more about how a candidate actually works. It is also the only open-source option here.",
+    ],
+    seo: {
+      title: 'Best TestGorilla Alternatives in 2026 (Compared)',
+      description:
+        'Looking for a TestGorilla alternative? We compare the best skills-assessment and technical interview platforms in 2026 on pricing, features, and candidate experience, including an open-source option.',
+      keywords: [
+        'testgorilla alternative',
+        'testgorilla alternatives',
+        'best testgorilla alternative',
+        'testgorilla competitors',
+        'cheaper than testgorilla',
+        'skills assessment software',
+        'coding assessment platform',
+      ],
+    },
+    faq: [
+      {
+        question: 'What is the best alternative to TestGorilla?',
+        answer:
+          'For technical hiring, CoderScreen is our top pick: an open-source platform with live coding interviews and hands-on assessment, from free to $50/mo, month to month. HackerRank and CodeSignal offer large coding-assessment libraries; Coderbyte suits async screening.',
+      },
+      {
+        question: 'Is there a TestGorilla alternative without an annual commitment?',
+        answer:
+          'Yes. TestGorilla requires a 12-month commitment on paid plans. CoderScreen is month-to-month with published pricing (free, then $50/mo), so you are not locked into a year.',
+      },
+      {
+        question: 'Is there a cheaper alternative to TestGorilla?',
+        answer:
+          "TestGorilla's Core plan is $142/mo billed annually ($1,704/yr). CoderScreen starts free and is $50/mo for 20 live interviews with no annual lock-in, which is cheaper for most technical hiring.",
+      },
+      {
+        question: 'What is a better TestGorilla alternative for developers?',
+        answer:
+          "TestGorilla covers many roles but its coding depth is limited. For developers specifically, CoderScreen's live coding, framework support, and playback give you stronger technical signal, and it is open source.",
+      },
+    ],
+  },
+
+  {
+    slug: 'qualified-alternative',
+    competitorName: 'Qualified',
+    toolSlugs: ['coderscreen', 'qualified', 'coderbyte', 'codesubmit', 'hackerrank', 'coderpad'],
+    heroIntro:
+      'Qualified offers rigorous, test-driven coding assessments, but pricing is quote-only, there is no real free plan, and it does not run live interviews. We compared the best Qualified alternatives on pricing, features, and candidate experience, including an open-source platform you can self-host.',
+    whyUs: [
+      'CoderScreen covers both sides of the funnel with published pricing: hands-on assessments and live collaborative interviews, plus a system-design whiteboard and full playback, starting free and $50/mo for 20 interviews. Qualified is assessment-only and quote-gated, with a trial capped at five results.',
+      'Both value realistic, hands-on evaluation over trivia. CoderScreen adds live interviewing, AI-assisted review, and, as the only open-source option here, the ability to self-host and keep full control of candidate data.',
+    ],
+    seo: {
+      title: 'Best Qualified.io Alternatives in 2026 (Compared)',
+      description:
+        'Looking for a Qualified.io alternative? We compare the best coding assessment and interview platforms in 2026 on pricing, features, and candidate experience, including an open-source option.',
+      keywords: [
+        'qualified alternative',
+        'qualified.io alternative',
+        'qualified io alternative',
+        'best qualified alternative',
+        'qualified competitors',
+        'coding assessment platform',
+      ],
+    },
+    faq: [
+      {
+        question: 'What is the best alternative to Qualified.io?',
+        answer:
+          'For a platform that does both assessments and live interviews on published pricing, CoderScreen is our top pick and the only open-source option. Coderbyte and CodeSubmit are strong for take-home assessments; HackerRank offers a large question library.',
+      },
+      {
+        question: 'Is there a free Qualified.io alternative?',
+        answer:
+          'Qualified has no free plan; its trial is capped at 5 results. CoderScreen offers a free plan with 3 live interviews per month, and CoderPad and CodeInterview also offer free tiers.',
+      },
+      {
+        question: 'Does Qualified.io publish pricing, and do alternatives?',
+        answer:
+          'Qualified is quote-only. If you want transparent, published pricing, CoderScreen ($50/mo for 20 interviews), CoderPad, and CodeSubmit all list their prices publicly.',
+      },
+      {
+        question: 'Which Qualified alternative also does live interviews?',
+        answer:
+          'Qualified is assessment-focused. CoderScreen adds first-class live collaborative interviews alongside hands-on assessments, with a whiteboard and playback included.',
+      },
+    ],
+  },
+
+  {
+    slug: 'codesubmit-alternative',
+    competitorName: 'CodeSubmit',
+    toolSlugs: ['coderscreen', 'codesubmit', 'coderbyte', 'qualified', 'coderpad', 'codeinterview'],
+    heroIntro:
+      'CodeSubmit is a friendly take-home assignment tool, but it is built mostly around asynchronous assessments and gates ATS, branding, and SSO behind higher tiers. We compared the best CodeSubmit alternatives on features, pricing, and candidate experience, including an open-source platform you can self-host.',
+    whyUs: [
+      'CoderScreen gives you first-class live interviews alongside hands-on assessment, with a system-design whiteboard and full playback included, on published pricing from free to $50/mo for 20 interviews. CodeSubmit is take-home-first, with ATS, branding, and SSO on higher tiers or add-ons.',
+      'Both keep pricing transparent and the candidate experience friendly. CoderScreen goes further on live, collaborative interviewing and AI-assisted review, and is the only open-source option here, so you can self-host and extend it.',
+    ],
+    seo: {
+      title: 'Best CodeSubmit Alternatives in 2026 (Compared)',
+      description:
+        'Looking for a CodeSubmit alternative? We compare the best take-home assessment and coding interview platforms in 2026 on pricing, features, and candidate experience, including an open-source option.',
+      keywords: [
+        'codesubmit alternative',
+        'codesubmit alternatives',
+        'best codesubmit alternative',
+        'codesubmit competitors',
+        'take home coding test',
+        'coding assessment platform',
+      ],
+    },
+    faq: [
+      {
+        question: 'What is the best alternative to CodeSubmit?',
+        answer:
+          'For a platform that adds first-class live interviews to take-home assessments, CoderScreen is our top pick and the only open-source option. Coderbyte offers flat-price async screening, Qualified rigorous test-driven assessments, and CoderPad polished live interviews.',
+      },
+      {
+        question: 'Is there a free CodeSubmit alternative?',
+        answer:
+          'CodeSubmit offers a trial rather than a permanent free plan. CoderScreen has a free tier with 3 live interviews per month, and CoderPad and CodeInterview also offer free tiers.',
+      },
+      {
+        question: 'Which CodeSubmit alternative also does live interviews?',
+        answer:
+          'CodeSubmit is take-home-first. CoderScreen adds live collaborative interviews with a whiteboard and playback, so you can run both assessments and interviews in one tool.',
+      },
+      {
+        question: 'Is there an open-source CodeSubmit alternative?',
+        answer:
+          'CoderScreen is the only fully open-source option here. You can self-host it, extend it, and keep full control of candidate data.',
+      },
+    ],
+  },
+];
+
+export const roundupData: Record<string, RoundupPage> = Object.fromEntries(
+  SPECS.map((spec) => [spec.slug, buildRoundup(spec)])
+);
diff --git a/apps/marketing/src/lib/toolsDatabase.ts b/apps/marketing/src/lib/toolsDatabase.ts
new file mode 100644
index 0000000..9450b40
--- /dev/null
+++ b/apps/marketing/src/lib/toolsDatabase.ts
@@ -0,0 +1,445 @@
+// Single source of truth for every tool that appears in a roundup page.
+// Each competitor lives here once and is referenced by slug from roundupConfig,
+// so updating a price or rating propagates to every roundup that lists it.
+//
+// Ratings are third-party review-site figures (G2 unless noted). Keep them honest
+// and separate from our own marketing claims. Verify quarterly.
+// Last verified: 2026-07-26.
+
+export interface ToolRating {
+  score: number;
+  source: string; // e.g. 'G2'
+  count?: number; // number of reviews
+}
+
+export interface ToolProfile {
+  slug: string;
+  name: string;
+  isUs?: boolean; // CoderScreen, always positioned first (renders the brand mark, no logo file)
+  website?: string;
+  logo?: string; // path under /public; omitted for CoderScreen (uses the Logo component)
+  rating?: ToolRating; // omitted for new tools with no meaningful sample
+  bestForTag: string; // short one-liner used in the at-a-glance table and card header
+  startingPrice: string; // headline price for the table, e.g. 'Free, then $50/mo'
+  freeOption: string; // 'Free plan', '14-day trial', 'No free employer plan'
+  idealTeamSize: string;
+  pricingTiers: string[]; // one line per tier
+  keyFeatures: string[];
+  pros: string[];
+  cons: string[];
+  bestForParagraph: string;
+}
+
+export const toolsDatabase: Record<string, ToolProfile> = {
+  coderscreen: {
+    slug: 'coderscreen',
+    name: 'CoderScreen',
+    isUs: true,
+    website: 'https://coderscreen.com',
+    bestForTag: 'Open-source live coding interviews with transparent pricing',
+    startingPrice: 'Free, then $50/mo',
+    freeOption: 'Free plan (3 interviews/mo)',
+    idealTeamSize: 'Startups to scaling engineering teams',
+    pricingTiers: [
+      'Basic: free forever, 3 live interviews/mo, 1 member',
+      'Starter: $50/mo, 20 live interviews/mo, 5 members, API access',
+      'Scale: $350/mo, 200 live interviews/mo, unlimited members, ATS integrations, custom branding',
+      'Enterprise: custom, unlimited interviews, SSO, whiteglove support',
+    ],
+    keyFeatures: [
+      'Fully open source and self-hostable',
+      'Real-time collaborative code editor with multi-file and framework support (React, Next.js)',
+      'Collaborative whiteboard for system design, included at no extra cost',
+      'Full interview playback to review every keystroke',
+      'AI-assisted candidate evaluation and interview summaries',
+      'Published, transparent pricing with no sales calls to start',
+      'ATS integrations (Greenhouse, Lever, Ashby) on Scale and up',
+    ],
+    pros: [
+      'Only fully open-source option here, so no vendor lock-in and you can self-host',
+      'System-design whiteboard bundled instead of sold as an add-on',
+      'Clear published pricing you can start on without talking to sales',
+      'Generous entry price versus incumbents ($50/mo for 20 interviews)',
+    ],
+    cons: [
+      'Newer platform with a smaller prebuilt question library than the incumbents',
+      'Smaller brand and community than HackerRank or CodeSignal',
+      'ATS integrations start on the Scale tier rather than the entry plan',
+    ],
+    bestForParagraph:
+      'CoderScreen fits teams that want a modern, live technical interview without the vendor lock-in, add-on fees, or sales-gated quotes common in this category. Because it is open source, you can inspect it, extend it, or self-host it, and the system-design whiteboard and interview playback come standard rather than as paid upgrades.',
+  },
+
+  coderpad: {
+    slug: 'coderpad',
+    name: 'CoderPad',
+    website: 'https://coderpad.io',
+    logo: '/company-logos/coderpad.png',
+    rating: { score: 4.4, source: 'G2', count: 435 },
+    bestForTag: 'A polished live-interview IDE with broad language support',
+    startingPrice: 'Free, then $80/mo (annual)',
+    freeOption: 'Free plan (2 tests/mo) + 14-day trial',
+    idealTeamSize: 'Small teams to mid-market',
+    pricingTiers: [
+      'Free: 2 tests/mo, pads expire after 4 days',
+      'Starter: $120/mo ($80/mo annual), 5 tests/mo, 400+ questions',
+      'Team: $400/mo, 30 tests/mo, 1,400+ questions',
+      'Custom/Enterprise: AI Reviewer, ATS, SSO, anti-cheat',
+    ],
+    keyFeatures: [
+      'Collaborative IDE with integrated video',
+      '99+ languages and frameworks',
+      'Code playback',
+      'CodinGame-based gamified Screen module',
+      'SOC 2 Type 2',
+    ],
+    pros: [
+      'Intuitive real-time collaborative editor that candidates find easy to use',
+      'Code playback shows how a candidate thinks and debugs',
+      'Very broad language and framework coverage',
+    ],
+    cons: [
+      'Free plan is very limited (2 tests/mo, pads expire in 4 days)',
+      'Open API and advanced features are locked to the top tiers',
+      'Native ATS integrations are thinner than HackerRank',
+      'Overages billed at $25 per extra test',
+    ],
+    bestForParagraph:
+      'CoderPad is a strong choice for teams that mainly run live technical interviews and want a refined editor with wide language support. The tradeoffs are a restrictive free plan and paid tiers that gate integrations and API access behind the more expensive plans.',
+  },
+
+  codesignal: {
+    slug: 'codesignal',
+    name: 'CodeSignal',
+    website: 'https://codesignal.com',
+    logo: '/company-logos/codesignal.png',
+    rating: { score: 4.5, source: 'G2', count: 1408 },
+    bestForTag: 'Standardized, defensible scoring for high-volume hiring',
+    startingPrice: '$79/mo (annual)',
+    freeOption: 'No free hiring tier',
+    idealTeamSize: 'Mid-market to enterprise',
+    pricingTiers: [
+      'Build: $99/mo ($79/mo annual), 60 credits/yr',
+      'Grow: $599/mo ($479/mo annual), 420 credits/yr',
+      'Pro/Enterprise: custom, advanced fraud prevention, RBAC',
+    ],
+    keyFeatures: [
+      'Standardized Coding Score for comparable results',
+      'Real-IDE assessments across 70+ languages',
+      'AI Interviewer spanning engineering and business roles',
+      'Benchmarking data and analytics',
+    ],
+    pros: [
+      'Standardized scoring makes candidate comparisons defensible in a hiring committee',
+      'Realistic real-IDE tasks rather than puzzle-style editors',
+      'AI Interviewer extends beyond engineering into sales and finance',
+      'Trusted at scale by companies like Google, Meta, and Anthropic',
+    ],
+    cons: [
+      'No public enterprise pricing and no free hiring tier to test first',
+      'Credit model escalates quickly, with $20 per overage credit',
+      'Large jump in price from the Build to the Grow tier',
+      'Integrity monitoring is narrower than HackerRank',
+    ],
+    bestForParagraph:
+      'CodeSignal suits mid-to-large engineering teams that hire continuously and need scores they can defend in a calibration meeting. It is a premium option: the credit model and the step up to the Grow tier make it expensive for teams with low or occasional hiring volume.',
+  },
+
+  hackerrank: {
+    slug: 'hackerrank',
+    name: 'HackerRank',
+    website: 'https://www.hackerrank.com',
+    logo: '/company-logos/hackerrank.jpg',
+    rating: { score: 4.5, source: 'G2' },
+    bestForTag: 'Volume developer hiring with deep proctoring and ATS support',
+    startingPrice: '$165/mo ($1,990/yr)',
+    freeOption: 'No free employer plan',
+    idealTeamSize: 'Growing teams to enterprise',
+    pricingTiers: [
+      'Starter: $165/mo ($1,990/yr), 1 user, 120 attempts/yr',
+      'Pro: $375/mo ($4,490/yr), unlimited users, 300 attempts/yr, ATS',
+      'Enterprise: custom, 7,500+ questions, SSO/SCIM, 40+ integrations',
+    ],
+    keyFeatures: [
+      'Large, validated question library',
+      'Screen plus Interview covers the full funnel',
+      'Strong plagiarism detection and proctoring',
+      '40+ ATS integrations on Enterprise',
+    ],
+    pros: [
+      'Huge, industrial-psychologist-validated question bank',
+      'Covers the whole funnel from take-home screen to live interview',
+      'Strong anti-cheat and wide ATS support',
+      'Many candidates already know the format, and Starter/Pro pricing is published',
+    ],
+    cons: [
+      'No free employer plan, and $165/mo is steep for occasional hiring',
+      'Attempt-based metering can inflate real costs',
+      'Some questions feel dated and there is no integrated debugger',
+      'Timed tests stress some candidates',
+    ],
+    bestForParagraph:
+      'HackerRank is the safe, established pick for engineering teams hiring developers at volume, where the question library, proctoring, and ATS depth justify the cost. It is harder to justify for small teams making occasional hires given the entry price and lack of a free employer plan.',
+  },
+
+  coderbyte: {
+    slug: 'coderbyte',
+    name: 'Coderbyte',
+    website: 'https://coderbyte.com',
+    logo: '/company-logos/coderbyte.png',
+    rating: { score: 4.5, source: 'G2', count: 300 },
+    bestForTag: 'Predictable flat pricing for unlimited async screening',
+    startingPrice: '$199/mo',
+    freeOption: '14-day trial',
+    idealTeamSize: 'Small teams to mid-market',
+    pricingTiers: [
+      'Monthly: $199/mo, unlimited candidates, up to 10 simultaneous',
+      'Annual: $1,799/yr, up to 50 simultaneous',
+      'Enterprise: $12,495/yr, 100-500 simultaneous',
+      'Add-ons (ATS, SSO, branding, proctoring) priced separately',
+    ],
+    keyFeatures: [
+      'Unlimited-usage plans with locked pricing',
+      'Screening, take-home projects, and interviews',
+      'Automated grading and reporting',
+      'Cheating detection and video responses',
+    ],
+    pros: [
+      'Transparent, predictable, unlimited-usage pricing',
+      'Covers screening through to interview in one tool',
+      'Affordable flat entry price with unlimited AI credits',
+    ],
+    cons: [
+      'Many features (ATS, SSO, branding, proctoring) are paid add-ons',
+      'Native ATS integrations are limited out of the box',
+      'Some reviewers report support and candidate-experience gaps',
+    ],
+    bestForParagraph:
+      'Coderbyte works well for teams that want predictable, flat pricing for unlimited asynchronous screening and take-home projects. Watch the add-on model: the headline price is low, but ATS, SSO, branding, and advanced proctoring each cost extra on top.',
+  },
+
+  codeinterview: {
+    slug: 'codeinterview',
+    name: 'CodeInterview',
+    website: 'https://codeinterview.io',
+    logo: '/company-logos/codeinterview.png',
+    rating: { score: 4.5, source: 'G2', count: 53 },
+    bestForTag: 'A simple, affordable live coding interview tool',
+    startingPrice: 'Free, then ~$89/mo',
+    freeOption: 'Free plan (2 interviews/mo) + 14-day trial',
+    idealTeamSize: 'Small to mid-sized teams',
+    pricingTiers: [
+      'Free: 2 interviews/mo',
+      'Starter: ~$89/mo, 8 interviews/mo',
+      'Pro: ~$320/mo, 40 interviews/mo',
+      'Enterprise: custom, SSO, API, ATS integration',
+    ],
+    keyFeatures: [
+      'Collaborative code editor with 40+ languages',
+      'Shell access, code playback, and video calling',
+      'Whiteboard, private notes, and templates',
+      'Chrome extension',
+    ],
+    pros: [
+      'Simple and fast to run interviews',
+      'Transparent pricing with a genuine free tier',
+      'Candidate-friendly, with whiteboard and playback included',
+    ],
+    cons: [
+      'Focused on live interviews, lighter on automated assessments and take-homes',
+      'ATS, SSO, and API are gated to the Enterprise tier',
+      'Smaller question library and fewer enterprise features',
+    ],
+    bestForParagraph:
+      'CodeInterview is a good fit for small-to-mid teams that want a straightforward, affordable live coding interview tool without a heavy assessment suite. Larger teams that need ATS, SSO, or API access will need the Enterprise tier.',
+  },
+
+  testgorilla: {
+    slug: 'testgorilla',
+    name: 'TestGorilla',
+    website: 'https://www.testgorilla.com',
+    logo: '/company-logos/testgorilla.png',
+    rating: { score: 4.5, source: 'G2' },
+    bestForTag: 'Broad skills testing across many roles, not just coding',
+    startingPrice: 'Free, then $142/mo (annual)',
+    freeOption: 'Free plan (10 credits/mo)',
+    idealTeamSize: 'SMBs to mid-market hiring across roles',
+    pricingTiers: [
+      'Free: 5 essential tests, 10 credits/mo',
+      'Core: $142/mo ($1,704/yr), 350+ test library, 250 credits',
+      'Plus: from $400/mo, AI interviews, custom tests, ATS, API',
+      'Enterprise: custom. Paid plans require a 12-month commitment',
+    ],
+    keyFeatures: [
+      '350+ tests: coding, cognitive, personality, role-specific',
+      'AI video interviews and AI resume scoring',
+      'Anti-cheat monitoring',
+      'Candidate sourcing pool and ATS integrations (Plus)',
+    ],
+    pros: [
+      'Huge breadth of tests to screen almost any role, not only engineers',
+      'Generous free plan to try skills-based hiring',
+      'Easy enough for non-technical recruiters to run',
+      'AI video interviews and resume scoring built in',
+    ],
+    cons: [
+      'Paid plans require a 12-month commitment, rough for occasional hiring',
+      'Credit-based pricing scales with volume',
+      'Coding assessment depth is shallower than dedicated developer tools',
+      'ATS integrations and API require the Plus plan',
+    ],
+    bestForParagraph:
+      'TestGorilla is best for teams hiring across many different roles that want one library of skills tests rather than a dedicated coding tool. For deep engineering assessment or live technical interviews you will get more signal from a developer-focused platform, and the mandatory annual commitment can sting smaller teams.',
+  },
+
+  leetcode: {
+    slug: 'leetcode',
+    name: 'LeetCode',
+    website: 'https://leetcode.com',
+    logo: '/company-logos/leetcode.png',
+    rating: { score: 4.2, source: 'G2', count: 18 },
+    bestForTag: 'Candidate practice for FAANG-style algorithm interviews',
+    startingPrice: 'Free, Premium $35/mo',
+    freeOption: 'Free (3,000+ problems)',
+    idealTeamSize: 'Individual candidates; limited employer use',
+    pricingTiers: [
+      'Free: 3,000+ practice problems',
+      'Premium: $35/mo or $159/yr (company tags, editorials, debugger)',
+      'Employer assessments: enterprise, custom pricing',
+    ],
+    keyFeatures: [
+      'Largest FAANG-style algorithm problem library',
+      'Company-tagged questions and weekly contests',
+      'In-browser editor with 20+ languages',
+      'Premium editorials and integrated debugger',
+    ],
+    pros: [
+      'Largest and most relevant problem set for algorithm interviews',
+      'Company tags show what specific firms ask',
+      'Active community with many solution approaches',
+      'Generous free tier for candidate practice',
+    ],
+    cons: [
+      'Built for candidate practice, not employer hiring or interviewing',
+      'Thin assessment and interview tooling for hiring teams',
+      'Limited system-design coverage',
+      'Best features require Premium; can reward memorization',
+    ],
+    bestForParagraph:
+      'LeetCode is the default for candidates practicing algorithm interviews, and its problem library is unmatched. But it is a practice platform, not a hiring tool. If you are an employer who needs to run live interviews or scored assessments, you want a platform built for that, which is where the alternatives below come in.',
+  },
+
+  karat: {
+    slug: 'karat',
+    name: 'Karat',
+    website: 'https://karat.com',
+    logo: '/company-logos/karat.png',
+    // No reliable public G2 score; shown as unrated rather than inventing a number.
+    bestForTag: 'Outsourced technical interviews run by human interviewers',
+    startingPrice: 'Custom (per interview)',
+    freeOption: 'No free plan',
+    idealTeamSize: 'Enterprises with high interview volume',
+    pricingTiers: [
+      'Custom, per-interview (~$200-450/interview by volume)',
+      'Minimum annual interview-volume commitments',
+      'Onboarding and custom-rubric fees quoted separately',
+      'Multi-year terms unlock lower per-interview rates',
+    ],
+    keyFeatures: [
+      'Interview-as-a-service with trained interviewers',
+      '24/7 scheduling and standardized rubrics',
+      'Structured scorecards and interview recordings',
+      'ATS integrations (Greenhouse, Lever, and others)',
+    ],
+    pros: [
+      'Offloads first-round technical interviewing from your engineers',
+      '24/7 trained, calibrated interviewers',
+      'Standardized rubrics reduce interviewer bias',
+      'Scales interview capacity without hiring more engineers',
+    ],
+    cons: [
+      'No public pricing and expensive on a per-interview basis',
+      'Minimum volume commitments, impractical for startups',
+      'Outsourced interviewers may miss company and culture fit',
+      'Covers technical roles only, and you still source candidates yourself',
+    ],
+    bestForParagraph:
+      'Karat fits large organizations that want to outsource high-volume first-round technical interviews to trained external interviewers. For most teams, especially startups and scale-ups, running your own interviews on a modern platform is far cheaper and keeps your engineers close to the hiring signal.',
+  },
+
+  qualified: {
+    slug: 'qualified',
+    name: 'Qualified',
+    website: 'https://www.qualified.io',
+    logo: '/company-logos/qualified.png',
+    rating: { score: 4.8, source: 'G2' },
+    bestForTag: 'Unit-test-driven, project-based coding assessments',
+    startingPrice: 'Custom (quote)',
+    freeOption: '14-day trial (up to 5 results)',
+    idealTeamSize: 'Mid-market to enterprise dev hiring',
+    pricingTiers: [
+      'No public pricing; custom quote (est. $100-500/mo range)',
+      '14-day free trial, capped at 5 assessment results',
+      'Seats: configurable managers and reviewers',
+      'Add-ons: SSO, ATS integration, API, dedicated account manager',
+    ],
+    keyFeatures: [
+      'Unit-test-driven coding challenges and project assessments',
+      'Browser IDE plus external IDE sync',
+      'Automated scoring and code playback',
+      'Pair-programming mode and code-similarity checks',
+    ],
+    pros: [
+      'Realistic, test-driven assessments produce strong hiring signal',
+      'Developer-friendly experience, including an external IDE option',
+      'Automated scoring saves reviewer time',
+      'High third-party review scores for content quality',
+    ],
+    cons: [
+      'No public pricing and no free plan (trial capped at 5 results)',
+      'Assessment-only, so it does not source candidates or run live interviews',
+      'Controlled sandbox strips the AI tools candidates use day to day',
+      'Opaque pricing means a sales call before you can properly test it',
+    ],
+    bestForParagraph:
+      'Qualified is a strong pick for teams that want rigorous, unit-test-driven coding assessments with a developer-friendly experience. It is assessment-focused, so you will still need a tool for live interviews, and the quote-only pricing means a sales call before you can properly volume-test it.',
+  },
+
+  codesubmit: {
+    slug: 'codesubmit',
+    name: 'CodeSubmit',
+    website: 'https://www.codesubmit.io',
+    logo: '/company-logos/codesubmit.png',
+    rating: { score: 4.9, source: 'G2', count: 12 },
+    bestForTag: 'Real-world take-home assignments candidates enjoy',
+    startingPrice: 'Free trial, then $49/mo',
+    freeOption: 'Free trial',
+    idealTeamSize: 'Startups to mid-market',
+    pricingTiers: [
+      'Solo: $49/mo, 3 candidates/mo, 1 active assignment',
+      'Startup: $199/mo, 15 candidates/mo',
+      'Scaleup: $299/mo, 30 candidates/mo, ATS, branding',
+      'Business: $499/mo, 60 candidates/mo. Enterprise from $12k/yr',
+    ],
+    keyFeatures: [
+      'Real-world take-home coding assignments',
+      'CodePair live interviews and short "Bytes" questions',
+      'Large challenge library plus custom and AI-built challenges',
+      'Plagiarism checks and ATS integrations (Scaleup and up)',
+    ],
+    pros: [
+      'Simple, transparent, upfront pricing with no sales gate to start',
+      'Take-home assignments plus live pairing in one tool',
+      'Strong, low-stress candidate experience',
+      'Large library of ready-made, real-world challenges',
+    ],
+    cons: [
+      'Per-candidate monthly quotas, with $20 overage per extra candidate',
+      'ATS, custom branding, and SSO are gated to higher tiers or add-ons',
+      'Can get pricey at higher hiring volume',
+      'Assessment-first, lighter on structured live-interview features',
+    ],
+    bestForParagraph:
+      'CodeSubmit is a great fit for teams that want realistic take-home assignments with a friendly candidate experience and clear, published pricing. Watch the per-candidate quotas and the features gated to higher tiers (ATS, branding, SSO) as your hiring volume grows.',
+  },
+};