Processing large volumes of resumes and matching candidates to open positions becomes increasingly difficult as hiring volumes grow. Manual review workflows often struggle to keep pace, making it harder to identify qualified candidates efficiently and consistently.
For a leading HR and staffing organization in Japan, this challenge was amplified by the need to process thousands of resumes and job descriptions in both Japanese and English. To address it, we built an AI-powered recruitment platform that automated information extraction, semantic search, and candidate-job matching at scale.
The proof of concept confirmed that AI could automate key recruitment workflows. The challenge was building a production-ready platform with the scalability, reliability, and operational control required for enterprise use.
What's in this article:
- Why we transitioned from a Python proof-of-concept to Java and Spring Boot for enterprise-grade reliability
- How we built validation layers to turn inconsistent AI outputs into reliable, structured data for business workflows
- Our approach to processing thousands of English and Japanese resumes concurrently without sacrificing performance
- Why we chose direct integration with AWS Bedrock to manage costs, performance, and monitoring effectively
Building a Multilingual Recruitment Platform
At its core, the platform connects candidate resumes with job opportunities through a three-stage pipeline:
- Parse: Resume and job description files (PDF, DOCX, and metadata feeds) are ingested from S3 and parsed into structured CV/JD records using configurable extraction paths (AWS Bedrock or TextKernel), with anomaly flags for invalid fields.
- Search: The structured data is indexed for recruiter workflows such as metadata search, boolean/target search, and suggestions, enabling users to filter candidates or jobs by skills, title, location, experience, and related parameters.
- Match: The engine computes CV-to-JD and JD-to-CV match scores using weighted criteria (location, skills, education, experience, salary, language, title, certifications), then returns ranked results and match details.
From Proof of Concept to Production
Before building the production platform, we developed a Python proof of concept to validate whether LLMs could accurately interpret resumes and job descriptions in both Japanese and English. The prototype helped us quickly evaluate extraction quality, matching accuracy, and overall workflow feasibility.
However, as we prepared the platform for production, the key question was no longer, "Can the model perform the task?" but, "How does the system behave when things go wrong?" In a production environment, recruiters depend on accurate and consistent outputs to make hiring decisions, making reliability just as important as model capability.
Unlike traditional software, large language models can produce slightly different outputs even when given the same input. That flexibility is what makes AI powerful, but it can also create challenges when AI output is part of business workflows. In some cases, a resume might be parsed perfectly. In others, the model might miss a certification, interpret a skill differently, or return information in an unexpected format.
Model responses could not be treated as facts. They had to be treated as inputs that required validation, normalization, and verification before being used by downstream systems.
Engineering for Production Scale
While Python worked well for experimentation and rapid prototyping, we needed a platform that could support long-running enterprise workloads, handle high concurrency, and provide strong operational controls. Java and Spring Boot gave us that foundation, offering a strong balance of runtime performance, scalability, and developer productivity for building and operating production-scale AI systems.
Several engineering decisions shaped the production architecture.
How We Validated AI Outputs
One of the first decisions we made was to treat every AI response as untrusted input rather than as application-ready data.
Resume parsing and candidate matching depend on information extracted by language models, and even small inconsistencies can affect recommendation quality. For example, if a model identified a candidate's technical skills but failed to extract years of experience or language proficiency, the resulting match score could be misleading.
Rather than allowing AI-generated data to flow directly into business processes, we built validation and normalization layers around every model interaction. Java records and sealed interfaces helped us define strict contracts for LLM responses and build robust deserialization and validation pipelines around them.
As a result, resume parsing and job matching became more reliable because incomplete or malformed model outputs were caught before they could affect downstream workflows.
How We Scaled Concurrent Workloads
Given the volume of resumes and job descriptions being processed, scalability was a requirement from day one. We chose Java and Spring Boot because the platform had to sustain high-volume recruiter workflows, coordinate many external AI calls, and operate predictably under load.
Many of the platform's AI workflows relied on calls to external services such as AWS Bedrock, making them primarily network-bound rather than CPU-bound. Java 21's virtual threads enabled us to handle high levels of concurrency efficiently without adding unnecessary complexity to the application architecture.
Spring Boot also gave us the operational foundation we needed out of the box, including automatic retries, health checks, production-grade HTTP clients, and application monitoring. Supporting technologies such as MyBatis, HikariCP, Flyway, and MapStruct helped simplify data access, schema management, and application maintenance.
Together, these choices gave us a stable, maintainable platform that could scale with usage while keeping engineering effort focused on recruitment workflows rather than infrastructure plumbing.
How We Controlled Model Usage in Production
We needed direct visibility and control over how foundation models were used in production.
Rather than relying on abstraction layers, we integrated directly with Amazon Bedrock through the AWS SDK for Java.
Different models were used for different tasks. Claude Sonnet handled resume parsing and content extraction, Claude Haiku supported lightweight operations such as search suggestions, and Amazon Titan Embed generated vector embeddings for semantic search.
Direct integration provided greater control over retries, timeouts, token management, and model-specific request handling. These capabilities were particularly important in a system where AI outputs directly influenced candidate matching and recruiter workflows.
The approach also enabled us to build the resilience and operational safeguards required to support production-scale AI workloads while optimizing both performance and cost.
Extend AI Observability
Standard infrastructure monitoring is not enough to operate AI reliably in production. Unlike traditional applications, AI systems can fail in ways that are not always visible through infrastructure monitoring. A model may return a successful response while still producing incomplete or low-quality output.
To address this, we tracked application metrics, model latency, error rates, and token consumption. These signals helped us identify operational issues quickly and understand how AI behavior affected downstream recruitment workflows.
Impact of the AI-Powered Recruitment System
Building a resilient technical foundation yielded immediate, measurable upgrades to the organization's core hiring operations.
- High-Volume Resume Parsing: The system has processed and indexed over 300,000 complex resumes and job descriptions across English and Japanese, maintaining data integrity despite language variations.
- Reduced Time to Hire: By automating the initial screening, parsing, and semantic matching phases, it reduced the manual loops in candidate matching and decision-making.
- Improved Reliability: The system actively intercepts malformed responses, ensuring recruiters work with the right candidate profiles.
- Optimized Operational ROI: Strategic model routing (matching Claude Sonnet, Haiku, and Titan to specific tasks) keeps token consumption costs predictable while maximizing processing speed.
Key Takeaway
Building a successful AI application involves much more than choosing the right model. Production AI requires validation, observability, scalability, and resilience as first-class engineering concerns. As AI becomes an integral part of enterprise systems, strong engineering foundations will be essential for translating model capabilities into measurable business outcomes.
Read Engineering Production-Ready AI for Global HR to see how we resolved API throttling, database pressure, and concurrency bottlenecks to make this AI platform production-ready.