When you visit a website, use a mobile application, or explore someone's GitHub profile, what do you usually see?

You see the final output. A beautifully designed interface, a working application, a collection of repositories, or perhaps an impressive project that solves a particular problem.

But have you ever wondered what goes into creating all of that?

Behind every website or application, there is a developer who has spent hours understanding problems, reading documentation, debugging errors, testing assumptions, making decisions, and sometimes questioning whether their approach is even correct.

And beyond all these technical activities, there are certain habits and ways of thinking that gradually shape the developer.

Most of these things never appear in a portfolio. You won't find a section showcasing how patiently someone debugged an issue for three hours, how many times they read the documentation before understanding a tool, or how many different approaches they considered before settling on one solution.

That made me think about something interesting: What if becoming a good developer is a little like an iceberg?

The Invisible Architecture of a Developer: an iceberg illustrating visible outputs, development processes, technical thinking, and the habits that shape a developer

The Invisible Architecture of a Developer: Illustration by me (Source)

We usually notice only the small portion of an iceberg that appears above the water. The much larger portion remains submerged beneath the surface.

I wanted to use this symbolism to represent a developer's journey. The top of the iceberg represents what people can see, while everything beneath the water represents the work, thinking, and personal habits that make those visible results possible.

I actually came up with the idea for this illustration while thinking about the article. I wanted something that could communicate the concept visually instead of simply listing different developer skills.

Even the colours, arrows, icons, and text in the illustration have a purpose. Each layer represents a different part of becoming a developer.

So let's start at the top and gradually move towards the deepest part of the iceberg.

🏔️ 1. Above the Surface: The Visible Output

Let's start with the tip of the iceberg.

In my illustration, the top section contains a white arrow pointing towards the words Website, App, GitHub Repositories, and Output. There is also a laptop and globe icon representing the digital products and experiences we create.

This is the part of development that everyone can easily notice.

Think about the things we usually associate with a developer:

  • Websites and web applications.
  • Mobile applications.
  • GitHub repositories.
  • Completed projects.
  • Features and working products.
  • Live demos and technical achievements.

These are the outputs we showcase in our portfolios, resumes, GitHub profiles, and professional conversations.

Someone visits your website, explores your application, or looks at your GitHub repositories and gets an idea of what you have built.

And there is absolutely nothing wrong with showcasing these things. They matter. A working project demonstrates that you can turn an idea into something people can actually use.

But here's the interesting part: the output doesn't tell the complete story.

Two developers might build applications that look equally impressive on the surface. However, the thinking, decisions, problem-solving approaches, and habits behind those applications might be completely different.

What we see is the final result. We don't necessarily see the journey that produced it.

And that's where the iceberg begins to get interesting.

🌊 2. Just Below the Surface: The Development Process

Now let's move below the water.

In the illustration, the first submerged section is represented using white arrows, white icons, and white text. This layer represents the development process: everything that happens while turning an idea into a working product.

Imagine building a website. You don't simply open your code editor, write a few lines, and magically end up with a finished application.

There is a whole process involved. And some of the most time-consuming parts aren't even about writing new code.

Let's look at a few of them.

Debugging: You write code, run your application, and suddenly something doesn't work as expected.

Maybe your JavaScript isn't rendering the content correctly. Maybe a heading is appearing in the centre when you expected it to be aligned to the left. Perhaps your right-side text isn't justified, an element is overflowing, or a particular feature behaves differently on mobile.

Now you have to investigate.

You inspect the browser console, examine the HTML and CSS, check the JavaScript execution, and try to identify where the actual problem is coming from.

Sometimes the issue is a tiny mistake. Sometimes it takes much longer to identify. The important thing is not to keep changing random lines of code and hoping something works.

You need to understand what is happening before deciding what to fix.

If you enjoy exploring practical debugging techniques, I have also written a separate article about it:

Debugging Tips: Approaches to Finding and Fixing Errors

Documentation: Another important part of development is reading documentation.

Suppose you want to use a new JavaScript library, integrate an API, or introduce a tool into your project. You first need to understand what that tool does, how it works, what methods it provides, and how to use it correctly.

That is where documentation becomes important.

Instead of depending entirely on random tutorials or copying code from somewhere, you learn to explore official documentation, understand examples, check parameters, and figure out how a particular feature works.

