Senior Software Engineer – Edge Compute & Computer Vision

Kappture; Galway; Hybrid; EUR 80,000 - 120,000; Full time

Job summary

Kappture in Ireland is seeking a Senior Software Engineer with strong experience in real-time edge computing, production C++, and computer-vision systems to help develop and scale the BRISK platform. You will design and implement performance-critical software that runs on edge devices, work with cameras, GPUs and edge hardware, and move research models into reliable production.

This is a hands-on, senior IC role with hybrid working from Galway; typically three days per week in the Galway office,

Skills

Real-time edge computing

Production C++

Computer vision

Multi-camera systems

GPU acceleration

Tools

CUDA

Edge hardware

Job description

Senior Software Engineer – Edge Compute & Computer Vision

Hybrid Ireland

Full-time

Company Overview

Kappture develops point-of-sale, payments and intelligent hospitality technology for high-volume environments, including stadiums, arenas, universities and major event venues.
Our products operate in live environments where transaction speed, reliability, throughput and operational simplicity are critical.
BRISK, powered by KapptureVision, is our AI-enabled tap-and-go hospitality platform. It combines computer vision, edge computing, real-time inference and operational analytics to enable fast, frictionless customer experiences in demanding venues.
The platform must reason accurately across multiple cameras and physical spaces while operating under realworld constraints such as variable lighting, occlusion, crowded environments, limited compute capacity and intermittent connectivity.
We are continuing to evolve both the BRISK platform and the way our engineering teams design, test and deliver production AI systems.

Role Purpose

We are seeking a Senior Software Engineer with strong experience in real-time edge computing, production C++ and computer-vision systems to help develop and scale the BRISK platform.
This is a senior, hands-on individual-contributor role. You will design and implement performance-critical software, work directly with cameras, GPUs and edge hardware, and help move computer-vision models from research and experimentation into reliable production operation.
The role requires more than implementing computer-vision algorithms in isolation. You will work across camera calibration, synchronisation, tracking, inference, device performance, telemetry, deployment and operational diagnostics.
You will be expected to challenge established approaches constructively and help improve the architecture, testability, deployment model and engineering practices of the BRISK platform.
You will also help accelerate the responsible use of AI-enabled engineering within the BRISK team. This includes using automation and AI-assisted tools to improve codebase understanding, test generation, performance analysis, diagnostics, documentation and technical discovery.
Deep computer-vision, mathematical and systems-engineering capability remains the primary requirement. AIenabled engineering practices should strengthen human judgement and production quality rather than replace appropriate design, validation or operational evidence.
Because this role involves regular hands-on work with cameras, edge-compute hardware and representative deployment environments, hybrid working from the Galway office is required. The expected working pattern is normally at least three days per week in Galway, with flexibility according to project and deployment needs.

Key Responsibilities

Computer Vision and Spatial Reasoning

• Design and implement computer-vision systems for complex, high-throughput hospitality environments.
• Develop multi-camera calibration, synchronisation and spatial-alignment capabilities.
• Build and improve multi-object tracking across cameras, space and time.
• Apply mathematical reasoning across linear algebra, geometry, optimisation, estimation and probabilistic modelling.
• Develop spatiotemporal reasoning capabilities for crowded and operationally variable environments.
• Improve system performance under conditions such as occlusion, lighting variation, camera movement and incomplete observations.
• Work with data scientists and machine-learning engineers to evaluate and improve model performance under real deployment constraints.
• Translate research outputs into clear, testable and maintainable production implementations.
• Define measurable accuracy and performance criteria for computer-vision capabilities.

Real-Time Edge Engineering

• Design, develop, test and maintain high-performance C++ software for edge-compute environments.
• Build and optimise real-time inference and image-processing pipelines.
• Work directly with GPU acceleration, memory constraints, device limitations and hardware-specific behaviour.
• Optimise inference for low latency, high throughput and predictable resource utilisation.
• Profile CPU, GPU, memory, I/O and data-pipeline performance to identify and remove bottlenecks.
• Design systems for deterministic, resilient and observable behaviour under load.
• Ensure edge services recover safely from camera, process, network or hardware failures.
• Consider thermal, power, storage and deployment constraints when designing solutions.
• Improve the efficiency and repeatability of edge-device configuration and deployment.

