QE Interview Preparation Guide

1. Application & Resume Screen (1-2 days)
    ↓
2. Recruiter Phone Screen (30 min)
    ↓
3. Technical Phone Screen (45-60 min)
    ↓
4. Take-Home Assignment (2-4 hours)
    ↓
5. Onsite/Virtual Interviews (3-5 hours)
   - Technical Deep Dive
   - Coding/Automation
   - System Design
   - Behavioral/Cultural Fit
   - Hiring Manager
    ↓
6. Offer & Negotiation

# John Doe
Quality Engineer | Test Automation | CI/CD
 
Email: john@example.com | LinkedIn: /in/johndoe | GitHub: @johndoe
 
## Summary
Quality Engineer with 5+ years experience in test automation, API testing, 
and CI/CD. Reduced test execution time by 60% and improved code coverage 
from 45% to 78% at TechCorp. Proficient in JavaScript, Python, and Java.
 
## Experience
 
### Senior QE, TechCorp (2022 - Present)
- Led test automation for payment platform processing $50M annually
- Designed and implemented API testing framework used by 20+ engineers
- Reduced CI/CD pipeline time from 45min to 15min through parallelization
- Mentored 3 junior QEs, 2 promoted to mid-level
- Technologies: JavaScript, Playwright, k6, Jenkins, AWS
 
### QE Engineer, StartupCo (2020 - 2022)
- Built end-to-end test automation suite from scratch (0 to 500 tests)
- Implemented visual regression testing, catching 15 critical bugs pre-release
- Integrated security testing into CI/CD with OWASP ZAP
- Improved deployment confidence score from 6/10 to 9/10
- Technologies: Python, Selenium, Docker, CircleCI
 
### Junior QE, BigCorp (2019 - 2020)
- Executed manual test cases for e-commerce platform
- Wrote first 50 automated tests using Selenium WebDriver
- Found and tracked 200+ bugs, including 5 critical security issues
- Learned API testing and database validation
 
## Skills
 
### Programming Languages
JavaScript (Expert), Python (Proficient), Java (Familiar)
 
### Test Automation
Playwright, Selenium, Cypress, RestAssured, Postman, k6
 
### CI/CD & DevOps
Jenkins, GitHub Actions, Docker, Kubernetes, AWS, Terraform
 
### Testing Types
API Testing, UI Testing, Performance Testing, Security Testing
 
### Tools & Frameworks
Jest, Mocha, pytest, JUnit, Git, JIRA, Grafana, Allure
 
## Projects
 
### Open Source Test Framework (GitHub: 500 stars)
Created reusable test automation framework for e-commerce sites
- Used by 10+ companies
- 85% code coverage
- Detailed documentation and examples
 
## Education
 
B.S. Computer Science, State University (2019)
 
## Certifications
 
- ISTQB Certified Tester Foundation Level
- AWS Certified Cloud Practitioner

// Question: Write an automated test for a login page
 
describe('Login Page Tests', () => {
  beforeEach(async () => {
    await page.goto('https://example.com/login');
  });
  
  it('should login successfully with valid credentials', async () => {
    // Arrange
    const validEmail = 'user@example.com';
    const validPassword = 'Test1234!';
    
    // Act
    await page.fill('[name="email"]', validEmail);
    await page.fill('[name="password"]', validPassword);
    await page.click('button[type="submit"]');
    
    // Assert
    await expect(page).toHaveURL(/.*dashboard/);
    await expect(page.locator('[data-testid="user-menu"]')).toBeVisible();
  });
  
  it('should show error with invalid credentials', async () => {
    // Act
    await page.fill('[name="email"]', 'invalid@example.com');
    await page.fill('[name="password"]', 'wrongpassword');
    await page.click('button[type="submit"]');
    
    // Assert
    await expect(page.locator('.error-message')).toContainText('Invalid credentials');
    await expect(page).toHaveURL(/.*login/); // Still on login page
  });
  
  it('should validate required fields', async () => {
    // Act - submit without filling
    await page.click('button[type="submit"]');
    
    // Assert
    await expect(page.locator('#email-error')).toContainText('Email is required');
    await expect(page.locator('#password-error')).toContainText('Password is required');
  });
});

// Question: Test a REST API endpoint
 
const fetch = require('node-fetch');
const { expect } = require('chai');
 
