Software Engineer II

Amtech Software; India; On-site; INR 1,200,000 - 1,800,000; Full time

Job summary

Amtech Software is seeking a Software Engineer II to own end-to-end features on the EnCore ERP platform. You will deliver testable, high-quality code and mentor newer engineers while collaborating with the team on architecture and performance.

You will focus on robust C# development, SQL efficiency, and test coverage, escalating complex architectural concerns to senior engineers as needed.

Qualifications

• Strong proficiency in C# and .NET with async/await patterns.
• Experience writing testable, maintainable code with DI and clean architecture.
• Deep knowledge of SQL including transactions, performance, and execution plans.
• Ability to write and review unit and integration tests.
• Experience mentoring engineers and participating in design discussions.
• Familiarity with enterprise ERP or multi-tenant systems is a plus.

Responsibilities

• Own features from specification to production, including design, tests, and docs.
• Write testable C# with DI and clean separation of concerns.
• Develop efficient SQL queries with proper transaction handling.
• Design and implement unit and integration tests.
• Lead code reviews and provide constructive feedback.
• Investigate performance issues using execution plans and diagnostics.

Skills

Advanced C#

.NET

SQL proficiency

Unit testing

Code reviews

Mentoring

Dependency injection

Education

Bachelor’s in CS/Engineering

Tools

SQL Server

Git

Job description

We are seeking aSoftware Engineer IIto 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 fixesfrom 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 querieswith correct transaction handling, understanding of execution plans, and performance optimization.
• Design and implement unit and integration teststhat catch real problems and remain reliable across code changes and environments.
• Lead code reviewof peer submissions, providing constructive feedback on correctness, testability, security, and performance.
• Investigate performance issuesin stored procedures and queries using execution plans, statistics, and production diagnostics.
• Support and mentor Associate Engineers, contributing to onboarding, pair programming, and knowledge building.
• Propose improvementsto team processes, tooling, and codebase consistency.

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.
• Independent delivery: Complete tasks from specification to production with minimal hand-holding; know when to ask for guidance.
• Communication: Explain design decisions, articulate trade-offs, and discuss business implications clearly.
• Collaboration: Contribute to code review, pair programming, and mentoring without ego.
• Ownership: Take responsibility for code quality, performance, and correctness; avoid blaming frameworks or "legacy code."
• Continuous improvement: Identify and propose fixes for process gaps, inconsistencies, and inefficiencies.

Preferred Qualifications

• Experience with enterprise systems (ERP, financial software, or complex multi-tenant applications).
• Exposure to real-world performance tuning and debugging in production systems.
• Familiarity with event-driven or message-based architectures.
• Experience with reporting systems or analytics.
• Understanding of database scaling, replication, or backup/recovery strategies.
• Contribution to open-source projects or active GitHub presence.
• Experience mentoring junior engineers or contributing to hiring and onboarding.
• Knowledge of SDLC best practices, secure coding, and threat modeling.
• Mature, large codebase: 13,000+ C# files across 50+ modules. You will navigate, improve, and extend existing systems.
• Production responsibility: Your code directly impacts manufacturing operations, financial transactions, and customer success. Rigor is rewarded.
• Collaborative technical culture: Architecture and design decisions are discussed; peer review is thorough and constructive.
• Growth-oriented: You'll learn from senior engineers while mentoring newer ones.
• Continuous learning: Unfamiliar frameworks (WiseJ, PPJ) are learned on the job through hands‑on work and pair programming.

Assessment Criteria

During interviews and in early assignments, we evaluate:

• Independent ownership– You can take a feature from specification to production without excessive hand-holding.
• Transaction safety– You design operations to be atomic and verify their correctness with row counts and state checks.
• SQL efficiency– You write queries that avoid full scans, understand execution plans, and consider data-volume impacts.
• Testable code– You separate concerns, use dependency injection, and write tests that catch real failures.
• Investigation skills– You systematically diagnose issues and propose solutions backed by evidence.
• Mentoring ability– You can explain your reasoning and help others improve their code.

Growth Path

Within 18 months, a successful Software Engineer II will:

• Ship 10–15 features and bug fixes independently with minimal rework.
• Mentor or pair-program with 2–3 Associate Engineers on significant features.
• Lead architectural discussions on assigned modules or cross-module concerns.
• Identify and fix a performance issue that improves production throughput or latency.
• Contribute 1–2 process improvements (tooling, testing, deployment, or documentation).

Beyond SE II, growth leads toSoftware Engineer III(senior architect),Technical Lead, orStaff Engineerroles, with responsibility for system design, strategic initiatives, and broad technical influence.