Montreal, QC · Software Developer

Imad Issafras

I build backend systems, AI agents and autonomous robots — from Java services behind enterprise finance platforms to the flight software that puts a drone in the air.

Currently a Software Developer at Bounteous, working on Morgan Stanley platforms. Previously Software Lead for McGill Robotics' autonomous drone team.

View projects Get in touch

Backend runtime cut: 4 min → 40 s
Drone team led: 2 seasons
B.Sc. Computer Science: McGill, 3.6 GPA

01 — About

Systems that have to work in the real world

I'm a software developer based in Montreal with a B.Sc. in Computer Science from McGill University. Most of my work sits where software meets something unforgiving — a trading platform that can't be slow, a drone that can't miss its landing, an LLM that can't invent an answer.

Day to day I write Java and Spring Boot services, Python and FastAPI APIs, and the Gradle and Jenkins plumbing that ships them. Lately a growing share of that work is agentic: LangChain and LangGraph agents, RAG pipelines over internal knowledge bases, and MCP servers that expose real tooling to Claude Code.

Before that I spent two years as Software Lead on McGill Robotics' autonomous drone, rebuilding the software team and the ROS 2 architecture behind it. We took the drone to competition for the first time in four years and came home with the team's first award.

I care about code that the next person can read, systems that degrade gracefully, and mentoring the people who inherit them.

02 — Experience

Where I've worked

Apr 2025 — Present

Montreal, QC
Software Developer

Bounteous · client: Morgan Stanley
- Migrated a legacy Java 8 / Scala endpoint to Java 21, cutting its runtime from 4 minutes to 40 seconds — an 83% improvement.
- Build and maintain scalable Spring Boot backend services for enterprise-grade financial applications.
- Design AI agents with LangChain and LangGraph, plus RAG pipelines over ChromaDB that ground responses in internal knowledge bases.
- Integrate the Claude Agent SDK with MCP servers to expose internal tools to Claude Code, and use Claude Code heavily to automate repo management and CI/CD scripting.
- Ship Python services with FastAPI and front ends in Angular and React for agentic AI applications.
- Own Gradle build tuning across multi-project repos and Jenkins pipelines for test, integration and deployment.
- Work with PostgreSQL and Snowflake — including Snowflake Cortex for agent-driven querying — optimizing queries and protecting data integrity.
- Java 21
- Spring Boot
- FastAPI
- LangGraph
- MCP
- Jenkins
- Snowflake
Sep 2023 — Apr 2025

Montreal, QC
Software Lead — Autonomous Drone

McGill Robotics Club
- Led the software team: bi-weekly milestone reviews, task assignment, and one-on-one mentoring for junior members.
- Architected the autonomy stack as ROS 2 nodes, keeping mission logic, planning and perception independently testable.
- Integrated the PX4 flight controller over MAVLink/MAVSDK and wrote mission-critical real-time control in C++ and Python — waypoint navigation, obstacle avoidance and payload delivery.
- Stood up a PX4 software-in-the-loop simulation in Gazebo so autonomy could be validated before any flight.
- Trained a custom YOLOv8 model and built the full CV pipeline — detection, classification and ground localization — running in real time on an NVIDIA Jetson Orin Nano.
- Took the drone to competition for the first time in four years and earned the team's first award.
- ROS 2
- PX4 / MAVSDK
- C++
- YOLOv8
- Jetson
- Gazebo

03 — Projects

Selected work

Click any project for the full write-up.

04 — Skills

Tools of the trade

Languages

Java
Python
C / C++
SQL
Bash
JavaScript

Frameworks & Libraries

Spring Boot
FastAPI
Angular
React
LangChain
LangGraph
ChromaDB

Platforms & Data

Linux
Docker
Jenkins
Gradle
Maven
PostgreSQL
Snowflake
Google Cloud

Robotics & AI

ROS 2
PX4
MAVLink / MAVSDK
Gazebo
NVIDIA Jetson
YOLOv8
OpenCV
MCP

Education

B.Sc., Computer Science

McGill University — Sep 2021 to Dec 2024 · 3.6 GPA

Advanced Algorithms, Machine Learning, Artificial Intelligence, Computer Vision, NLP, Object-Oriented Software Design, Database Systems, Operating Systems, Combinatorial Optimization, Concurrent Programming.

