When people hear developer, they often imagine lines of code, algorithms, and technical jargon. But my journey didn't start with code - it started with design. As a teenager, I spent countless hours creating logos and visual identities on platforms like Freelancer.com.
What I didn't know at the time was that this creative background would later shape my approach to software development. Today, as a CTO, I still use the principles of design thinking I learned in my design days to build better applications, guide teams, and create products that users actually love.
From Logos to Logic
At 16, I started selling logos online. Designing wasn't just about making something pretty - it was about understanding what the client wanted to express:
- Who is the target audience?
- What emotion should the design trigger?
- How does the visual identity align with the brand's goals?
These same questions apply to development:
- Who will use the product?
- What problem does the app solve?
- How can we build something both functional and enjoyable?
That mindset naturally translated into my coding journey.
What is Design Thinking for Developers?
Design thinking is a human-centered approach to solving problems. For developers, it means not just writing code but designing experiences.
The core pillars:
- Empathize: Understand the user's needs.
- Define: Clarify the problem you're solving.
- Ideate: Explore multiple solutions.
- Prototype: Build quickly to test ideas.
- Test: Get feedback, iterate, and improve.
When applied to code, these steps prevent us from building features nobody uses.
How My Design Background Shapes My Code
Attention to Detail
Design taught me that small details matter. A pixel off in a logo could ruin balance. Similarly, in code, a poorly named variable or inconsistent API can break usability.
User-Centered Development
Designing logos forced me to put myself in the client's shoes. As a developer, I now naturally think about the end-user:
- Is this UI intuitive?
- Is this API clear for other developers?
- Is performance optimized for real-world use cases?
Visual Thinking → Better Architecture
Visual composition in design is about harmony. In coding, I see architecture the same way: modules, services, and components must flow together like elements of a good layout.
Creativity Meets Problem-Solving
Design is problem-solving with colors and shapes. Development is problem-solving with logic and code. Both require creativity. My early design work gave me the confidence to think outside the box when coding.
Practical Example: Building a UI with Design Thinking
Let's say we're building a multilingual form in a web app. Without design thinking, we might just throw together inputs and validation.
With design thinking:
- We first empathize: non-native users might struggle with French labels.
- We define: form needs to be bilingual (FR/EN at minimum).
- We ideate: multiple ways to switch languages (dropdown, auto-detect).
- We prototype: build a quick toggle.
- We test: real users confirm if the toggle is intuitive.
The result is not just a form - it's a thoughtful, user-friendly experience.
Lessons for Developers Who Want to Think Like Designers
- Always start with the user's perspective.
- Don't underestimate simplicity - minimal design, minimal code.
- Sketch or diagram solutions before coding - just like wireframing.
- Iterate quickly, don't aim for perfection from day one.
Conclusion
My journey from logo designer to CTO might seem unusual, but the truth is: design and development are deeply connected. The creativity, empathy, and problem-solving I learned through design still shape my code and leadership today.
If you're a developer, try to embrace design thinking. It's not about making things look pretty - it's about making things work beautifully.
