Echelon Launch

Inspiration

As computer science and engineering students, we've experienced firsthand how frustrating opportunity discovery can be. Internships live on one platform, research positions are buried across university pages, scholarships appear in newsletters, and campus jobs or organizations are scattered across dozens of websites.

The problem isn't that students don't want opportunities. It's that finding the right opportunities takes an enormous amount of searching, filtering, and guesswork.

We started with a simple question:

What if discovering your next internship, research position, scholarship, or campus opportunity was as easy as swiping?

That's where Echelon came from.

Echelon is a personalized opportunity navigator built around one goal: instead of making students search through hundreds of listings, bring the opportunities most relevant to them directly to their phone.

What it does

Echelon creates a personalized feed of internships, research positions, jobs, fellowships, scholarships, organizations, hackathons, and other opportunities based on who a student is and where they want to go.

When a student joins Echelon, they can provide information about their interests, goals, skills, coursework, experience, and resume. Echelon uses that information to build a structured student profile and determine which opportunities are actually relevant to them.

Instead of scrolling through a traditional job board, users receive opportunities as swipeable cards.

Swipe left to pass.

Swipe right to save an opportunity.

Each recommendation includes more than just a title and description. Echelon analyzes the student's profile against the opportunity and surfaces information such as:

why the opportunity matches them
which skills and interests align
relevant career tracks
eligibility requirements
potential qualification gaps
location, compensation, time commitment, and deadline information

Saved opportunities are collected into a dedicated list where students can revisit them later. When they're ready to apply, Echelon opens the original application page directly in their browser.

Echelon also includes an AI career assistant that can learn additional information about a student's interests through conversation and use that context to improve their recommendations.

The result is less time searching and more time actually pursuing opportunities.

How we built it

We designed Echelon as a native iOS application backed by an AI-driven recommendation and data platform.

The iOS application is written in Swift and SwiftUI, giving us a fully native interface for onboarding, discovery, saved opportunities, and user profiles. We built the central discovery experience around an interactive card interface so evaluating an opportunity takes seconds rather than minutes.

Authentication is handled through Firebase Authentication. The mobile application sends the user's Firebase ID token to our backend, allowing every profile, recommendation, and saved opportunity to remain associated with the correct user without exposing backend credentials inside the app.

Our backend is built with Python, FastAPI, and Pydantic. FastAPI serves as the interface between the mobile client, our AI services, and our data layer, while Pydantic provides strict schemas for student profiles, opportunities, recommendations, and other data moving throughout the system.

We integrated the Google Gemini API throughout the recommendation pipeline.

When a student uploads a resume, Gemini analyzes the document and converts unstructured resume content into a structured profile containing information such as skills, coursework, experience, interests, major, and class year.

Gemini is also used to understand and normalize opportunity data and to rerank promising opportunities based on the student's profile. Rather than returning an unexplained similarity score, Echelon generates a human-readable reason describing why a specific opportunity may be relevant.

For our data platform, we integrated Databricks. Opportunity information, student profiles, recommendation data, and interaction history are structured for persistence through Databricks-backed services. Our ingestion pipeline collects opportunities from multiple sources, validates them, normalizes inconsistent listing formats into a common schema, and prepares them for the recommendation system.

Our recommendation pipeline combines several stages rather than relying entirely on an LLM:

Authenticate the student and retrieve their profile.
Load candidate opportunities from our data layer.
Run candidates through our eligibility engine.
Compare skills, interests, and career-track alignment.
Retrieve the strongest candidates.
Rerank those candidates using Gemini.
Generate personalized match explanations.
Send the final opportunity cards to the iOS application.

We deliberately separated eligibility, retrieval, and generative AI rather than asking an LLM to make every decision. This made the system more predictable while still letting Gemini handle the parts it is particularly good at: understanding messy human data and explaining semantic relationships.

We also created the Echelon Agent, a conversational Gemini-powered assistant that can interpret additional career preferences from natural-language conversations and incorporate that information into the student's profile.

Our primary stack includes Swift, SwiftUI, Python, FastAPI, Pydantic, Firebase Authentication, Google Gemini, and Databricks.

Challenges we ran into

One of our biggest challenges was connecting several very different systems into one coherent pipeline.

Our application wasn't simply an iOS frontend connected to a database. A single recommendation could involve authentication, profile retrieval, eligibility logic, normalized opportunity data, AI processing, backend validation, and mobile rendering.

Keeping the contracts between those components synchronized became extremely important. We created explicit API models and shared data structures so that the Swift frontend and Python backend agreed on exactly what an opportunity, student profile, and recommendation should contain.