Award: Tomlinson Engagement Award for Mentoring (TEAM)

Certification

Claude Certified Architect — Foundations

Anthropic

Claude Code, Claude Agent SDK, Claude API, and the Model Context Protocol (MCP).

Languages

French & English

Montreal-based, fully bilingual

French — native proficiency. English — full professional proficiency.

05 — Contact

Let's build something

I'm always happy to talk about backend systems, agentic AI or anything that flies. The fastest way to reach me is email.

As the drone division of the McGill Robotics Club, our objective was to design and build an autonomous aircraft for the 2025 SUAS competition. The mission is unforgiving: the drone must take off autonomously and fly 10 predetermined waypoints, staying inside the mission boundary while avoiding trees and a second UAV sharing the airspace.

It then has to locate and identify ground targets drawn from a fixed catalogue — a mannequin, scale-model vehicles, a stop sign, sports equipment, luggage, and more — and perform a precise water-bottle airdrop onto each of four of them before returning and landing at its takeoff point. The whole mission has a 30-minute budget, which makes energy management as much of a design constraint as accuracy.

To meet that, we chose a Vertical Take-Off and Landing design, combining a quadcopter's precision with fixed-wing endurance. The payoff is range; the cost is complexity, most of it landing in software at the transition between the two flight modes.

System design

We ran a full requirement elicitation pass over the rulebook before writing code, which produced the ROS 2 node graph the whole stack is built on:

ROS 2 node graph for the 2025 drone — The ROS 2 architecture: mission logic, planning and perception as independently testable nodes.

What I built

I wrote the flight controller node in C++. Having spent the previous season deep in PX4 firmware documentation, I knew the previous year's Python implementation could not meet the real-time demands of our constrained onboard computer, a Jetson Orin Nano — so the rewrite was a deliberate change of language, not just of code. Despite the added complexity of a hybrid VTOL system, iterative development and hard testing produced a controller we could trust.

In parallel, other team members generated a custom training dataset using Blender's scripting API, giving the computer vision models accurate, well-labelled examples of every target class in the rulebook.

The project is ongoing. For context on the platform that preceded it, see the 2024 drone write-up.

For the CodeJam 14 hackathon we took on the challenge in this repository: build an AI chatbot that helps customers find a car matching their preferences. The bar was a bot that could retrieve and reason over real listings while holding a distinct personality.

Splitting the work

Our team of two divided cleanly — I owned the backend AI, my teammate the frontend and server endpoints. Getting the bot to answer from real inventory rather than pre-trained guesses led me to retrieval-augmented generation.

Why RAG

RAG fetches relevant records from an external knowledge base before the model generates its answer. For a dealership that's exactly right: recommendations come from live inventory, hallucination drops, and the catalogue can change without retraining anything.

The constraint I set

I deliberately avoided external APIs — no OpenAI models, no Pinecone. Everything ran on open-source models and self-hosted vector search, so the system stayed independent and cheap to scale. That pointed at LangChain, which gave me three things at once: local models through Ollama (LLaMA 3 and 3.2:1b, the strongest open weights available at the time), ChromaDB as a local vector store, and a clean way to wire retrieval into the prompt.

Prompt architecture

System prompt — the bot's goal and persona.
Relevant cars — populated dynamically by vector similarity search.
Conversation history — context from prior turns.
Current query — the user's latest message.

The hard part was section two. Each listing became a document, embedded and stored in ChromaDB; at query time we retrieved the nearest neighbours to the user's question. With 100,000 cars at 30+ attributes each, embedding everything was far too expensive for a hackathon clock — so we cut each car to its 10 most decisive fields (seats, condition, make, model, and so on) and moved the embedding job to a GPU-backed Google Cloud Compute Engine instance. That took us from 10 minutes per 1,000 cars to the entire inventory in 30 minutes.

The persona

We wanted the bot to sound like the "My New Character" meme — relaxed, easygoing, unbothered. Holding that tone across a retrieval pipeline took more prompt engineering than the retrieval itself did.

What I'd fix

The bot worked, but it still hallucinated occasionally. With more time I would have:

