Engineering Intern for T2D3 OS

The ground floor of the platform team — where the Systems Engineer path begins.

The Engineering Intern is the newest builder on the core T2D3 OS team, learning the platform from the ground up. AI can wire infrastructure together, fire deploys, and pass the easy tests; you learn to read what it produces, catch what it gets wrong, and keep the gates honest before anything ships. The founder writes the product with Claude Code, the product lead shapes what gets built, and the Founding Systems Engineer owns the platform it all runs on — you come in alongside them, on the real codebase, from your first week. You come in curious, not finished.

This starts as an unpaid, semester-length internship built around your class schedule — the pay up front is real production experience, mentorship, and work that ships to customers from day one. It's built to grow: strong interns convert to a paid part-time seat, and from there become eligible for founding equity as the platform and the team grow. Most internships won't look at you before your junior or senior year. We will, because we hire for trajectory, not résumés. Come in with curiosity, drive, and a sense of ownership, and we'll meet you at the very start of the ladder below — the same ladder the Systems Engineer sits further up — and grow together, teaching, pairing, and backing you the whole way.

What you'd do

• Write and run the tests that prove new code is sound, and keep them green
• Help keep deploys, environments, and monitoring healthy — and learn the runbook by working it
• Build small, well-scoped features and fixes behind the platform's security, with a human check before they merge
• Wire up and test MCP connectors and agent workflows, and keep the AI's output honest before it ships
• Help stand up and drill the backup instance, and see for yourself what proven recovery actually means
• Turn a vague problem into a small, shippable piece — and then ship it

How it's different from a traditional seat

You're not fetching coffee or writing throwaway scripts that never see daylight. This is real work on the real platform, next to the founders. The founder owns the functionality, the Systems Engineer owns the platform and the gates — and you're here to learn how both hold, by doing the work under people who want you to get good. AI does the boilerplate, so what you're really building is judgment: the ability to tell when the machine is wrong before it reaches production.

Where you might come from

First- and second-year CS or related students, self-taught builders, hackathon regulars, and anyone who's shipped a side project, a bot, a game, or a script for the fun of it. A curiosity about how systems fail — and how you'd stop them — is worth more to us than a long résumé. You don't need to have done this before; you need to want it.

You might be a fit if…

• You've built something real, and you can show it to us
• You're curious about how things break and who they expose, not just how to make them work
• You already use AI tools, and you're honest about where they help and where they lie
• You can read code you didn't write and work out how it behaves
• You're energized, not threatened, by an AI-native workflow with tools like Claude Code and agents

The stack you'll work in

Next.js 15 on Vercel, with Supabase at the heart: Postgres across roughly 150+ production tables, authentication, Security, storage, and edge functions. GitHub for source and CI, Capacitor for mobile, MCP connectors for AI agents, and Claude Code as the daily working environment. You won't know all of it on day one — nobody does. You'll learn it by building in it, next to the person who owns it.

How you grow as a Systems Engineer

Designs, automates, and protects the systems that carry the product at scale. The Engineer is the Syntropy job family that turns infrastructure into leverage. AI can stitch infrastructure together and fire deploys; the Engineer decides what should exist, builds the gates that stop entropy from scaling, and makes the platform compound instead of crack. Thinks like an architect, not an operator. Interns join at the ground floor of the Operator rung and grow from there — the same path the Founding Systems Engineer is further along.

Operator, Level 1 of 4

Keeps the platform running. Deploys, environments, monitoring, and backups stay healthy and on time.

• Keeps deploys, environments, monitoring, and backups running without breakage
• Executes test runs and routine operations reliably and on time
• Follows the runbook accurately and keeps the alerting clean and trustworthy

Level up: Stop doing ops by hand and start building the systems that do it for you. Automate the repeatable, instrument the rest.

Builder, Level 2 of 4

Builds the automation and the gates. CI/CD, infrastructure as code, and the test suites that protect every merge.

• Ships CI/CD pipelines, infrastructure as code, and automated tests that gate every merge
• Treats security checks and quality gates as code the pipeline enforces, not manual reviews
• Reduces toil measurably, judged on incidents prevented and hours saved, not scripts written

Level up: Think like an architect. Design the platform end-to-end and own the security and scalability calls, not just the automation beneath them.

Architect, Level 3 of 4

Designs the platform end-to-end. Security posture, scalability, and disaster recovery, with judgment that cannot be scripted.

• Owns security posture, Row Level Security design, scalability architecture, and disaster recovery
• Builds privacy-by-design and a recovery capability proven by drill rather than asserted on a slide
• Makes the high-leverage calls, including when the modular monolith should begin to fracture

Level up: Make reliability and security compound across the product. Set the standards and coach others to build to them instead of owning every system yourself.

Systems Strategist, Level 4 of 4

Runs an instrumented, compounding platform. The product scales without the operational load scaling with it.

• Success is measured by uptime sustained, breaches avoided, and toil eliminated across the org, not systems shipped
• Reusable platform and guardrails let the product grow while the Frankenstack shrinks and the architecture matures
• Coaches and hires the platform team so reliability multiplies everyone's output, not just their own

At the top: Ceiling rung. The move is outward, setting the platform and security standard the org and market are measured against.

A friendly note on the journey: the real unlock isn't typing faster than the AI — it's the judgment to know what's worth building and when the model is wrong. That's a muscle we help you build, and it's what opens up the next rung.

How to apply

We'd love to see something real. Send us one thing you built — a repo, a live site, a game, a script, anything — and a couple of sentences on what you'd change if you built it again. And if you have one, show us something you made with an AI tool and tell us what you had to fix in what it gave you. That last one tells us more than any transcript could — we're looking for the person who can tell when the machine is wrong.

We read for judgment, not buzzwords, and we reply to everyone who writes something real.