Junior Software Engineer - Backend + AI

Junior Software Engineer (Backend + AI)

About Newton Research
Newton Research builds an AI-powered research and analysis platform used by enterprises to unlock insights from their data. Our platform connects to major data warehouses (BigQuery, Snowflake, Databricks, Redshift), runs autonomous AI agents that reason over structured and unstructured data, and presents findings through a rich interactive frontend. We're a small, high-output team where interns work on production code from week one.

Our stack is real, and we want you to know what you're getting into:

• Backend: Python 3.13, Django 5.2, Django REST Framework, PostgreSQL, Redis

• AI/ML: OpenAI, Anthropic, and Google LLM APIs; LangChain + LangGraph agent orchestration; sentence-transformers for vector embeddings; RAGAS for evaluation

• Data Science: NumPy, Pandas, Polars, scikit-learn, XGBoost, PyMC (Bayesian), Prophet, Plotly

• Frontend: React 19, TypeScript, Vite, Ant Design, TanStack Query, SCSS Modules

• Infra: Docker, GitHub Actions CI/CD, AWS (S3, ECR), MinIO, Sentry, RQ (Redis Queue) for async workers

• Testing: pytest with 4,700+ tests, Vitest, Playwright E2E, parallel execution via xdist

What You'll Actually Do
This isn't a "shadow an engineer and take notes" internship. You'll touch production code in a codebase with 7,700+ lines of Django models, complex multi-table relationships, and AI agent pipelines that call LLMs, execute tools, and reason over enterprise data.
Typical intern-level work here looks like:
Build API endpoints — Write DRF serializers and viewsets that serve data to our React frontend. Our models have real complexity (JSONFields, custom managers, mixin patterns) so you'll learn to think about data modeling.
Extend AI agent capabilities — Add new tools to our LangGraph-based agents. Understand how retrieval-augmented generation works by working on our memory system (vector embeddings + semantic search).
Write async task workers — Our RQ workers process everything from document parsing (PDF/Excel/PowerPoint) to LLM inference pipelines. You'll write and debug distributed task logic.

• Improve test coverage — We take testing seriously. You'll write pytest tests with real database fixtures, mock external APIs with responses and moto, and learn to catch N+1 queries with nplusone.

• Ship frontend features — Build React components with TypeScript, wire them to TanStack Query for data fetching, and style them with SCSS Modules. Our frontend includes rich text editing (Milkdown), interactive charts (Nivo, Plotly, Highcharts), and virtualized data tables.

• Debug AI output — When an agent hallucinates or a retrieval pipeline returns irrelevant results, you'll help diagnose and fix it. This is the skill that separates AI-era developers from everyone else.

Who We're Looking For
We're realistic: true full-stack engineers are rare at the intern level. We're looking for someone who's strong on backend fundamentals, curious about AI, and willing to learn frontend. Here's what matters:
Required:

• Solid Python fundamentals — you can write a class, debug a traceback, and reason about data structures without AI autocomplete

• Familiarity with web APIs (you understand HTTP methods, JSON serialization, request/response cycles)

• Comfort with Git (branching, rebasing, resolving merge conflicts)

• Experience with at least one database (SQL queries, basic schema design)

• Genuine curiosity about AI/ML — you've used LLM APIs, built a RAG pipeline, fine-tuned a model, or at least experimented seriously beyond just chatting with ChatGPT

• Ability to debug AI-generated code — we use AI tools extensively, but shipping broken AI output is worse than writing it yourself

Nice to Have:

• Django or Flask experience

• React/TypeScript exposure (even a personal project)

• Familiarity with Docker and containerized development

• Experience with vector databases, embeddings, or LLM orchestration frameworks (LangChain, etc.)

• Contributions to open-source projects

• A deployed project you can demo (we value this more than your GPA)

What We Value (Read: What Our Code Says About Us)

• Testing is non-negotiable. 4,700+ tests, parallel CI execution, time-mocking with freezegun, AWS mocking with moto. If you write a feature, you write the test.

• Automation over manual process. We have 40+ CI/CD deployment pipelines, automated versioning with semantic-release, pre-commit hooks with husky + lint-staged. We invest in tooling.

• Clean architecture matters. Mixins, custom model managers, structured serializer patterns, typed frontend components. The codebase is organized, and we expect contributions to match.

• AI is a tool, not magic. We build AI products and we use AI to build them. We expect you to be fluent with AI coding tools, but also to understand what they produce and when they're wrong.

What You'll Learn

• How a production AI platform works end-to-end — from data ingestion to LLM inference to user-facing results

• Django at scale — complex querysets, database optimization, async task processing

• Modern AI engineering — not just calling APIs, but building retrieval systems, managing embeddings, evaluating output quality with RAGAS

• Real software engineering practices — code review, CI/CD, testing, observability (Sentry, LangSmith)

• How to work with enterprise data connectors (BigQuery, Snowflake, Databricks) in a production system

Logistics

• Permanent, Full-time

• Format: Hybrid — we value in-person collaboration but offer flexibility

• Compensation: $90,000-$110,000

How to Apply
Send us:
Your GitHub (or equivalent portfolio) — a deployed project, an open-source contribution, or even a well-documented experiment beats a resume

• A short note on what you've built with AI tools (not what you've used — what you've built)

• Your resume (we'll read it, but #1 and #2 matter more)

We review applications on a rolling basis. The best candidates move fast — don't wait.
Newton Research Inc is an equal opportunity employer. We hire based on skill, curiosity, and demonstrated ability — not pedigree. (edited)