describe('Products API', () => {
  const baseUrl = 'https://api.example.com';
  
  it('should get list of products', async () => {
    const response = await fetch(`${baseUrl}/products`);
    const data = await response.json();
    
    expect(response.status).to.equal(200);
    expect(data.products).to.be.an('array');
    expect(data.products.length).to.be.greaterThan(0);
    
    // Validate product structure
    const product = data.products[0];
    expect(product).to.have.all.keys('id', 'name', 'price', 'stock');
    expect(product.price).to.be.a('number');
    expect(product.price).to.be.greaterThan(0);
  });
  
  it('should create a new product', async () => {
    const newProduct = {
      name: 'Test Product',
      price: 99.99,
      stock: 100
    };
    
    const response = await fetch(`${baseUrl}/products`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(newProduct)
    });
    
    const data = await response.json();
    
    expect(response.status).to.equal(201);
    expect(data.id).to.exist;
    expect(data.name).to.equal(newProduct.name);
    expect(data.price).to.equal(newProduct.price);
  });
  
  it('should return 404 for non-existent product', async () => {
    const response = await fetch(`${baseUrl}/products/999999`);
    
    expect(response.status).to.equal(404);
  });
  
  it('should validate required fields', async () => {
    const invalidProduct = { name: 'Missing Price' };
    
    const response = await fetch(`${baseUrl}/products`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(invalidProduct)
    });
    
    expect(response.status).to.equal(400);
    const data = await response.json();
    expect(data.errors).to.include.members(['price is required']);
  });
});

// Question: Write a function to wait for an element with timeout
 
async function waitForElement(page, selector, timeout = 5000) {
  const startTime = Date.now();
  
  while (Date.now() - startTime < timeout) {
    try {
      const element = await page.$(selector);
      if (element && await element.isVisible()) {
        return element;
      }
    } catch (error) {
      // Element not found yet
    }
    
    await new Promise(resolve => setTimeout(resolve, 100)); // Wait 100ms
  }
  
  throw new Error(`Element ${selector} not found within ${timeout}ms`);
}
 
// Usage
const loginButton = await waitForElement(page, 'button[type="submit"]');
await loginButton.click();

api-test-suite/
├── README.md                    # Clear setup instructions
├── package.json                 # Dependencies
├── .env.example                 # Config template
├── tests/
│   ├── products/
│   │   ├── get-products.test.js
│   │   ├── create-product.test.js
│   │   ├── update-product.test.js
│   │   └── delete-product.test.js
│   ├── auth/
│   │   └── authentication.test.js
│   └── utils/
│       ├── api-client.js        # Reusable API wrapper
│       └── test-data.js         # Test data generators
├── reports/                     # Test reports
└── .github/
    └── workflows/
        └── tests.yml            # CI/CD setup

# API Test Suite
 
Automated test suite for Example API covering CRUD operations, authentication, and edge cases.
 
## Setup
 
```bash
npm install
cp .env.example .env
# Edit .env with your API key

# All tests
npm test
 
# Specific suite
npm test -- tests/products
 
# With coverage
npm run test:coverage

 
### Take-Home Best Practices
 
**DO:**
✓ Exceed requirements (but don't overdo it)  
✓ Write comprehensive README  
✓ Include tests for your test code  
✓ Follow language conventions  
✓ Add comments where helpful  
✓ Make it easy to run  
 
**DON'T:**
✗ Submit incomplete work  
✗ No documentation  
✗ Overly complex solutions  
✗ Ignore edge cases  
✗ Copy-paste from StackOverflow without understanding  
 
## Stage 4: Onsite Interviews
 
### System Design for QE
 
**Question: "Design a test strategy for a microservices e-commerce platform"**
 
**Strong Answer Structure:**
 
1. **Clarify Requirements**
   - How many microservices?
   - Traffic volume?
   - Deployment frequency?
   - Team size?
 
2. **Test Strategy**
 
```markdown
## Test Pyramid
 
### Unit Tests (70%)
- Each service has unit tests
- Mock dependencies
- Fast feedback (<1 min)
- Run on every commit
 
### Integration Tests (20%)
- Service + database
- Service + message queue
- Contract testing between services
- Run in CI pipeline
 
### E2E Tests (10%)
- Critical user journeys only
- Full stack (UI → Services → DB)
- Run before deployment
- Smoke tests in production
 
## Service-Specific Testing
 
### API Gateway
- Rate limiting
- Authentication/authorization
- Request routing
- Load testing
 
### Product Service
- CRUD operations
- Search functionality
- Cache invalidation
- Database performance
 
### Payment Service
- Transaction processing
- Idempotency
- Gateway integration
- Fraud detection
 
### Order Service
- State machine transitions
- Saga pattern validation
- Race conditions
- Data consistency
 
