Barclays Interview Questions 2026 (with Answers for Freshers)

Last Updated: March 2026

Introduction

Barclays is a British multinational universal bank headquartered in London, England. With over 325 years of history, Barclays operates in over 40 countries and employs approximately 80,000 people worldwide. The bank offers a comprehensive range of services including personal banking, corporate banking, wealth management, and investment banking.

Barclays has made significant investments in technology and digital transformation, establishing major technology centers in India (Pune, Noida, Chennai), the UK, and other global locations. The bank's technology teams work on mission-critical financial systems including trading platforms, risk management systems, digital banking applications, and regulatory compliance solutions.

For freshers, Barclays offers excellent opportunities to work on mission-critical financial systems, comprehensive training programs, and exposure to cutting-edge banking technology in a global environment.

Barclays Selection Process 2026

Stage	Description	Duration
Round 1: Online Assessment	Cognitive ability, Behavioral, Coding	90-120 minutes
Round 2: Technical Interview	Core CS, Banking concepts, Coding	45-60 minutes
Round 3: HR/Behavioral Interview	Barclays Values, Culture fit, Situational	30-45 minutes
Round 4: Final Interview	Senior leader discussion	30 minutes

Eligibility Criteria:

Minimum 60% or 6.0 CGPA throughout academics
No active backlogs
CS/IT/ECE/MCA preferred
Strong programming fundamentals required

HR Interview Questions and Answers

1. Tell me about yourself.

2. Why do you want to join Barclays?

3. What do you know about Barclays' business?

Barclays UK: Personal banking, consumer credit, and wealth management serving over 24 million customers
Barclays International: Corporate and investment banking, private banking, and US consumer cards

Key business areas include:

Retail Banking: Current accounts, savings, mortgages, and digital banking
Corporate Banking: Working capital, trade finance, and transactional banking
Investment Banking: Trading, advisory, and capital markets
Wealth Management: Investment management and private banking

Barclays has been investing heavily in technology including:

Mobile banking applications
Real-time payment systems
AI-powered fraud detection
Blockchain for trade finance
Cloud migration initiatives

The bank's technology strategy focuses on modernizing legacy systems, enhancing digital capabilities, and improving customer experience through technology."

4. What are Barclays' core values?

Respect: Treating everyone with dignity and fairness, valuing diversity and inclusion
Integrity: Acting with honesty, transparency, and ethical behavior in all dealings
Service: Putting customers and clients at the center of everything, delivering excellence
Excellence: Striving for the highest standards in execution and continuous improvement
Stewardship: Taking responsibility for our actions and their impact on society

These values guide decision-making and behavior across the organization. Barclays also emphasizes:

Citizenship: Contributing positively to communities and the environment
Innovation: Embracing new ideas and technologies to better serve customers
Collaboration: Working together across teams and boundaries to achieve common goals"

5. What are your strengths and weaknesses?

As for weaknesses, I sometimes spend extra time ensuring my code handles all edge cases, which can impact initial delivery timelines. However, I recognize that in banking systems, this thoroughness is actually beneficial. I am working on better time estimation and prioritizing edge cases based on risk assessment. I have learned to use automated testing to speed up this process while maintaining quality."

6. Where do you see yourself in 5 years?

7. How do you handle high-pressure situations?

I also believe in proactive communication during pressure situations, keeping stakeholders informed about progress and any blockers. Regular exercise and mindfulness practices help me manage stress effectively. I view pressure as a catalyst for growth and an opportunity to demonstrate resilience."

8. Why are you interested in banking technology specifically?

Additionally, banking technology is at the forefront of innovation in areas like blockchain, AI for fraud detection, real-time payments, and open banking. The regulatory environment also adds interesting constraints that require creative solutions. Working in banking technology means contributing to the financial well-being of millions of people and businesses, which I find highly motivating."

9. How do you ensure code quality?

Following Coding Standards: Adhering to style guides and best practices for readability and maintainability
Unit Testing: Writing comprehensive unit tests covering normal cases, edge cases, and error conditions
Code Reviews: Participating in peer reviews to catch issues and learn from others
Static Analysis: Using tools like SonarQube to identify potential bugs and security vulnerabilities
Documentation: Writing clear comments and maintaining up-to-date technical documentation
Refactoring: Regularly improving code structure without changing functionality

