Abstract thinking in programming is the ability to work with ideas you can't directly see or touch. A "user", a "payment" or a "server" in software isn't a physical thing. It is a model, a simplified picture that hides messy details so you can focus on what matters. Being comfortable with those models, and moving between levels of detail, is what we mean by thinking in layers.
TechDNA calls this trait Abstraction Tolerance. The word "tolerance" is deliberate. Many beginners find abstraction uncomfortable at first, because it feels vague. People who do well in technical roles learn to tolerate that discomfort until the picture becomes clear.
This article explains what abstraction looks like in practice, which roles need it most, and how you can get better at it.
What does "abstraction" actually mean?
Abstraction means hiding detail behind a simpler idea. You already use it every day.
When you send money with a banking app, you press "Transfer". You don't think about the networks, databases and security checks happening underneath. The button is an abstraction. It gives you a simple layer on top of something very complex.
Software is built from many layers like this:
- The user interface: what people see and tap
- The application logic: the rules, such as "a transfer can't exceed the balance"
- The data layer: where information is stored and retrieved
- The infrastructure: the servers, networks and operating systems underneath
Each layer only needs to know about the one next to it. That is what lets thousands of people work on huge systems without each person understanding every detail.
What is abstraction tolerance?
Abstraction tolerance is how comfortable you are reasoning about things that aren't concrete. People with high tolerance can hold a mental model, accept "I don't need to know how this works inside yet", and reason about how parts connect. People with lower tolerance tend to want to see and touch everything before they trust it. Both styles have value, but technical roles often require the first.
Why does thinking in layers matter in tech?
Without abstraction, nobody could build modern software. It matters for several practical reasons:
- It makes complexity manageable. You can focus on one layer at a time.
- It helps you learn faster. You can use a tool before you understand its internals, then dig deeper later.
- It helps you design. Good engineers decide what each part should hide and what it should expose.
- It helps you debug. When something breaks, you ask "which layer is this in?" and rule out the others.
Imagine a mobile app that shows the wrong account balance. Is the screen displaying it wrongly, is the logic calculating it wrongly, or is the stored data wrong? Thinking in layers turns one confusing problem into three smaller questions.
Which tech roles lean on abstraction most?
Of the nine roles TechDNA scores, these depend on abstraction tolerance most heavily:
- Backend Engineer. You design how data and logic are organised, often for systems with no visual interface at all.
- ML / AI Engineer. Models are mathematical abstractions. You reason about patterns in data that you can't see directly.
- DevOps / SRE. You work with virtual machines, containers, networks and cloud services, many layers removed from physical hardware.
- Security Engineer. You think about trust boundaries between layers and how an attacker might move between them.
Frontend Engineers also use abstraction, for example through reusable components, but they balance it with strong visual thinking. Data Analysts work with abstractions like data models and metrics. Product Managers need enough of it to understand how systems fit together without building them.
Roles like Frontend Engineer and QA Engineer often work closer to the concrete, real behaviour of a product, which can suit people who prefer things they can see and test.
If you'd like to know where you sit, you can take the free TechDNA assessment. It measures abstraction tolerance alongside seven other traits and suggests roles that match.
How do you build abstract thinking?
Abstract thinking improves with exposure and practice. These steps help.
1. Draw the layers
Pick an app you use daily, such as a ride-hailing or food delivery app. On paper, sketch what happens when you place an order: the screen, the request sent over the internet, the server, the database, the driver's app. You won't get it perfectly right, and that's fine. The exercise trains you to see systems as connected layers.
2. Learn how computers work, one level at a time
Harvard CS50 is a free course that starts at the lowest level (how computers represent information) and works upwards. It is one of the best ways to see abstraction in action. Techera's TechLearnX also has free foundation courses covering computing and Linux that build this picture step by step.
3. Write functions
In programming, a function is a small abstraction: you give it a name and a job, and then you use it without thinking about its insides. Practising with Python or JavaScript, using the Python.org tutorial or freeCodeCamp, helps you get comfortable creating and using your own abstractions.
4. Use analogies, then let them go
Analogies help at the start. A database is like a filing cabinet; an API is like a waiter taking your order to the kitchen. Use them to get started, but notice where they break down. That gap is where real understanding grows.
5. Read roadmaps to see the big picture
roadmap.sh shows how topics in each tech field connect. Seeing the whole map helps you place each new concept in its layer instead of treating everything as a separate fact.
6. Accept "black boxes" for now
You don't need to understand everything at once. Professionals use tools every day whose insides they have never studied. Give yourself permission to say "this layer handles that" and move on, then return later when you need to.
Common mistakes with abstraction
- Needing to understand everything first. This can stall your learning for months. Learn top-down, then go deeper.
- Getting lost in theory. Abstraction should make real problems easier. Always tie concepts back to something you can build or test.
- Over-abstracting. Experienced developers sometimes create too many layers. Simple and clear usually beats clever.
- Assuming discomfort means you can't do it. Feeling lost at first is normal. Clarity usually comes with repetition.
How does abstraction relate to other traits?
Abstraction tolerance pairs closely with analytical reasoning, since both involve working through ideas logically. If you find yourself thinking more in pictures than in layers, our article on tech careers for visual thinkers may be useful. And if you're comparing technical paths, our guide on frontend vs backend shows how much abstraction each side involves.
Frequently asked questions
Is abstract thinking the same as intelligence?
No. It is one particular way of thinking. Many very capable people prefer concrete, hands-on work, and plenty of tech roles reward that preference. Abstraction tolerance simply describes how comfortable you are working with unseen models.
Can I work in tech if abstraction feels hard?
Yes. Roles such as Frontend Engineer, QA Engineer and Product Manager stay closer to what users can see. Abstraction also becomes easier with practice, so a low starting point doesn't have to be permanent.
What is the fastest way to get better at abstract thinking?
There is no shortcut, but building small programs is very effective. Each time you create a function or organise code into parts, you practise abstraction. Pair that with a course like CS50 that explains how the layers fit together.
Do I need advanced maths to think abstractly?
Not for most roles. ML / AI Engineering does involve mathematical abstraction, but Backend, DevOps and Security roles rely more on logical models than on advanced maths.
Want to see how comfortable you are with abstraction compared with your other strengths? Take the free TechDNA assessment and find the tech roles that suit the way you think.