Combined vector search with keyword search for better recall.
Filtered duplicate listings before embedding.
Added a judge model to validate retrieved results before they entered the prompt.

We started 24 hours into a 50-hour window, as a team of two instead of four, and still shipped a deployed product — the submission is here. It was my real introduction to RAG, prompt engineering and AI system design, and it shapes how I build agents at work today.

Our team's brief for the SUAS 2024 competition was a fully autonomous drone capable of a complex aerial mission — and this is the season where almost everything went wrong before it went right.

The requirements

Take off and fly 10 waypoints inside a defined mission boundary.
Identify and classify targets — a mannequin, or a paper cutout whose shape and letter colours uniquely identify it.
Perform four precise airdrops, matching each payload to its designated target.
Hold altitude between 50 and 400 feet AGL, finish within 30 minutes, and operate with at most two humans in the loop.

We initially planned a VTOL aircraft to maximize endurance while keeping precise control for takeoff, landing and airdrops.

Stepping in as lead

The project stalled early: with no software lead there was no direction, and the team bled members. As one of the more experienced developers still around, I was asked to take over — having never worked under a lead myself, so I had no template to copy. Midterms thinned participation further, and most of the remaining team had completed ROS 2 tutorials without ever writing project code. By the end of winter break we had neither a working codebase nor a design.

I fell back on requirement elicitation techniques from my software engineering class, working through the rulebook to produce an environment model, a domain model and a concept model:

Concept model derived from the SUAS 2024 rulebook — The concept model that turned a 40-page rulebook into assignable work.

With a plan in hand I reassigned tasks — but confidence was low, the assignments felt large, and the gap between tutorial knowledge and implementation proved wide. Over time I took on the majority of the development myself to keep the schedule alive.

Cutting scope to ship

Two months out, VTOL was no longer reachable: too complex, no prior experience on the team, and too little runway to integrate and test the fixed-wing transition. We pivoted to a quadcopter-only design and redesigned the software around a ROS 2 node architecture:

ROS 2 node diagram for the 2024 drone — The mission stack after the pivot.

The nodes

Offboard node — an action queue (takeoff, land, navigate) that abstracts PX4 communication for every other node. It simplified command execution and state monitoring, but locked us to quadcopter mode: MicroXRCE, which exposes PX4's internal pub-sub topics to ROS, had no support for VTOL transitions.
Local planner (VFH+) — a Vector Field Histogram Plus planner steering toward waypoints without crossing the mission boundary. Its obstacle-avoidance role had to be disabled: we lacked both suitable onboard sensors and the compute for real-time detection.
Mission node — the finite state machine at the centre of it all, sequencing publications across WAITING, PERFORMING_LAP, SURVEY_AREA, PERFORMING_AIRDROP and RTH. It was also the operator's interface for mission parameters and the start signal.
Computer vision node — two YOLOv8 models, one for shapes and letters and one for mannequins, with colour classification via OpenCV in HSV space. Identified targets were converted to ground positions and passed to the mission node.
Airdrop controller — a micro-ROS node on an Arduino Due driving the release mechanism, supporting arming and per-hub payload release.

Outcome

We competed for the first time in four years and won the Tenacity Award — the team's first competition recognition. Two lessons stuck. Structured leadership is not overhead: a clear roadmap and well-scoped assignments are often the difference between a project shipping and dissolving. And adaptability beats ambition on a deadline — dropping VTOL cost us endurance and speed, but bought stability and far simpler integration, which is what actually got us to the flight line.

Imad Issafras

Systems that have to work in the real world

Where I've worked

Software Developer

Software Lead — Autonomous Drone

Selected work

Tools of the trade

Languages

Frameworks & Libraries

Platforms & Data

Robotics & AI

B.Sc., Computer Science

Claude Certified Architect — Foundations

French & English

Let's build something

Autonomous VTOL Drone

System design

What I built

ChillGuy — RAG Chat Assistant

Splitting the work

Why RAG

The constraint I set

Prompt architecture

The persona

What I'd fix

Autonomous Drone 2024

The requirements

Stepping in as lead

Cutting scope to ship

The nodes

Outcome

Online Multiplayer Splendor

Stack

What I built

Challenges

Outcome