Suppose a set of tasks must be accomplished, and some sub-tasks must be completed before others. A topological sort gives an ordering that satisfies these requirements.

In daily life, a shirt is worn before a blazer, so “wearing a shirt” must come before “wearing a blazer” in any valid topological ordering.

Applications that process tabular data, spreadsheets, for example, allow cell values to be calculated using formulas that reference other cells. Before a cell’s value can be computed, the values of all cells it depends on must already be calculated. To do this correctly, the application builds a dependency graph and topologically sorts it, then evaluates each cell in that order.

This is exactly why circular references cause errors in spreadsheets: a cycle in the dependency graph means no valid topological ordering exists.

Topological sort is commonly implemented using depth-first search, though other approaches, such as Kahn’s algorithm, are widely used too.

This was my first professional experience, and it was a memorable one.

Location Solutions was a small business with close to 100 employees across all departments. The tech team, as far as I know, had just 5 people.

I was onboarded by the team lead, who explained what the company did and told me what I would be working on: a revamp of a legacy client-facing application that ingested data and provided reports to users. It was slow and needed new features.

I went through the existing application to understand what a user could do with it. I then put together a feature list combining the current requirements with new ideas and presented it to the team, receiving a positive response.

I was given a UI design from the design team. I then worked on the high-level and low-level system design, and once it was approved, built the application using Next.js on the frontend and Express on the backend.

A key part of this was implementing database join algorithms to execute in-memory joins on the application data. I also conducted comprehensive testing and debugging, and added unit tests to the core backend algorithms.

Before the general release, I showed the application to 5 internal teammates with client-facing support roles, selected as pilot users. They liked it and shared a few minor UX improvement suggestions.

It felt great to see my work make a real difference - the revamp reduced service time by close to 20%.

Working with the agile team was a great experience, and I came away with both technical and interpersonal growth.

The internship began with a structured learning phase - Java, Spring Boot, concurrency, and design principles - but I moved on to real ownership fairly quickly.

The project I’m most proud of is the webhooks I designed and delivered for our service platform, spanning multiple environments including pre-prod, prod, and prod-EU. I architected it as a modular, plug-and-play system, so onboarding a new webhook publisher takes minimal effort. It went on to become a core platform component powering critical async workflows for Hyundai and Ford integrations. Delivering it meant working closely with a partner team to align on shared design patterns and rollout timelines, which taught me a lot about collaborating across team boundaries.

I also took end-to-end ownership of the backend for a GM vehicle check-in feature, from design to delivery. The centerpiece was a screen-agnostic job-creation API - a single clean, reusable contract that serves every consuming screen without any per-screen logic.

Another big theme of my work has been Open APIs. I developed APIs for external integration consumers, which were key enabler for a Ford repair-order integration, and spent time stabilizing the Open APIs through enhancements and defect fixes so partners have a reliable contract to build against.

Not all of the work was greenfield. I identified and fixed critical defects in the warranty posting pipeline - issues with direct financial-accuracy impact for dealers. Beyond patching the bugs, I added upstream validation to reject invalid entries before they could propagate, and backed the fixes with automation test coverage to prevent regressions.

Along the way, I was an early adopter of AI-assisted development tools, and built structured workflows that I shared with my team - improving developer efficiency beyond just my own productivity.

The day-to-day stack is Java and Spring Boot, with Kafka, Redis, Elasticsearch, and MongoDB. It’s been a period of fast growth, and I’m looking forward to taking on more architectural responsibility as Tekion scales.