Amazon Bedrock を活用した AI 搭載採用アシスタントの構築方法

According to a people management survey of 748 HR leaders, recruiters spend an average of 17.7 hours per vacancy on administrative work. That’s more than two working days per hire. A separate 2024 SmartRecruiters survey found that 45% of talent acquisition leaders spend more than half their working hours on tasks that could be automated. This administrative burden forces superficial screening that overlooks qualified candidates while advancing matches based on formatting and keyword density rather than genuine competency alignment.

In this post, we demonstrate how to build an AI-powered recruitment assistant using Amazon Bedrock that brings efficiencies to candidate evaluation, generates personalized interview questions, and provides data-driven insights for human hiring decisions. This post presents a reference architecture for learning purposes — not a production-ready solution. Amazon Bedrock and the AWS services used here are general-purpose tools that customers can combine to support a wide variety of use cases, including recruitment workflows. The architecture demonstrates one possible approach; customers should adapt it to their specific requirements.

You learn to deploy specialized AI capabilities for resume parsing, candidate scoring, skill assessment, and interview question generation—with Amazon Bedrock Guardrails providing PII anonymization, prompt attack detection, and bias-related content filtering—all working together through a coordinated serverless architecture. The solution uses the Amazon Bedrock Converse API with Amazon Nova Pro, AWS Lambda for processing, Amazon API Gateway for routing, Amazon DynamoDB and Amazon Simple Storage Service (Amazon S3) for data storage, and Amazon Bedrock Guardrails for responsible AI evaluation.

Solution overview

The AI candidate screening assistant uses foundation models (FMs) available in Amazon Bedrock to help with candidate evaluation, streamline interview preparation, and provide data-driven insights for hiring decisions. The solution processes resumes with comprehensive analysis, calculates multi-dimensional compatibility scores, and generates personalized interview questions based on job requirements and candidate profiles.

The authentication and frontend layer uses AWS Amplify to host the web application and Amazon Cognito for user authentication. Amazon Cognito handles user registration, sign in, and provides JWT tokens that are validated by the Amazon API Gateway Cognito Authorizer on every API request.

The backend layer uses Amazon API Gateway to route requests to specialized AWS Lambda functions, with each Lambda function handling a specific workflow. The Lambda functions call the Amazon Bedrock Converse API to perform deep resume analysis, calculate compatibility scores, and generate role-specific interview questions.

Architecture diagram

The following diagram illustrates the architecture of the AI Recruiting Assistant.

The architecture contains the following key sections:

Frontend Layer: AWS Amplify hosts a responsive React-based web application that provides recruiters with an intuitive interface for managing job postings, reviewing AI-generated candidate assessments, and accessing personalized interview preparation materials.

Security Layer: Amazon Cognito manages user registration and authentication, providing JWT tokens that are validated by the Amazon API Gateway Cognito authorizer on every API request. AWS Identity and Access Management (IAM) roles provide least-privilege access for AWS Lambda functions to interact with storage and AI services. Customers are responsible for properly configuring these security controls.

API Layer: Amazon API Gateway orchestrates client-server communications through RESTful endpoints for job management, AI-powered candidate matching, resume upload processing, and interview question generation services.

Processing Layer: Specialized AWS Lambda functions handle recruitment workflows, each designed with appropriate timeout and memory configurations.

AI Processing Layer: Amazon Bedrock FMs perform analysis using the Converse API to conduct deep resume analysis, calculate multi-dimensional compatibility scores, generate role-specific interview questions, and identify transferable skills. Amazon Bedrock Guardrails filter each request by anonymizing PII in the input, blocking prompt injection attempts from resume content, and denying responses that reference candidate demographics.

The following code snippet shows how the solution uses Amazon Bedrock Guardrails (which automatically anonymize PII in the input before the model processes it), structured prompting with evidence-based scoring, and bias-aware system instructions:

import json