Sometimes you spend more time reading and understanding something than actually implementing it. And that's completely normal.

Testing: Writing code is one thing. Making sure it actually works is another.

Testing isn't limited to checking whether a button works or whether a page loads successfully. There are several things you need to consider depending on what you're building.

  • Functional testing: Does the feature behave as expected?
  • Responsiveness testing: Does the website work properly on different screen sizes?
  • Performance testing: Does the application load efficiently?
  • Compatibility testing: Does it behave consistently across different browsers and environments?
  • Accuracy testing: Does the system produce correct results for the intended inputs?

For machine learning models, testing can involve evaluating metrics such as accuracy, precision, and recall. For a website, it might involve checking responsiveness, accessibility, and functionality.

The kind of testing changes depending on the project, but the underlying idea remains the same: never assume something works just because you wrote the code.

Refactoring: This one is particularly interesting because I have experienced it quite a bit while developing my own projects.

When I initially started writing code, I used to put almost everything into one file. My HTML, CSS, and JavaScript would keep growing, and eventually the file would become unnecessarily long and difficult to manage.

At first, it feels convenient because everything is in one place. You don't have to think about where a particular piece of code belongs.

But as the project grows, things become messy. Finding a particular section becomes difficult, making changes becomes harder, and maintaining the code takes more effort.

That's when you realise that you need to reorganise things.

Refactoring means improving the internal structure of existing code without changing its intended functionality. You might separate code into smaller files, create reusable components, remove duplication, or simplify complicated logic.

It's not always about adding something new. Sometimes, making your existing code cleaner is equally important.

And there is much more involved in this layer:

  • Error handling.
  • API integrations.
  • Version control using Git.
  • Code reviews.
  • Understanding project requirements.
  • Researching unfamiliar tools and libraries.
  • Maintaining existing code.
  • Writing reusable and modular code.

These activities might not look particularly exciting from the outside. They don't always produce something that can be displayed in a portfolio.

But they are essential to building software that works reliably and can be maintained over time.

Personally, I think this is one of the first things you begin to understand as you spend more time developing. You realise that writing code is only one part of the job. A considerable amount of the work happens before, during, and after writing it.

And once you become comfortable with the development process, another layer starts to emerge.

🧠 3. Deep Underwater: The Thinking Behind a Developer

This is where things become even more interesting.

In my illustration, this section is marked by a yellow dotted line, yellow arrows, and yellow icons. It represents the thinking that goes behind the development process.

You can learn a programming language, understand its syntax, and become familiar with different frameworks. But when you encounter a completely unfamiliar problem, what helps you move forward?

It's your ability to think through the problem.

Let's explore the different parts of this layer.

Problem-solving: The first thing you need to do when you encounter a problem is understand what the actual problem is.

And sometimes, you even need to question whether the problem requires a solution in the first place.

For example, imagine you have an idea for a new feature on your website. Before immediately starting to implement it, ask yourself:

  • What problem am I actually trying to solve?
  • Does this problem affect my users?
  • Is this feature really necessary?
  • Is there already a simpler way to achieve the same result?

Once you understand the problem, you can break it into smaller pieces and work towards a solution.

Because sometimes we become so excited about building something that we forget to ask whether it actually needs to be built.

Critical thinking: Understanding a problem is important, but questioning your own assumptions is equally important.

You might have a solution in mind, but is it really the best approach? Are you considering all the possible scenarios? Are there limitations you haven't thought about?

Let's say you want to develop a new application. You might be excited about its features and technical possibilities, but have you considered whether there is an actual audience for it?

Will people use it? Does it solve a meaningful problem? Does the effort required to build and maintain it make sense?

These are not merely coding questions. They require you to think beyond the code itself.

Critical thinking helps you evaluate ideas, question assumptions, and make more informed decisions.

System design: This is another important part of becoming a developer.

When you start building something, you need to think about how different parts of your application will fit together.

How will your files communicate? Where should a particular piece of functionality live? How should the data be organised? Which parts can be reused? How will you maintain the project as it grows?

Let me give you an example from my own website.

My personal website uses Jekyll. When working with Jekyll, you begin to understand that a website isn't simply a collection of HTML pages. There is an underlying structure involving layouts, includes, data files, configuration, and individual content files.

