Junior Software Support

DUTIES AND RESPONSIBILITIES

• Provide first-line technical support to customers by diagnosing, reproducing, and analysing software issues.

• Investigate API-related problems by reviewing requests/responses, inspecting HTTP status codes, and analysing REST/GraphQL behaviour.

• Troubleshoot application errors by forming hypotheses, validating them through logs and configuration checks, and documenting findings.

• Reproduce customer-reported issues using test environments, sample payloads, and developer tools.

• Collaborate with engineering teams to escalate complex issues with clear, structured documentation (steps, evidence, logs).

• Analyze log data using tools such as Application Insights, Log Analytics, or equivalent cloud monitoring platforms.

• Support identity and authentication troubleshooting, such as OIDC/SAML configuration issues, token validation, redirect problems, or JWT-related errors (with training if needed).

• Decode and inspect JWTs to validate claims or identify common issues (expiry, wrong audience/issuer).

• Assist with configuration reviews for customer integrations, including API keys, endpoints, redirect URIs, and authentication settings.

• Document issues clearly and thoroughly, including troubleshooting steps taken, root-cause insights, and recommended actions.

• Communicate technical findings to both technical and non-technical stakeholders in a clear and structured manner.

• Follow runbooks and standard procedures, while contributing improvements when gaps are identified.

• Participate in knowledge base creation, including writing or updating technical articles, troubleshooting guides, and FAQs.

• Support onboarding of new customers by assisting with integration validation or initial configuration checks.

• Maintain a customer-first mindset, ensuring timely follow-ups and issue resolution that builds customer trust.

• Collaborate closely with peers to share context, ensure smooth handoffs, and continuously improve support processes.

• Stay up to date with relevant technologies (JavaScript/TypeScript, GraphQL, cloud tools, identity/authentication patterns).

QUALIFICATIONS

• Degree in Computer Science, IT, Software Engineering or equivalent practical experience.

• 1–3 years combined experience across:

• Software development (internships, junior roles, freelance, or substantial projects), and/or

• Technical support / application support / implementation roles / customer success.

• Evidence (CV/portfolio) of:

• Working with JavaScript/TypeScript.

• Calling and debugging APIs (REST and/or GraphQL).

• Basic work with tokens/JWTs or authentication flows.

• Programming foundations

• 1–3 years academic or commercial experience with JavaScript or TypeScript.

• Able to read and reason about code in NodeJS and/or React (handlers, components, basic business logic).

• Web & API fundamentals (REST + GraphQL)

• Solid understanding of HTTP (methods, status codes, headers, request/response patterns).

• Comfortable working with JSON payloads and query parameters.

• Experience calling APIs using Postman/Insomnia, browser dev tools or similar tools.

• Ideally have at least some exposure to GraphQL APIs:

• Able to read and construct simple queries/mutations.

• Understands concepts like schema, types, fields, variables, and errors.

• Can interpret typical GraphQL error responses and use them in troubleshooting.

• Troubleshooting mindset

• Able to take an error message / symptom and:

• Reproduce it systematically.

• Form a hypothesis about likely causes.

• Check logs and configuration to confirm or rule out ideas.

• Can interpret log messages at a basic level and narrow down whether an issue might relate to infrastructure availability, software functionality, configuration or integration.

• Identity & authentication

• Conceptual understanding of at least one of:

• OpenID Connect (OIDC)

• SAML

• Preferably be familiar with traditional federated identity concepts such as:

• Client/application registration

• Redirect URIs, scopes, claims, and tokens

• IdP vs SP / RP (e.g. Azure AD/Entra, Okta, Ping)

• Able to read an OIDC/SAML error message and search for likely causes (incorrect redirect URL, issuer/audience mismatch, certificate issues, etc.).

• JWTs & public key concepts

• Awareness of public key cryptography in this context:

• Public vs private keys, the idea of signing, verifying, encrypting and decrypting and the role of each key in these processes.

• Why signatures are used to validate tokens and avoid tampering.

• Preferably possess a high-level understanding of OIDC JWKS endpoints or public key discovery

• Basic understanding of JSON Web Tokens (JWTs):

• Structure: header, payload, signature.

• Difference between an encoded vs decoded token.

• Candidates should be able to:

• Decode a JWT using standard tools.

• Inspect claims (subject, issuer, audience, expiry, etc.).

• Spot obvious issues (expired token, wrong audience, wrong issuer).

• Exposure to Azure or another major cloud platform.

• Comfort with log analysis:

• Using tools like Azure Workbooks, Application Insights, or Log Analytics.

• Filtering and searching logs by:

• Time range

• Request ID / correlation ID

• Error codes / specific message text.

• Strong written English:

• Can document an issue clearly:

• Steps to reproduce.

• Expected vs actual behaviour.

• Evidence collected (logs, screenshots, timestamps, sample requests/responses).

• Can summarise technical findings so non-developers can understand them.

• Comfortable communicating with technical stakeholders (developers, architects, customer technical contacts).

• Able to follow structured runbooks and also adapt when the situation is not yet documented.

• Customer-oriented: aims to resolve the customer's problem and maintain trust.

• Analytical and curious: enjoys digging into problems and learning new technologies (identity, tokens, cloud, GraphQL).

• Detail-focused: careful with timestamps, timezones, identifiers, configuration values and reproduction steps.

• Resilient under pressure: can manage multiple open issues without losing structure.

• Team-player: willing to escalate appropriately, hand off cleanly and share context with others.