About the role

We build the software that runs DC rapid chargers and syncs them to a cloud backend. Inside every charger sits an embedded Linux controller running our own Yocto-based image, our control stack in containers, and a permanent link to our AWS IoT backend. This role owns that controller as an operational thing: getting the image onto hardware and provisioned correctly on a manufacturing line, getting a charger back to health when it misbehaves in the field, and turning today's scripts into tooling other people can run without us.

This is deliberately a hands-on device role rather than a pure build-engineering one.

A normal week might contain all of the following: a batch of controllers needs provisioning, signing and flashing for a customer's production line; a charger at a customer site will not come online and you are in its logs over SSH; a container on the device starts four minutes late and you are reading systemd units and network dependencies; sixty devices need updating and version-verifying, so you write the loop.

We are looking for someone with at least 2–3 years of solid hands-on Linux experience who is comfortable at a shell prompt on a machine they cannot physically reach. We do not need a Yocto architect — we need someone who can read a recipe, change a partition layout, rebuild an image, and be careful about it, because a wrong flag here can brick a board or ship a device that is not production-ready. Depth in any single tool we can build together; carefulness, curiosity and a habit of writing things down we cannot.

It is also a product-minded role: a provisioning pipeline exists so a factory can ship chargers on schedule, not for its own sake, and we expect that to drive your decisions.

What you'll actually work on

This is a snapshot of our real backlog — the variety is the point:

- Factory provisioning and device signing — running, hardening and progressively automating the pipeline that turns a freshly built image into a provisioned controller with its own identity: per-device key generation and secure-boot signing, encrypted root and data partitions, credentials registered in AWS IoT, artifacts published to S3. Much of this is a chain of bash scripts run by hand today; the goal is a pipeline a factory can run reliably and in parallel.

- Field re-flash and device recovery — building the kit that lets an engineer or customer technician restore a fielded charger from a laptop in minutes: fetch that device's artifacts from S3, assemble the image, flash over USB — no build server, no Yocto checkout, and safe defaults that cannot damage a device already in the field.

- Embedded Linux image work in our Yocto layer — recipes and layer configuration in our own meta-layer on top of the NXP i.MX BSP: partition and WIC layout, A/B rootfs schemes, full-disk encryption and the initramfs around it,



kernel configuration changes, and systemd service and network units.

- Docker on the device — our control stack ships to chargers as containers. You debug why a container starts late or not at all, untangle startup ordering and network-online dependencies, and keep image size sane for over-the-air delivery.

- Remote access and fleet operations — SSH key management for device access, our self-hosted WireGuard-based VPN and the reverse-tunnel setup it replaces, and the everyday reality of reaching hundreds of chargers safely across customer networks.

- Diagnostics and log tooling — getting logs off deployed chargers, log rotation on devices with little disk, diagnostic packages triggered on demand over MQTT, and Python that turns a pile of log files into an answer.

- Batch device operations — Python and bash glue for fleet-wide jobs: firmware rollout across a lab or customer fleet, certificate migrations, config pushes, and wait-and-verify-after-reboot loops that report honestly when something did not take.

- Field support with our customer-facing teams — when a charger misbehaves on site, you are one of the few people who can say what the Linux side is really doing, and turn that into a fix or a runbook.

You will work across our embedded, cloud/IoT, DevOps and support teams, on several customer projects in parallel. Two urgent requests landing at once is a normal week, not an exception.

What we require

(Technical must have)
- 2–3 years or more of hands-on Linux professionally, on servers or embedded targets. The command line is your primary tool, not a fallback.
- Bash scripting. You can read someone else's long provisioning script, work out exactly what it does, and change it without breaking it. Understanding a script before running it matters more here than writing an elegant new one.
- Linux storage fundamentals — partitions, filesystems, mounts, loop devices, disk images — enough to reason about an A/B layout and a data partition that must survive an update intact.
- Yocto / BitBake. Practical exposure: you have built an image, edited a recipe, added a layer and debugged a build failure. Deep meta-layer architecture experience is a plus, not a requirement.
- Docker — building images, debugging why a container will not start, and working with docker-compose.
- AWS from a scripting and consumer angle — the AWS CLI against S3, IoT Core and DynamoDB.



Not an infrastructure architect; someone who can script against cloud services confidently.
- Linux networking — iptables/ip6tables, basic routing and NAT, bridges and VLANs, plus enough ip and tcpdump to work out why traffic is not arriving.
- Git as a daily tool — branching, rebasing and resolving conflicts without fear.
- SSH and remote device management — key-based authentication, jump hosts and tunnels, plus the instincts of someone who has locked themselves out of a remote machine once and does not intend to repeat it.
- Python for glue code — log parsing, batch operations across many devices, small CLI tools. Readable beats clever.

Maturity and way of working (weighted as heavily as the technical side
- Careful with production hardware. You read before you run, check what a destructive step will actually do, and say so when unsure — we would much rather hear "let me verify this on a bench device first" than find out afterwards.
- Self-driven. You take a loosely defined problem from a busy backlog, clarify it and drive it to done across team boundaries without being managed day-to-day.
- Documents by default. Runbooks are part of the deliverable, not an afterthought — a central point of this role is that provisioning and recovery stop depending on one person's laptop and memory.
- Calm under pressure. When a production line is waiting or a charger is down on site, you prioritise by impact, communicate the trade-off and hand over cleanly — you don't silently absorb the load or let things drop.
- Communicates beyond engineering. You explain things to support engineers, factory operators and customer technicians

-in writing, often at short notice.
- Product-oriented. You can explain in business terms what the project does and who it serves, and your technical choices reflect that.

Nice to have
- EV-charging, IoT, or connected-device / embedded Linux domain experience.
- NXP i.MX platforms, U-Boot, secure-boot / chain-of-trust concepts, LUKS / dm-crypt.
- OTA update systems (Mender or similar) and A/B update schemes for fielded devices.
- CI/CD exposure — GitHub Actions or GitLab CI — especially for long-running image builds.
- Experience supporting a manufacturing line, or several customer projects in parallel.
- Interest in applying AI-assisted tooling to log analysis and support automation.

How we'll Evaluate The interview is practical: we will put real material in front of you — a provisioning script, a container that will not start, a device that will not come online — and talk through what you would check first. How you reason about a system you have never seen, and how carefully you treat a device you could break, matter more to us than a checklist of tools. Documentation habits and an honest "I don't know yet, but here is how I'd find out" count as heavily as raw depth.

📌 Linux Engineer (Kolkata Metropolitan Area)
🏢 Cordial Solutions
📍 Kolkata Metropolitan Area