Junior Developer & QA Tester Internship

Role Overview

We are looking for a Developer + QA Tester who will work directly under the Senior Developer and assist with development, testing, debugging, project monitoring, and technical tasks.

The employee will be responsible for ensuring that assigned features are properly developed, tested, verified, and reported before they are considered complete.

The candidate should be comfortable with AI-assisted development / vibe coding and should have a strong understanding of modern software testing methodologies and tools.

---

Key Responsibilities

1. Development Responsibilities

- Assist the Senior Developer with development tasks.

- Implement small and medium-sized features.

- Modify and maintain existing applications.

- Fix bugs and reported issues.

- Work with APIs and third-party integrations.

- Work with databases and backend services where required.

- Use Git/GitHub for version control.

- Understand existing codebases and make changes safely.

- Use AI-assisted coding tools such as Cursor, GitHub Copilot, ChatGPT, Claude, etc.

- Review AI-generated code before using it in production.

- Follow the architecture and coding standards defined by the Senior Developer.

---

2. Testing Responsibilities

The employee will be responsible for thoroughly testing assigned features and applications before reporting them as completed.

Functional Testing

- Verify that every feature works according to the requirements.

- Test normal user flows.

- Test different input combinations.

- Verify buttons, forms, navigation, APIs, and business logic.

- Confirm that expected results are produced.

Negative Testing

The employee should not only test whether something works.

They should also try to break the feature.

Examples:

- Empty inputs.

- Invalid inputs.

- Incorrect formats.

- Very large inputs.

- Duplicate submissions.

- Rapid button clicks.

- Unauthorized access.

- Network failure.

- Server/API failure.

- Expired sessions.

- Incorrect permissions.

Regression Testing

After every major change or bug fix:

- Check the new functionality.

- Check previously working functionality.

- Verify that the new change has not broken another feature.

- Test important existing user flows.

API Testing

The employee should be familiar with tools such as Postman and should be able to:

- Test GET, POST, PUT, PATCH and DELETE APIs.

- Verify status codes.

- Verify response data.

- Test authentication.

- Test invalid requests.

- Test required and optional parameters.

- Test API error responses.

- Verify API performance at a basic level.

UI Testing

Check:

- Layout.

- Buttons.

- Forms.

- Navigation.

- Text.

- Images.

- Loading states.

- Error messages.

- Empty states.

- Responsive behaviour.

- Different screen sizes.

- Mobile and desktop behaviour where applicable.

Mobile Application Testing

For mobile applications:

- Android testing.

- Different screen sizes.

- Different Android versions where available.

- Login/logout.

- Permissions.

- Notifications.

- App background/foreground behaviour.

- Network changes.

- App crashes.

- Installation/update/uninstallation.

- Deep links where applicable.

Cross-Browser Testing

For web applications, test major browsers such as:

- Chrome

- Edge

- Firefox

- Safari

---

3. Bug Reporting

Every important bug must be properly documented.

A bug report should include:

Bug Title

Module/Feature

Environment

Steps to Reproduce

Expected Result

Actual Result

Screenshots / Screen Recording

Console Logs / API Response, where applicable

Severity

Priority

Status

Example

Bug: Login button does not respond after entering an incorrect password.

Steps:

1. Open login page.

2. Enter valid email.

3. Enter incorrect password.

4. Click Login.

Expected: Proper error message should be displayed.

Actual: Button remains loading indefinitely.

Severity: High

Evidence: Screen recording attached.

---

4. Testing Report

The employee must provide a clear testing report to the Senior Developer after completing testing.

The report should clearly show:

Project

Project/Application name

Feature Tested

Name of the feature/module

Testing Date

Date and time of testing

Environment

Development / Staging / Production

Test Cases

- Total test cases

- Passed

- Failed

- Blocked

- Not Tested

Bugs

- Total bugs found

- Critical bugs

- High-priority bugs

- Medium-priority bugs

- Low-priority bugs

- Fixed bugs

- Pending bugs

Final Status

PASS — Feature is ready.

PASS WITH ISSUES — Feature works but has minor known issues.

FAILED — Feature is not ready for release.

BLOCKED — Testing cannot continue because of an external/blocking issue.

---

5. Daily Status Reporting

The employee should provide regular updates to the Senior Developer.

The update should contain:

Completed

- Tasks completed today.

- Features tested.

- Bugs verified.

In Progress

- Current tasks.

- Current testing.

Bugs Found

- New issues discovered.

- Severity and priority.

Bugs Fixed & Verified

- Issues fixed by developers.

- Issues successfully retested.

Blockers

- Anything preventing further development/testing.

Next Tasks

- What will be worked on next.

---

6. Release Verification

Before any important release, the employee should perform a final verification.

They should confirm:

- Build is working.

- Important features are working.

- Login/signup works.

- APIs are responding.

- Database operations work.

- Critical user flows work.

- No critical bugs remain.

- Previously fixed bugs remain fixed.

- No major regression issues exist.

The employee should provide a Release Testing Report before the Senior Developer approves the release.

---

7. Project Update Monitoring

The employee will also be responsible for checking whether projects are properly updated.

This includes:

- Checking pending tasks.

- Checking completed tasks.

- Checking Git branches/commits.

- Checking application builds.

- Checking API status.

- Checking reported bugs.

- Checking whether bugs have actually been fixed.

- Checking whether testing has been completed.

- Identifying outdated features or dependencies where applicable.

- Reporting anything that requires the Senior Developer's attention.

The employee should not simply mark a task as completed because the developer says it is completed. They should verify it themselves.

---

8. Tools & Technologies

Development

- JavaScript / TypeScript

- React / React Native

- Flutter / Dart

- Node.js

- REST APIs

- Git / GitHub

- MySQL / PostgreSQL / MongoDB

AI-Assisted Development

- Cursor

- GitHub Copilot

- ChatGPT

- Claude

- Other AI coding assistants

Testing

- Postman

- Selenium

- Cypress

- Playwright

- Appium

- Browser DevTools

- API testing tools

- Bug tracking systems

- Test case management tools

The candidate does not need expert-level knowledge of every tool, but should have a strong understanding of QA concepts and be capable of learning new testing technologies quickly.

---

9. What We Expect From the Employee

The employee should be able to take a task from:

Requirement → Development → Testing → Bug Identification → Bug Fix Verification → Regression Testing → Final Report

The Senior Developer will guide the employee and handle complex technical decisions, while the employee is expected to independently handle assigned development and testing responsibilities.

Ideal Working Approach

«Don't just tell me that it works. Test it, try to break it, verify it, document the result, and then report it.»

---

Candidate Profile

We are looking for someone who is:

- Technically curious.

- Detail-oriented.

- Comfortable with both development and testing.

- Good at finding bugs.

- Comfortable using AI for development.

- Able to understand existing projects quickly.

- Responsible for assigned tasks.

- Good at reporting issues.

- Comfortable working under a Senior Developer.

- Willing to learn new technologies and testing tools.