Software Engineer II

Amtechsoftware; India; On-site; INR 1,400,000 - 2,100,000; Full time

Job summary

Amtechsoftware is seeking a Software Engineer II to own end-to-end features on the EnCore ERP platform. You will independently deliver in familiar domains, mentor newer engineers, and contribute to architectural discussions for scalable, high-quality software.

You will write testable C# with DI, craft efficient SQL, and lead code reviews while ensuring transaction safety and robust testing. This role emphasizes ownership and continuous improvement.

Qualifications

• Advanced C# and .NET expertise with LINQ and async/await patterns.
• SQL proficiency including complex queries and transactions.
• Focus on data safety, atomic operations, and migration scripting.

Responsibilities

• Own discrete features and bug fixes from specification to production.
• Write testable, maintainable C# using DI and separation of concerns.
• Develop efficient SQL queries with proper transaction handling and performance.
• Design and implement unit and integration tests.
• Lead code review and provide constructive feedback on correctness and security.
• Investigate performance issues in stored procedures and queries using execution plans.
• Participate in database schema design and write safe migration scripts.
• Support and mentor Associate Engineers and contribute to onboarding.
• Propose improvements to team processes, tooling, and codebase consistency.

Skills

Advanced C# & .NET

SQL proficiency

Data safety & transactions

Testing & quality

Debugging & investigation

Mentoring

Code reviews

Job description

Software Engineer II - Job Description

Position Overview

We are seeking a Software Engineer II to take ownership of discrete features and workstreams on the EnCore ERP platform. You will work independently on familiar domains while collaborating with the team to deliver predictable, high-quality output. At this level, you bridge the gap between individual contributor and technical leader—you own end-to-end implementation, including testing, code review, and knowledge transfer.

This role emphasizes independent delivery, testable code, transaction safety, and SQL efficiency. You will mentor newer engineers, contribute to architectural discussions, and take increasing accountability for system quality and performance.

Key Responsibilities

• Own discrete features and bug fixes from specification to production, including design, implementation, testing, and documentation.
• Write testable, maintainable C# using dependency injection, appropriate abstractions, and separation of concerns (UI, business logic, data access).
• Develop efficient SQL queries with correct transaction handling, understanding of execution plans, and performance optimization.
• Design and implement unit and integration tests that catch real problems and remain reliable across code changes and environments.
• Lead code review of peer submissions, providing constructive feedback on correctness, testability, security, and performance.
• Investigate performance issues in stored procedures and queries using execution plans, statistics, and production diagnostics.
• Participate in database schema design and write safe, rerunnable migration scripts.
• Support and mentor Associate Engineers, contributing to onboarding, pair programming, and knowledge building.
• Propose improvements to team processes, tooling, and codebase consistency.

AI Proficiency (L2: AI Practitioner)

Scope:

Scope: Personal productivity and routine task automation

• Understanding: Understand when AI is appropriate for your work; recognize its strengths (code generation, documentation, explanation) and limitations (complex logic, business rules, data accuracy).
• Validation discipline: Verify AI-generated code independently; understand the logic before merging; validate SQL queries against schema and business rules.
• Routine tasks: Use AI confidently for boilerplate code, test scaffolding, documentation, and refactoring within your understanding.
• Escalation: Recognize when a problem requires human judgment (security, architecture, business logic) and discuss with peers or leads.
• Team standards: Follow established patterns for AI usage; don't use AI to bypass security or code review.

Examples:

• Use Claude to generate unit test scaffolding while you write test logic.
• Ask AI for SQL query optimization suggestions, then verify with execution plans.
• Generate documentation and README content with AI, then edit for accuracy.
• Use Copilot for boilerplate code, but always review and understand.
• Escalate complex architectural decisions or security concerns to senior engineers.

Required Qualifications

Technical Foundation

• Advanced C# and .NET:
  • Proficiency with async/await, Task-based APIs, and understanding of completion vs. performance.
  • Ability to identify and fix issues with fire-and-forget async calls.
  • Knowledge of dependency injection and constructor-based dependency patterns.
  • Understanding of interface-driven design for testability.
  • Comfortable with LINQ, collections, and modern C# features.
  • Experience with exception handling, logging, and graceful degradation.
• SQL competence:
  • Ability to write complex queries using CTEs, window functions (ROW_NUMBER,RANK, etc.), and advanced joins.
  • Understanding of execution plans and how to identify scans vs. seeks.
  • Knowledge of when to apply functions inWHEREclauses impacts performance.
  • Proficiency with transactions, isolation levels, and transaction safety across multiple statements.
  • Ability to write safe, rerunnable database migration scripts that check current state.
  • SQL parameterization as a standard, not an afterthought.
• Data safety and transaction design:
  • Deep understanding of why business operations (e.g., "complete alert and insert history") must be atomic.
  • Recognition that UI validation and application logic are not sufficient safeguards—database constraints and transactions provide the final guarantee.
  • Ability to identify partial-failure scenarios and design for rollback.
  • Verification of row counts and state before/after operations.
• Testing and quality:
  • Ability to write unit tests that are isolated, repeatable, and do not depend on execution date, static state, or file system artifacts.
  • Understanding of test fixtures, mocks, and fakes.
  • Familiarity with test-driven development (TDD) or test-first workflows.
  • Recognition that tests must be maintained and refactored as code evolves.
• Debugging and investigation:
  • Systematic approach to identifying root causes in production issues.
  • Proficiency with debuggers, profilers, logs, and execution plans.
  • Ability to reproduce issues reliably and document findings.
  • Understanding of when to add instrumentation vs. when a problem is already well-understood.