SYSTEM_PROMPT = """You are an expert recruitment analyst. Evaluate
candidates based exclusively on demonstrated skills, experience,
and qualifications. Do not reference or make assumptions based on
candidate names, contact details, demographics, or personal
characteristics. Focus only on job-relevant qualifications.
For every claim, cite the specific resume text as evidence."""

ANALYSIS_PROMPT = """Analyze the following candidate resume against
the job requirements. Return a structured JSON response.


{job_description}



{resume_content}


Provide your analysis in the following JSON format:
{{
  "compatibilityScore": 0-100,
  "scoreJustification": "Evidence-based reasoning with resume quotes",
  "technicalSkills": {{
    "matched": [{{"skill": "X", "evidence": "resume quote"}}],
    "missing": ["skill3"],
    "transferable": [{{"skill": "Y", "evidence": "resume quote"}}]
  }},
  "experienceAnalysis": {{
    "relevantYears": 0,
    "industryAlignment": "high|medium|low",
    "keyAccomplishments": ["accomplishment with evidence"]
  }},
  "strengths": ["strength with specific resume evidence"],
  "concerns": ["concern with context"],
  "interviewQuestions": [
    {{
      "question": "Targeted question text",
      "purpose": "What this question evaluates",
      "lookFor": "Ideal response indicators"
    }}
  ],
  "overallRecommendation": "strong_match|good_match|partial_match|weak_match"
}}"""

response = bedrock_client.converse(
    modelId=model_id,
    system=[{"text": SYSTEM_PROMPT}],
    messages=[{
        "role": "user",
        "content": [{"text": ANALYSIS_PROMPT.format(
            job_description=job_description,
            resume_content=resume_content
        )}]
    }],
    inferenceConfig={
        "maxTokens": 4096,
        "temperature": 0.2,
        "topP": 0.9
    },
    guardrailConfig={
        "guardrailIdentifier": guardrail_id,
        "guardrailVersion": guardrail_version,
        "trace": "enabled"
    }
)

# Validate informational output for recruiter; not a hiring recommendation
try:
    analysis = json.loads(
        response["output"]["message"]["content"][0]["text"]
    )
except json.JSONDecodeError:
    analysis = {"error": "Model returned invalid JSON"}

*Note: We use a low temperature (0.2) to produce consistent, reproducible candidate evaluations. When Guardrails intervenes (for example, blocking a prompt injection embedded in a resume), the response includes a GUARDRAIL_INTERVENED action—implement error handling to log these events and return a safe fallback response to the recruiter.*

Data Layer: Amazon DynamoDB stores structured job postings and analysis results. Amazon S3 provides storage for candidate resumes with server-side encryption (AES-256), Block Public Access, and HTTPS-only bucket policies.

The following steps describe the request flow when a recruiter analyzes candidates:

• The recruiter opens the AWS Amplify-hosted web application and authenticates through Amazon Cognito.

• The recruiter creates a job posting with role requirements, required skills, and experience level.

• The recruiter uploads candidate resumes (PDF, DOCX, or TXT format) for the job posting.

• The frontend sends a POST request to the Amazon API Gateway /matches endpoint.

• The API Gateway Cognito authorizer validates the JWT token from the request header.

• API Gateway routes the authenticated request to the AI recruitment Lambda function.

• The Lambda function retrieves the job posting from Amazon DynamoDB and candidate resumes from Amazon S3. The function calls the Amazon Bedrock Converse API with the job requirements and resume content.

• Amazon Bedrock analyzes each candidate, calculating compatibility scores, identifying strengths and concerns, and generating personalized interview questions.

• The results are stored in Amazon DynamoDB and returned to the recruiter in the web interface.

Key capabilities

Intelligent resume analysis** The solution processes resumes, then analyzes them for skill depth and experience relevance rather than relying on keyword matching alone. It calculates compatibility scores against job requirements with specific evidence from the resume text, and identifies transferable skills that manual screening often misses.

