Skip to content
JournalTORIS / FIELD NOTES

← Blog Project notes

From Frontend to Spring: Taking Ownership of What Happens Behind the Screen

On the Itda SM project I widened my scope to Spring and MyBatis, going from waiting on an API to explaining the whole data flow. A look back at that shift.

3 min read Read the Korean original

Joohwan Yu · Founder, Full Stack Developer

Toris · Published

Contents

After a period focused on React frontend work, I joined the Itda (잇다) SM project when the team was reorganized. I came to work on the Spring backend and MyBatis mappers as well, and my scope grew. What stayed with me more than adding a backend to my skills list was that the range of things I had to explain about what appears on screen had changed.

There were product decisions before the API response

When I only looked at the frontend, the center of my work was receiving response data and building the screen. Once I took on the backend, I had to follow what conditions the query uses to produce the same response, which states it excludes, and which permissions it checks. Even a single number on screen was produced through SQL conditions and service logic.

This experience helped when designing APIs. Because I had personally dealt with responses that are hard to assemble on the frontend, I could see what the consumer would have to recalculate. That said, endlessly creating a separate response for every screen was not the answer. I had to draw the line between convenience for the screen and consistency of the domain rules.

The cost of “seeing the whole thing”

I had to learn Spring’s dependency injection and service structure and MyBatis XML mappers on the job. Being able to touch both frontend and backend is flexibility, but it also meant I couldn’t gloss over either side. A correct SQL query is still a problem if the permission check is missing, and a correct API is still a problem if the UI hides failures and the user accepts a wrong result.

If I did it now, I would briefly trace each change in the order of screen, request, service, query, and response. The point isn’t to document all the code but to write down which layer is responsible for a rule. Before copying the same check into several places, I would decide where the final judgment lives.

What maintenance taught me about being done

On an operating project, a new feature being visible didn’t mean the job was finished. What existing users were doing had to keep working. My regret about the testing and error handling that were lacking at the time became clearer in this environment. If I did it again, I would check not only the path I changed but also the screens that share the same query or service.

This transition didn’t make me an expert in every field. What I gained instead is knowing where to follow the trail when a problem is outside the screen. More than the word “full-stack,” the change that matters to me is that I can now explain the flow of a single user action reaching the data and coming back to the screen.

Related post: The experience that led from Semware to Itda SM

Advertisement