BonV Aero — Mission Systems & GCS Engineer

"I am a full-stack developer with a strong focus on backend architecture and automation. Recently, I built Eagle Esports, an automated tournament management platform from scratch. I developed the frontend dashboards in JavaScript and Tailwind, and built a RESTful API in PHP with a MySQL database. My biggest achievement was integrating Google's Vision AI and building a custom fuzzy-matching algorithm to completely automate match result processing. I'm really excited about BonV because I want to take this experience in building real-time, operator-facing dashboards and apply it to Ground Control Software for drones."

"I designed the backend using a Front Controller design pattern. Instead of having fifty different PHP files, all frontend requests hit a single API endpoint. The backend intercepts the request, verifies the user's Session Token for security, and then routes it to the correct function. I also made sure to use CORS headers and sanitize all inputs to prevent SQL injection."

"To prevent the UI from freezing, I heavily relied on Asynchronous JavaScript. When the dashboard fetches live match data or processes AI images, it uses async/await so it doesn't block the main thread. If I were handling live drone telemetry at 60 frames per second, I wouldn't use standard HTTP polling. Instead, I would open a WebSocket connection for real-time data push, and I would use Data Throttling on the frontend to only update the DOM a few times a second to keep the dashboard running smoothly."

"When an admin uploads a screenshot, the frontend converts the image into a Base64 encoded string and sends it to the backend via a JSON payload. My PHP server then securely forwards this to the Google Gemini Vision API with a highly specific prompt. The AI returns a JSON array of the player names and kills it detected. Finally, I run that data through my custom matching engine before saving it to the database."

"That was actually my biggest challenge! Because of weird gaming fonts, the AI would often misspell names. I couldn't use a strict exact match. So, I built a custom Fuzzy Matching algorithm on the backend. I used the Levenshtein distance method to calculate the mathematical similarity between the AI's text and the registered names in my database. If the similarity score is 75% or higher, the system accepts it as a match. This made the automation incredibly reliable."

"To prevent overbooking, I implemented strict Concurrency Control. When a user tries to book the last slot, I use Database Transactions with row-level locking. This tells MySQL to lock that specific tournament row while processing User A. User B's request has to wait a fraction of a second until User A is finished. If anything fails during the payment, the transaction triggers a Rollback, ensuring the data is never corrupted."

"I implemented strict Role-Based Access Control (RBAC). When a user logs in, the backend generates a secure token and enforces a Single-Device policy by deleting any old tokens. On the database side, I never store plain-text passwords; I hash everything using BCRYPT. Every time an API request is made, the backend checks the token to ensure the user has the correct 'Role ID' before allowing them to delete or modify data."

"I always assume external APIs will fail. In my backend, I wrapped all third-party API calls (like the Gemini AI or the Payment Gateway) in robust Try-Catch blocks. If the AI server goes down or times out, my application doesn't crash. It catches the exception, logs the error, and sends a clean message to the frontend, allowing the admin to seamlessly switch to manual data entry. Graceful degradation is a priority for me."

"If my PHP server tried to text 500 users one by one, it would time out. Instead, I integrated Firebase Cloud Messaging (FCM). My backend packages all the user Device Tokens into a single payload and sends it to Google's servers. This offloads the heavy lifting to Firebase, acting as a highly scalable background job, which keeps my server resources free for critical database operations."

"I love building software that solves complex, real-world problems. Building the dashboards and backend for Eagle Esports taught me how to handle real-time data, optimize APIs, and build interfaces for operators. But I want to take these skills out of the web and apply them to the physical world. BonV is building deep-tech autonomous drones for defense and logistics, and I want to be the engineer who builds the Ground Control Software that makes those drones easy and reliable to operate."

"I would never load 100,000 records at once because it would crash the browser and max out the server's RAM. In Eagle Esports, I implemented Server-Side Pagination and Data Limiting (LIMIT and OFFSET in SQL). The frontend only requests 50 matches at a time. As the user scrolls, JavaScript triggers an asynchronous request to fetch the next batch. On the database side, I ensure that frequently searched columns, like user_id or match_date, are strictly Indexed so the queries run in milliseconds."

"Security was a top priority. To prevent SQL Injection, I strictly used Prepared Statements (bind_param in PHP) instead of concatenating raw user input directly into SQL queries. To prevent Cross-Site Scripting (XSS), I made sure to sanitize and escape all output on the frontend so that if a malicious user tried to enter a script tag as their username, it would be rendered as harmless text rather than executed by the browser."

