Kamal Mehta

Root cause work on over a hundred field issues.

A client says the system is not working. Often that is all you get. There is no error attached.

You start at the locomotive and work backwards. Where the driving was in doubt, I rebuilt the trip in simulation.

The causes were spread across the stack. Lost messages, wrong train lists, clocks out of sync, models deleted.

Finding a cause is not fixing it. Each went to the team that owns that code, and to testing.

Fleet availability went from ninety to ninety-nine percent. That was a hundred small fixes, not one.

A year of reports nobody had run.

Twelve months of field trips had gone unreported. Nobody could say how it was doing. A bad thing not to know.

I wrote it as two questions. Did the system get a fair chance to run? And once it ran, did it do the job?

A year of history was not in fast storage. Getting it back meant staged restores from the archive.

The backlog cleared in one month. After that it needs about half an hour of somebody's week.

The reports were not the point. The failures they exposed were. Each got a fix and a test.

How I use A I coding tools in my own work.

Every team has small manual checks. Each costs somebody an hour a week. None is worth a sprint.

That arithmetic is what changed. The tools were always possible to build. They were not worth the days they used to take.

Two of them shipped. One checks a deployed container holds the right model files. The other verifies hashes that Q A did by hand.

A repeating request now comes back as a tool. It does not come back as a favor.

This is a habit rather than a project. I list it because how I work changed.

A bug in the air brake model, and what it taught.

I found it while calibrating. After each brake release they disagreed. Only there, and always the same way.

Trains brake with air. In simulation they refilled in a second. A real train takes four; the air has to travel.

Each car refills by its distance from the locomotive. The delay is geometry. Nothing is fitted.

The fix exposed the brake state to the driving model. It learned the refill timing. It stopped braking and powering at once.

The fix itself was small. The signal it exposed was worth more than the fix.

Path planning and obstacle avoidance.

My thesis worked out where things are. It stopped at that. This is the other half of the same problem.

The vehicle builds a map while it drives. It plans a route on that map, then follows it. Each stage runs on the last one's output.

When something blocks the route, it plans a new one. It does not stop and wait for a person. That is the part worth building.

I built it in simulation on purpose. A crash costs nothing there, and I can repeat it.

I have not run this on real hardware. I would rather say so than let it be assumed.

Building train make-ups, from a week to an afternoon.

A make-up lists what is in the train. Building those took about a week. Every new route needed a fresh set.

I went to the source data instead of the exports. Then I ran the conversions in parallel. That is the whole trick.

Twenty-five hundred of them in four to five hours. That is about ten times quicker than before.

A small tool shipped with it, for one at a time. Field engineers and Q A use it without me.

Expansion was waiting on this. Territories went from fifty-five to a hundred and twenty.

Dashboards that clients use to judge the system.

There are three of them. Fuel, fleet performance, and route summaries. Clients read them to decide.

The reporting tool has limits on what it can work out. They landed on the metrics people wanted most.

So the numbers are worked out in Python, ahead of it. The dashboard only draws them. It stays alive that way.

It produced numbers I did not expect to ship. Best horsepower per ton, and pacing speed, by route. Sales took those.

One rule held it up. Every number traces back to a trip. A client will ask.

A second braking system in the physics engine.

Most trains brake with air, car by car. Some brake electrically, every car at once. Our engine knew only the first.

There was nothing to copy from. I built it from research papers, from the railroads already running it, and from the protocol.

The easy path was a second engine. Instead I made brake type a setting on the one we had.

It opened a market we could not serve. The first Australian deployment went ahead.

Two codebases would have drifted apart. That call mattered more than the physics.

A crawler that checks every locomotive's health.

A faulty build reached the computers on the trains. It knocked their clocks out and dropped network rules. The system went offline.

Engineers were checking locomotives by hand. By the time they found it, the client had too.

A crawler now reaches every locomotive twice a day. It checks the containers, the clock and the rules. It corrects what drifted.

It only writes where it has confirmed that is safe. If it is not certain, it does nothing.

Twenty to forty engineer hours back every month. And we find these first.

Floor plans, recovered from raw sensor readings.

A device walks a building and measures distance. Could a floor plan come out of that? Nobody knew.

Two things ruin the map. The device drifts as it walks. And the laser itself is noisy.

A wall is where the readings crowd together. So I clustered by density. Then sorted them horizontal and vertical.

I proved it in simulation before touching the device. Then the same code ran on the hardware.

Six months, from an open question to a working demo. I was the only engineer on it.

Calibrating the simulator's physics.

The simulator was off. Two numbers were the reason. How hard the train pulls, and how well it brakes.

I tried the clever search methods. Each one settled somewhere wrong. The problem has more than one valley.