Layouts help define the overall structure of pages. Includes allow you to reuse smaller pieces of HTML. Data files help organise information separately, while configuration controls different aspects of the website.

All these pieces work together to generate the final website.

Understanding how they communicate and where things belong is part of system design, even when you're working on a personal blog rather than a large-scale application.

I also wrote about my experience moving my personal website to Jekyll. If you're interested, you can read it here:

My Jekyll Migration Journey

Understanding trade-offs: Sometimes, the problem isn't that you don't know how to implement something. It's that you need to decide whether implementing it is worth the effort.

And this is something I have experienced while working on my own website.

There have been times when I wanted to redesign certain sections, restructure the website, or refactor parts of the code. I could see several things that could be improved.

But then I had to think about the amount of time and effort required to make those changes.

Would the improvement be significant enough? Would it make the website easier to use? Would it be worth spending that much time on it right now?

Sometimes, I decided not to proceed with the changes immediately.

And that's a trade-off too. You don't always have to implement every improvement you can think of. You need to understand your priorities and decide where your effort will make the most difference.

Trade-offs also appear in technical decisions. For example, in machine learning, increasing recall can sometimes come at the cost of precision, depending on the model and decision threshold. You might want to identify as many relevant cases as possible, but doing so could also increase false positives.

There isn't always one perfect answer. The right choice depends on the problem, the requirements, and what matters most.

Another important ability that connects all these areas is learning to ask better questions.

Instead of repeatedly asking, "Why isn't my code working?", you start asking:

  • What exactly did I expect to happen?
  • What is actually happening?
  • At which point does the behaviour become unexpected?
  • What assumptions am I making?
  • Can I reproduce the issue consistently?
  • Is my current approach unnecessarily complicated?
  • What evidence supports my current explanation?

Notice the difference. You're no longer randomly changing code and hoping something works. You're investigating, reasoning, and gradually narrowing down the possibilities.

And honestly, I think this is one of the most valuable transitions in a developer's journey: moving from simply knowing how to write code to understanding how to approach problems.

Because frameworks change. Programming languages evolve. New tools appear every year. But the ability to think critically, understand problems, and make informed decisions remains useful across technologies.

🔴 4. The Deepest Layer: Habits That Shape a Developer

Now we reach the deepest part of the iceberg.

In the illustration, this layer is represented by the red dotted line, red arrows, and red icons. It contains four things: adaptability, consistency, discipline, and continuous learning.

And I deliberately placed these at the deepest point because I believe they are among the most important qualities that shape a developer over time.

Let's understand why.

Adaptability: Technology never stays the same. You have new versions, new frameworks, new tools, and new ways of doing things. Something that works today might need to be replaced or improved tomorrow.

I'll give you an example from my own journey.

When I initially started creating my personal blog, I was quite comfortable working with plain HTML, CSS, and JavaScript. I could create pages, structure content, and make things work.

But as the website grew, I started noticing how repetitive the whole process was. I had similar structures appearing across different pages, and maintaining everything manually was becoming increasingly inconvenient.

That's when I started exploring Jekyll.

Of course, switching to something new wasn't immediately easy. I had to understand how Jekyll worked, learn about layouts, includes, front matter, collections, and configuration files. There were errors, things I didn't understand, and several moments when I had to go back and figure out what I was doing wrong.

But gradually, I became more comfortable with it.

That experience taught me something important: being comfortable with one technology shouldn't stop you from exploring another when your requirements change.

Adaptability means being willing to learn, experiment, and adjust your approach instead of remaining attached to the same tools forever.

Consistency: This is something I have started appreciating much more after spending around three years working on websites and learning web technologies.

When you first learn HTML, you might understand tags, elements, attributes, and the basic structure of a page quite quickly. You might even build a complete website within a short time.

But knowing how to write HTML and truly understanding how to use it well are two different things.

Over time, you start understanding semantic structure, accessibility, maintainability, document organisation, and how HTML interacts with CSS and JavaScript.

The same applies to almost every technology. You might learn the basic syntax of a programming language in a few days, but becoming comfortable with its ecosystem, understanding its deeper concepts, and knowing when to use particular features takes much longer.

It's a little like learning to ride a bicycle, drive a car, or ride a scooty. You might learn the basic controls relatively quickly, but becoming confident, understanding different situations, and developing real mastery takes practice.

