Two years ago, when I got my first freelance client, I was still in my final semester of college.
A guy approached me on LinkedIn because he wanted an app built for some gym equipment he was selling.
To this day, he’s probably one of the most professional people I’ve worked with.
And being the naive amateur I was, I thought the hard part would be building the product.
You know… the actual coding part.
The React Native components.
The backend logic.
The deployment.
The bugs.
That was the “real work” in my head.
Everything else felt secondary.
I was wrong almost immediately.
As the project progressed though, things actually started going surprisingly smoothly.
Which was honestly lucky because life outside the project was kind of falling apart at the same time.
I had just gone through a heartbreak, my final semester was ending, career uncertainty was sitting in the background constantly… and somehow in the middle of all that, I was building this app with my friend @hisukurifu. Really grateful for his support, even today.
Looking back, I think having work to focus on genuinely helped me hold myself together during that phase.
And somehow, despite all the chaos, the project itself stayed stable.
The client paid on time.
The scope stayed reasonable.
Communication stayed respectful.
Hell, the guy even paid for renting a Mac because we needed it to build the iOS version and neither of us owned one at the time 😭
At that point, freelancing looked very simple from the outside.
A client needs something.
You build it.
You get paid.
Everybody wins.
Clean. Logical. Straightforward.
At least that’s what Instagram reels and “How I Made $10k Freelancing” YouTube thumbnails had convinced me of.
Reality felt very different.
Because suddenly there were things nobody really talks about when you’re learning development.
Things like:
- figuring out what the client actually wants
- discussing timelines
- dealing with uncertainty
- deciding pricing
- revisions
- feature changes halfway through
- awkward conversations
- scope creep
- waiting for replies
- wondering if the project will even go through
And honestly?
At the beginning, all of that felt more overwhelming than the code itself.
But slowly, we figured things out as we went.
One thing I still remember is that I never made a written agreement with that client.
Everything was done through pure verbal trust.
And thank GOD he didn’t suddenly increase the scope or disappear halfway through because looking back now… yeah that could’ve gone very badly 😭
Guess some small part of the world is still rainbows and sunshine lol.
But around five months after that project ended, another client opportunity came up.
This time we actually started properly planning things out beforehand.
Discussions.
Requirements.
Agreement drafting.
And then after about a week…
the whole thing just ended abruptly because the project itself was still being aligned internally on their side.
Nobody’s fault honestly.
But that experience finally made something click for me.
I remembered one piece of advice a friend had given me during my freelancing phase:
“You don’t get lucky twice with clients. Make agreements beforehand.”
At the time, that sounded overly serious to me.
Like bro… we’re just building websites 😭
But eventually I understood what they meant.
Because the more I zoomed out on freelancing as a career path, the more I realized I wasn’t just building software.
I was managing:
- expectations
- communication
- trust
- uncertainty
The code was only one part of the system.
And honestly, that realization changed how I looked at work entirely.
The strange thing is… I thought this problem only existed in freelancing.
Then I entered corporate.
And somehow the exact same realization came back wearing formal clothes.
Before starting my job, I still had this very simplified mental image of software engineering.
I thought:
“Okay, now I’ll finally work in a proper engineering environment.”
Meaning:
- coding
- solving technical problems
- building systems
- learning architecture
And yes, those things do exist.
But again, there was this whole invisible layer nobody really prepares you for.
Things like:
- hierarchy
- communication styles
- meetings
- visibility
- asking questions correctly
- understanding team dynamics
- knowing when to speak
- knowing when not to
- learning how people actually work together
And once again, I realized:
The technical part was only one layer of the job.
Even learning Japanese started feeling the same way after I began using it professionally.
At first, language learning felt like:
vocabulary + grammar = communication
Simple.
Then workplace conversations arrived and suddenly communication became:
- timing
- confidence
- hierarchy
- context
- listening
- reading atmosphere
- adapting to people
Different field.
Same realization.
Even marketing ended up teaching me this.
I originally got into it thinking:
“Okay this is probably just posting content and promoting things.”
But behind that was:
- positioning
- audience psychology
- negotiations
- understanding attention
- figuring out why some things spread and others don’t
Again, the visible part was tiny compared to everything underneath.
And honestly, I think this pattern exists in almost every career.
From the outside, most professions look simple because we only see the visible output.
Everything is an iceberg.
We see:
- the deployed app
- the successful freelancer
- the polished presentation
- the fluent speaker
- the viral post
But we usually don’t see:
- uncertainty
- communication
- failed attempts
- invisible coordination
- emotional pressure
- relationships
- trust
- adaptation
The deeper you go into anything, the more human it becomes.
And I think that was the biggest surprise for me.
Not that coding was hard.
But that almost every meaningful thing around coding involved people.
Looking back, I think younger me believed careers were mostly about skills.
Now I think they’re more about people skills.
Technical systems.
Social systems.
Communication systems.
Even emotional systems sometimes.
And honestly? That realization used to overwhelm me a little.
Now I weirdly find it interesting.
Because it makes every field feel deeper than it first appears.
So yeah.
Turns out coding wasn’t “the job.”
It was just the most visible part of it.
And maybe that’s true for a lot more things in life than we realize.
I’m curious now though:
Have any of you had a similar realization after entering a field professionally?
Where the thing you thought was “the main skill” ended up being only a small part of the actual job?