## Cross-Cutting Concerns
 
### Contract Testing
- Pact/Postman for API contracts
- Prevent breaking changes
- Consumer-driven contracts
 
### Performance Testing
- k6 for load testing
- Baseline performance metrics
- Bottleneck identification
 
### Security Testing
- OWASP ZAP in pipeline
- Dependency scanning
- Secret detection
 
### Chaos Engineering
- Latency injection
- Service failure simulation
- Database failover
 
## Infrastructure
 
### CI/CD
- Parallel test execution
- Test environment per PR
- Progressive deployment
 
### Observability
- Distributed tracing
- Metrics dashboards
- Alerting on failures
 
### Test Data
- Synthetic data generation
- Production data sanitization
- Database seeding

// Create a generator for realistic user data
 
class UserDataGenerator {
  constructor() {
    this.usedEmails = new Set();
  }
  
  generateEmail(firstName, lastName) {
    const domain = ['gmail.com', 'yahoo.com', 'example.com'];
    const randomDomain = domain[Math.floor(Math.random() * domain.length)];
    const timestamp = Date.now();
    const email = `${firstName.toLowerCase()}.${lastName.toLowerCase()}+${timestamp}@${randomDomain}`;
    
    // Ensure uniqueness
    while (this.usedEmails.has(email)) {
      email = `${firstName.toLowerCase()}.${lastName.toLowerCase()}+${Date.now()}@${randomDomain}`;
    }
    
    this.usedEmails.add(email);
    return email;
  }
  
  generatePhone() {
    // US phone number format
    const areaCode = Math.floor(Math.random() * 900) + 100;
    const firstPart = Math.floor(Math.random() * 900) + 100;
    const secondPart = Math.floor(Math.random() * 9000) + 1000;
    return `${areaCode}-${firstPart}-${secondPart}`;
  }
  
  generatePassword(length = 12) {
    const lowercase = 'abcdefghijklmnopqrstuvwxyz';
    const uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    const numbers = '0123456789';
    const special = '!@#$%^&*';
    
    const allChars = lowercase + uppercase + numbers + special;
    
    let password = '';
    // Ensure at least one of each type
    password += lowercase[Math.floor(Math.random() * lowercase.length)];
    password += uppercase[Math.floor(Math.random() * uppercase.length)];
    password += numbers[Math.floor(Math.random() * numbers.length)];
    password += special[Math.floor(Math.random() * special.length)];
    
    // Fill remaining length
    for (let i = password.length; i < length; i++) {
      password += allChars[Math.floor(Math.random() * allChars.length)];
    }
    
    // Shuffle
    return password.split('').sort(() => Math.random() - 0.5).join('');
  }
  
  generateUser() {
    const firstNames = ['John', 'Jane', 'Alice', 'Bob', 'Charlie'];
    const lastNames = ['Smith', 'Johnson', 'Williams', 'Brown', 'Jones'];
    
    const firstName = firstNames[Math.floor(Math.random() * firstNames.length)];
    const lastName = lastNames[Math.floor(Math.random() * lastNames.length)];
    
    return {
      firstName,
      lastName,
      email: this.generateEmail(firstName, lastName),
      phone: this.generatePhone(),
      password: this.generatePassword(),
      dateOfBirth: this.generateDateOfBirth(),
      address: this.generateAddress()
    };
  }
  
  generateDateOfBirth() {
    // Random age between 18 and 80
    const age = Math.floor(Math.random() * 62) + 18;
    const birthYear = new Date().getFullYear() - age;
    const month = Math.floor(Math.random() * 12) + 1;
    const day = Math.floor(Math.random() * 28) + 1;
    
    return `${birthYear}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
  }
  
  generateAddress() {
    const streets = ['Main St', 'Oak Ave', 'Maple Dr', 'Pine Rd'];
    const cities = ['Springfield', 'Portland', 'Austin', 'Denver'];
    const states = ['CA', 'NY', 'TX', 'FL'];
    
    return {
      street: `${Math.floor(Math.random() * 9999) + 1} ${streets[Math.floor(Math.random() * streets.length)]}`,
      city: cities[Math.floor(Math.random() * cities.length)],
      state: states[Math.floor(Math.random() * states.length)],
      zip: String(Math.floor(Math.random() * 90000) + 10000)
    };
  }
  
  generateMultiple(count) {
    return Array.from({ length: count }, () => this.generateUser());
  }
}
 
// Usage
const generator = new UserDataGenerator();
const testUsers = generator.generateMultiple(10);