You can learn the basics of a technology in a week. But understanding it deeply is a much longer journey.

And that's why consistency matters. You don't need to understand everything immediately. You need to keep learning, practising, and improving.

Discipline: Let's be honest. Development isn't always exciting.

There are days when your code works perfectly, your project progresses smoothly, and everything feels great.

And then there are days when you encounter one bug after another. Something breaks, an implementation doesn't work, an approach fails, and you spend hours trying to understand what went wrong.

Sometimes, you simply don't feel like continuing.

That's when discipline becomes important.

Discipline isn't about feeling motivated every day. It's about building habits that help you continue even when motivation is missing.

For example, setting aside time to practise coding, working on a personal project, solving problems, or maintaining a learning routine can help you make progress over time.

Even things like maintaining a GitHub contribution streak or a LeetCode streak can serve as small reminders to stay engaged with your learning goals.

Of course, a streak itself doesn't define your technical ability. Missing a day doesn't mean you've failed. The bigger idea is to develop the discipline to return to your work and keep improving.

And sometimes, discipline simply means sitting down, opening your code editor, and patiently investigating that one bug you've been avoiding.

Continuous learning: Finally, we have continuous learning.

Becoming a developer doesn't mean reaching a point where you know everything. There will always be unfamiliar concepts, new technologies, and better ways to approach existing problems.

You might be comfortable with HTML today, but tomorrow you might need to learn a JavaScript framework. You might understand frontend development, but a project could require you to explore backend development, databases, or cloud services.

And the learning doesn't stop when you finish a project.

Sometimes, completing a project teaches you what you should have done differently. Sometimes, debugging an issue introduces you to a concept you had never explored before. Sometimes, reading documentation leads you towards an entirely new area of technology.

That's the interesting thing about development: there is always something more to discover.

These four habits might not be directly visible in your code, but they influence how you approach your work, how you respond to challenges, and how you grow over time.

And that's why I consider this the deepest and perhaps the most important layer of the iceberg.

💡 The Invisible Architecture Exists Beyond Programming Too

While creating this illustration, I started thinking about something else.

What if this iceberg isn't just about developers?

Think about almost anything people achieve in life. We usually see the visible result: someone's career, a successful business, a completed project, a personal achievement, or a skill they have developed.

But we don't always see the invisible part behind it.

We see someone's success, but we don't necessarily see their difficult days, the struggles they went through, the failures they experienced, or the discipline required to keep showing up.

We see someone achieving something impressive, but we rarely see the consistency, patience, adaptability, and continuous learning that helped them reach that point.

The same idea applies to developers.

When someone builds an impressive application, we appreciate its design, features, and functionality. We see the final product and perhaps admire how well everything works.

But there are so many things behind that output. The hours spent debugging, the documentation they read, the approaches they discarded, the decisions they made, and the mistakes they learned from along the way.

And that's exactly what I wanted this iceberg to represent.

This illustration was my idea. I initially thought about the concept for this article and then decided to create a visual representation of it. I chose an iceberg because its structure perfectly captures the difference between what is visible and everything that remains hidden beneath the surface.

The white arrows, icons, and text represent the development process. The yellow layer represents the thinking and decision-making behind the code. And the red, deepest layer represents the habits and mindset that shape a developer over time.

For me, the biggest takeaway is that becoming a good developer isn't just about learning programming languages, collecting frameworks, or building an impressive portfolio.

Those things are important, but they are only part of the picture.

It's also about learning to ask better questions, developing the patience to debug, understanding how to design systems, questioning assumptions, making thoughtful trade-offs, and building the discipline to keep learning.

And most importantly, it's about developing qualities that remain useful even outside programming.

The code might be what people see, but the thinking and habits behind it are what help you keep growing.

"People see the product, but rarely the process, thinking, and habits that made it possible."

So, the next time you look at someone's impressive project, remember that there might be an entire iceberg beneath it.

And if you're a developer yourself, don't focus only on what you can showcase. Pay attention to the invisible parts you're building along the way, too.

Because sometimes, the most important architecture isn't the one you write in code. It's the one you develop within yourself.

What would you add to this iceberg? Which invisible quality do you think has made the biggest difference in your journey as a developer?

I would love to hear your thoughts!