Job Description:

Python Developer

Engineering - Mid-Level - 3-6 Years

Role Overview:

We are looking for a self-sufficient Python Developer who goes well beyond writing code. You will own modules end to end from understanding a design brief, making meaningful architectural decisions at the module level, through to shipping production-ready, well-tested Python. You should be equally comfortable reading a system design document and turning it into a working library as you are collaborating with AI coding tools to accelerate your output.

If you need constant hand-holding from a tech lead to ship features, this role is not the right fit. If you take a problem statement and return a solution, read on.

Job Details:

Job Title: Python Developer

Level: Mid-Level (Individual Contributor)

Experience: 3-6 Years

Reports To: Engineering Lead / Tech Lead

Employment Type: Full-Time

Location: Hybrid / Remote

What Ownership Means in This Role:

We use the word ownership deliberately. Here is what it looks like day to day:

- Given a design doc or a high-level requirement, you can independently build a complete, production-grade Python library or module - no step-by-step lead guidance needed.

- You can read an architectural diagram or API contract and translate it into a clean, well-structured implementation without needing it translated for you.

- You can design a module yourself - break down requirements, decide on class structures, define interfaces, and make defensible tradeoffs.

- You are comfortable using AI coding tools (Cursor, Copilot, ChatGPT, Claude) as a force multiplier - vibe-coding to prototype fast, then sharpening the output to production quality.

- You catch your own bugs, write your own tests, and review your own PRs before asking anyone else to look at them.

Key Responsibilities:

Independent Development:

- Build Python libraries, services, and modules end-to-end from requirement to deployment with minimal supervision.

- Own the full development lifecycle of assigned modules: design, implementation, testing, documentation, and maintenance.

- Translate product requirements and technical designs into clean, maintainable, and performant Python code.

- Make context-appropriate architectural decisions at the module and component level - data structures, design patterns, dependency choices.

Design & Technical Thinking:

- Read and interpret system design documents, ERDs, sequence diagrams, and API specifications independently.

- Design module-level solutions - define interfaces, plan component boundaries, and present design choices with clear rationale.

- Identify potential design flaws or scalability concerns early and raise them proactively, not reactively.

- Contribute meaningfully to technical discussions and design reviews with your own perspective, not just implementation updates.

Code Quality & Craftsmanship:

- Write well-structured, idiomatic Python - clean APIs, sensible abstractions, appropriate use of OOP and functional patterns.

- Maintain strong test coverage: unit tests, integration tests, and edge case handling as a default, not an afterthought.

- Follow and contribute to coding standards, style guides, and internal conventions.

- Participate actively in code reviews - both giving and receiving feedback constructively.

AI-Augmented Development:

- Use AI coding assistants effectively to scaffold code, explore approaches, and accelerate delivery.

- Apply critical judgment to AI-generated code - validate logic, catch hallucinations, refactor to meet quality standards.

- Leverage vibe-coding workflows responsibly: rapid prototyping with AI, followed by deliberate review and hardening.

Required Skills & Experience:

- 3-6 years of professional Python development experience.

- Proven ability to build and ship complete features or libraries independently, without task-level guidance.

- Strong command of Python fundamentals: typing, async/await, decorators, context managers, generators, and the standard library.

- Experience designing and consuming REST APIs and/or gRPC services.

- Solid understanding of software design principles (SOLID, DRY, separation of concerns) and ability to apply them pragmatically.

- Hands-on experience with testing frameworks: pytest, unittest, and mocking patterns.

- Familiarity with packaging and dependency management: pip, Poetry, or similar.

- Working knowledge of Git workflows, code review practices, and CI/CD pipelines.

- Ability to read, understand, and work from design documents and technical specifications independently.

- Comfort with AI-assisted development tools and the discipline to validate their output.

Good to Have:

- Experience building internal Python libraries or SDKs used across teams.

- Familiarity with FastAPI, Flask, or Django for service development.

- Exposure to data pipelines, task queues (Celery, RQ), or event-driven systems.

- Basic understanding of containerization (Docker) and deployment workflows.

- Experience contributing to or maintaining open-source Python projects.

- Exposure to LLM APIs, prompt engineering, or AI/ML-adjacent tooling.

What We Are Not Looking For:

To be direct about expectations:

- Someone who needs a tech lead to break down every task before they can begin.

- A developer who can implement instructions but cannot design or think through a module independently.

- Someone who treats AI-generated code as final output without applying engineering judgment.

- A candidate who mistakes familiarity with Python syntax for the ability to architect and ship a complete solution.

What We Offer:

- A team that respects your autonomy and trusts you to own your work.

- Challenging, greenfield problems - not just maintenance and ticket-grinding.

- Exposure to modern AI-augmented development workflows.

- Clear growth path toward Senior Developer or Tech Lead roles.

- Competitive compensation, flexible working, and a learning & development budget.