"In a mission-critical dashboard, silent failures are dangerous. If the WebSocket or API connection drops, the UI must immediately reflect that. I would implement a Heartbeat mechanism—the dashboard pings the drone every second. If 3 pings fail, the UI instantly grays out the live telemetry, displays a clear 'Connection Lost' warning, and freezes the last known GPS coordinates. Once the connection is re-established, the dashboard gracefully resyncs the state without requiring a hard refresh."

"I strictly use Git for version control. I maintain a main branch for stable production code and create separate feature branches when building things like the AI Scanner. Before pushing to production, I use a custom Node.js script I wrote (minify-assets.js) to automatically minify my CSS and JavaScript to reduce file sizes. I also run a Cache-Busting script that updates the version tags on all files, guaranteeing that users immediately get the newest version of the dashboard without clearing their browser cache."

"For Eagle Esports, I used the Google Gemini API, which is Cloud Computing because my server had a stable internet connection. However, I know that drones in remote border areas (GPS-denied or offline environments) cannot rely on cloud APIs. In that scenario, I would transition the architecture to Edge Computing. We would deploy a lightweight, quantized AI model (like YOLO for object detection) directly onto the drone's onboard hardware, such as an NVIDIA Jetson, so it can process images locally without needing an internet connection."

"When building the Webhook for the payment gateway, the payments were succeeding, but the database wasn't updating. It was incredibly frustrating. Instead of guessing, I systematically isolated the issue. I used tools like Postman to simulate the webhook requests and checked the server error logs via SSH. I realized the payment gateway was sending a slightly different JSON structure than the documentation stated. By implementing strict logging of the raw incoming payloads, I was able to parse the correct fields and fix the issue. It taught me to always log raw data when working with external APIs."

"The Backend State is the ultimate truth—it lives in the MySQL database and represents the actual data, like a user's wallet balance. The Frontend State is just a temporary visual representation of that data living in the browser's memory. In Eagle Esports, if an admin updates a match score, I update the frontend state immediately for a fast, snappy UI (Optimistic UI updating), while simultaneously making an asynchronous API call to update the backend state. If the backend fails, I roll back the frontend state to keep them perfectly synced."

"Before deploying, I did rigorous testing. For the backend, I used tools like Postman to test all API endpoints manually, ensuring they returned the correct HTTP status codes (200 for success, 401 for unauthorized). For the AI Scanner, I ran Edge Case Testing by feeding it blurry screenshots, completely dark images, and images with corrupted text to ensure my Try-Catch blocks and Fuzzy Matching algorithms handled the errors gracefully without crashing the server."

"I chose PHP and vanilla JavaScript because it allowed me to build and deploy a highly performant, lightweight platform very quickly. While React is fantastic for massive single-page applications, plain JavaScript allowed me to have granular control over DOM manipulation and keep the bundle size incredibly small. However, I understand the component-based architecture of React, and I am highly adaptable. If the BonV Ground Control Software is built on React or Qt, my deep understanding of vanilla JS means I can easily transition to those frameworks."

"In the next two years, I want to transition from being a strong full-stack web developer to a specialized Mission Systems Engineer. I want to deeply understand how software interfaces with hardware. I see myself taking ownership of the Ground Control Software—ensuring that the dashboards our pilots use to control drone swarms are the fastest, most reliable, and most intuitive in the industry. I want to be the bridge between the complex autonomous AI and the human operator."

"TCP (Transmission Control Protocol) is reliable. It guarantees that every packet of data arrives in the correct order, but it is slower because it requires a 'handshake'. UDP (User Datagram Protocol) is fast but unreliable. It just blasts data out and doesn't care if a few packets get lost.

For a drone's live video feed, I would use UDP. If a few frames of video drop, the screen might glitch for a millisecond, but the feed stays real-time. If we used TCP, the video would constantly pause and buffer to retrieve lost frames, which is dangerous for a pilot. However, for sending critical flight commands (like 'Return to Home'), I would use TCP to guarantee the drone receives the command."

"Multiprocessing uses multiple CPU cores. Each process has its own separate memory space. If one process crashes, the others keep running. It is great for heavy, independent tasks like running an AI vision model.

Multithreading runs multiple threads inside a single process. They share the same memory space, which makes communication between them very fast, but if one thread crashes, the whole process can crash. It is useful for lightweight tasks like updating a UI while listening for network data."