In banking contexts, I would additionally emphasize:

Security reviews and secure coding practices
Compliance with regulatory requirements
Performance testing under load
Thorough error handling and logging"

10. What do you know about financial regulations affecting technology?

PCI DSS: Payment Card Industry Data Security Standard for handling card data
GDPR: Data protection and privacy for EU customers
SOX (Sarbanes-Oxley): Financial reporting accuracy and internal controls
Basel III/IV: Capital requirements affecting risk calculation systems
PSD2: Payment Services Directive enabling open banking APIs
MiFID II: Markets in Financial Instruments Directive affecting trading systems

These regulations impact technology through requirements for:

Data encryption and secure storage
Audit trails and logging
Access controls and authentication
Regular security assessments
Change management processes
Business continuity planning"

Technical Interview Questions and Answers

1. Explain ACID properties in database transactions.

ACID Properties ensure reliable processing of database transactions:

Atomicity: All operations in a transaction complete successfully or none do.

BEGIN TRANSACTION;
UPDATE Account SET Balance = Balance - 100 WHERE AccountId = 'A';
UPDATE Account SET Balance = Balance + 100 WHERE AccountId = 'B';
COMMIT;

Consistency: Database moves from one valid state to another, maintaining all constraints.

Isolation: Concurrent transactions don't interfere with each other.

Durability: Once committed, changes persist even in case of system failure.

2. Write a program to implement a thread-safe bank account.

Java Implementation:

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class BankAccount {
    private final String accountNumber;
    private double balance;
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }
    
    public void deposit(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("Invalid amount");
        
        lock.writeLock().lock();
        try {
            balance += amount;
        } finally {
            lock.writeLock().unlock();
        }
    }
    
    public boolean withdraw(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("Invalid amount");
        
        lock.writeLock().lock();
        try {
            if (balance >= amount) {
                balance -= amount;
                return true;
            }
            return false;
        } finally {
            lock.writeLock().unlock();
        }
    }
    
    public double getBalance() {
        lock.readLock().lock();
        try {
            return balance;
        } finally {
            lock.readLock().unlock();
        }
    }
}

3. What is the difference between Monolithic and Microservices architecture?

Feature	Monolithic	Microservices
Architecture	Single unified codebase	Multiple independent services
Deployment	Deploy entire application	Deploy individual services
Scalability	Scale entire application	Scale individual components
Technology	Single technology stack	Polyglot (different tech per service)
Complexity	Simpler initially	Higher initial complexity
Database	Shared database	Database per service

4. Write a program to detect fraudulent transactions.

from datetime import datetime, timedelta
from dataclasses import dataclass

@dataclass
class Transaction:
    transaction_id: str
    account_id: str
    amount: float
    timestamp: datetime
    location: str

class FraudDetector:
    def __init__(self):
        self.account_history = {}
    
    def is_fraudulent(self, transaction):
        reasons = []
        
        # Rule 1: Unusually large amount
        avg_amount = self._get_average_amount(transaction.account_id)
        if transaction.amount > avg_amount * 5:
            reasons.append(f"Amount 5x above average")
        
        # Rule 2: Multiple transactions in short time
        recent_count = self._count_recent_transactions(transaction.account_id, minutes=10)
        if recent_count > 3:
            reasons.append(f"{recent_count} transactions in 10 minutes")
        
        return len(reasons) > 0, reasons

5. What is the CAP Theorem?

CAP Theorem states that a distributed system can guarantee at most two of:

Consistency (C): All nodes see the same data at the same time.

Availability (A): Every request receives a response.

Partition Tolerance (P): System continues despite network failures.

Combinations:

CP: Consistency + Partition Tolerance (Banking systems)
AP: Availability + Partition Tolerance (Social media)
CA: Consistency + Availability (Single-node systems)

6. Write a program to calculate compound interest.

from decimal import Decimal, ROUND_HALF_UP