So I searched the whole space, in five percent steps. It costs more compute and it cannot miss. Each train type gets its own pair of numbers.

New trip data lands and it reruns itself. Nobody has to remember to run it.

Trip time and fuel estimates came up ten percent. The driving model trains inside that simulator.

Two interns, over two years, and two things still running.

An intern gets one summer. You can hand them a practice problem or a real one. I gave real ones.

The first built simulation artifacts at scale for field engineers. I handed over my own tool and walked him through it.

The second traced a recurring fault to the locomotives it hit. He extended my tool, and it still feeds a dashboard.

I stayed in it with them, all the way to delivery. Not just at the review points.

Both of them shipped, and both are still in use today. That is the part of it I would want judged.

Features that let one model cover new ground.

Every route needed its own model. There were hundreds of them. Expansion was capped by that, and nothing else.

So I asked what it was really reading. It had learned the routes. It had not learned the terrain.

The fix was the hill ahead, not the hill underneath. One to two miles of look-ahead. New track still looks familiar that way.

Hundreds of models came down to four or six. Training cost fell by about eighty percent.

Deployment across territories followed. The same features shape the driving model's reward.

Sensor fusion on an unmanned ground vehicle.

This was my master's thesis. A camera says what a thing is. A laser says how far.

I labeled eleven thousand images. Nothing existed for this vehicle. Training dropped to eight hours.

One filter holds both sensors. It keeps one estimate of where each object is. Neither reading is trusted alone.

Ninety-six percent on the test set. Nineteen misses out of two hundred and twenty. None were called the wrong thing.

It ran on the vehicle, not in simulation. Sixty milliseconds a frame.

Recovering trip data that never reached the numbers.

Reports were made on the train itself. If that failed, the trip was gone. Twelve to fifteen percent were missing.

So I rebuilt them in the office, from the raw data. The train no longer has to be the thing that does it.

The original method could not run across years. I changed the algorithm so it could.

The recovered trips were the interesting part. They exposed bugs in the metrics themselves. Precision is ninety-nine percent now.

A report made on the train cannot be corrected. One made in the office can be run again.

Three hundred locomotives upgraded in one release week.

Releases were installed by hand, one locomotive at a time. Before each one you check the clock and the rules.

Three hundred of them went out inside a single week. I installed a large share of those myself, out in the field.

While doing it I wrote down where the time actually went. And where the mistakes came from.

That became a list of automation requirements. The device team took them and built from them.

Installing software by hand is not engineering. Writing the spec that removes it is.

A tool that rebuilds any field trip in simulation.

Something goes wrong on a train. To study it you rebuild that exact trip. That meant hunting through logs.

Now you give it a date, a locomotive and a train. It assembles the rest. That is the whole interface.

The recordings have stretches that were never captured. The tool fills those from reference data, not with holes.

It became the normal way to do this. Training, validation and lab testing all run through it.

One check gates the output. If the track and the speed limits are misaligned, the trip is not the trip.

Driving strategy for autonomous freight trains.

It replaced a decision tree. A tree stays confident on track it has never seen. It degrades quietly.

I reframed it as reinforcement learning. Same inputs as before. It is scored on the trip, not on copying a driver.

Training takes eight to ten times longer. You pay that once. Inference runs every trip.

The policy came out a thousand times smaller. Small enough to run on the locomotive itself.

No large slack incident in operation. That is the failure that breaks a train in two.

The numbers behind a twelve percent fuel saving.

This number went to the E P A. A regulator checks it. It had to survive somebody paid to doubt it.

I split the trips by type, route and power. Then I looked for trips a driver won. Those set the target, because they had been reached.

Simulation and the field do not save the same. I measured that gap once. Then a fuel target could be set.

The reporting tool could not express the calculations. So they moved into Python, ahead of it.

Certified at twelve percent. I kept measuring it every week afterwards.

A data pipeline for an Australian client.

The train carries two recorders. One logs what it is doing. The other logs where it is. They did not agree.

One ran on universal time, one on local. One had gaps where the radio dropped. I put both on one clock and filled the gaps. Training needs one record.

The track itself came out of map files. Elevation, curvature and grade, matched to position.

It runs on new client data without me. That was the point of building it.

It carried the pilot, then the whole fleet. It helped win the contract.

A design for tracking data from the train to the cloud.

Data leaves the locomotive and ends in the cloud. It crosses four protocols and three services. Nobody saw the whole path.

A missing file surfaced weeks later, as a hole in a report. You could not say which step of the path dropped it.

I mapped the path and wrote the scope of work. Track each file at every hop. Then a loss is caught where it happens.

Every file, not a sample. Sampling does not answer the question anybody asked.

This is a design, not an implementation. Deciding what to build is part of the job.