Backend Developer, Technology Platform Team

Backend Developer, Technology Platform Team 

At Simple Education Foundation (SEF) we work with government schools and education systems  to build statewide programs for educators to improve the quality of teaching and learning in government schools across India. We work across teachers, school leaders and education systems to build solutions that can improve outcomes for children.

We are a highly driven team with over 50 years of cumulative experience in teaching in classrooms and working with government school systems. Our team is young, dynamic, bold, and audacious enough to make this mission come true in our lifetime. To help us accelerate our impact, we are looking to onboard more members on our paper plane!

Technology is increasingly becoming an important part of how we do this work. Our Technology Platform Team builds and operates the platforms and systems that support SEF’s growing portfolio of products. Through this role, you’ll use your technology skills to contribute to a larger social purpose, strengthening public education and supporting teachers to create better learning experiences. 

About the role

We’re looking for a Backend Developer to join our Technology Platform Team and contribute to the development of the platforms that power SEF’s technology efforts.

You’ll work on platforms that support a range of products SEF develops over time. Currently, these include products such as Compass, SparC, and STB, with more in progress.

You’ll be joining a growing technical team and working within an existing codebase with established architectural decisions, engineering patterns and project disciplines. You won’t be expected to know the system or every technology it uses from day one. We do expect you to bring a strong foundation in backend development, take the time to understand the system you’re working within, and progressively take ownership of larger pieces of the platform. This is a hands-on engineering role. You’ll begin with well-defined pieces of work while building familiarity with the architecture and, over time, take on increasingly independent backend development and platform responsibilities.

IMPORTANT: Please ensure that you include links to relevant work or projects, including your GitHub portfolio, in your CV at the time of application. 

What will you do?

You’ll begin with well-defined, bounded pieces of the platform while you build familiarity with the architecture. Your work will include:

• Authoring and extending configuration-driven logic using the platform’s existing engine and supported building blocks.
  

• Writing and extending automated tests for existing and new functionality.
  

• Building smaller, well-scoped utility and platform functions, including data-access and repository functions, within established architectural patterns.
  

• Fixing bugs and implementing scoped feature requests in areas of the codebase you have become familiar with.
  

• Investigating existing code and system behaviour as part of implementing assigned work, rather than expecting every implementation detail to be provided upfront.
  

• Maintaining documentation, implementation records, checkpoints and other project artefacts required as part of your work.
  

• Gradually taking on larger pieces of the platform as you build familiarity with its architecture, including areas such as processing logic, routing, session lifecycle, persistence and integrations.
  

As you grow into the codebase, there will be a path toward owning larger, independent pieces of platform work. The expectation is not that you will independently architect major capabilities from day one, but that your ability to take work from assignment through implementation, verification, review and completion will steadily increase.

• 1–3 years of relevant software development experience, with meaningful hands-on experience writing and working with application code.
  

• Working knowledge of Python and a demonstrated foundation in backend development.
  

• Experience building or working with backend applications, whether through professional work, substantial personal projects, internships or structured technical coursework.
  

• Familiarity with web APIs and the basic architecture of backend applications.
  

• Familiarity with relational databases and SQL, including an understanding of how application code interacts with persistent data.
  

• Familiarity with Git and normal version-control workflows.
  

• Experience writing, running or working with automated tests.
  

• Ability to read existing code carefully and follow established patterns rather than defaulting to reinventing an approach from scratch.
  

• Curiosity about why code is structured a certain way, not just how to make something work. Our codebase has architectural intent behind it, and we’re looking for someone who wants to understand that intent before changing it.
  

• Discipline in working within an established engineering process. Documentation, implementation notes, checkpoints, verification and other required project records are part of completing engineering work.
  

• Clear communication and comfort asking questions early. We would much rather you investigate something, identify what you don’t understand and ask a precise question than spend a long time silently guessing.
  

• Evidence that you have actually built things. Personal projects, coursework projects, internship work, professional work, open-source contributions or other demonstrable software are all valid evidence.
  

At SEF, we value people who bring strong role-specific skills while also collaborating with empathy, communicating with clarity, continuing to learn and grow, and thoughtfully using data and design to shape their work. 

You do not need prior experience with every technology or system our platforms use. Exposure to a few of the following will be helpful:

• FastAPI, Flask, Django or another Python web framework
  

• SQLAlchemy or another ORM
  

• PostgreSQL
  

• Async programming in Python
  

• Docker and containerised development environments
  

• Chatbots, conversational systems or messaging APIs
  

• AI/LLM integrations and the practical considerations involved in incorporating AI capabilities into application systems
  

We won’t expect you to know the codebase on day one. We’ll provide onboarding, architectural context, knowledge transfer, clear work-item definitions and regular review. Once a work item is assigned, you’re expected to:

• Understand the relevant system and identify what you need to learn or clarify
  

• Ask questions early and surface blockers
  

• Implement, test and carry the work through review and completion
  

• Keep required project records current
  

Mentorship provides support and context, but developing the ability to discover, reason and drive your own work is an important part of the role.

• Understand existing architectural decisions and boundaries before changing them.
  

• If something appears unnecessary, overly complicated or worth redesigning, question it — but first understand why it exists and discuss the change rather than silently replacing an established approach.
  

We work through defined work items, checkpoints, implementation records, verification and documentation to maintain a reliable understanding of what the system does and why.

• Completion of all required documentation, evidence, checkpoint updates, and other project artefacts is part of the Definition of Done (DoD).
  

• If something takes significant time, creates unexpected complexity or appears unnecessary, communicate that rather than bypassing or routing around the process.
  

• You’ll be expected to work from clearly defined contracts and boundaries, test your implementation against them, and surface cases where implementation reveals that an existing assumption or design no longer holds.
  

• You’ll be expected to build and test with production concerns in mind, including session lifecycle, reliability safeguards, persistent state, routing, validation and external integrations, etc.
  

• As you gain familiarity with the codebase, you’ll progressively take responsibility for changes that interact with these areas.
  

Initially, success means being able to take a bounded work item, understand the relevant part of the system, ask good questions, implement it within established patterns, test it properly, document what needs documenting, and take it through review.

Over time, we expect the amount of context and implementation guidance you need to decrease. This can mean progressing from extending existing flows and functions, to owning backend features, to taking responsibility for larger pieces of a capability and contributing meaningfully to architectural discussions.

The goal is not simply to become faster at implementing tasks. It is to develop the judgment required to understand an existing system, reason about changes within it, identify when something doesn’t fit, and communicate clearly enough to help us make better engineering decisions together.

Location: Delhi