2 Databases & SQL

Your home turf. 15 years of SQL is an asset — model it as a normalized relational core + append-only audit/version log + explicit entitlement layer.

-- Latest version of each document (window fn, no self-join)
SELECT case_id, document_id, version_id, version_no, gcs_uri
FROM (
  SELECT d.*, ROW_NUMBER() OVER (
           PARTITION BY document_id ORDER BY version_no DESC) AS rn
  FROM document_versions d )
WHERE rn = 1;    -- BigQuery/Snowflake: use QUALIFY to skip the subquery

-- Medical chronology by content-derived date, with gaps between events
SELECT case_id, event_date, event_type, provider, description,
       DATE_DIFF(event_date,
         LAG(event_date) OVER (PARTITION BY case_id ORDER BY event_date),
         DAY) AS days_since_prev
FROM medical_events
WHERE case_id = @case_id
ORDER BY event_date;   -- Postgres/AlloyDB: event_date - LAG(...) instead of DATE_DIFF

-- Audit: who extracted what, in a date range
SELECT u.email, d.source_filename, e.model_version, e.extracted_at,
       COUNT(f.field_id) AS fields_extracted
FROM extractions e
JOIN users u ON u.user_id = e.extracted_by
JOIN document_versions dv ON dv.version_id = e.document_version_id
JOIN documents d ON d.document_id = dv.document_id
LEFT JOIN extracted_fields f ON f.extraction_id = e.extraction_id
WHERE e.extracted_at >= '2026-01-01' AND e.extracted_at < '2026-02-01'
GROUP BY u.email, d.source_filename, e.model_version, e.extracted_at
ORDER BY e.extracted_at;

Naming QUALIFY, row-level security, and pre-filtering the vector search reads as fluent-in-warehouse. Never SELECT * on PII/medical tables; think execution plan, not just result.

3 Infrastructure & setup the flagged gap

Convert "I do this on AWS" into "on GCP that's X" without hesitating. These details are what AWS/Azure people routinely miss.

4 Java / Spring Boot backend

CURE's product dev is on Guidewire (Java); the doc-agent backend is likely Java/Spring Boot on GCP. You have 5 yrs Java + 10 yrs C#/.NET — the enterprise patterns transfer directly.

The Spring Boot service doesn't sit on a request thread doing OCR. It accepts the upload, persists job + document rows, hands heavy work to async workers / Pub/Sub, and exposes status + review. Layered controller → service → repository (maps 1:1 from .NET: Controller, Application layer, EF DbContext). DTOs are Java records — never leak JPA entities over the wire.

POST   /api/v1/claims/{claimId}/documents   → 202 Accepted + jobId + Location
GET    /api/v1/jobs/{jobId}                  → poll status (QUEUED/SPLITTING/EXTRACTING…)
GET    /api/v1/documents/{docId}/extraction  → fields/chronology/values (latest version)
GET    /api/v1/documents/{docId}/versions    → version history
POST   /api/v1/documents/{docId}/review      → human review (approve/correct/reject)

• Upload returns 202, not the result — a 1,000-page job is minutes long; the client polls or subscribes.
• Idempotency-Key header (or content hash) with a unique constraint → a client retry returns the existing jobId, not a second 1,000-page run.
• Bean Validation on request DTOs; a @RestControllerAdvice maps errors to RFC 9457 ProblemDetail.

A blocked servlet thread ties up the pool, exhausts DB connections under 50-100 users, and dies on the Cloud Run request timeout. Accept fast, process out-of-band, report status. This is the single most important architectural point in the eval.

@Bean Step extractPagesStep(JobRepository repo, PlatformTransactionManager tx,
                      PageItemReader reader, DocumentAiProcessor processor,
                      ExtractionWriter writer) {
  return new StepBuilder("extractPages", repo)
      .<PageRef, PageExtraction>chunk(10, tx)   // commit every 10 pages
      .reader(reader).processor(processor).writer(writer)
      .faultTolerant()
      .retryLimit(3).retry(TransientAiException.class)
      .skipLimit(20).skip(UnprocessablePageException.class)
      .build();
}

Idempotent: workers upsert keyed on jobId:pageRange (at-least-once will redeliver). Retryable: Pub/Sub redelivery + dead-letter after N; Spring Retry backoff on AI calls. Restartable: Batch resumes at the last committed chunk.

// Spring AI ChatClient → Gemini, with RAG advisor + structured output
ClaimNarrative generate(ExtractionBundle facts) {
  return chat.prompt()
    .user(u -> u.text("Draft the claim narrative per business rules:\n{facts}")
                .param("facts", facts.asJson()))
    .call()
    .entity(ClaimNarrative.class);   // typed record, not raw text
}
// builder: .defaultAdvisors(QuestionAnswerAdvisor.builder(vectorStore).build())

// Document AI — use batchProcessDocuments for >200 pages (async, GCS in/out)
try (DocumentProcessorServiceClient client = DocumentProcessorServiceClient.create()) {
  String name = ProcessorName.of(projectId, location, processorId).toString();
  RawDocument raw = RawDocument.newBuilder()
      .setContent(ByteString.copyFrom(pdf)).setMimeType("application/pdf").build();
  return client.processDocument(
      ProcessRequest.newBuilder().setName(name).setRawDocument(raw).build());
}

Auth is Application Default Credentials via Workload Identity — no key files. Spring AI starters: spring-ai-starter-model-vertex-ai-gemini, spring-ai-starter-vector-store-pgvector. Embeddings via VertexAiTextEmbeddingModel → PgVectorStore (HNSW index).