Want to know if this job is worth applying to?
Delft, Zuid-Holland, Nederland
Hybrid
TL;DR: We build the software behind our autonomous flight systems, plus a surprising amount of the supporting software around it. This role is for the people who want to build the latter.
Preferred starting date: ASAP
Weekly availability: full-time (5 days/week)
Location(s):
Aerospace Innovation Hub, Delft, The Netherlands
Fiducial is a young but fast-growing deep-tech start-up with big ambitions at the frontier of autonomy, perception, and defence. We develop and deploy software for on-board UAV 3D vision in military applications. Our software solutions are built for scalability first, using low-cost and widely available sensors and compute.
We develop our software in the field and close to the points of use. Flight testing is key for what we do and we test all across Europe. Our team members have strong academic background in different fields such as Aerospace Engineering, Computational Science and Engineering, Robotics and Computer Graphics. Our main office is located in the TU Delft campus in the faculty of Aerospace Engineering.
We work closely with top-tier partners, ranging from drone manufacturers to research institutes. Our projects span from orders in collaboration with operational partners to low-TRL research with government agencies. Whether through formal R&D programs or rapid prototyping tracks, we operate at the intersection of innovation and deployment.
You will build the internal tools, shared libraries, and product-supporting infrastructure the rest of the company runs on. You reach for Python, Rust, C++, or the browser depending on the problem. You drop into an unfamiliar domain and form strong architectural opinions within a week. You’d rather understand a problem deeply than be handed a spec.
We build fast, and we expect fluency with vibe coding as a core, daily skill. We expect you to use these tools to get from a well-understood problem to sound, working software quickly. You also know their failure modes: you read the code you ship, and you own its correctness and architecture.
Some examples of what a Software Generalist here develops:
Flight operations dashboard: Flight planning, weather integration, and test-location scouting for our internal flight ops team. Python + web.
A Rust deployment tool: For fast compile → build → deploy from our servers out to edge devices, over links unreliable enough that normal deployment tooling falls over.
A high-performance C++ camera-interfacing library: Used across our fiducial products. Latency and throughput matter here in a way most application code never has to think about.
Data annotation software: The tooling our annotators use every day. Its quality sets the ceiling on the quality of the data our models learn from.
Product-metric CI dashboards: Surfacing critical performance metrics against reference datasets, across commits and branches, so regressions are caught the moment they land.
You embed with the team you’re building for. You ship them something early and then keep working next to them as it evolves and as you discover the shape of the final solution jointly. Concretely, for the examples above:
You deploy to the field with flight ops before there’s a dashboard, again with an early version in hand, and again once they’ve been living with it.
You take deployment shifts, and you keep taking them after the tool exists.
You work inside our product codebases until you understand how they consume a camera library, and you stay close as both sides change.
You annotate data yourself, sitting next to the annotators. You feel the thousandth repetitive click, eliminate it, and go back to annotating to find the next one.
The empathy you earn on the ground is what lets you build the right thing, fast. Software Generalists build the tool the team didn’t know how to ask for. If doing someone else’s job for a week, then coming back a week later to watch them use what you built sounds energizing, this role is for you.
You own outcomes. You don’t throw software over a wall. You talk to the people who’ll use what you build, most often colleagues down the hall, sometimes the users of our products. You sit with them, watch where they stumble, and find usability friction. "Done" means someone’s job got easier.
You orient fast in unfamiliar territory. Dropped onto an arbitrary problem, you build an accurate mental model quickly of two things: the unfamiliar codebase or domain, and the unfamiliar human workflow underneath it.
You architect for use and for change. Your software is well-built in the ordinary sense and shaped around how it will be used and how it will need to grow. You tend to pre-build the next feature request, because you know the user well enough to see it.
Language-agnostic. You’ve shipped real software in more than one of Python, Rust, C++, and modern web stacks, and you treat languages as tools you pick up as needed rather than as an identity. You don’t need mastery of all of them on day one, you need to be someone who becomes competent in a new one fast.
Strong systems and performance instinct. Some of our work lives or dies on performance. You have a felt sense for where the time and bytes go, and you reach for a profiler by reflex. A computer graphics or game-development background is a real plus. Other work barely touches any of it, and you can tell the difference and right-size your effort accordingly.
Background in graphics, game dev, or real-time systems
Networking depth — you understand what happens when topologies get ugly
Rust and/or modern C++ in production
Experience owning internal tooling or developer-experience work
Comfort with hardware-in-the-loop or field-deployed systems
You’ve built the in-house version of something other teams usually buy
Money, of course.
25 vacation days per year.
Reimbursed travel expenses and company laptop.
(Really) flexible working hours and option to work from home 2 days per week when in the Netherlands.
Working in an international, world-class team of engineers and entrepreneurs solving real-life problems with amazing technology.
Large freedom in how you work and implement solutions, project ownership is incredibly important to us.
The opportunity to take technical risks, to implement stuff the ‘right’ way and to iterate quickly with tight feedback loops. We are innovating, learning is to be expected.
Responsibility over the things you implement, you are the expert on what you build.
Traveling abroad to test the solutions you built in relevant environments.
If after reading the above you are convinced you are the right person for the job, send us some information about yourself; this can be a resume, website or other source, as long as we get a clear impression of your background and skills.
We’ll get back to you as soon as possible. If we see a potential fit, you’ll first receive a short follow-up questionnaire. Based on your answers, we’ll invite you for a technical interview. This interview is an opportunity to talk through a real problem/scenario and show us you think and communicate.
If at this point we feel you are the person we are looking for, we’ll discuss the specifics.
Welcome to the team!
