diff --git a/feature/pdf/src/androidHostTest/kotlin/org/groundplatform/feature/pdf/render/FakePdfCanvas.kt b/feature/pdf/src/androidHostTest/kotlin/org/groundplatform/feature/pdf/render/FakePdfCanvas.kt
index e0dc2efe08..d40479cd30 100644
--- a/feature/pdf/src/androidHostTest/kotlin/org/groundplatform/feature/pdf/render/FakePdfCanvas.kt
+++ b/feature/pdf/src/androidHostTest/kotlin/org/groundplatform/feature/pdf/render/FakePdfCanvas.kt
@@ -20,15 +20,17 @@ import android.text.StaticLayout
 import org.groundplatform.feature.pdf.render.image.PdfImage
 
 internal class FakePdfCanvas : PdfCanvas {
-  val startedPages = mutableListOf<Int>()
+  val startedPageNumbers = mutableListOf<Int>()
+  val startedPageSizes = mutableListOf<PdfPageSize>()
   var finishedPages = 0
   val drawnText = mutableListOf<String>()
   val drawnImages = mutableListOf<PdfImage>()
   val drawnLines = mutableListOf<PdfLine>()
   val drawnOverlays = mutableListOf<Pair<MapOverlay, Boolean>>()
 
-  override fun startPage(pageNumber: Int) {
-    startedPages += pageNumber
+  override fun startPage(pageNumber: Int, pageSize: PdfPageSize) {
+    startedPageNumbers += pageNumber
+    startedPageSizes += pageSize
   }
 
   override fun finishPage() {
diff --git a/feature/pdf/src/androidHostTest/kotlin/org/groundplatform/feature/pdf/render/PdfCanvasTest.kt b/feature/pdf/src/androidHostTest/kotlin/org/groundplatform/feature/pdf/render/PdfCanvasTest.kt
index 2f0adcecc7..f19c33f755 100644
--- a/feature/pdf/src/androidHostTest/kotlin/org/groundplatform/feature/pdf/render/PdfCanvasTest.kt
+++ b/feature/pdf/src/androidHostTest/kotlin/org/groundplatform/feature/pdf/render/PdfCanvasTest.kt
@@ -31,7 +31,7 @@ class PdfCanvasTest {
     val layout = StaticLayout.Builder.obtain("body", 0, "body".length, TextPaint(), 100).build()
     val image = PdfImage(Bitmap.createBitmap(10, 10, Bitmap.Config.ARGB_8888))
     with(MeasurementPdfCanvas) {
-      startPage(pageNumber = 1)
+      startPage(pageNumber = 1, pageSize = PdfConfig.REPORT_PAGE_SIZE)
       drawStaticLayout(layout, x = 0f, y = 0f)
       drawImage(image, RectF(0f, 0f, 10f, 10f), smoothScaling = true)
       drawLine(0f, 0f, 10f, 10f)
diff --git a/feature/pdf/src/androidHostTest/kotlin/org/groundplatform/feature/pdf/render/PdfWriterTest.kt b/feature/pdf/src/androidHostTest/kotlin/org/groundplatform/feature/pdf/render/PdfWriterTest.kt
index e0bae8dc8d..c8ab98a852 100644
--- a/feature/pdf/src/androidHostTest/kotlin/org/groundplatform/feature/pdf/render/PdfWriterTest.kt
+++ b/feature/pdf/src/androidHostTest/kotlin/org/groundplatform/feature/pdf/render/PdfWriterTest.kt
@@ -46,16 +46,43 @@ class PdfWriterTest {
 
     newPdfWriter(EMPTY_DOCUMENT, PdfImageSet(emptyMap()), canvas).drawDocument(EMPTY_DOCUMENT)
 
-    assertEquals(0, canvas.startedPages.size)
+    assertEquals(0, canvas.startedPageNumbers.size)
     assertEquals(0, canvas.finishedPages)
   }
 
   @Test
-  fun `opens and closes exactly one page for a single-page document`() {
+  fun `opens and closes a qr page and one content page for a single-page document`() {
     val canvas = renderDocument(SINGLE_PAGE_DOCUMENT)
 
-    assertEquals(listOf(1), canvas.startedPages)
-    assertEquals(1, canvas.finishedPages)
+    assertEquals(listOf(1, 2), canvas.startedPageNumbers)
+    assertEquals(2, canvas.finishedPages)
+  }
+
+  @Test
+  fun `draws the qr on an A7 page ahead of the A4 content pages`() {
+    val canvas = renderDocument(SINGLE_PAGE_DOCUMENT)
+
+    assertEquals(
+      listOf(PdfConfig.QR_PAGE_SIZE, PdfConfig.REPORT_PAGE_SIZE),
+      canvas.startedPageSizes,
+    )
+  }
+
+  @Test
+  fun `does not open a qr page when no qr image is provided`() {
+    val canvas = renderDocument(SINGLE_PAGE_DOCUMENT, pdfImageSet(qr = null))
+
+    assertEquals(listOf(PdfConfig.REPORT_PAGE_SIZE), canvas.startedPageSizes)
+  }
+
+  @Test
+  fun `draws no header or footer on the qr page`() {
+    val tableless =
+      SINGLE_PAGE_DOCUMENT.copy(table = SINGLE_PAGE_DOCUMENT.table.copy(rows = emptyList()))
+
+    val canvas = renderDocument(tableless, pdfImageSet(qr = pdfImage()))
+
+    assertEquals(listOf(QR_BLOCK.submissionName, QR_BLOCK.scanCaption), canvas.drawnText)
   }
 
   @Test
@@ -86,10 +113,10 @@ class PdfWriterTest {
 
     pdfWriter.drawDocument(TEST_PDF_DOCUMENT)
 
-    assertTrue(pdfWriter.pageCount > 1)
-    assertEquals(pdfWriter.pageCount, canvas.drawnText.count { it == HEADER.surveyName })
+    assertTrue(pdfWriter.bodyPageCount > 1)
+    assertEquals(pdfWriter.bodyPageCount, canvas.drawnText.count { it == HEADER.surveyName })
     assertEquals(
-      pdfWriter.pageCount,
+      pdfWriter.bodyPageCount,
       canvas.drawnText.count {
         it == "${FOOTER.dataCollectorLabel}: ${FOOTER.dataCollectorName}, ${FOOTER.userEmail}"
       },
@@ -97,12 +124,13 @@ class PdfWriterTest {
   }
 
   @Test
-  fun `draws the qr image and caption when a qr image is provided`() {
+  fun `draws the qr image, its submission title and caption when a qr image is provided`() {
     val qr = pdfImage()
     val canvas = renderDocument(SINGLE_PAGE_DOCUMENT, pdfImageSet(qr = qr))
 
     assertTrue(canvas.drawnImages.any { it.bitmap === qr.bitmap })
     assertTrue(canvas.drawnText.contains(QR_BLOCK.scanCaption))
+    assertTrue(canvas.drawnText.contains(QR_BLOCK.submissionName))
   }
 
   @Test
@@ -144,7 +172,7 @@ class PdfWriterTest {
   }
 
   @Test
-  fun `includes the page number in the footer when totalPages is set`() {
+  fun `numbers the content pages in the footer, leaving the qr page out of the count`() {
     val canvas = renderDocument(SINGLE_PAGE_DOCUMENT, totalPages = 1)
 
     assertTrue(canvas.drawnText.contains("1/1"))
@@ -175,8 +203,8 @@ class PdfWriterTest {
     pdfWriter.drawDocument(TEST_PDF_DOCUMENT)
 
     // Every page resets the flag, so each page's first row draws exactly 1 top border.
-    assertTrue(pdfWriter.pageCount > 1)
-    assertEquals(pdfWriter.pageCount, canvas.topBorderCount())
+    assertTrue(pdfWriter.bodyPageCount > 1)
+    assertEquals(pdfWriter.bodyPageCount, canvas.topBorderCount())
   }
 
   @Test
@@ -186,7 +214,7 @@ class PdfWriterTest {
 
     val canvas = renderDocument(tableless, pdfImageSet(qr = pdfImage()))
 
-    assertEquals(listOf(1), canvas.startedPages)
+    assertEquals(listOf(1), canvas.startedPageNumbers)
     assertFalse(canvas.drawnText.contains(TABLE.submissionLabel))
   }
 
@@ -200,7 +228,7 @@ class PdfWriterTest {
   private fun renderPageCount(totalPages: Int?): Int =
     newPdfWriter(TEST_PDF_DOCUMENT, PdfImageSet(emptyMap()), MeasurementPdfCanvas, totalPages)
       .apply { drawDocument(TEST_PDF_DOCUMENT) }
-      .pageCount
+      .bodyPageCount
 
   private fun newPdfWriter(
     document: SubmissionPdfDocument,
@@ -252,7 +280,7 @@ class PdfWriterTest {
         userEmail = "user@gmail.com",
       )
 
-    val QR_BLOCK = SubmissionPdfDocument.QrBlock(scanCaption = "Scan")
+    val QR_BLOCK = SubmissionPdfDocument.QrBlock(submissionName = "Plot 42", scanCaption = "Scan")
 
     val TABLE =
       SubmissionPdfDocument.Table(
diff --git a/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/AndroidPdfImageProvider.kt b/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/AndroidPdfImageProvider.kt
index 5e41d143f8..b732d528aa 100644
--- a/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/AndroidPdfImageProvider.kt
+++ b/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/AndroidPdfImageProvider.kt
@@ -33,7 +33,7 @@ import kotlinx.coroutines.coroutineScope
 import org.groundplatform.feature.pdf.render.fitInside
 import org.groundplatform.feature.pdf.render.image.PdfImage
 import org.groundplatform.feature.pdf.render.image.PdfImageSet
-import org.groundplatform.feature.pdf.render.layout.QrBlockLayout
+import org.groundplatform.feature.pdf.render.layout.QrPageLayout
 import org.groundplatform.feature.pdf.render.layout.TableLayout
 import org.groundplatform.feature.pdf.render.pointsToRenderPixels
 import org.groundplatform.ui.components.qrcode.PDF_LOGO_SIZE_FRACTION
@@ -56,7 +56,7 @@ class AndroidPdfImageProvider(
   @DrawableRes private val logoDrawableRes: Int,
 ) : PdfImageProvider {
 
-  private val qrMaxPx = pointsToRenderPixels(QrBlockLayout.QR_SIZE)
+  private val qrMaxPx = pointsToRenderPixels(QrPageLayout.QR_SIZE)
   private val photoMaxWidthPx = pointsToRenderPixels(TableLayout.ANSWER_TEXT_WIDTH.toFloat())
   private val photoMaxHeightPx = pointsToRenderPixels(TableLayout.PHOTO_MAX_HEIGHT.toFloat())
 
diff --git a/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/AndroidPdfRenderer.kt b/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/AndroidPdfRenderer.kt
index 19d0949e86..037e632407 100644
--- a/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/AndroidPdfRenderer.kt
+++ b/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/AndroidPdfRenderer.kt
@@ -55,7 +55,7 @@ class AndroidPdfRenderer(private val ioDispatcher: CoroutineDispatcher) : PdfRen
   private fun measurePageCount(document: SubmissionPdfDocument, images: PdfImageSet): Int =
     writer(document, images, MeasurementPdfCanvas, totalPages = null)
       .apply { drawDocument(document) }
-      .pageCount
+      .bodyPageCount
 
   private fun writer(
     document: SubmissionPdfDocument,
diff --git a/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/DocumentPdfCanvas.kt b/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/DocumentPdfCanvas.kt
index 012c36bed2..5064c2ab2a 100644
--- a/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/DocumentPdfCanvas.kt
+++ b/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/DocumentPdfCanvas.kt
@@ -65,9 +65,8 @@ internal class DocumentPdfCanvas(private val pdf: PdfDocument) : PdfCanvas {
 
   private val mapOverlayTextPaint = PdfTextPaints().mapOverlay
 
-  override fun startPage(pageNumber: Int) {
-    val info =
-      PdfDocument.PageInfo.Builder(PdfConfig.PAGE_WIDTH, PdfConfig.PAGE_HEIGHT, pageNumber).create()
+  override fun startPage(pageNumber: Int, pageSize: PdfPageSize) {
+    val info = PdfDocument.PageInfo.Builder(pageSize.width, pageSize.height, pageNumber).create()
     currentPage = pdf.startPage(info)
   }
 
diff --git a/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/PdfCanvas.kt b/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/PdfCanvas.kt
index e0fcc07438..da411ad61a 100644
--- a/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/PdfCanvas.kt
+++ b/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/PdfCanvas.kt
@@ -21,7 +21,7 @@ import org.groundplatform.feature.pdf.render.image.PdfImage
 
 /** Abstraction for drawing onto a PDF page. */
 internal interface PdfCanvas {
-  fun startPage(pageNumber: Int)
+  fun startPage(pageNumber: Int, pageSize: PdfPageSize)
 
   fun finishPage()
 
@@ -36,7 +36,7 @@ internal interface PdfCanvas {
 
 /** Used during the page-counting phase. Drops every drawing call. */
 internal object MeasurementPdfCanvas : PdfCanvas {
-  override fun startPage(pageNumber: Int) = Unit
+  override fun startPage(pageNumber: Int, pageSize: PdfPageSize) = Unit
 
   override fun finishPage() = Unit
 
diff --git a/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/PdfTextPaints.kt b/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/PdfTextPaints.kt
index be8defef4b..b41fef74c6 100644
--- a/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/PdfTextPaints.kt
+++ b/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/PdfTextPaints.kt
@@ -25,6 +25,7 @@ import org.groundplatform.feature.pdf.render.PdfConfig.TITLE_SIZE
 internal class PdfTextPaints {
   val title: TextPaint = textPaint(TITLE_SIZE, bold = false)
   val body: TextPaint = textPaint(BODY_SIZE, bold = false)
+  val bodyLabel: TextPaint = textPaint(BODY_SIZE, bold = true)
   val metaLabel: TextPaint = textPaint(CAPTION_SIZE, bold = true, textColor = Color.GRAY)
   val meta: TextPaint = textPaint(CAPTION_SIZE, bold = false, textColor = Color.GRAY)
   val caption: TextPaint = textPaint(CAPTION_SIZE, bold = false)
diff --git a/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/PdfWriter.kt b/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/PdfWriter.kt
index d23bfe5a12..f11adcb4d5 100644
--- a/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/PdfWriter.kt
+++ b/feature/pdf/src/androidMain/kotlin/org/groundplatform/feature/pdf/render/PdfWriter.kt
@@ -36,7 +36,7 @@ import org.groundplatform.feature.pdf.render.image.PdfImage
 import org.groundplatform.feature.pdf.render.image.PdfImageSet
 import org.groundplatform.feature.pdf.render.layout.PageFooterLayout
 import org.groundplatform.feature.pdf.render.layout.PageHeaderLayout
-import org.groundplatform.feature.pdf.render.layout.QrBlockLayout
+import org.groundplatform.feature.pdf.render.layout.QrPageLayout
 import org.groundplatform.feature.pdf.render.layout.TableLayout
 
 /**
@@ -53,16 +53,19 @@ internal class PdfWriter(
 ) : PdfPageController.PageLifecycle {
   private val paints = PdfTextPaints()
 
+  private val coverImage = images[PdfImageSet.ImageRef.Qr]
+
   private val footerLayout: StaticLayout = buildFooterLayout(footer)
   private val cursor =
     PdfCursor(footerReserve = PageFooterLayout.reserve(footerLayout.height.toFloat()))
-  private val pageController = PdfPageController(cursor, this)
+  private val pageController =
+    PdfPageController(cursor, this, coverPages = if (coverImage == null) 0 else 1)
 
-  val pageCount: Int
-    get() = pageController.pageCount
+  val bodyPageCount: Int
+    get() = pageController.bodyPageCount
 
   override fun onPageStarted(pageNumber: Int) {
-    pdfCanvas.startPage(pageNumber)
+    pdfCanvas.startPage(pageNumber, PdfConfig.REPORT_PAGE_SIZE)
     drawPageHeader()
   }
 
@@ -72,26 +75,34 @@ internal class PdfWriter(
   }
 
   fun drawDocument(document: SubmissionPdfDocument) {
-    drawQrBlock(document.qrBlock)
+    drawQrPage(document.qrBlock)
     drawTable(document.table)
     finalizePage()
   }
 
-  private fun drawQrBlock(block: QrBlock) {
-    val qr = images[PdfImageSet.ImageRef.Qr] ?: return
-    pageController.ensurePage()
-    val captionLayout =
+  private fun drawQrPage(block: QrBlock) {
+    val qr = coverImage ?: return
+    val blockWidth = QrPageLayout.QR_SIZE.toInt()
+    val titleLayout =
       staticLayout(
-        block.scanCaption,
-        paints.caption,
-        QrBlockLayout.QR_SIZE.toInt(),
-        Layout.Alignment.ALIGN_CENTER,
+        text = block.submissionName,
+        paint = paints.bodyLabel,
+        maxWidth = blockWidth,
+        alignment = Layout.Alignment.ALIGN_CENTER,
+        maxLines = QrPageLayout.TITLE_MAX_LINES,
       )
+    val captionLayout =
+      staticLayout(block.scanCaption, paints.caption, blockWidth, Layout.Alignment.ALIGN_CENTER)
     val layout =
-      QrBlockLayout.compute(top = cursor.y, captionHeight = captionLayout.height.toFloat())
+      QrPageLayout.compute(
+        titleHeight = titleLayout.height.toFloat(),
+        captionHeight = captionLayout.height.toFloat(),
+      )
+    pdfCanvas.startPage(COVER_PAGE_NUMBER, PdfConfig.QR_PAGE_SIZE)
+    drawStaticLayoutAt(titleLayout, layout.titleOffset)
     drawImage(qr, layout.qrFrame, smoothScaling = false)
     drawStaticLayoutAt(captionLayout, layout.captionOffset)
-    cursor.moveTo(layout.nextCursorY)
+    pdfCanvas.finishPage()
   }
 
   private fun drawTable(table: SubmissionPdfDocument.Table) {
@@ -183,7 +194,7 @@ internal class PdfWriter(
     totalPages?.let { total ->
       val pageNumber =
         staticLayout(
-          "${pageController.pageCount}/$total",
+          "${pageController.bodyPageCount}/$total",
           paints.meta,
           layout.pageNumberMaxWidth,
           alignment = Layout.Alignment.ALIGN_OPPOSITE,
@@ -238,19 +249,19 @@ internal class PdfWriter(
   private fun drawLine(line: PdfLine) =
     pdfCanvas.drawLine(line.startX, line.startY, line.endX, line.endY)
 
-  private fun buildFooterLayout(footer: Footer): StaticLayout {
-    val footerLabel = footer.dataCollectorLabel
-    val footerText =
-      SpannableString("$footerLabel: ${footer.dataCollectorName}, ${footer.userEmail}").apply {
-        setSpan(StyleSpan(Typeface.BOLD), 0, footerLabel.length, Spanned.SPAN_INCLUSIVE_EXCLUSIVE)
-      }
-    return staticLayout(
-      footerText,
+  private fun buildFooterLayout(footer: Footer): StaticLayout =
+    staticLayout(
+      labeled(footer.dataCollectorLabel, "${footer.dataCollectorName}, ${footer.userEmail}"),
       paints.meta,
       PageFooterLayout.TEXT_MAX_WIDTH,
       maxLines = PageFooterLayout.MAX_LINES,
     )
-  }
+
+  /** Builds a `"<label>: <value>"` string with the label in bold. */
+  private fun labeled(label: String, value: String): SpannableString =
+    SpannableString("$label: $value").apply {
+      setSpan(StyleSpan(Typeface.BOLD), 0, label.length, Spanned.SPAN_INCLUSIVE_EXCLUSIVE)
+    }
 
   /**
    * Lays out [text] wrapped to [maxWidth]. When [maxLines] is set, overflow is ellipsized so a
@@ -273,4 +284,12 @@ internal class PdfWriter(
         }
       }
       .build()
+
+  private companion object {
+    /**
+     * The QR page opens the document, so the body pages start at 2 whenever there is this cover
+     * page.
+     */
+    const val COVER_PAGE_NUMBER = 1
+  }
 }
diff --git a/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/mapper/LoiReportMapper.kt b/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/mapper/LoiReportMapper.kt
index 970f49c839..c238338aec 100644
--- a/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/mapper/LoiReportMapper.kt
+++ b/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/mapper/LoiReportMapper.kt
@@ -52,7 +52,7 @@ class LoiReportMapper(
     val document =
       SubmissionPdfDocument(
         header = buildHeader(details, submission),
-        qrBlock = buildQrBlock(),
+        qrBlock = buildQrBlock(loiReport.loiName),
         footer = buildFooter(details),
         table =
           Table(
@@ -93,8 +93,11 @@ class LoiReportMapper(
           dateFormatter.formatTime(submission.lastModified.clientTimestamp),
     )
 
-  private suspend fun buildQrBlock(): QrBlock =
-    QrBlock(scanCaption = strings.resolve(Res.string.scan_this_qr_to_download_geojson))
+  private suspend fun buildQrBlock(loiName: String): QrBlock =
+    QrBlock(
+      submissionName = loiName,
+      scanCaption = strings.resolve(Res.string.scan_this_qr_to_download_geojson),
+    )
 
   private suspend fun buildFooter(details: LoiReport.SubmissionDetails): Footer =
     Footer(
diff --git a/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/model/SubmissionPdfDocument.kt b/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/model/SubmissionPdfDocument.kt
index 5a2f5553d5..8c6ad09f37 100644
--- a/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/model/SubmissionPdfDocument.kt
+++ b/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/model/SubmissionPdfDocument.kt
@@ -38,7 +38,7 @@ data class SubmissionPdfDocument(
     val timestamp: String,
   )
 
-  data class QrBlock(val scanCaption: String)
+  data class QrBlock(val submissionName: String, val scanCaption: String)
 
   data class Table(val submissionLabel: String, val loiName: String, val rows: List<Row>)
 
diff --git a/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/PdfConfig.kt b/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/PdfConfig.kt
index 488cb2e7e2..de80b58557 100644
--- a/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/PdfConfig.kt
+++ b/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/PdfConfig.kt
@@ -28,6 +28,18 @@ internal object PdfConfig {
   /** Page height in points (A4 portrait, 297mm). */
   const val PAGE_HEIGHT = 842
 
+  /** QR page width in points (A7 portrait, 74mm). */
+  const val QR_PAGE_WIDTH = 210
+
+  /** QR page height in points (A7 portrait, 105mm). */
+  const val QR_PAGE_HEIGHT = 298
+
+  /** Size of the report body pages. */
+  val REPORT_PAGE_SIZE = PdfPageSize(PAGE_WIDTH, PAGE_HEIGHT)
+
+  /** Size of the standalone QR page. */
+  val QR_PAGE_SIZE = PdfPageSize(QR_PAGE_WIDTH, QR_PAGE_HEIGHT)
+
   /** Page margin applied to all four edges. */
   const val MARGIN = 40
 
diff --git a/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/PdfGeometry.kt b/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/PdfGeometry.kt
index 3b55da2103..345d3a3a29 100644
--- a/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/PdfGeometry.kt
+++ b/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/PdfGeometry.kt
@@ -28,6 +28,9 @@ internal fun pointsToRenderPixels(points: Float): Int =
 
 internal data class PdfItemSize(val width: Float, val height: Float)
 
+/** Dimensions of a PDF page, in points. */
+internal data class PdfPageSize(val width: Int, val height: Int)
+
 internal data class PdfOffset(val x: Float, val y: Float)
 
 internal data class PdfLine(val startX: Float, val startY: Float, val endX: Float, val endY: Float)
diff --git a/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/PdfPageController.kt b/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/PdfPageController.kt
index 3224310098..bb905dc3f0 100644
--- a/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/PdfPageController.kt
+++ b/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/PdfPageController.kt
@@ -22,6 +22,7 @@ package org.groundplatform.feature.pdf.render
 internal class PdfPageController(
   private val cursor: PdfCursor,
   private val lifecycle: PageLifecycle,
+  private val coverPages: Int = 0,
 ) {
   interface PageLifecycle {
     /** Called after a new page has been allocated. The header should be drawn here. */
@@ -31,15 +32,21 @@ internal class PdfPageController(
     fun onPageEnding(pageNumber: Int)
   }
 
-  private var pageIndex = 0
   private var pageOpen = false
 
   var isFirstTableRowOnPage = true
     private set
 
-  /** Number of pages emitted so far. Equals the current page number while a page is open. */
-  val pageCount: Int
-    get() = pageIndex
+  /**
+   * Number of content pages emitted so far. Does not include cover pages as they have no page
+   * numbering. Equals the current page number while a page is open.
+   */
+  var bodyPageCount: Int = 0
+    private set
+
+  /** Where the current page sits in the PDF itself, counting the cover pages ahead of the body. */
+  private val pdfPageNumber: Int
+    get() = coverPages + bodyPageCount
 
   fun ensurePage() {
     if (!pageOpen) beginPage()
@@ -59,15 +66,15 @@ internal class PdfPageController(
 
   fun finalizePage() {
     if (!pageOpen) return
-    lifecycle.onPageEnding(pageIndex)
+    lifecycle.onPageEnding(pdfPageNumber)
     pageOpen = false
   }
 
   private fun beginPage() {
-    pageIndex++
+    bodyPageCount++
     pageOpen = true
     isFirstTableRowOnPage = true
     cursor.reset()
-    lifecycle.onPageStarted(pageIndex)
+    lifecycle.onPageStarted(pdfPageNumber)
   }
 }
diff --git a/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/layout/QrBlockLayout.kt b/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/layout/QrBlockLayout.kt
deleted file mode 100644
index edf77eb30f..0000000000
--- a/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/layout/QrBlockLayout.kt
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright 2026 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.groundplatform.feature.pdf.render.layout
-
-import org.groundplatform.feature.pdf.render.PdfConfig.LINE_SPACING
-import org.groundplatform.feature.pdf.render.PdfConfig.MARGIN
-import org.groundplatform.feature.pdf.render.PdfConfig.PAGE_WIDTH
-import org.groundplatform.feature.pdf.render.PdfOffset
-import org.groundplatform.feature.pdf.render.PdfRect
-
-/**
- * Pre-computed layout for the right-aligned QR code block with its caption. Compute should only be
- * called when a QR image is available; the caption is meaningless without it.
- *
- * @param qrFrame Position and size of the QR image.
- * @param captionOffset Top-left position of the caption text (centered under the QR).
- * @param nextCursorY Cursor Y position after this block.
- */
-internal data class QrBlockLayout(
-  val qrFrame: PdfRect,
-  val captionOffset: PdfOffset,
-  val nextCursorY: Float,
-) {
-  companion object {
-    /** Target size of the QR code block. */
-    const val QR_SIZE = 200f
-
-    fun compute(top: Float, captionHeight: Float): QrBlockLayout {
-      val x = PAGE_WIDTH - MARGIN - QR_SIZE
-      val captionTop = top + QR_SIZE + LINE_SPACING
-      return QrBlockLayout(
-        qrFrame = PdfRect(x, top, QR_SIZE, QR_SIZE),
-        captionOffset = PdfOffset(x, captionTop),
-        nextCursorY = captionTop + captionHeight + LINE_SPACING * 2,
-      )
-    }
-  }
-}
diff --git a/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/layout/QrPageLayout.kt b/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/layout/QrPageLayout.kt
new file mode 100644
index 0000000000..9d50a6fbe3
--- /dev/null
+++ b/feature/pdf/src/commonMain/kotlin/org/groundplatform/feature/pdf/render/layout/QrPageLayout.kt
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.groundplatform.feature.pdf.render.layout
+
+import org.groundplatform.feature.pdf.render.PdfConfig.LINE_SPACING
+import org.groundplatform.feature.pdf.render.PdfConfig.QR_PAGE_HEIGHT
+import org.groundplatform.feature.pdf.render.PdfConfig.QR_PAGE_WIDTH
+import org.groundplatform.feature.pdf.render.PdfOffset
+import org.groundplatform.feature.pdf.render.PdfRect
+
+/**
+ * Pre-computed layout for the QR page: the submission title, the QR code and its caption centered
+ * on a page of [QR_PAGE_WIDTH] x [QR_PAGE_HEIGHT]. Compute should only be called when a QR image is
+ * available; the title and caption are meaningless without it.
+ *
+ * @param titleOffset Top-left position of the submission title (centered above the QR).
+ * @param qrFrame Position and size of the QR image.
+ * @param captionOffset Top-left position of the caption text (centered under the QR).
+ */
+internal data class QrPageLayout(
+  val titleOffset: PdfOffset,
+  val qrFrame: PdfRect,
+  val captionOffset: PdfOffset,
+) {
+  companion object {
+    const val MARGIN = 16f
+
+    /** Target size of the QR code, spanning the page width between the margins. */
+    const val QR_SIZE = QR_PAGE_WIDTH - 2 * MARGIN
+
+    /** Maximum number of lines rendered for the submission title. */
+    const val TITLE_MAX_LINES = 2
+
+    fun compute(titleHeight: Float, captionHeight: Float): QrPageLayout {
+      val blockHeight = titleHeight + LINE_SPACING + QR_SIZE + LINE_SPACING + captionHeight
+      val top = (QR_PAGE_HEIGHT - blockHeight) / 2
+      val qrTop = top + titleHeight + LINE_SPACING
+      return QrPageLayout(
+        titleOffset = PdfOffset(MARGIN, top),
+        qrFrame = PdfRect(MARGIN, qrTop, QR_SIZE, QR_SIZE),
+        captionOffset = PdfOffset(MARGIN, qrTop + QR_SIZE + LINE_SPACING),
+      )
+    }
+  }
+}
diff --git a/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/PdfExportServiceTest.kt b/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/PdfExportServiceTest.kt
index 3119d6512e..51fbddb925 100644
--- a/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/PdfExportServiceTest.kt
+++ b/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/PdfExportServiceTest.kt
@@ -108,7 +108,7 @@ class PdfExportServiceTest {
             jobName = "Job name",
             timestamp = "timestamp",
           ),
-        qrBlock = SubmissionPdfDocument.QrBlock(scanCaption = "Scan"),
+        qrBlock = SubmissionPdfDocument.QrBlock(submissionName = "Loi", scanCaption = "Scan"),
         footer =
           SubmissionPdfDocument.Footer(
             dataCollectorLabel = "Collector",
diff --git a/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/mapper/LoiReportMapperTest.kt b/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/mapper/LoiReportMapperTest.kt
index 5aeae233af..1041880f56 100644
--- a/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/mapper/LoiReportMapperTest.kt
+++ b/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/mapper/LoiReportMapperTest.kt
@@ -166,6 +166,16 @@ class LoiReportMapperTest {
     assertEquals("Survey_Loi_User_DATE42_TIME42", request!!.fileName)
   }
 
+  @Test
+  fun `qr block carries the labelled submission name and the scan caption`() = runTest {
+    val report = FakeDataGenerator.newLoiReport(loiName = "Loi")
+
+    val qrBlock = mapper.map(report, submission)!!.document.qrBlock
+
+    assertEquals("Loi", qrBlock.submissionName)
+    assertEquals("scan_this_qr_to_download_geojson", qrBlock.scanCaption)
+  }
+
   @Test
   fun `mapper returns null when submissionDetails are missing`() = runTest {
     val report = FakeDataGenerator.newLoiReport(submissionDetails = null)
diff --git a/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/render/PdfPageControllerTest.kt b/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/render/PdfPageControllerTest.kt
index bc2ebdc2a9..86cb91271f 100644
--- a/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/render/PdfPageControllerTest.kt
+++ b/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/render/PdfPageControllerTest.kt
@@ -39,7 +39,7 @@ class PdfPageControllerTest {
 
   @Test
   fun `Should have zero pages at the start`() {
-    assertEquals(0, controller.pageCount)
+    assertEquals(0, controller.bodyPageCount)
     assertTrue(lifecycle.events.isEmpty())
   }
 
@@ -47,7 +47,7 @@ class PdfPageControllerTest {
   fun `ensurePage starts the a page`() {
     controller.ensurePage()
 
-    assertEquals(1, controller.pageCount)
+    assertEquals(1, controller.bodyPageCount)
     assertEquals(listOf<PageEvent>(PageEvent.Started(1)), lifecycle.events)
   }
 
@@ -57,7 +57,7 @@ class PdfPageControllerTest {
     controller.ensurePage()
     controller.ensurePage()
 
-    assertEquals(1, controller.pageCount)
+    assertEquals(1, controller.bodyPageCount)
     assertEquals(listOf<PageEvent>(PageEvent.Started(1)), lifecycle.events)
   }
 
@@ -65,7 +65,7 @@ class PdfPageControllerTest {
   fun `finalizePage does nothing if there is no page open`() {
     controller.finalizePage()
 
-    assertEquals(0, controller.pageCount)
+    assertEquals(0, controller.bodyPageCount)
     assertTrue(lifecycle.events.isEmpty())
   }
 
@@ -75,7 +75,7 @@ class PdfPageControllerTest {
     controller.finalizePage()
     controller.finalizePage()
 
-    assertEquals(1, controller.pageCount)
+    assertEquals(1, controller.bodyPageCount)
     assertEquals(listOf(PageEvent.Started(1), PageEvent.Ending(1)), lifecycle.events)
   }
 
@@ -91,7 +91,7 @@ class PdfPageControllerTest {
   fun `newPageIfShort starts a page if there is none open`() {
     controller.newPageIfShort(spaceNeeded = 10f)
 
-    assertEquals(1, controller.pageCount)
+    assertEquals(1, controller.bodyPageCount)
     assertEquals(listOf<PageEvent>(PageEvent.Started(1)), lifecycle.events)
   }
 
@@ -99,7 +99,7 @@ class PdfPageControllerTest {
   fun `newPageIfShort does not emit more pages if impossible to fit content in a new page`() {
     controller.newPageIfShort(spaceNeeded = Float.MAX_VALUE)
 
-    assertEquals(1, controller.pageCount)
+    assertEquals(1, controller.bodyPageCount)
     assertEquals(listOf<PageEvent>(PageEvent.Started(1)), lifecycle.events)
   }
 
@@ -110,7 +110,7 @@ class PdfPageControllerTest {
 
     controller.newPageIfShort(spaceNeeded = 10f)
 
-    assertEquals(1, controller.pageCount)
+    assertEquals(1, controller.bodyPageCount)
     assertTrue(lifecycle.events.isEmpty())
   }
 
@@ -122,7 +122,7 @@ class PdfPageControllerTest {
 
     controller.newPageIfShort(spaceNeeded = Float.MAX_VALUE)
 
-    assertEquals(2, controller.pageCount)
+    assertEquals(2, controller.bodyPageCount)
     assertEquals(listOf(PageEvent.Ending(1), PageEvent.Started(2)), lifecycle.events)
   }
 
@@ -145,7 +145,7 @@ class PdfPageControllerTest {
     controller.newPageIfShort(spaceNeeded = Float.MAX_VALUE)
     controller.finalizePage()
 
-    assertEquals(3, controller.pageCount)
+    assertEquals(3, controller.bodyPageCount)
     assertEquals(
       listOf(
         PageEvent.Started(1),
@@ -160,13 +160,37 @@ class PdfPageControllerTest {
   }
 
   @Test
-  fun `pageCount reflects the current page number while the page is open`() {
+  fun `bodyPageCount reflects the current page number while the page is open`() {
     controller.ensurePage()
-    assertEquals(1, controller.pageCount)
+    assertEquals(1, controller.bodyPageCount)
 
     cursor.advance(100f)
     controller.newPageIfShort(spaceNeeded = Float.MAX_VALUE)
-    assertEquals(2, controller.pageCount)
+    assertEquals(2, controller.bodyPageCount)
+  }
+
+  @Test
+  fun `a cover page pushes the body down the document`() {
+    val controller = PdfPageController(cursor, lifecycle, coverPages = 1)
+
+    controller.ensurePage()
+
+    assertEquals(listOf<PageEvent>(PageEvent.Started(2)), lifecycle.events)
+  }
+
+  @Test
+  fun `a cover page is left out of the page count`() {
+    val controller = PdfPageController(cursor, lifecycle, coverPages = 1)
+
+    controller.ensurePage()
+    cursor.advance(100f)
+    controller.newPageIfShort(spaceNeeded = Float.MAX_VALUE)
+
+    assertEquals(
+      listOf(PageEvent.Started(2), PageEvent.Ending(2), PageEvent.Started(3)),
+      lifecycle.events,
+    )
+    assertEquals(2, controller.bodyPageCount)
   }
 
   @Test
diff --git a/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/render/layout/QrBlockLayoutTest.kt b/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/render/layout/QrBlockLayoutTest.kt
deleted file mode 100644
index eabb71ddc0..0000000000
--- a/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/render/layout/QrBlockLayoutTest.kt
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright 2026 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.groundplatform.feature.pdf.render.layout
-
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import org.groundplatform.feature.pdf.render.PdfConfig
-import org.groundplatform.feature.pdf.render.layout.QrBlockLayout.Companion.QR_SIZE
-
-class QrBlockLayoutTest {
-
-  private val margin = PdfConfig.MARGIN
-  private val pageWidth = PdfConfig.PAGE_WIDTH
-  private val qrSize = QR_SIZE
-  private val lineSpacing = PdfConfig.LINE_SPACING
-
-  private val expectedX = pageWidth - margin - qrSize
-
-  @Test
-  fun `QR frame is a square anchored at the right margin`() {
-    val layout = QrBlockLayout.compute(top = 0f, captionHeight = 10f)
-
-    assertEquals(expectedX, layout.qrFrame.x)
-    assertEquals(0f, layout.qrFrame.y)
-    assertEquals(qrSize, layout.qrFrame.width)
-    assertEquals(qrSize, layout.qrFrame.height)
-    assertEquals((pageWidth - margin).toFloat(), layout.qrFrame.right)
-  }
-
-  @Test
-  fun `caption sits directly below the QR with line spacing between them`() {
-    val top = 100f
-    val layout = QrBlockLayout.compute(top = top, captionHeight = 10f)
-
-    assertEquals(expectedX, layout.captionOffset.x)
-    assertEquals(top + qrSize + lineSpacing, layout.captionOffset.y)
-  }
-
-  @Test
-  fun `caption shares its X with the QR frame`() {
-    val layout = QrBlockLayout.compute(top = 0f, captionHeight = 10f)
-
-    assertEquals(layout.qrFrame.x, layout.captionOffset.x)
-  }
-
-  @Test
-  fun `nextCursorY accounts for QR, caption, and trailing spacing`() {
-    val top = 50f
-    val captionHeight = 14f
-    val layout = QrBlockLayout.compute(top = top, captionHeight = captionHeight)
-
-    val expectedCaptionTop = top + qrSize + lineSpacing
-    assertEquals(expectedCaptionTop + captionHeight + lineSpacing * 2, layout.nextCursorY)
-  }
-}
diff --git a/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/render/layout/QrPageLayoutTest.kt b/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/render/layout/QrPageLayoutTest.kt
new file mode 100644
index 0000000000..1442faa5e9
--- /dev/null
+++ b/feature/pdf/src/commonTest/kotlin/org/groundplatform/feature/pdf/render/layout/QrPageLayoutTest.kt
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.groundplatform.feature.pdf.render.layout
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.groundplatform.feature.pdf.render.PdfConfig
+import org.groundplatform.feature.pdf.render.layout.QrPageLayout.Companion.MARGIN
+import org.groundplatform.feature.pdf.render.layout.QrPageLayout.Companion.QR_SIZE
+
+class QrPageLayoutTest {
+
+  private val pageWidth = PdfConfig.QR_PAGE_WIDTH
+  private val pageHeight = PdfConfig.QR_PAGE_HEIGHT
+  private val lineSpacing = PdfConfig.LINE_SPACING
+
+  @Test
+  fun `QR frame is a square spanning the page width between the margins`() {
+    val layout = compute()
+
+    assertEquals(MARGIN, layout.qrFrame.x)
+    assertEquals(QR_SIZE, layout.qrFrame.width)
+    assertEquals(QR_SIZE, layout.qrFrame.height)
+    assertEquals(pageWidth - MARGIN, layout.qrFrame.right)
+  }
+
+  @Test
+  fun `title sits directly above the QR with line spacing between them`() {
+    val titleHeight = 12f
+    val layout = compute(titleHeight = titleHeight)
+
+    assertEquals(layout.qrFrame.y - lineSpacing - titleHeight, layout.titleOffset.y)
+  }
+
+  @Test
+  fun `caption sits directly below the QR with line spacing between them`() {
+    val layout = compute()
+
+    assertEquals(layout.qrFrame.bottom + lineSpacing, layout.captionOffset.y)
+  }
+
+  @Test
+  fun `title and caption share their X with the QR frame`() {
+    val layout = compute()
+
+    assertEquals(layout.qrFrame.x, layout.titleOffset.x)
+    assertEquals(layout.qrFrame.x, layout.captionOffset.x)
+  }
+
+  @Test
+  fun `the whole title QR and caption block is centered vertically on the page`() {
+    val captionHeight = 14f
+    val layout = compute(titleHeight = 12f, captionHeight = captionHeight)
+
+    val spaceAbove = layout.titleOffset.y
+    val spaceBelow = pageHeight - (layout.captionOffset.y + captionHeight)
+    assertEquals(spaceAbove, spaceBelow)
+  }
+
+  @Test
+  fun `taller captions push the QR further up the page`() {
+    val short = compute(captionHeight = 10f)
+    val tall = compute(captionHeight = 30f)
+
+    assertEquals(short.qrFrame.y - 10f, tall.qrFrame.y)
+  }
+
+  @Test
+  fun `taller titles push the QR further down the page`() {
+    val short = compute(titleHeight = 10f)
+    val tall = compute(titleHeight = 30f)
+
+    assertEquals(short.qrFrame.y + 10f, tall.qrFrame.y)
+  }
+
+  private fun compute(titleHeight: Float = 12f, captionHeight: Float = 10f) =
+    QrPageLayout.compute(titleHeight = titleHeight, captionHeight = captionHeight)
+}