"The four pillars are:

• Encapsulation: Hiding the internal state of an object and requiring all interaction to be performed through an object's methods (using private/public variables).
• Abstraction: Hiding complex implementation details and only showing the essential features (like a drone class having a takeOff() method, without showing the complex motor logic).
• Inheritance: Creating new classes based on existing ones to reuse code (e.g., a Quadcopter class inheriting from a base Drone class).
• Polymorphism: The ability of different classes to be treated as instances of the same class through a common interface (e.g., calling move() on both a Drone and a Ground Rover, and each handles it differently).

"A memory leak happens when a program allocates memory (like using new or malloc in C++) but fails to release it back to the system when it's done. Over time, the program eats up all the RAM until the system crashes.

To prevent it in C++, I would use Smart Pointers (like std::unique_ptr), which automatically clean up memory when they go out of scope. In garbage-collected languages like JavaScript or Python, I make sure to clear global variables, remove event listeners, and close database connections."

"Big O Notation describes how the runtime of an algorithm grows as the amount of data increases. If I am searching for a specific item in an unsorted Array, the time complexity is O(n), meaning in the worst case, I have to check every single item one by one. However, if I use a Hash Map (or a Dictionary), the time complexity is O(1) (constant time). The system uses a hash function to jump directly to the data, which is instantly fast no matter how large the dataset is."

"I would represent the map as a Graph or a Grid. To find the shortest path, I would use graph traversal algorithms like Dijkstra's Algorithm, or more commonly in robotics, the A* (A-Star) Algorithm. A-Star is highly efficient because it uses a 'heuristic' (like the straight-line distance to the target) to prioritize which paths to explore first, making it much faster at avoiding obstacles in real-time."

"The Pub-Sub model is an architectural pattern where senders of messages (Publishers) do not send messages directly to specific receivers (Subscribers). Instead, they send messages to a central 'Topic' or 'Message Broker' (like MQTT or RabbitMQ).

For example, a drone's camera (Publisher) publishes video frames to a 'Video Topic'. It doesn't care who is watching. The AI Model and the Ground Control Dashboard (Subscribers) both 'subscribe' to that topic to receive the video stream. This decoupling makes the system highly scalable and prevents one slow component from crashing the rest of the system."

"REST APIs (like the ones I built) use HTTP and JSON. JSON is easy for humans to read, but it is 'heavy' because it transfers data as text.

gRPC, developed by Google, uses HTTP/2 and Protocol Buffers (Protobuf). Protobuf compresses data into a binary format before sending it. Because binary is much smaller than text, gRPC is incredibly fast and uses very little bandwidth. In a drone system where bandwidth over a radio link is limited, I would prefer gRPC or MAVLink over REST to send telemetry and commands efficiently."

"I chose a Relational Database (MySQL) for my esports project because I was handling financial transactions and user relationships, which require strict schemas and ACID compliance.

However, I would choose a NoSQL database (like MongoDB or InfluxDB) if I need to store massive amounts of unstructured or semi-structured data at very high speeds. For example, if a drone is logging hundreds of sensor readings per second (temperature, wind speed, motor RPM), a NoSQL or Time-Series database is much better because it doesn't require a strict schema and can handle high-velocity 'write' operations much faster than SQL."

"Caching is the process of storing frequently accessed data in high-speed, temporary memory (like RAM) instead of fetching it from the main database every time.

If a Ground Control Station has 10 operators viewing the same drone's map coordinates, querying the MySQL database 10 times a second is inefficient. Instead, I would use an In-Memory Data Store like Redis. The backend fetches the coordinates from the drone, saves them to Redis, and all 10 operators read from the incredibly fast Redis cache. This dramatically reduces database load and cuts latency down to sub-milliseconds."

"CI/CD stands for Continuous Integration and Continuous Deployment. It is an automated pipeline. When a developer pushes code to GitHub, the CI pipeline automatically runs tests to ensure the new code doesn't break anything. If it passes, the CD pipeline automatically deploys it to the server.

Docker is a tool that packages an application and all its dependencies into a single 'Container'. This solves the classic 'It works on my machine but not on the server' problem. For drones, Docker is amazing because you can containerize an AI model on your laptop, and deploy that exact same container directly onto the drone's onboard Linux computer, guaranteeing it will run perfectly."