Software Engineer III

• Own modules or significant components end-to-end, including design, implementation, testing, documentation, and incremental improvement.
• Solve non-routine problems that require understanding of concurrency, transaction design, database locking, state machines, and production behavior.
• Design safe concurrent systems including queue claiming, background processing, multi-instance coordination, and idempotent operations.
• Trace and understand complex legacy code across module boundaries, identify bottlenecks, and improve it incrementally without full rewrites.
• Lead database design and migration for large production tables, consider blocking, deployment order, rollback, and customer schema differences.
• Diagnose and fix production issues using logs, execution plans, database locks, and systematic tracing—not guessing.
• Create testable boundaries around legacy UI logic, extracting pure business logic that can be tested independently.
• Guide peers informally through code review, design discussions, and mentoring; contribute to technical hiring.
• Strengthen test coverage and reliability by identifying failure modes, designing retry and cancellation, and improving system observability.
• Evaluate trade-offs between pessimistic and optimistic concurrency, locking strategies, and deployment safety.

AI Proficiency (L2–L3 Transition: AI Practitioner to Power User) Scope : Team-level productivity; beginning to set workflow patterns

• Independent workflow design : Make decisions about when and how AI fits into your development process (code generation, refactoring, testing, documentation). Validation discipline : Own output risk; verify AI-generated code against your expertise and team standards before shipping.
• Complex task automation: Use AI for complex refactoring, test coverage analysis, and architectural documentation—but validate results thoroughly.
• Peer guidance: Help teammates use AI effectively; explain when AI is appropriate and what to validate.
• Pattern setting: Propose AI workflow patterns (e.g., "use AI for test scaffolding, but always review for coverage") for your module.

• Advanced C# and .NET architecture - Proficiency with async/await, CancellationToken, and safe cleanup patterns. - Ability to design testable boundaries around event-driven and legacy code. - Understanding dependency injection at scale, service composition, and cross-module communication. - Comfortable with SOLID principles and refactoring legacy code without full rewrites. - Recognition of when code should be extracted into services vs. when it should remain in the UI layer.
• Expert SQL and transaction design: - Deep understanding of SQL Server locking (shared, exclusive, update locks), lock escalation, and deadlock prevention. - Proficiency with concurrency patterns: optimistic vs. pessimistic, versioning, and state-transition locks. - Ability to write complex queries with CTEs, window functions, and OUTPUT clauses for atomic claim-and-update operations. - Safe sequence generation without race conditions. - Experience with large-table migrations: nullable columns, backfill strategies, phased deployment. - Understanding of index impact on locking and query performance.
• Concurrency and distributed system design : - Design of multi-instance queue processors with claiming, stale-work recovery, and cancellation. - Recognition that application-level existence checks are insufficient without database-level atomicity. - Understanding of idempotency controls (correlation IDs, unique constraints, conditional state transitions). - Safe service-to-service communication: contract versioning, timeouts, retries, circuit breaking. - Lease-based work distribution and stale-claim recovery mechanisms.
• Production debugging and observability: - Ability to diagnose issues using logs, execution plans, SQL waits, and blocking analysis. - Systematic root-cause analysis; understanding of correlation IDs, distributed tracing, and logging standards. - Recognition of when to add instrumentation vs. when the problem is already well-understood. - Design of logs for operations teams: business context, customer database, processing stage, duration, status transitions.
• Safe database change management: - Phased deployment strategy for schema changes, data migrations, and backward compatibility. - Understanding of customer schema variations, deployment ordering, and rollback plans. - Consideration of transaction-log growth, blocking on large tables, and verification steps. - Safe handling of old application versions running against new schema.

• Module ownership : Complete end-to-end responsibility for correctness, performance, and reliability; proactive about technical debt.
• Non-routine problem solving : Tackle unfamiliar domains, research solutions, and propose safe alternatives.
• Communication and influence : Articulate trade-offs, explain complex decisions, and guide technical discussions without dominating.
• Mentoring: Help peers improve through code review, pair programming, and design discussions.
• Continuous improvement : Identify patterns, propose systemic fixes, and contribute to team practices and tooling.
• Pragmatism : Balance correctness with shipping; know when to iterate vs. when to get it right the first time.

• Experience owning production systems serving millions of transactions or thousands of concurrent users.
• Deep familiarity with at least one large enterprise system (ERP, financial platform, or high-volume transaction processing).
• Experience with background processing systems, queues, and message-driven architectures.
• Understanding of database backup, recovery, replication, and failover strategies.
• Exposure to multi-tenant SaaS systems and customer-isolation concerns.
• Mentoring or hiring experience; demonstrated impact on team growth.
• Speaking or writing about technical topics; active in open-source or community contributions.
• Experience with production incident response and post-mortems.

• Large, mature system : 13,000+ C# files across 50+ modules serving real manufacturing operations. You will own critical paths and improve legacy systems.
• Production accountability : Your decisions directly impact financial transactions, manufacturing schedules, and customer success. Rigor is paramount.
• Technical leadership : Architecture decisions are discussed peer-to-peer with other senior engineers and leadership.
• Mentoring culture : You are expected to grow the team through code review, pair programming, and knowledge sharing.
• Continuous learning: Complex systems always have edge cases and surprises; growth mindset is valued.

At Amtech, you will drive meaningful financial impact in a growing enterprise software organization while benefiting from Vista’s world-class ecosystem.

You’ll collaborate with talented peers, leverage cross-portfolio learning programs, and help shape the future of Amtech’s financial operations and systems.

Build your career with Amtech — backed by the strength, scale, and innovation culture of Vista.