Developer L3 – Product Support Engineering

Developer L3 / Product Support Engineer (Enterprise Integrations)
Title: Developer L3 – Product Support Engineering Location: United States/Canada (Remote) Type: Full-time

About the Role
We're looking for a hands-on Developer L3 / Product Support Engineer to own complex, real-world issues in a mature enterprise platform that integrates with external systems such as physical access control systems (PACS).
This is a blended role:

• Part development-focused L3: deep-dive analysis, SQL, logs, root-cause.
• Part product support engineering: working closely with Services, QA and Product teams, and sometimes directly with customer technical teams.

This role spans two distinct but equally important support contexts:

• Active project deployments (pre-go-live): working alongside the services delivery team to investigate and resolve blockers that arise as customers are being onboarded — new integrations, first-time feature deployments, and environments that don't behave like the lab.
• Live production support: owning complex L3 escalations for customers already in production — performance degradation, integration failures, database instability, and anything the L1/L2 team can't resolve.

Together, these give you full-lifecycle visibility: from first deployment through long-term production stability. You'll investigate and resolve high-impact issues in both contexts, analyse database and integration behaviour, and turn your findings into product improvements and internal knowledge articles. You'll work heavily with SQL Server, a .NET-style backend, scheduler-driven dataflows, PACS integrations (e.g. via APIs/adapters similar to Lenel OpenAccess), and a platform that runs on both cloud-native (Kubernetes) and on-premises infrastructure.
We'll train you on the product and processes; you bring strong engineering fundamentals, curiosity and ownership. This is a US/Canada-based role operating Monday–Friday, and forms part of a growing global L3 team built for follow-the-sun coverage.

What You'll Do
Own complex issues end-to-end

• Take L3-escalated tickets from investigation through to resolution and follow-up.
• Work with customer DBAs and infrastructure teams on issues involving database performance, failover behaviour, and high-frequency queries.
• Use logs, telemetry, SQL and configuration analysis to isolate and validate root causes.

Support active project deployments (pre-go-live)

• Be a technical resource for the services delivery team during customer rollouts — investigate blockers that arise when new features, adapters or integrations are deployed for the first time.
• Troubleshoot issues in customer environments that don't reproduce locally: permissions, network topology, infrastructure differences (on-prem vs cloud, air-gapped environments).
• Help validate that deployment runbooks, configuration guides and environment prereqs are accurate and repeatable before a customer goes live.

Analyse and troubleshoot production behaviour

• Investigate performance and stability issues (e.g. high-memory / high-frequency queries triggered by scheduled jobs).
• Correlate application behaviour with external systems and APIs (e.g. PACS integrations via an OpenAccess-style API and adapter services).
• Propose and verify remediation plans that are safe, consistent, and well-documented.

Collaborate with internal teams

• Partner with L1/L2 Support to clarify problem statements and define clear next steps.
• Work with QA to reproduce defects, validate fixes and refine regression coverage.
• Work with Product Engineering to raise bugs and enhancements, validate patches and influence design based on what you see in the field.

Create and maintain knowledge

• Convert recurring or high-value investigations into knowledge base articles, runbooks and troubleshooting guides.
• Contribute to internal playbooks, decision trees and standard remediation patterns for L3 support.
• Help refine escalation criteria and improve which issues should reach L3 versus earlier tiers.

Contribute to product quality

• Identify code, configuration or data patterns that drive incidents and feed that insight back into the product roadmap.
• Participate in incident reviews and post-mortems; define preventative and hardening actions.
• Where appropriate, design, code, and merge hotfixes and stability patches directly to the codebase, including scripts and data migrations.

Typical Problems You'll Work On

• Investigating database failovers caused by high-frequency reporting or sync queries.
• Analysing synchronisation schedules (e.g. event sync every few minutes vs daily location sync) and their impact on load.
• Tracing behaviour through APIs and adapters connecting to external systems (e.g. PACS/OpenAccess-style APIs) to find which job or feature is generating problematic queries.
• Validating that proposed changes (schedules, indexing strategies, configuration adjustments, data cleanup patterns) are safe and repeatable.
• Reviewing customer configuration of dataflows, schedules and integrations against best-practice guides and recommending improvements.
• Debugging a deployment that works in the internal lab but fails in a customer environment — isolating whether the issue is permissions, infrastructure configuration, environment parity, or a product defect.
• Helping the services team get hands-on with a newly released feature or component before they deploy it at a customer site.

Tech Environment
Microsoft SQL Server

• T-SQL query analysis and tuning.
• Indexing and execution plan reasoning.
• Understanding of locking, isolation levels and HA/failover scenarios.

Backend services in a .NET-style enterprise stack

• Multi-tier application architecture.
• Background services / schedulers for recurring jobs (event syncs, location syncs, reporting dataflows).

Enterprise integrations

• APIs and adapter services integrating with external systems, including physical access control systems (PACS) via OpenAccess-style APIs.
• Log- and configuration-driven debugging across multiple components.

Cloud-native and on-premises infrastructure

• Kubernetes-based deployments: understanding how containerised services behave differently from traditional Windows-hosted applications.
• On-premises and air-gapped environments: familiarity with deployment tooling and the challenges of environments with restricted connectivity.
• Ability to reason about infrastructure differences between an internal lab and a customer environment (networking, permissions, resource constraints).

Tooling & Workflow

• Jira (or similar) for incident/issue tracking and workflow — including structured pre-production and support ticket types.
• Confluence (or similar) for documentation, runbooks and knowledge base content.

About You
You're an engineer who enjoys debugging and understanding complex systems — whether that's a live production incident or a deployment blocker mid-rollout. You like being close to real customer problems and seeing them through to resolution.
Must-haves

• 3–5+ years in software engineering, application support engineering, SRE, or similar roles.
• Strong debugging and problem-solving skills in distributed or integrated systems.
• Solid experience with relational databases, ideally SQL Server:
  • Confident reading and reasoning about complex T-SQL queries.
  • Understanding indexes, query plans, and performance impact.
• Comfortable working with logs, traces and configuration to correlate and explain system behaviour.
• Experience with enterprise integrations (APIs, adapters, scheduled dataflows).
• Excellent written and verbal communication:
  • Able to explain technical findings clearly to Support, Product and occasionally customer technical teams.
  • Able to write clear, actionable knowledge base articles and runbooks.
  • Proven ability to troubleshoot collaboratively in a remote/async environment (e.g. debugging over screen-share, leaving clear trail-of-thought comments in Jira).
• A strong sense of ownership and follow-through: you close the loop and make sure issues truly stay resolved.

Nice-to-haves (or things you'll learn here)

• Experience with physical access control systems (PACS) or other security/compliance-critical integrations.
• Prior L3 / product support or SRE-style on-call experience.
• Familiarity with .NET (C#) or similar backend technologies used in enterprise environments.
• Experience with Kubernetes, container orchestration, or cloud-native application stacks.
• Exposure to on-premises or air-gapped deployment patterns and the tooling that supports them.
• Experience with Jira and Confluence in a structured incident and knowledge-management setup.

How We'll Support You
You don't need prior experience with this exact product. You'll get:

• Structured onboarding to our L3 workflows, SLAs and escalation paths — covering both project delivery support and production support processes.
• Access to existing knowledge base articles, runbooks and past incident analyses.
• Mentoring from experienced L3 engineers, QA and Support team members.
• A counterpart in Europe: you'll be part of a two-person L3 team designed for follow-the-sun coverage, so handoffs and collaboration across time zones are built into the role.
• Time explicitly set aside for learning, documentation and continuous improvement — not just ticket throughput.

3MfBNovYMJ