Advanced candidate matching**** The system compares candidate profiles against job descriptions using natural language processing (NLP) and provides percentage-based match scores with quoted resume evidence. It highlights candidate strengths and concerns while ranking candidates by compatibility for efficient recruiter review.

Personalized interview preparation**** The solution creates tailored interview questions based on specific job roles and candidate backgrounds, generating assessment frameworks with scoring rubrics. It produces detailed interview guides with conversation starters and follow-up suggestions.

Workflow automation**** The system assists with repetitive administrative tasks and supports bulk actions. It integrates with existing systems through RESTful APIs and provides usage analytics.

Prerequisites

Before you begin, verify that you have:

• An AWS account with appropriate permissions for Amazon Bedrock, AWS Identity and Access Management (IAM), AWS CloudFormation, Amazon API Gateway, Amazon Cognito, Amazon DynamoDB, Amazon S3, AWS Lambda, and AWS Amplify.

• Amazon Bedrock model access for Amazon Nova Pro in your deployment AWS Region. You can use a different supported model of your choice. For current model availability, see Model support by AWS Region.

• The AWS Command Line Interface (AWS CLI) v2.0 or later installed and configured with appropriate credentials.

• Python 3.10 or newer installed.

• Terminal or command prompt access.

Cost estimate:** For testing with 100 candidates, the total cost is approximately $1–2 per month. Amazon Bedrock (Nova Pro at $0.80/$3.20 per million input/output tokens) costs under $1 for 100 analyses. Amazon Bedrock Guardrails adds approximately $0.01 per candidate. Other services mentioned in this post fall within the AWS Free Tier for testing volumes. For detailed estimates, use the AWS Pricing Calculator.

Important: Verify AWS Region consistency** Verify that the following are all configured to use the same AWS Region: your aws configure default Region, the Region where you have enabled Amazon Bedrock model access, and all resources created during deployment.

Deploy the solution

Deploy the backend infrastructure**. You will incur costs for the AWS resources used in this solution.

The console redirects you to AWS CloudFormation with the template URL prepopulated in the stack parameters.

• For Stack name, enter a name for your deployment (default: AIRecruiterAssistantBlogSetup).

• For BedrockModelId, choose the Amazon Bedrock model to use (default: Amazon Nova Pro).

• Review the stack configuration.

• Choose Create stack.

• After successful deployment, note the following values from the CloudFormation stack’s Outputs tab:

• ApiGatewayUrl

• CognitoUserPoolId

• CognitoClientId

• AWSRegion

• AmplifyAppUrl

• AmplifyConsoleUrl

Deploy the frontend application

• Download the AIRecruitingAssistantFrontEndAmplifyDeployment.zip file.

• Navigate to AmplifyConsoleUrl under CloudFormation Outputs.

• Choose the ai-recruitment-system-frontend app.

• Choose Deploy updates.

• For Method, choose Drag and drop.

• Choose the .zip file to upload.

• Choose Save and deploy.

Testing the solution

After the infrastructure is deployed and the frontend application is running, you can test the AI Recruiting Assistant’s core functionality through the web interface.

Step 1: Configure application settings

Navigate to the System Configuration page and enter the values from your CloudFormation stack outputs:

• API Gateway URL: Enter the ApiGatewayUrl

• Amazon Cognito User Pool ID: Enter the CognitoUserPoolId

• Amazon Cognito Client ID: Enter the CognitoClientId

• AWS Region: Enter the AWS Region

Step 2: User registration and sign in

• Choose SIGN UP on the login page.

• Enter your name, email, and a secure password.

• Choose Create Account.

• Enter the one-time verification code sent to your email.

• Choose Verify Email.

• After successful verification, sign in using your email and password.

Step 3: Create a job posting

• Navigate to the AI Recruiting Assistant dashboard and create a new job posting.

<a href="https://d2908q01vomqb2.cloudfront.net/f1f836cb4ea6efb2a0b1b99f41ad8b103eff4b59/2026/04/24/