About the role
SpringVerify is a background verification and identity-checking platform used by companies across India to run employment, education, address, and identity checks at scale. Every single day, our systems process large volumes of highly sensitive candidate data — a single incorrect result or broken flow can affect someone's job offer. That is why quality and reliability aren't a phase we tack on at the end; they are part of how we build.
As a Software Development Engineer in Test (SDET) intern, you sit at the intersection of software engineering and quality. You won't just click through screens and file bugs — you'll write code to test code. You'll build automated checks at every layer of the stack (user interface, API, and unit level), reason about how features can fail before they ship, and help us release faster with confidence. This is a hands-on engineering internship, and you'll be treated like an engineer from day one.
We're hiring two interns for this role, so you'll have a peer going through the same journey alongside you.
How we work
We are a fully remote company, and that makes communication the single most important skill on the team. When nobody shares an office, your work is only as visible as you make it. We expect you to communicate clearly and proactively — write things down, share progress before you're asked, flag blockers early, ask precise questions, and keep the people who depend on you in the loop. Strong written communication isn't a bonus here; it's the job working at all.
We're looking for people who are motivated from day one — who want to make an impact early, contribute real work, and take genuine ownership of what they're given. You'll always have context, direction, and mentorship, and there are genuinely no bad questions. At the same time, we thrive on self-direction: we'd love you to take initiative, explore answers on your own first, and keep your work moving rather than waiting to be told each next step. If figuring things out and driving your own progress is what energizes you, you'll feel right at home here.
How we work with AI
We give every engineer access to AI coding tools, and we actively encourage you to use them. AI can help you move faster — writing boilerplate, recalling syntax, drafting a first version of a test, or explaining an unfamiliar piece of code.
But be very clear on this: AI assists the execution; the thinking has to come from you. The core of this role — deciding what to test, reasoning about how a feature could break, spotting the edge case nobody else considered, and judging whether a test is actually meaningful — is your job, not the AI's. We're hiring your thought process, your judgment, and your curiosity, not your ability to paste a prompt and accept whatever comes back. You are expected to fully understand, question, and stand behind every line of test code you submit, whether you wrote it by hand or an AI helped draft it. If you can't explain why a test exists and what it protects, it isn't done.
What you'll actually do
Over the six months, your work will grow from writing your first tests under guidance to independently owning test suites for real features. Concretely, you will:
Write end-to-end (E2E) UI tests with Playwright. These tests open a real browser, walk through a complete user journey the way an actual customer would, and assert that the right things happen on screen. You'll learn to write tests that are stable and readable rather than flaky and cryptic.
Write API tests for our backend services. A large part of our platform is REST APIs built on Node.js. You'll write automated tests that call these endpoints directly — sending requests with valid, invalid, missing, and malformed inputs, and verifying the response status codes, response bodies, error messages, authentication/authorization behavior, and the resulting changes in the database. API testing is faster and more precise than driving everything through the UI, and it's a core skill for this role.
Write unit and integration tests for backend code using Mocha, Sinon, and Chai — the frameworks our backend already uses. You'll learn to isolate a single function or module, stub out its dependencies, and prove it behaves correctly across the full range of inputs, including the edge cases the original author didn't think of.
Build the supporting tools that make tests reliable: reusable test fixtures, mock data generators, helper utilities, and data-setup/teardown routines so that every test runs in a clean, predictable, isolated state.
Reproduce and pin down reported bugs. When a bug comes in, you'll reproduce it, write a failing automated test that captures exactly what's broken, and then confirm the fix makes that test pass — so the same bug can never quietly come back.
Keep our continuous integration (CI) test suites green. You'll help run tests automatically on every code change, investigate failures, and hunt down "flaky" tests (tests that pass and fail randomly) until they behave deterministically.
Think about testing before code is written. You'll read feature requirements, ask "how could this break?", and turn the answer into a written test plan that covers the normal path, boundary conditions, negative cases, and failure scenarios.
Pair with backend and frontend engineers to make the product itself easier to test — better logging, clearer error handling, and more testable interfaces.
What we're looking for
We care far more about your fundamentals, curiosity, and attitude than about the exact tools you've used before. If you're missing some of the "nice-to-haves," that's genuinely fine — the internship exists so you can learn them.
Must-haves
Currently pursuing, or recently completed, a degree in Computer Science, Engineering, or a related field.
Solid programming fundamentals in JavaScript or TypeScript. If your strongest language is something else (Python, Java, C++, etc.) but your fundamentals are strong and you're genuinely excited to pick up JavaScript quickly, we still want to hear from you.
A real curiosity about how things break. The best testers instinctively ask, "What happens if the input is empty? Enormous? Malformed? What if two things happen at once? What if the network drops halfway through?"
The ability to think independently and own your reasoning — especially when using AI tools. You should be able to explain the "why" behind every test you write and defend your test strategy, not just produce code.
Self-motivation and initiative. You're driven to contribute from day one, you unblock yourself before asking, and you push your own work forward without needing to be managed step by step.
A working understanding of core testing concepts — the difference between unit, integration, and end-to-end tests; what assertions are; what mocking and stubbing mean; and why test isolation matters. You don't need deep expertise, just a clear mental model.
Basic comfort with Git and the command line.
Excellent written communication — non-negotiable in a fully remote team. You keep others informed, write clearly, flag blockers early, and file precise, reproducible bug reports.
Nice-to-haves (genuinely optional)
Hands-on experience with a UI automation tool — Playwright, Cypress, Selenium, or similar.
Experience testing REST APIs, whether through automated tests or tools like Postman, Bruno, or curl.
Familiarity with Node.js and how HTTP/REST APIs work (methods, status codes, headers, request/response bodies).
Ability to read and write basic SQL (we use MySQL) to set up test data and verify results directly in the database.
Exposure to CI/CD (e.g. GitHub Actions), Docker, or a cloud platform such as AWS.
Any personal, academic, or open-source project where you wrote automated tests — we'd love to see it.
What you'll learn and take away
Real ownership from day one. You'll own test suites that gate actual production releases — not throwaway practice exercises.
Testing across the full stack: UI, API, and unit level, and how to choose the right layer to test something at.
How to work with AI the right way — using it to move faster while keeping the judgment, strategy, and understanding firmly your own.
Mentorship and code review. Senior engineers will review everything you ship and explain the "why," so you leave a noticeably stronger engineer than you arrived.
Exposure to a production system at scale — distributed services, message queues, cloud infrastructure, and real customer data flows.
A clear path to a full-time offer. Strong performers will be considered for a full-time SDET or software engineering role at the end of the internship.
Stipend Offered: 25k/month
Internship tenure: 6 months
Learn More About Springworks