Authentication presented another challenge. We needed Firebase to authenticate users on iOS while still making FastAPI the security boundary for Gemini and Databricks. We solved this by validating Firebase ID tokens server-side and deriving the student's identity from the authenticated token rather than accepting arbitrary user IDs from the client.

Opportunity data was another major problem. Real listings are extremely inconsistent. One source may describe an opportunity by major, another by skills, another by degree level, and another only through paragraphs of text. We built an ingestion and normalization layer that converts those listings into a canonical opportunity model before they enter the recommendation system.

We also had to determine where AI actually improved the product and where traditional software was more reliable. It was tempting to send everything directly through Gemini, but eligibility rules and structured filters need deterministic behavior. We ultimately built a hybrid system where programmatic filters narrow the search space and Gemini handles semantic understanding, reranking, resume interpretation, and personalized explanations.

Finally, developing a native iOS application as a team introduced its own workflow challenges. Parts of the project were developed across Windows and macOS machines while the final SwiftUI application required Xcode and Apple tooling. Maintaining a clean separation between frontend and backend development allowed the team to continue working in parallel while integrating through documented API contracts.

Accomplishments that we're proud of

We're proud that Echelon became much more than a swipe interface placed on top of a list of jobs.

We built an end-to-end architecture that can take an unstructured student resume, understand the student's background, transform that information into a structured profile, retrieve relevant opportunities, evaluate eligibility, rank candidates, explain those recommendations, and deliver them through a native mobile experience.

We're particularly proud of our recommendation system. Rather than returning opportunities simply because they contain the same keywords as a resume, Echelon considers multiple dimensions of fit, including skills, interests, career direction, academic background, and eligibility.

We also built Echelon around explainability. Every recommendation should answer an important question:

"Why am I seeing this?"

Giving students an understandable reason behind a recommendation makes the system significantly more useful than a black-box ranking algorithm.

We're also proud of integrating Gemini and Databricks as complementary technologies rather than isolated hackathon features. Gemini handles unstructured information and semantic reasoning, while Databricks provides the foundation for storing, organizing, retrieving, and scaling the opportunity data that powers the platform.

Finally, we built the application with a real product architecture in mind. Authentication, data models, backend APIs, ingestion, recommendation services, native mobile views, and testing are separated into modular components that can continue growing beyond the hackathon.

What we learned

Building Echelon taught us that recommendation systems are fundamentally data problems as much as they are AI problems.

A powerful model doesn't help very much if the underlying opportunity data is incomplete, inconsistent, outdated, or impossible to compare. We spent significant effort thinking about canonical schemas, eligibility rules, data ingestion, and how to represent career interests in a form that machines could reason about.

We also learned that LLMs are most useful when they are given a clearly defined responsibility. Gemini performed extremely well when we used it for tasks like extracting structured information from resumes, interpreting natural language, understanding semantic relationships, and generating explanations. Traditional software remained the better choice for authentication, validation, deterministic eligibility rules, and API contracts.

Building the project also gave us experience designing systems across several layers at once: native iOS development, REST APIs, authentication, data engineering, AI integration, recommendation systems, and cloud infrastructure.

Most importantly, we learned how difficult it is to turn a good AI demo into an actual product. The interesting part isn't simply calling a model API. The real engineering happens in everything surrounding it: deciding what context the model receives, validating what comes back, connecting it to live data, protecting credentials, handling failures, and turning the result into an experience someone would actually want to use.

What's next for Echelon

Our long-term goal is to turn Echelon into a continuously improving opportunity discovery platform for students.

The first step is expanding our ingestion system to cover significantly more sources both inside and outside Virginia Tech. Research labs, campus organizations, scholarships, fellowships, university employment, startup internships, traditional job boards, hackathons, and external programs could all feed into the same personalized discovery system.

We also want recommendations to become increasingly adaptive. Swipes provide valuable feedback: when a student consistently likes embedded-systems research but passes on web-development internships, Echelon should learn from that behavior and adjust future recommendations accordingly.

Future versions of Echelon could also introduce:

deadline reminders and push notifications
application-status tracking
richer preference controls
opportunity collections and sharing
improved semantic search
continuously refreshed opportunity feeds
calendar integration for deadlines and events
career-path visualization
recommendation feedback loops based on swipe behavior
additional university and geographic ecosystems
broader mobile and web availability

We also see Echelon becoming more proactive. Rather than only answering "What opportunities fit me today?", it could eventually help answer:

"What should I do next to become qualified for the opportunities I want tomorrow?"

That means identifying missing skills, recommending coursework or projects, tracking progress, and connecting students with opportunities at the right point in their academic journey.

Our vision for Echelon is simple: students shouldn't have to know exactly where to look in order to find the opportunities that could change their careers.

Echelon brings those opportunities to them.