C++ developer

act digital; Lisboa; On-site; EUR 45,000 - 65,000; Full time

Job summary

act digital is seeking experienced C++ Software Engineers to evolve a long-standing desktop application built with C++20 and Qt. You will understand a large codebase, add new capabilities, and modernize components while preserving stability for users.

The role focuses on pragmatic decisions, refactoring, and improving test coverage. You will contribute to architecture discussions and work across desktop, test, and build optimization tasks in a mature development environment.

Qualifications

• Proficient in Modern C++ design and STL
• Experience maintaining desktop software with C++20/Qt
• Strong debugging and problem-solving skills
• Ability to refactor legacy code with safety

Responsibilities

• Develop and evolve desktop software using Modern C++
• Design maintainable APIs, modules, and components
• Understand and improve a large established codebase
• Modernize legacy components without risking stability
• Improve test coverage with automated tests
• Troubleshoot complex issues in Linux environments
• Participate in code reviews and architectural discussions
• Contribute to software quality, performance and reliability

Skills

C++

Qt

Modern C++

Linux

Testing Catch2

CMake

Multithreading

Tools

Catch2

Google Test

Boost.Test

Google Mock

CMake

Job description

We are looking for experienced C++ Software Engineers to contribute to the evolution of a large and business-critical desktop application built with C++20 and Qt.

The product has more than 15 years of development history and is supported by a substantial, long-lived codebase. You will be responsible for understanding existing components, developing new capabilities, resolving complex technical issues, and progressively modernizing the platform while protecting the stability and reliability expected by its users.

This opportunity is ideal for an engineer who enjoys exploring complex systems, making pragmatic technical decisions, and improving mature software through thoughtful refactoring, stronger test coverage, and modern C++ engineering practices.

As a C++ Software Engineer, you will:

• Develop and evolve desktop software using Modern C++.
• Design maintainable software components, APIs, and system capabilities.
• Understand and improve a large, established codebase.
• Modernize legacy components without introducing unnecessary risk.
• Build reliable automated tests and improve test coverage.
• Troubleshoot complex software issues in Linux environments.
• Participate actively in code reviews and architectural discussions.
• Improve software quality, maintainability, performance, and long-term sustainability.

C++ Software Development

• Design, develop, test, and maintain software using Modern C++.
• Build reliable and reusable software components.
• Apply strong C++ design principles, including:
• Resource ownership
• RAII
• Const-correctness
• Smart pointers
• Standard Library usage
• Write clean, maintainable, and testable code.
• Balance functional delivery with long-term code quality.
• Contribute to the evolution of the application without compromising existing behavior.

Desktop Application Development

• Maintain and improve existing user-facing and system-level components.
• Work with Qt 5.15 or later where applicable.
• Contribute to reliable communication between the interface, business logic, and system components.
• Investigate platform-specific behavior and application performance issues.
• Support the long-term evolution of the desktop architecture.

Software Design & Architecture

• Design maintainable APIs, modules, and application components.
• Contribute to system design and technical architecture discussions.
• Evaluate technical trade-offs related to:
• Performance
• Maintainability
• Reliability
• Complexity
• Backward compatibility
• Propose pragmatic improvements rather than unnecessary rewrites.
• Document relevant technical and architectural decisions.

Legacy Code Modernization

• Understand and safely modify a codebase with more than 15 years of development history.
• Identify technical debt and areas suitable for incremental modernization.
• Refactor legacy components while preserving product stability.
• Improve modularity, readability, and maintainability.
• Increase automated test coverage around critical functionality.
• Reduce risk by validating behavior before and after changes.

Automated Testing

• Develop and maintain unit tests using frameworks such as:
• Catch2
• Google Test
• Boost.Test
• Use mocking frameworks where appropriate, including:
• Google Mock
• Create tests for both new functionality and existing behavior.
• Support regression prevention through reliable automated test suites.
• Improve testability when refactoring existing components.
• Contribute to practical and sustainable testing strategies.

Multithreading & Concurrency

• Develop and maintain concurrent or multi-threaded application components.
• Diagnose race conditions, deadlocks, and synchronization issues.
• Design safe resource-sharing and execution models.
• Apply modern C++ concurrency principles.
• Consider thread safety when designing APIs and shared components.
• Optimize performance without compromising correctness or maintainability.
• Develop, build, and debug applications in Linux environments.
• Work confidently through the Linux command line.
• Use standard development and diagnostic tools.
• Investigate runtime errors, build failures, and system-level issues.
• Analyze logs, processes, dependencies, and application behavior.
• Support reliable software execution across target Linux environments.

