Correctness before speed
Validate data and outputs first. Optimize execution time once the results are right.
Hi, I'm
Saikiran Gandla
Software Engineer | |
I build scalable Python systems that turn raw images, video, and data into production-ready AI workflows — currently powering CV & Physical AI data pipelines.
📍 Hyderabad, India · Open to new opportunities
01. About Me
I'm a Software Engineer with 4 years of experience in Python development, Computer Vision, AI automation, backend development, and data processing pipelines.
I design and build Python solutions for enterprise client portals, workflow orchestration, data annotation platforms, and cloud storage integrations. I research and evaluate open-source CV models, plug pre-trained models into image & video inference pipelines, and automate the full flow: preprocessing, inference, post-processing, and annotation generation.
I care about reliability, performance, scalability, and maintainable design. Outside of work, I'm exploring AI/ML and Zero-Knowledge Proofs.
What I bring
- CV model evaluation & inference pipelines
- GenAI apps & LLM-powered automation
- REST / gRPC API integrations
- ETL & large-scale data processing
- Video processing with FFmpeg
- Django, Flask, FastAPI, Streamlit
02. How I Engineer
Five principles behind the pipelines on this page, and where on the site you can check each one.
Automation with recovery in mind
Plan for errors, partial failures, bounded retries, and reruns that do not repeat finished work.
Observability by design
Logs, progress tracking, validation reports, and clear failure summaries, so a system can be operated, not just run.
Practical trade-offs
Balance performance, reliability, maintainability, and complexity against the problem in front of me.
Business-oriented development
Measure success by less manual effort, better data quality, and workflows people can depend on.
Evidence beyond the resume
Architecture diagrams
System-design ability
Interactive demos
Practical implementation
Before-and-after results
Measurable impact
Validation reports
Attention to correctness
Debugging write-ups
Root-cause analysis
Technical decision records
Engineering judgment
Lessons learned
Reflection and improvement
03. Impact
Engineering outcomes from production work. The two figures below are measured. The rest are operational results from the same systems.
Less manual annotation
Pre-labeling with pre-trained detection models cut the labeling effort on customer datasets by 60%.
Reduced Manual Effort/Review by 50%
GenAI Slack bot that automatically runs scripts on demand.
Before and after
Workflow
Before
After
First-pass labeling
Annotators drew every box from scratch
Model pre-labels reviewed by people, 60% less manual effort
Production backups
Manual copy into the repository each day
Scheduled Python and Git job, 2–3 hours saved daily
YOLO conversion
Hand-converted batches, missing boxes found late
Client-triggered export that handles missing boxes and metadata
Running scripts on request
Ask an engineer to find and run the right script
GenAI Slack bot picks and runs the script on demand
Annotation integrity
Batch export to YOLO and pre-annotation formats now accounts for missing bounding boxes and pulls task metadata through, so labeling tasks are not created from incomplete predictions.
Reliable task sync
API automation that fetches, filters, and syncs tasks across environments includes error handling, retries, and logging, so a failed call is visible and can be rerun.
High-volume media handling
Multithreaded file processing and cloud storage operations move large image and video batches through onboarding without one-file-at-a-time manual uploads.
Validated data in, structured data out
ETL for CSV, JSON, Excel, and multimedia checks records before they move downstream. On the banking GenAI pipeline, multi-source results are merged with a confidence score.
04. Engineering Case Studies
Four problems from the computer-vision and automation work: what was broken, what I built, what made it hard, and what changed.
Case study 01 · Video and annotation pipelines
Turning large video batches into annotation-ready tasks
Problem
Enterprise clients onboard large image and video datasets that have to become labeling tasks. Doing frame extraction, format conversion, and first-pass labeling by hand does not keep up with the volume.
Approach
I built Python pipelines around FFmpeg for transcoding, segmentation, and timestamp extraction, then ran pre-trained object-detection models over the frames. Predictions are post-processed into the annotation platform and into YOLO or pre-annotation formats.
Challenges
Source media arrives in mixed formats. Model output is not a labeling task: boxes, scores, and task metadata have to be mapped, and missing boxes have to be handled before export. Cloud storage and local processing have to stay in step on large batches.
Outcome
Clients can convert a batch into YOLO or pre-annotation format automatically. Pre-labeling reduced manual annotation effort by 60%.
Case study 02 · Annotation integrity
Resolving frame-count mismatches before they reach annotators
Problem
A clip’s extracted frame count and its annotation JSON can disagree. Frames referenced past the end of the video, duplicate frames, or boxes with missing values produce labeling tasks that look valid and are wrong.
Approach
Validation sits between extraction and export. Frame indices are checked against the extracted count, bounding boxes must be complete, and task metadata is carried into the YOLO or pre-annotation file. Batches that fail the check are held back with a reason.
Challenges
Trimmed clips, dropped frames during segmentation, and detections that return no box all look similar in the output file. The check has to tell a real object with a bad box apart from a frame that should not exist.
Outcome
Export handles missing bounding boxes and task metadata explicitly, so annotators receive tasks that still match the media. The same checks are in the frame-validation demo below.
Case study 03 · Batch workflows
Designing batch processing that survives a partial failure
Problem
Onboarding, questionnaires, task creation, and annotation all run as batches. One bad file or one failed API call used to force a person to find the failure and restart the work.
Approach
I integrated REST and gRPC for task creation, batch management, and annotation workflows, and wrote API automation that fetches, filters, and syncs tasks across environments. Each unit of work is recorded as success or failure, with retries and logs. File processing runs multithreaded where the work is I/O bound.
Challenges
A retry must not create a second task for an object that already succeeded. Environment differences mean the same batch can pass in one place and fail in another, so logs have to say which environment and which id failed.
Outcome
Operators get a batch they can rerun from the failed items, with an audit trail, instead of a script that stops on the first error. The batch monitor demo shows that control loop.
Case study 04 · APIs and cloud storage
Connecting upload, storage, and delivery into one path
Problem
Media and tabular data were crossing too many manual steps: upload, check, process, store, then hand off to the portal or the next system. Each handoff was a place to lose a file or skip a validation.
Approach
Python services tie the client portal, REST and gRPC APIs, and Google Cloud Storage together. ETL validates CSV, JSON, Excel, and multimedia before processing. The same pattern showed up on the banking GenAI system: search, scrape, validate, score, and deliver a structured record.
Challenges
Large objects fail partway through. Transient storage and API errors should retry; bad formats and missing required fields should not. The pipeline has to report both without marking the whole batch as done.
Outcome
Onboarding through pre-annotation is an automated path with less manual intervention, and downstream systems receive structured output instead of a folder of raw files.
05. System Design
How the pipelines are shaped, from the first file to a result someone can use, and how a one-off script becomes something I would run in production.
Data path
Ingestion, validation, processing, storage, and delivery stay separate so a failure has one place to land.
IngestVideo, images, CSV, JSON, Excel
ValidateSchema, frame count, required fields
ProcessFFmpeg, inference, ETL, GenAI
StoreCloud storage and structured output
DeliverTasks, YOLO files, portal, queue
API orchestration
- Call REST or gRPC with the environment’s token.
- Classify the result: success, retryable, or permanent.
- Retry transient failures with a bounded count and a log line.
- Hold permanent failures (auth, bad payload, missing fields) with the id and reason.
- Sync only the records that are still outstanding.
Batch, concurrency, and monitoring
- Split the batch into records with stable ids.
- Run a fixed number of workers so cloud and API limits stay predictable.
- Record queued, running, retried, succeeded, and failed.
- Rerun from the failed ids so successes are not repeated.
- Watch logs for the environment, the batch, and the record.
From a prototype to a production run
1
Script
Prove the transform on one file: one video, one spreadsheet, one API call.
2
Validation
Reject bad frames, missing boxes, and incomplete rows before anything is written.
3
Batch and retries
Stable ids, a worker limit, and retries only for transient errors.
4
Integrations
Cloud storage, REST or gRPC, and the portal or queue that consumes the output.
5
Operable
Logs, a success and failure summary, and a rerun that continues where the last one stopped.
06. Problem-Solving Journal
Short notes on failures I have had to unwind in these pipelines, and the check I use the next time.
Debugging API authorization and model-access errors
When a pipeline dies on the first call, I split the failure in two before I change any code. An HTTP 401 or 403 on the task or batch API is an authorization problem: wrong environment, expired bearer token, or a scope that cannot create tasks. A call that authenticates and then cannot load weights is a model-access problem: a gated Hugging Face repo, a missing local path, or a token that can call our API and still cannot read the model.
I log the status code, the endpoint, and which environment supplied the token. Retries are only for timeouts and 5xx. An auth failure stops the batch immediately, because repeating it just burns the quota and hides the real error under a pile of identical lines.
Scripts that can process thousands of records safely
A loop that writes back onto the source file is how a large run becomes unrecoverable. I read in chunks, validate each record, append successes to a new artifact, and append failures to an error file with the record id and the reason. The success file is the checkpoint: a rerun skips ids already listed there.
Concurrency stays on the I/O: uploads, downloads, and API calls. The validation itself stays simple and single-purpose so a bad row fails that row, not the worker. CSV, JSON, Excel, and media each get their own check, and the batch summary is success count, failure count, and the error file path.
Validating video frames against annotation JSON
After FFmpeg and FFprobe, I treat the extracted frame count as the source of truth for that clip. Every annotation frame index has to fall inside it. A box needs four numbers. A null box, a short box, or the same frame and label written twice is a data error, not a detection to export.
Out-of-range frames usually mean the clip was trimmed after the JSON was produced, or segmentation dropped frames and the indices were not rebuilt. I block the YOLO or pre-annotation export until the counts agree, and I keep the task metadata on the records that pass. You can run that check on sample data in the demo section.
Partial failures in cloud ingestion
A large upload rarely fails as a whole. Some objects land in cloud storage and some do not. I store a state per object key: stored, retrying, or failed. Timeouts and 503s get a bounded retry. A bad format or missing metadata is permanent and goes to a quarantine list with the reason.
The batch is finished only when every key is stored or explicitly failed. The next run reads that state and uploads the outstanding keys, so a rerun does not create duplicates of the files that already made it. The log line always includes the batch id, the object key, and the attempt number.
Technical decision records
Decision 01
Threads for I/O, not for validation
- Context
- Uploads, downloads, and API calls spend most of their time waiting on the network.
- Decision
- Use a bounded thread pool for I/O. Keep validation sequential per record.
- Trade-off
- Not the maximum possible throughput, but predictable load on cloud and API limits, and failures that are easy to trace.
Decision 02
Validate before export, not after
- Context
- A bad YOLO file is only noticed once annotators are already working on the task.
- Decision
- Check frame ranges, boxes, and metadata before the export step, and hold failing batches with a reason.
- Trade-off
- An extra pass over each batch, in exchange for not having to rework labels later.
Decision 03
Fail fast on auth, retry on transient errors
- Context
- Treating every error the same either hides an auth problem or gives up on a brief outage.
- Decision
- Stop on 401 and 403. Retry timeouts and 5xx a bounded number of times.
- Trade-off
- Error classes need maintaining, but logs stay readable and quota is not wasted.
Decision 04
Checkpoint successes for safe reruns
- Context
- Restarting a large batch from zero duplicates tasks and uploads.
- Decision
- Record each success by stable id, and have the rerun skip those ids.
- Trade-off
- A small state file to keep, so a failed run can resume instead of starting over.
Lessons learned
- Silent success is the worst bug. A script that exits cleanly with bad output costs more than one that crashes, so every run ends with a summary of counts.
- Make the second run cheap. If rerunning a batch is safe, operators recover in minutes instead of escalating.
- Model output is not a deliverable. Predictions only matter after they are validated and mapped into the format the next team uses.
- Automate the boring, frequent task first. The 2–3 hour daily backup saved more than any clever optimization.
- Write the error message for the operator. Environment, batch id, record id, and reason, so the next person does not need me to read the log.
07. Interactive Demos
These run in the browser on sample data. They are the same checks and control loops as the pipelines above, and they are not connected to any client system.
Video-frame validation
Paste annotation JSON, or load the broken sample. The check compares frame indices, boxes, and duplicates with the clip’s frame count.
08. Experience
CV Robotics – Physical AI · Client: Uber
Software Engineer (External Consultant)
Building and improving Uber's Client Solutions Portal for end-to-end data onboarding, annotation, and workflow management for enterprise clients.
- Evaluated and integrated open-source Computer Vision models (GitHub / Hugging Face) into Python image/video inference pipelines: frame extraction, preprocessing, inference, post-processing.
- Ran pre-trained object detection models on large datasets to generate pre-annotations, cutting manual labeling effort by 60%.
- Built a GenAI-powered Slack bot that finds and runs the right Python scripts for each use case, so teams get automation on demand.
- Shipped a feature that converts client batches into YOLO / pre-annotation formats, handling missing bounding boxes and metadata.
- Integrated REST & gRPC APIs for task creation, batch management, and annotation workflows.
- Designed multithreaded high-volume file processing and cloud storage operations.
- Built FFmpeg video pipelines for transcoding, segmentation, and timestamp extraction.
- Designed ETL pipelines for CSV, JSON, Excel, and multimedia data with thorough validation.
GenAI Systems for Banking · LNRS & Fitch (via WNS Global)
Python GenAI Developer
An AI-driven app that extracts, enriches, and validates project information using GenAI, search engines, and web scraping.
- Designed an end-to-end pipeline combining GenAI, Google/Bing Search APIs, and web scraping.
- Built parallel multithreaded search workflows and field-specific GenAI extractors for structured output.
- Added scraping fallback logic with robots.txt compliance and site validation rules.
- Merged multi-source results into one dataset with confidence scoring.
Front Arena Cross-Asset Trading & Risk · Client: FIS Global (Europe)
Python Developer
- Wrote Python (ACM/AEL) scripts to create, update, read, and delete trades, portfolios, and instruments in production.
- Automated daily Git backups, saving 2–3 hours of manual work per day.
- Set up distribution configs and calculation environments, and automated service installation on PACE Server.
Online Banking Migration · Client: Nedbank (South Africa)
Jr. Python Developer
- Migrated a Java codebase to Python using Django.
- Wrote income verification and XML data segregation scripts with Pandas.
- Built web scrapers with Scrapy and BeautifulSoup.
Employee Management System · Internal
Python Trainee
- Led a team of 5 to deliver a Django web app for employees, appraisals, and timesheets.
- Deployed it live on PythonAnywhere.
09. Skills
🧠 AI & Computer Vision
🐍 Languages
⚙️ Frameworks & APIs
☁️ Cloud & Data
🎬 Video & Media
🛠️ Tools
10. Achievements & Certifications
🏆 Achievements
- Spot Award from client senior management during their visit to Zensar Pune (Feb 2024)
- Mentioned by name with positive feedback from the Director
- Top performer in Zensar's Clad Ethon during training
- Client appreciation email for finding and fixing a critical bug
📜 Certifications
- AEF Base Certified Developer – FIS
- Front Arena Boarding Pass Level 2 Mastery
- AWS Cloud
- Aviatrix Certified Engineer – Multi-Cloud Network Associate
- HTML5 & CSS3 – Pirple
🎓 Education
B.Tech, Computer Science & Engineering, Jawaharlal Nehru Technological University, Hyderabad, 2022
