Backend Engineering Intern (2027-2028)

Stipend: ₹5,000/month
Duration: Minimum 4 months
Commitment: Approximately 25–30 hours/week
Work Mode: Remote — India
Graduation Year: 2027 or 2028 preferred
Experience: Previous employment not required; demonstrable technical experience is mandatory
Equity: None

Important: Read Before Applying

This is a hands-on, high-ownership engineering internship for students who already have practical experience with Golang (Go), REST API development, SQL and relational databases.

We are looking for candidates who can understand an existing backend codebase, investigate technical problems independently, and contribute to production APIs, data models and backend workflows.

Prior hands-on knowledge of Go is mandatory. This internship is not intended for candidates who plan to learn Go from scratch after joining.

You should be comfortable writing Go code, designing and debugging APIs, working with databases, and reasoning about how backend systems behave under normal and failure conditions.

You will receive guidance on our existing architecture, product requirements and engineering workflows, but you must already possess the technical foundations needed to contribute.

The internship offers a ₹5,000/month stipend, direct founder collaboration, meaningful backend ownership and practical experience maintaining real production systems.

About Auto Wisdom

Auto Wisdom is building automotive intelligence and digital products that help people make better decisions around cars, ownership and automotive services.

Our products rely on backend services that manage APIs, authentication, data processing, business workflows and integrations with external systems.

We are a founder-led engineering team, where backend developers work closely with frontend engineers, product development and infrastructure.

You will contribute to real backend systems used by real customers — not isolated tutorials or practice applications.

Why Join Us?

At Auto Wisdom, you will:

• Develop and maintain production backend services using Go and PostgreSQL.
• Work with an existing Go codebase using Gin and GORM.
• Contribute to APIs, authentication, database operations and background workflows.
• Collaborate directly with the founder on engineering and architecture decisions.
• Understand how backend services interact with frontend applications, databases and infrastructure.
• Debug production issues and improve reliability, correctness and maintainability.
• Participate in code reviews, testing, QA and deployment processes.
• Own assigned engineering tasks from requirement understanding through release.

Our Technology Stack

Backend: Golang (Go), Gin, GORM and REST APIs.

Database and Caching: PostgreSQL, Redis, database migrations, relational modelling and transactional workflows.

Authentication and Security: OAuth 2.0, JWT, session management, middleware, validation and access control.

Engineering and Infrastructure: Git, GitHub, Docker, CI/CD, Supabase, Railway, DigitalOcean and cloud-hosted services.

You do not need expert-level experience with every infrastructure platform, but you must already have practical backend development knowledge.

What You'll Do

Backend Development

• Build, modify and maintain backend services using Go and Gin.
• Implement and evolve REST APIs and request/response contracts.
• Work with existing handlers, service layers, middleware and business logic.
• Implement database operations using GORM and PostgreSQL.
• Design and modify database models, relationships, queries and migrations.
• Implement request validation, structured error handling and API responses.
• Work on authentication, authorization and secure account workflows.
• Develop and maintain background tasks and asynchronous processes.
• Integrate Redis for caching, temporary state or coordination where required.
• Implement appropriate transaction handling, retries and idempotency controls.
• Investigate backend performance, API failures and database issues.
• Debug frontend-backend integration problems.

Engineering Ownership

• Read and understand existing implementation before introducing changes.
• Evaluate API compatibility, data integrity and backward compatibility.
• Identify failure cases, concurrency concerns and potential regressions.
• Reuse established architecture before proposing additional abstractions.
• Write maintainable, testable and idiomatic Go code.
• Implement appropriate tests for success, failure and edge-case scenarios.
• Use logs, database queries and debugging tools to investigate problems.
• Review your own code and Git diff before submitting pull requests.
• Participate in code reviews and technical discussions.
• Document important implementation decisions and trade-offs where necessary.
• Take assigned tasks through implementation, review, QA and final closure.

Mandatory Technical Requirements

1. Golang (Go)

You must already have a practical understanding of:

• Go syntax, types, structs, interfaces, pointers and methods.
• Go packages, modules and project organization.
• Error handling, error propagation and idiomatic Go practices.
• Slices, maps and standard-library utilities.
• Context propagation, cancellation and timeouts.
• Goroutines, channels and basic concurrency principles.
• HTTP servers, handlers, middleware and request processing.
• Writing, running and debugging Go applications.
• Writing basic unit tests using Go's testing tools.

2. REST APIs and Backend Architecture

You should be comfortable with:

• Developing RESTful APIs using Go.
• Working with Gin or another comparable Go HTTP framework.
• HTTP methods, status codes, headers and JSON payloads.
• Request validation and consistent error handling.
• Authentication, authorization and middleware.
• API contracts and frontend-backend integration.
• Understanding existing service boundaries and code organization.
• Handling failures, timeouts and invalid requests.
• Basic API security and secure coding practices.

3. PostgreSQL and Database Fundamentals