class CompoundInterestCalculator:
    @staticmethod
    def calculate(principal, rate, time, frequency=12):
        p = Decimal(str(principal))
        r = Decimal(str(rate)) / Decimal('100')
        t = Decimal(str(time))
        n = Decimal(str(frequency))
        
        # A = P(1 + r/n)^(nt)
        amount = p * (Decimal('1') + r / n) ** (n * t)
        interest = amount - p
        
        return {
            'principal': float(p),
            'final_amount': float(amount.quantize(Decimal('0.01'))),
            'interest_earned': float(interest.quantize(Decimal('0.01')))
        }

# Example
 calc = CompoundInterestCalculator()
result = calc.calculate(100000, 7.5, 2, frequency=4)
print(f"Final Amount: ₹{result['final_amount']}")

7. What is the difference between REST and SOAP web services?

Feature	REST	SOAP
Protocol	HTTP/HTTPS	Multiple protocols
Format	JSON, XML	XML only
Standards	Architectural style	Strict standards (WSDL)
Security	HTTPS, OAuth	WS-Security
Performance	Lightweight, faster	Verbose, slower
Caching	Can be cached	Cannot be cached easily

8. Write a SQL query to find customers with consecutive transactions.

-- Find customers with transactions on consecutive days
WITH DailyTransactions AS (
    SELECT 
        customer_id,
        DATE(transaction_date) as txn_date,
        COUNT(*) as txn_count
    FROM Transactions
    GROUP BY customer_id, DATE(transaction_date)
),
ConsecutiveDays AS (
    SELECT 
        customer_id,
        txn_date,
        DATE_SUB(txn_date, INTERVAL 
            ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY txn_date) DAY
        ) as grp
    FROM DailyTransactions
)
SELECT 
    customer_id,
    COUNT(*) as consecutive_days
FROM ConsecutiveDays
GROUP BY customer_id, grp
HAVING COUNT(*) >= 3;

9. Explain different types of software testing.

Testing Levels:

Unit Testing: Tests individual components
Integration Testing: Tests component interactions
System Testing: Tests complete application
Acceptance Testing: Validates against requirements

Testing Types:

Functional: Validates features work correctly
Performance: Measures speed and scalability
Security: Identifies vulnerabilities
Usability: Evaluates user experience
Compatibility: Tests across environments

10. Write a program to implement rate limiting.

import time
from collections import deque
from threading import Lock

class RateLimiter:
    def __init__(self, max_requests, window_seconds):
        self.max_requests = max_requests
        self.window_seconds = window_seconds
        self.requests = {}
        self.lock = Lock()
    
    def is_allowed(self, client_id):
        with self.lock:
            now = time.time()
            
            if client_id not in self.requests:
                self.requests[client_id] = deque()
            
            # Remove old requests
            while (self.requests[client_id] and 
                   self.requests[client_id][0] < now - self.window_seconds):
                self.requests[client_id].popleft()
            
            if len(self.requests[client_id]) < self.max_requests:
                self.requests[client_id].append(now)
                return True
            
            return False

Behavioral Interview Questions (STAR Format)

1. Describe a time when you had to handle sensitive information.

2. Tell me about a time when you identified a potential risk.

3. Give an example of explaining a technical concept to a non-technical person.

4. Describe a time when you balanced speed with quality.

5. Tell me about adapting to a significant change.

Barclays-Specific Interview Tips

Understand Banking Fundamentals: Research accounts, loans, payments, trading
Focus on Security: Study OWASP, encryption, authentication
Learn Financial Regulations: GDPR, PCI DSS, SOX, PSD2
Practice Low-Latency Coding: Optimize algorithms
Study Concurrency: Thread synchronization, deadlock prevention
Research Barclays Values: Respect, Integrity, Service, Excellence, Stewardship
Prepare for Situational Questions: Use STAR format
Show Interest in FinTech: Open banking, blockchain, AI
Practice Live Coding: Explain your approach while solving
Ask Intelligent Questions: Technology stack, career development

FAQs

Q: What is the salary for freshers at Barclays in 2026? A: ₹8.0 to ₹12.0 LPA for technology roles depending on position and background.

Q: Does Barclays have a service agreement? A: Yes, typically 1-2 years for campus hires.

Q: What technologies does Barclays use? A: Java, Python, C++, JavaScript/TypeScript, React, AWS, Azure, Oracle, PostgreSQL, MongoDB.

Best of luck with your Barclays interview!