Beyond the Code: Mentoring the Next Generation of Engineers at Six Flags

Mainuddin — Tue, 05 May 2026 17:36:16 +0000

Technology is often viewed through the lens of lines of code and GitHub commits, but its true impact lies in the community it builds. Recently, representatives from Open Source with SLU stepped away from our development environments to serve as ambassadors for the future of computer science during a regional outreach event.

While the setting was informal, the goal was high-stakes: inspiring curiosity in middle and high school students. As a representative of our open-source program, my role wasn't just to talk about software, but to demystify the "black box" of technology for students who are just starting to explore STEM.

We focused our conversations on the core philosophy of Open Source:

Collaboration: Explaining how developers who have never met can build global tools together.

Transparency: Showing students that they don't just have to use apps—they can actually read, understand, and change the code behind them.

Accessibility: Breaking down the barrier that computer science is only for "math geniuses" and showing it as a creative toolkit for problem-solving.

Professional leadership in a technical context is often measured by project management or code quality. However, this experience reminded me that true leadership also includes mentorship and advocacy. Seeing a student’s perspective shift from "I could never do that" to "How do I start?" is a powerful reminder of why we share our knowledge.

As computer science students, we often get lost in the logic of our specific sprints. Acting as a bridge for these younger students allowed us to step back and see the "big picture" of our field.

Being a leader means being the best advocate for your community. By representing Open Source with SLU in a public, high-energy environment, we strengthened our program’s external presence and took a meaningful step in fostering the next generation of technical talent.

Building an AI Prediction API with FastAPI: Lessons from an Open Source Project

Mainuddin — Thu, 05 Mar 2026 02:05:31 +0000

Artificial Intelligence projects often focus heavily on training models, but an equally important step is making those models usable. A trained model is only truly useful when other systems or users can interact with it easily. One of the most practical ways to do this is by exposing the model through an API.

While working on an open-source AI research project, I had the opportunity to build a prediction API using FastAPI. The goal was simple: allow users to send input data and receive predictions from the model quickly and reliably. During this process, I learned several useful lessons about building clean, maintainable AI APIs.

Why FastAPI?

FastAPI has quickly become one of the most popular frameworks for building APIs in Python. It is particularly well suited for machine learning and AI projects.

A few reasons why FastAPI works well for AI systems:

It is fast and lightweight
It works naturally with Python-based ML frameworks
It provides automatic documentation
It includes strong input validation

For machine learning workflows where models are already written in Python, FastAPI provides a simple and efficient way to turn those models into services.

Basic Architecture of an AI Prediction API

At a high level, the architecture of a prediction API is straightforward. A user sends data to the API, the API processes the request, the model generates a prediction, and the response is returned.

The workflow typically looks like this:

User → API Request → Model Prediction → Response

In practice, the API needs to handle several tasks, including validating inputs, loading the model, and returning structured outputs.

A Simple Example

Below is a minimal example of a FastAPI prediction endpoint.

from fastapi import FastAPI
app = FastAPI()
@app.get("/predict")
def predict():
result = "sample prediction"
return {"prediction": result}

This example is simple, but it demonstrates the core idea. The API exposes an endpoint, processes a request, and returns a structured response.

In real applications, this endpoint would load a trained model and run inference using the provided input data.

Lessons Learned
While building this system, a few best practices became very clear.

Input validation is essential

APIs should never assume that incoming data is valid. FastAPI’s built-in validation tools help ensure that requests contain the correct data types and structure.

This prevents many errors before they reach the model itself.

Keep the API separate from the model logic

It is important to separate the model implementation from the API layer. This keeps the code organized and makes the system easier to maintain.

For example:

Model code handles predictions
API code handles requests and responses

Automate formatting and testing

In open-source projects, maintaining code quality is important. Tools such as:

Black (for formatting)
Flake8 (for linting)
GitHub Actions (for CI)
help ensure that code remains consistent across contributors.

Clear documentation improves collaboration

One thing I noticed quickly is that good documentation makes a huge difference. When other developers can understand how the API works and how to interact with it, collaboration becomes much smoother.

FastAPI automatically generates interactive API documentation, which is incredibly helpful for testing and onboarding new contributors.

Final Thoughts

Building an AI model is only one part of the process. Making that model accessible through a clean and reliable API is what allows it to be integrated into real systems.

FastAPI provides an excellent framework for this purpose. Its simplicity, performance, and strong Python ecosystem make it a great choice for AI and machine learning projects.

For developers working on AI systems, learning how to expose models through APIs is a valuable skill that bridges the gap between research and real-world applications.

Forem: Mainuddin

Beyond the Code: Mentoring the Next Generation of Engineers at Six Flags

Building an AI Prediction API with FastAPI: Lessons from an Open Source Project