We are looking for a Senior Embedded Build, Release & Integration Developer to own the infrastructure and integration path between software development, external technology partners, and formal product QA.

Our products are distributed embedded systems combining multiple processors and independently versioned software components: bare-metal and RTOS firmware, embedded Linux, inter-processor communications, networking and audio services, vendor SDKs, and internally and externally developed code.

This role is responsible for making those pieces work together reliably.

Advantages What Success Looks Like Developers do not lose productive time fixing shared build infrastructure.

External software deliveries are integrated predictably without destabilizing active development.

The team always knows which firmware and software versions belong together.

Technical integration problems are caught and diagnosed before becoming product-level QA problems. QA receives stable, traceable, and documented builds.

Senior developers spend less time on recurring build, merge, and release work.

Cross-system bugs are diagnosed systematically rather than relying on tribal knowledge.

Useful AI-assisted engineering capabilities evolve from individual tool usage into repeatable team workflows.

Responsibilities What You Will Own Build & CI Infrastructure Maintain build servers, build scripts, containers, toolchains, Yocto/Bit

Bake environments, and CI pipelines.

Keep builds reproducible and shared development infrastructure reliable.

Investigate and resolve build and CI failures.

Automate recurring build, integration, and release tasks.

Maintain artifacts, versioning, tagging, and release traceability.

Software & Vendor Integration Integrate software and firmware delivered by internal teams and external technology partners.

Maintain integration branches and resolve complex Git integration conflicts.

Manage compatibility across independently versioned firmware, Linux software, middleware, and vendor components.

Maintain transparent version matrices defining validated component combinations.

Produce traceable integrated builds for development, QA, and manufacturing.

Investigate problems spanning firmware, Linux, middleware, transport, and processor boundaries.

System Integration & Technical Validation Validate software changes that require system-level technical knowledge beyond normal product QA.

Verify bug fixes and technical stories by examining logs, services, processes, IPC, network traffic, system state, and interactions between processors and software components.

Investigate systemd/journald logs, crashes, traces,



and runtime behavior to confirm whether changes actually resolve the underlying problem.

Develop repeatable tests for technical requirements that are difficult to verify through user-facing QA.

Verify compatibility across firmware/software version combinations.

Work with developers when failures cross subsystem boundaries and help determine where the problem originates.

Automate recurring integration and system-level validation where practical.

Developers remain responsible for testing the correctness of their own changes.

Product QA remains responsible for user-facing functionality and regression testing.

This role owns the technical validation layer between those two, particularly where verification requires understanding the internals of the system.

Agentic Debugging & Engineering Automation Help us move beyond AI autocomplete and chatbot usage toward automated, codebase-aware engineering workflows.

Potential applications include: Giving coding agents controlled access to multiple repositories, Git history, build results, logs, and test results.

Automating cross-repository investigation of difficult system-level bugs.

Tracing interfaces, dependencies, and changes across subsystems.

Comparing failing and known-good builds.

Generating diagnostic tests and investigation steps.

Integrating AI-assisted analysis into build, debugging, and failure-triage workflows.

We are particularly interested in workflows where substantial automated analysis can reduce engineering time spent investigating complex failures.

Qualifications What We Need Strong hands-on experience with the following core technical requirements: Yocto / Bit

Bake build systems and embedded Linux development/troubleshooting mandatory. C/C++ codebases in embedded environments.

Advanced Git: branching, merging, rebasing, and complex conflict resolution across vendor and internal development streams.

Automated build or CI infrastructure such as Jenkins, Git

Lab CI, Git

Hub Actions, or custom build servers.

Python, Bash, or similar scripting for build, release, and engineering automation.

Docker or comparable container tooling for reproducible build environments.

Systematic debugging across subsystem boundaries, including systems involving multiple processors, IPC, serial consoles,



and system logs such as systemd/journald.

Ability to investigate unfamiliar systems by gathering evidence, forming hypotheses, and isolating root causes.

Experience with FreeRTOS, Zephyr, inter-processor communication, audio/networking stacks, hardware-in-the-loop testing, or third-party embedded SDKs is highly valued.

Important Scope Note This is an embedded systems role, not a cloud/SRE role.

Candidates whose Dev

Ops experience is primarily Kubernetes, AWS/Azure/GCP, Terraform, web deployment, or cloud operations must also have substantial hands-on embedded Linux build and system-integration experience.

Summary Agentic Engineering Experience Asset Hands-on experience building automated LLM or coding-agent workflows is an asset, particularly in areas such as: Repository-scale or multi-repository code analysis.

Integrating LLM APIs or coding agents with repositories, build/test infrastructure, or diagnostic data.

Tool calling, MCP, agent orchestration, or similar mechanisms.

Automated debugging, test generation, failure triage, or engineering analysis.

Interactive use of ChatGPT, Gemini, Copilot, or similar tools alone does not constitute this experience.

This experience is an asset, not a substitute for strong embedded systems and integration fundamentals.

Randstad Canada is committed to fostering a workforce reflective of all peoples of Canada.

As a result, we are committed to developing and implementing strategies to increase the equity, diversity and inclusion within the workplace by examining our internal policies, practices, and systems throughout the entire lifecycle of our workforce, including its recruitment, retention and advancement for all employees.

In addition to our deep commitment to respecting human rights, we are dedicated to positive actions to affect change to ensure everyone has full participation in the workforce free from any barriers, systemic or otherwise, especially equity-seeking groups who are usually underrepresented in Canada''s workforce, including those who identify as women or non-binary/gender non-conforming; Indigenous or Aboriginal Peoples; persons with disabilities (visible or invisible) and; members of visible minorities, racialized groups and the LGBTQ2+ community.

Randstad Canada is committed to creating and maintaining an inclusive and accessible workplace for all its candidates and employees by supporting their accessibility and accommodation needs throughout the employment lifecycle.

We ask that all job applications please identify any accommodation requirements by sending an email to to ensure their ability to fully participate in the interview process.

📌 Sr. Embedded Build, Release and Integration Developer (Mississauga)
🏢 randstad canada
📍 Mississauga