Production AI Systems

• Take models and algorithms from research or prototype stage into hardened production systems.
• Design model packaging, versioning, deployment, controlled rollout and rollback mechanisms.
• Establish validation criteria before models or inference changes reach live environments.
• Build telemetry for model accuracy, inference latency, data quality, drift, resource utilisation and system health.
• Design safe fallback and degradation behaviour where model confidence or system health falls below agreed thresholds.
• Support repeatable comparison of model and pipeline versions.
• Improve observability across camera input, pre-processing, inference, tracking and downstream decision making.
• Support investigation of production accuracy, performance and reliability issues.
• Ensure model changes are traceable, measurable and operationally supportable.

Hardware, Camera and Deployment Integration

• Work hands-on with cameras, edge-compute devices, GPUs and associated networking equipment.
• Support camera selection, positioning, calibration and deployment validation.
• Develop repeatable hardware and software configurations for development, testing and live deployment.
• Diagnose failures across cameras, drivers, operating systems, GPU runtimes, network communication and application services.
• Collaborate with engineering, operations and deployment teams during installation, commissioning and production support.
• Document firmware, driver, model, application and configuration dependencies.
• Help build representative office-based environments that reproduce important live-site behaviours.
• Participate in occasional customer-site or partner-site deployment and investigation activities.

Architecture and Engineering Quality

• Contribute to the ongoing architecture and modernisation of the BRISK edge platform.
• Improve modularity, interface design, concurrency management, resource ownership and error handling.
• Apply appropriate modern C++ practices within the constraints of supported hardware and toolchains.
• Identify and reduce high-risk technical debt.
• Produce clear technical designs, diagrams and Architecture Decision Records where appropriate.
• Ensure software is understandable and supportable by engineers other than its original author.
• Participate in architectural, algorithmic and code reviews.
• Balance experimental development with production maintainability and operational safety.

Testing, Validation and Release

• Develop unit, integration, performance, hardware-in-the-loop and system-level automated tests.
• Define representative datasets and scenarios for validating accuracy and performance.
• Improve automated regression testing across camera, model, inference and tracking changes.
• Build repeatable validation for latency, throughput, memory usage, GPU utilisation and stability.
• Work with QA and data-science colleagues to define acceptance thresholds and regression criteria.
• Help integrate static analysis, profiling, automated quality checks and repeatable validation into CI/CD.
• Support release assessment, controlled rollout and investigation of production issues.
• Ensure critical system behaviours can be validated across representative hardware, camera and environmental conditions.

Change and Platform Acceleration

• Identify and lead practical improvements to the BRISK codebase, tooling, engineering practices and delivery workflows.
• Challenge technical approaches constructively where they create avoidable complexity, risk or delivery delay.
• Modernise established areas incrementally while protecting production stability and hardware compatibility.
• Improve developer feedback loops through better local tooling, simulation, automated testing, profiling and CI/CD.
• Identify repetitive development, validation, investigation and deployment activities that can be automated.
• Reduce dependency on specialist or undocumented knowledge through clearer interfaces, documentation, diagnostics and test coverage.
• Improve the speed and reliability of moving changes from experimentation into controlled production use.
• Help establish engineering standards for real-time C++, computer vision, edge deployment and production AI systems.
• Measure whether improvements reduce lead time, performance regressions, escaped defects, investigation time or operational effort.
• Help colleagues adopt stronger tools and practices through mentoring, pairing and practical implementation.

AI-Enabled Engineering

• Contribute to defining and implementing AI-enabled engineering practices within the BRISK development lifecycle.
• Move beyond individual use of coding assistants by identifying, implementing and evaluating repeatable workflows that can be adopted safely by the team.
• Use AI-assisted engineering for codebase exploration, test generation, debugging, documentation, controlled refactoring and technical discovery.