You must understand:

• SQL queries, joins, filtering, grouping and aggregation.
• Relational database design and data modelling.
• Primary keys, foreign keys, constraints and relationships.
• Database indexes and basic query-performance considerations.
• Transactions, consistency and data integrity.
• Database migrations and schema changes.
• ORM concepts and practical database access from Go.
• Common database errors and how to investigate them.

4. Software Engineering Fundamentals

You must be able to:

• Use Git confidently, including branches, commits and pull requests.
• Read and understand unfamiliar code before modifying it.
• Debug problems systematically using logs, tests and targeted investigation.
• Explain why an implementation works and where it could fail.
• Identify edge cases, security concerns and potential data-integrity issues.
• Test changes before requesting code review.
• Understand basic concurrency risks and failure recovery.
• Communicate technical decisions, assumptions and blockers clearly.

Candidates must be able to demonstrate their technical knowledge through previous projects, code discussions or practical evaluation.

How We Work

We value engineers who reason carefully about correctness, reliability and maintainability.

You will be expected to:

• Understand the requirement, existing code and data flow before implementation.
• Investigate relevant modules and dependencies independently.
• Break non-trivial tasks into clear implementation plans.
• Identify important assumptions, failure modes and edge cases early.
• Research unfamiliar concepts before choosing an approach.
• Avoid repeated trial-and-error fixes without investigating the underlying cause.
• Ask specific questions when blocked instead of remaining silently confused.
• Estimate work realistically and communicate potential delays before deadlines.
• Provide revised estimates when committed timelines change.
• Consider security, concurrency, data integrity and backward compatibility.
• Test your own changes thoroughly before requesting review.
• Apply code-review feedback consistently.
• Take responsibility for assigned work through final completion.

You are not expected to know Auto Wisdom's internal architecture before joining. However, you must be technically prepared to understand it and become productive after a focused codebase orientation.

AI-Assisted Development

We actively use AI-assisted engineering tools.

AI can accelerate implementation, debugging and research, but it does not replace engineering judgment.

You must be able to:

• Explain the code and technical decisions you submit.
• Independently review and validate AI-generated Go code.
• Identify incorrect assumptions or architectural mismatches.
• Recognize potential concurrency, security and database issues.
• Verify AI-generated recommendations against actual implementations and documentation.
• Debug problems independently when generated solutions fail.
• Test all AI-assisted changes, including failure scenarios.
• Take full responsibility for the correctness, security and maintainability of your implementations.

Do not submit backend code you cannot independently understand, explain, debug or validate.

Bonus Points

• Hands-on experience with Gin and GORM.
• Redis caching, key design and expiration strategies.
• Docker and containerized applications.
• Background jobs, queues and worker systems.
• Database query optimization and indexing.
• Advanced concurrency patterns and race-condition debugging.
• Transactions, idempotency and retry strategies.
• OAuth 2.0, JWT and secure session management.
• CI/CD pipelines and GitHub Actions.
• Experience with Supabase, Railway, DigitalOcean or similar infrastructure.
• Logging, monitoring and production troubleshooting.
• Previous internships, deployed backend applications or open-source contributions.
• Interest in system design, reliability and scalable backend systems.
• Interest in automotive technology or mobility.

Eligibility

• Students pursuing B.Tech, B.E. or a related technical degree.
• Preferably graduating in 2027 or 2028.
• At least four months of availability.
• Ability to commit approximately 25–30 hours per week.
• Existing practical experience with Go, REST APIs and relational databases.
• Ability to work independently on appropriately scoped engineering tasks.
• Comfortable collaborating remotely and communicating progress consistently.

Candidates from all colleges are welcome. Practical engineering capability matters more than college brand.

Stipend

₹5,000 per month.

What You'll Gain

• Direct exposure to founder-led backend engineering and architectural decisions.
• Ownership of real production APIs and backend workflows.
• Experience maintaining an existing Go codebase.
• Practical exposure to PostgreSQL, authentication, caching and asynchronous workflows.
• Experience debugging production backend systems.
• Regular technical feedback, code reviews and engineering discussions.
• Exposure to real QA, CI/CD and release processes.
• Experience collaborating across frontend, backend and infrastructure.
• A ₹5,000 monthly stipend.
• A letter of recommendation based on performance.
• Priority consideration for future internships or full-time opportunities, based on performance and business requirements.

Ready to Apply?

Share your GitHub profile and at least one meaningful backend project developed using Go.

Tell us:

1. What did you personally build using Go?
2. Which components, APIs or services did you own end-to-end?
3. How did you design your API contracts and database models?
4. What was one difficult backend engineering problem you encountered?
5. How did you investigate and debug the issue?
6. How did you test that your solution was correct, including edge cases and failures?

We may discuss your existing code or ask you to complete a practical backend engineering assessment.

We are looking for candidates who already know how to develop backend applications using Go and are ready to contribute to production engineering work.