Integration Engineer / Full-Stack Systems Developer

Project: Unified Help Center & Ticketing Gateway Engagement: Contract or consulting initially, with potential for ongoing work About the Role GainSide is looking for a hands-on Integration Engineer / Full-Stack Systems Developer to help build and expand a multi-tenant customer Help Center and Unified Ticketing Gateway. This is a practical engineering role for someone comfortable working across application development, cloud infrastructure, identity, APIs, and third-party systems. The ideal person is equally comfortable debugging Node.js code, testing a REST API, configuring an Azure App Service, troubleshooting authentication, and determining why a ticket was routed incorrectly. The system is already operational and is being expanded incrementally. This is not a greenfield “start from scratch” assignment. You will work with an existing codebase and help us evolve it safely without disrupting working customer functionality. The Project The GainSide Help Center provides customer-facing support portals with tenant-specific authentication, branding, request forms, and ticket routing. The current platform includes integrations with: - Microsoft Azure - Node.js / Express - Microsoft Entra ID - SAML and OIDC authentication - Azure App Service - Azure Key Vault - Azure Cosmos DB - Autotask PSA - Jira Cloud / Jira Service Management - REST APIs and webhooks - HTML / CSS / JavaScript administrative and customer portal interfaces The system supports multiple customers with different ticketing requirements. For example, some requests are routed to Autotask PSA, while selected Veryon product-support requests are being routed directly into Jira Service Management. The goal is to continue developing this into a provider-neutral ticketing gateway where the end user simply submits a request and the system determines which backend system should receive and manage it. What You Will Work On Responsibilities will include: - Maintain and extend an existing Node.js / Express web application. - Build and troubleshoot integrations with Jira Cloud and Jira Service Management REST APIs. - Maintain and enhance the existing Autotask PSA integration. - Develop routing logic that sends different customer request types to the appropriate backend system. - Build customer-facing request forms based on Jira, Autotask, or other service schemas. - Normalize tickets from multiple backend systems into a common portal experience. - Expand the portal's My Tickets / My Requests capabilities across multiple ticket providers. - Implement ticket comments, attachments, status updates, and synchronization. - Develop secure webhook endpoints for real-time ticket updates. - Work with Microsoft Entra ID, SAML, OIDC, sessions, and multi-tenant authentication. - Maintain tenant-specific configuration and routing through the application's administrative portal. - Troubleshoot Azure App Service deployments and runtime issues. - Work with Azure Key Vault references and application configuration without exposing credentials. - Use PowerShell and Azure CLI for deployment, testing, and diagnostics. - Diagnose integration issues using API responses, application logs, Azure logs, and direct API testing. - Improve error handling, validation, logging, and operational visibility. - Write maintainable code and preserve existing working integrations while adding new capabilities. - Document integrations, field mappings, configuration requirements, deployment procedures, and troubleshooting steps. Immediate Work The first work will focus on expanding a Jira Service Management integration that has already been proven through direct API testing. A working Jira request has already been successfully created through the API, and the application now has an initial Jira routing implementation. Immediate priorities include: 1. Stabilizing the Jira-backed customer portal request flow. 2. Completing the Veryon Applications / Engineering Support form. 3. Ensuring Jira-backed requests do not unnecessarily depend on Autotask configuration. 4. Improving provider-neutral ticket routing. 5. Adding Jira-created tickets to the customer My Tickets experience. 6. Supporting Jira comments and attachments. 7. Synchronizing ticket status and updates. 8. Adding additional Jira Service Management request types such as Salesforce and NetSuite support. 9. Preparing the architecture for additional customer-specific ticketing integrations. 10. Microsoft Teams and Slack request ingestion. Required Technical Skills We are looking for someone with strong practical experience in several of the following areas: - JavaScript / Node.js - Express.js - REST API integrations - JSON and API payload/schema troubleshooting - Azure App Service - Azure CLI - PowerShell - Microsoft Entra ID / Azure AD - OAuth, OIDC, SAML, and authentication concepts - Azure Key Vault - NoSQL or document-oriented data stores - Jira Cloud REST API - Jira Service Management - Webhooks - HTML / CSS / server-rendered web applications - Git, source control, patches, and deployment workflows Strongly Preferred Experience with any of the following would be particularly valuable: - Autotask PSA REST API - Multi-tenant SaaS applications - Jira custom fields and Jira Service Management request types - Ticketing/help desk platform integrations - Microsoft Graph - Azure managed identities - Customer portal development - Identity federation - API security - Azure application diagnostics - Integration testing - Data synchronization between independent SaaS platforms The Person We Need This role is best suited for someone who enjoys systems integration and troubleshooting—not someone who only wants isolated front-end or algorithmic programming work. You should be comfortable receiving a problem such as: “The user can authenticate, but the portal fails before displaying a Jira-backed request because an unrelated Autotask configuration value is missing.” …and tracing that problem across routes, services, tenant configuration, authentication, logs, and backend integrations until the architectural cause is identified and corrected. We value engineers who: - Investigate before changing things. - Avoid introducing placeholder configuration simply to suppress an error. - Understand the difference between fixing a symptom and fixing an architectural dependency. - Can work safely in an existing production-style environment. - Test integrations directly against APIs when appropriate. - Document what they changed and why. - Protect credentials and customer information. - Can explain technical decisions clearly to both technical and non-technical stakeholders. - Are comfortable taking ownership of a problem from diagnosis through deployment and validation. Success in This Role A successful engineer will help us move from individual ticketing integrations toward a clean architecture such as: Customer Portal / Teams / Slack | v GainSide Ticketing Gateway | +------+------+ | | v v Autotask Jira | | +------+------+ | v Unified Ticket View Customers should not need to understand which backend ticketing platform is being used. The Gateway should handle routing, normalization, authentication, synchronization, and presentation. Working Style This project is being developed incrementally. We prefer small, testable changes over large rewrites. You should expect to: - Review existing code before proposing architectural changes. - Preserve known-good functionality. - Work from actual API schemas and responses rather than assumptions. - Test changes in the Azure test environment. - Provide clear rollback procedures for deployments. - Collaborate closely with the project owner on workflow and business requirements. To Apply Please send: A short description of your relevant experience. Examples of API or systems-integration projects you have built. Your experience with Node.js and Azure. Any Jira/Jira Service Management or Autotask experience. Examples of multi-system integrations you have designed or supported. Your availability and preferred engagement model. Your hourly rate or compensation expectations. If available, include a GitHub profile, code samples, or a brief description of a difficult integration/debugging problem you personally solved. Please distinguish work you personally implemented from projects where you were primarily managing or supervising other developers.