Description
We’re looking for a hands‑on Software Engineer who loves building high‑quality software using modern engineering practices. You will design, build, test and continuously deliver cloud‑native risk services on Microsoft Azure using our C#/.NET. You lead through craft, example, mentorship and by raising the engineering bar.
What You Will Do Core Engineering
- Design APIs and message contracts (REST/gRPC/event) with clear versioning and backward compatibility.
- Write clean, maintainable, refactor‑friendly code in C#/.NET.
- Work with existing and new SQL code.
- Contribute to the modernisation of existing services by building new .NET‑based solutions and integration layers, improving modularity, testability, performance and observability while avoiding risky rewrites.
- Build and evolve Azure‑hosted containerised services — e.g. Docker‑based workloads running on Azure Kubernetes Service (AKS) and/or Azure Container Apps, plus event‑driven components, storage and data pipelines.
- Work with Angular/React code to support or extend new and existing UI components when needed.
- Design, build, and maintain ETL/ELT pipelines for ingesting data from internal and external sources.
- Develop scalable data processing solutions using Azure Data Factory, Databricks/Spark, SQL Server, Synapse, or equivalent.
- Build and optimise data lakes, warehouses
- Implement data quality checks, monitoring, and lineage tracking.
- Optimise SQL queries, stored procedures, and analytical data models.
- Integrate structured and unstructured data from multiple systems, APIs, and database.
Quality & Delivery Practices
- Practice test‑first / TDD for business logic; use property‑based and contract tests where valuable.
- Help the team adopt Continuous Integration (single trunk/main, small frequent commits, fast green builds).
- Automate deployments (Continuous Delivery) with Azure DevOps pipelines and Infrastructure as Code (Bicep/Terraform).
- Strengthen the testing pyramid: fast unit tests, service/component tests, selective integration/system tests.
- Embed observability (structured logging, metrics, tracing) from the start.
- Use short‑lived feature branches (hours/days) merged via peer‑reviewed pull requests; keep main releasable.
- Ensure regulated‑app test gates: security scanning (SAST/DAST), dependency vulnerability checks, data masking tests, audit logging verification.
- Treat non‑functional tests (performance, resilience) as part of definition of done where risk impact warrants.
- Minimise manual handoffs; optimise flow from idea to production.
AI Augmentation & Enablement
- Use AI tools (e.g. GitHub Copilot) to accelerate coding, test generation, documentation drafts — with critical review.
- Curate effective prompts and patterns; avoid leaking secrets or sensitive data.
- Teach teammates how to use AI responsibly to improve speed and quality.
- Identify where AI adds leverage (e.g. scaffolding .NET code, generating edge‑case tests) vs where human design thinking is essential.
Collaboration & Mentorship
- Pair/mob program when it improves design or spreads knowledge.
- Give pragmatic code reviews: clarity, simplicity, testability, correctness, maintainability.
- Share learning through lightweight design spikes, brown bags, and example repos.
- Raise the bar without gatekeeping; coach rather than dictate.
- Facilitate respectful peer review sessions (synchronous or async) focused on learning and improving code, not defending ego.
- Encourage inclusive language and psychological safety in reviews; critique code, not people.
Continuous Improvement
- Help reduce sources of toil (long builds, flaky tests, manual deployments).
- Champion trunk‑based development and improving deployment frequency safely.
- Use metrics (lead time, change fail rate, MTTR, test feedback time) to guide improvements — not to assign blame.
Must Have
- 6+ years professional software engineering, building production systems.
- Strong in C#/.NET.
- Solid SQL skills (intermediate or above) and experience working with an ORM (e.g. Entity Framework Core or similar).
- Experience working with legacy systems and incremental modernisation.
- Experience with document databases such as CosmosDB.
- Proven application of TDD / automated testing (can explain strategy trade‑offs and test design).
- Hands‑on CI/CD experience (Azure DevOps or similar) with Infrastructure as Code (Bicep or Terraform).
- Practical experience using AI coding tools (e.g. Copilot) and integrating them into daily flow.
- Strong Azure fundamentals, especially:
- Containerisation (Docker) and Azure Kubernetes Service (AKS) and/or Azure Container Apps
- Messaging, storage, identity, pipelines
Certifications:
AZ-900 (Microsoft Azure Fundamentals) – Mandatory
AZ-204 (Developing Solutions for Microsoft Azure) – Certified or in‑progress
- Clear, concise technical communication (written and verbal).
- Experience delivering in regulated or high‑governance environments (e.g. financial risk, Basel/BCBS, audit constraints) with demonstrated test and evidence practices.
- Ability to identify and execute safe modernisation strategies (strangler patterns, incremental refactors) rather than large rewrites.
How We Work
- Trunk‑based development, code always releasable.
- Test‑first mindset; production‑like environments early.
- “Automate it” bias for repeatable manual steps.
- Keep designs simple; evolve as we learn — prefer readable over clever.
- Psychological safety: problems are surfaced early; blame‑free postmortems.
Mindset & Behaviours
- Curiosity: asks why before how.
- Ownership: finishes what is started; leaves code better than found.
- Pragmatism: balances ideal engineering with delivery goals.
- Teaching orientation: lifts others consistently.
Integrity: challenges poor practices respectfully.