Build Engineering

• Use CMake to configure, build, and maintain software projects.
• Improve build scripts and dependency configurations.
• Troubleshoot compilation, linking, and dependency issues.
• Ensure builds remain reproducible and maintainable.
• Contribute to consistent development and build workflows.

Code Quality & Reviews

• Participate actively in peer code reviews.
• Provide clear, constructive, and technically grounded feedback.
• Review solutions for correctness, maintainability, performance, and test coverage.
• Use static analysis, sanitizers, and quality tools where available.
• Help create a collaborative engineering environment focused on continuous improvement.

Git-Based Collaboration

• Work with Git-based development workflows.
• Create and review merge requests or pull requests.
• Maintain clear and manageable commits.
• Collaborate with other engineers on shared components and branches.
• Resolve merge conflicts and support controlled code integration.
• Ensure technical changes remain traceable and properly reviewed.

Debugging & Problem Resolution

• Investigate complex application defects and unexpected behavior.
• Reproduce issues and perform structured root cause analysis.
• Use suitable diagnostic and debugging tools.
• Develop sustainable fixes rather than temporary workarounds.
• Take ownership of problems through to resolution.
• Communicate risks, findings, and proposed solutions clearly.

What We’re Looking For

• Strong understanding of Modern C++ design principles.
• Experience with:
• Resource ownership
• Const-correctness
• Standard Library
• Maintainable and testable code
• Experience designing software components, APIs, or system architecture.
• Strong debugging and problem-solving capabilities.
• Experience developing automated tests using:
• Catch2
• Google Test
• Boost.Test
• Or equivalent frameworks
• Experience participating in code reviews.
• Familiarity with Git-based workflows.
• Experience developing and debugging applications on Linux.
• Confidence using the Linux command line.
• Hands-on experience with CMake.
• Experience working with large, long-lived, or legacy codebases.
• Good written and verbal communication skills in English.

Core Development

• C++
• Modern C++
• C++17
• C++20
• Standard Template Library
• Object-Oriented Programming
• Resource Management

Desktop Development

• Qt 5.15+
• Desktop Applications
• Event-Driven Interfaces
• Cross-Platform Development

Build & Development Environment

• CMake
• Linux Command Line
• Git
• Merge Requests
• Pull Requests

Testing

• Catch2
• Google Test
• Boost.Test
• Google Mock
• Unit Testing
• Regression Testing
• Test Automation

Quality & Performance

• Static Analysis
• Performance Analysis
• Refactoring
• API Design
• Multithreading
• Concurrency
• Legacy Modernization

Nice to Have

• Strong professional experience with C++17 and C++20.
• Previous involvement in modernizing established C++ codebases.
• Experience introducing automated testing into legacy components.
• Knowledge of multi-threaded and concurrent application development.
• Experience with Trompeloeil, Google Mock, or equivalent mocking frameworks.
• Familiarity with:
• Static analysis
• Experience improving application performance and resource usage.
• Knowledge of cross-platform software development.

Pragmatic Engineering

• Ability to understand existing design decisions before proposing changes.
• Focus on incremental improvements with measurable value.
• Comfortable balancing modernization with product stability.
• Avoids unnecessary rewrites when safe refactoring is more appropriate.

Technical Ownership

• Ability to take responsibility for technical problems from investigation to resolution.
• Proactive approach to identifying risks and improvement opportunities.
• Strong accountability for code quality and application reliability.
• Ability to explain technical concepts clearly in English.
• Comfortable discussing alternative technical approaches.
• Provides constructive and respectful feedback through code reviews.
• Open to receiving feedback and adapting solutions when needed.

Analytical Thinking

• Strong debugging and root cause analysis capabilities.
• Ability to understand complex interactions within a mature system.
• Structured approach to ambiguous or technically challenging problems.

Quality Mindset

• Strong commitment to automated testing and maintainable code.
• High attention to detail.
• Focus on reliability, stability, and continuous improvement.
• Appreciation for long-term product sustainability.
• Work on a technically challenging desktop application built with C++20 and Qt.
• Gain deep exposure to a substantial codebase with over 15 years of evolution.
• Solve complex engineering and debugging challenges.
• Apply modern C++ practices to a mature and business-critical product.
• Improve architecture, testing, build processes, and code quality incrementally.
• Collaborate in an environment that values thoughtful code reviews and pragmatic decisions.
• Contribute to the long-term evolution of a stable software platform.