<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kamil İşler on Medium]]></title>
        <description><![CDATA[Stories by Kamil İşler on Medium]]></description>
        <link>https://medium.com/@kmlisler?source=rss-15df87d1d0f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Xu2eyStcab7lPi_kzwoG7g.png</url>
            <title>Stories by Kamil İşler on Medium</title>
            <link>https://medium.com/@kmlisler?source=rss-15df87d1d0f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 12:05:46 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kmlisler/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[1. What Makes an Application Data-Intensive?]]></title>
            <link>https://kmlisler.medium.com/1-what-makes-an-application-data-intensive-06bd01db105d?source=rss-15df87d1d0f------2</link>
            <guid isPermaLink="false">https://medium.com/p/06bd01db105d</guid>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[data-engineering]]></category>
            <dc:creator><![CDATA[Kamil İşler]]></dc:creator>
            <pubDate>Thu, 09 Jul 2026 16:18:23 GMT</pubDate>
            <atom:updated>2026-07-09T16:18:23.626Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Why modern applications are less about raw computation and more about data volume, complexity, movement, and trust.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6bh1IrQwDTIdrDxa7sN4FA.png" /></figure><p>In the previous article, I wrote about why data systems matter more in the age of AI. This article takes one step back and asks a simpler question: what actually makes an application data-intensive?</p><p>The answer is not just “a lot of data.” A system can become data-intensive because the data is large, but also because it is complex, constantly changing, shared across teams, or used by many different parts of the product.</p><p>This distinction matters because it changes how we design software. The hard part is no longer only writing code that computes a result. The hard part is designing the path through which data is created, stored, moved, transformed, queried, observed, and trusted.</p><h3>Compute-intensive vs Data-intensive</h3><p>Not all hard software problems are hard in the same way.</p><p>In compute-intensive applications, the main bottleneck is usually CPU or GPU power. The challenge is to perform expensive calculations efficiently. Video rendering, simulations, cryptographic workloads, and model training jobs are good examples.</p><p>In data-intensive applications, the bottleneck is different. Raw CPU power is rarely the main problem. The larger challenge is data itself: how much of it exists, how complicated it is, and how quickly it changes.</p><p>Think about an e-commerce order system. It may not perform heavy mathematical computation. But it has to deal with orders, payments, stock movements, customer events, delivery states, campaign rules, refunds, analytics, and reporting. The difficulty comes from keeping all of these data flows correct and useful over time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4OaPk5PDw0DB4bYAoXdoxg.png" /><figcaption><em>Figure 1. Compute-intensive and data-intensive applications require different design lenses.</em></figcaption></figure><p><strong>The three signals: volume, complexity, and change speed</strong></p><p>A simple way to recognize a data-intensive system is to look for three signals: data volume, data complexity, and change speed. Data volume is the most obvious signal. The system has many records, events, files, logs, or long histories that cannot be handled comfortably with a naive approach.</p><p>Data complexity is usually more interesting. The same entity may appear in different systems with slightly different meanings. One team may say customer, another team may say user, another team may say account. If nobody agrees on what the data represents, the system becomes difficult to evolve.</p><p>Change speed is the third signal. Some data changes slowly, like a product category. Some data changes continuously, like clickstream events, order statuses, inventory levels, or fraud signals. When data changes quickly, the system must keep derived views fresh without losing correctness.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/1*L5i0n0BE-ndhp48pPCf6xA.png" /><figcaption><em>Figure 2. Volume, complexity, and change speed are the three common signals.</em></figcaption></figure><p>A data-intensive application is usually a composition. A growing application is rarely built with a single component. Different needs appear at different points in the product.</p><ul><li>We need to store operational data.</li><li>We need to speed up reads.</li><li>We need to search text.</li><li>We need to move events asynchronously.</li><li>We need to run batch jobs.</li><li>We need to process streams.</li><li>We need to serve analytics.</li><li>We need to monitor whether the whole system is healthy.</li></ul><p>That is why modern applications often combine databases, caches, search indexes, message brokers, batch processors, stream processors, data warehouses, and observability tools. Each one solves a different problem. Each one also introduces a new trade-off.</p><p>A cache can make reads faster, but now we need to think about cache invalidation. A search index can make discovery easier, but now we need to keep it in sync with the main database. A message broker can decouple services, but now we need to handle retries, duplicate messages, ordering, and backlogs.</p><p>This is the point where application development becomes data system design. Once we combine several tools and expose them as one product experience, we are responsible for the behavior of the whole system, not only for the individual components.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KGQE40TsnuKWdIdQlB_e6A.png" /><figcaption><em>Figure 3. A data-intensive application is usually a composition of specialized data systems.</em></figcaption></figure><p>The hard part is not choosing tools. When engineers discuss data architecture, the conversation can quickly become tool-first: Should we use Kafka? PostgreSQL? MongoDB? BigQuery? Spark? Airflow? A vector database?</p><p>These are useful questions, but they should not be the first questions.</p><p>The better starting point is system behavior. What is the source of truth? How fresh does this data need to be? What happens if the same event is processed twice? Which parts can be eventually consistent? How do we recover after a failed job? Which team owns this data? What business concept does this table, topic, or API actually represent?</p><p>Tools matter. But tools are only useful when we understand the problem they are supposed to solve. Good design starts with the guarantees we need, the trade-offs we accept, and the failure modes we are ready to handle.</p><p>This also protects us from unnecessary complexity. Not every application needs Kafka. Not every analytics problem needs streaming. Not every search problem needs a new database. A strong engineer is not the person who always chooses the most advanced tool, but the person who understands the cost of each tool.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wEhRcOBlVa6CKjlw5aWOFQ.png" /></figure><h3>Domain thinking is part of data architecture</h3><p>There is one more point that is easy to miss: data architecture is not only about storage and processing. It is also about meaning.</p><p>A table is not just a table. A Kafka topic is not just a stream. An API response is not just JSON. A feature is not just a column. Each one represents something in the business domain: customer, order, payment, product, session, inventory, campaign, recommendation, or risk score.</p><p>If these concepts are unclear, the system becomes harder to understand every month. Teams start using the same words with different meanings. Pipelines become difficult to maintain. Dashboards become hard to trust. AI layers built on top of this data inherit the same confusion.</p><p>This is why domain modeling belongs in the conversation. Good data systems are not only technically correct. They also reflect the business concepts they are supposed to support.</p><h3>Key takeaway</h3><p>A data-intensive application is one where the main challenge comes from data, not raw computation. The challenge may be data volume, data complexity, change speed, or the need to combine several data systems into one reliable product experience.</p><p>In the age of AI, this distinction becomes even more important. Many meaningful AI products depend on data freshness, correctness, observability, domain clarity, and scalable architecture.</p><p>So before asking which model, tool, database, or framework to use, we should ask a more fundamental question: what kind of data system are we designing?</p><p>That question will guide the next articles in this series.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=06bd01db105d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Don’t Just Manage Time. Design Your Direction.]]></title>
            <link>https://kmlisler.medium.com/dont-just-manage-time-design-your-direction-04f39ccd48de?source=rss-15df87d1d0f------2</link>
            <guid isPermaLink="false">https://medium.com/p/04f39ccd48de</guid>
            <category><![CDATA[time-management]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[system-architecture]]></category>
            <category><![CDATA[data-engineering]]></category>
            <dc:creator><![CDATA[Kamil İşler]]></dc:creator>
            <pubDate>Thu, 18 Jun 2026 09:58:31 GMT</pubDate>
            <atom:updated>2026-06-18T09:59:51.247Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IK-mWr-PHTPRW5FAfsO3Kg.png" /></figure><h3>A Strategic Work Model for Engineers, Inspired by Atatürk</h3><h3>What This Article Covers</h3><p>Before diving in, here is what this article will cover:</p><ul><li>Why being busy is not the same as making real progress</li><li>Why a to-do list alone is not enough for meaningful work</li><li>How Atatürk’s disciplined way of thinking can inspire a modern work model</li><li>The five steps of the <strong>Strategic Time System</strong>: Direction, Discovery, Classification, Execution, Reflection</li><li>How engineers can use this model to learn better, prioritize better, and build a more sustainable working system</li><li>A simple weekly practice you can apply without making your productivity system unnecessarily complex</li></ul><p>In this article, I will describe a work model I call the <strong>Strategic Time System</strong> — or, in Turkish, <strong>Kurmay Zaman Sistemi</strong>. It is inspired by the disciplined working principles associated with Mustafa Kemal Atatürk and adapted to the way modern engineers think, learn, prioritize, and execute.</p><p>The reason I draw inspiration from Atatürk is not only that he was the founding leader of modern Türkiye, but also that he was more than a commander and statesman. He was a disciplined thinker, a lifelong learner, and a reformer who placed reason, science, education, and intellectual development at the center of progress.</p><p>One of his most powerful statements captures this mindset:</p><blockquote>“Hayatta en hakiki mürşit ilimdir, fendir.”</blockquote><blockquote><em>“The truest guide in life is science.”</em></blockquote><blockquote>— Mustafa Kemal Atatürk</blockquote><p>When we talk about time management, we usually hear the same advice:</p><ul><li>Wake up early.</li><li>Divide your day into time blocks.</li><li>Use Pomodoro.</li><li>Put your phone away.</li><li>Make a to-do list.</li></ul><p>All of these can be useful. But especially in disciplines like software engineering and product development, the real problem is often not a lack of effort. The real problem is working on the wrong things, in the wrong order.</p><p>You can have an incredibly busy day. You join meetings, answer messages, close a few small tasks, read some documentation, write a bit of code. At the end of the day, you feel tired — but one question remains:</p><blockquote><em>What actually moved forward today?</em></blockquote><p>That question matters. Because being busy and making progress are not the same thing.</p><p>The <strong>Strategic Time System</strong> is built around a simple idea: time should not be treated as empty space to be filled, but as a strategic resource to be directed.</p><p>It consists of five steps:</p><blockquote><em>Direction → Discovery → Classification → Execution → Reflection</em></blockquote><p>In simpler terms:</p><blockquote><em>Know where you are going. Gather information. Separate the work. Put it on the calendar. Then review it in writing.</em></blockquote><h3>Why a to-do list is not enough</h3><p>A to-do list feels comforting. You take everything out of your head, put it into a list, and check things off one by one. But a list does not give you strategy.</p><p>On the same list, you might have:</p><ul><li>Learn a new technical topic</li><li>Update your CV</li><li>Exercise</li><li>Fix a bug</li><li>Write a blog post</li><li>Reply to emails</li><li>Research a new framework</li><li>Read a book</li><li>Build a project</li></ul><p>They appear side by side, as if they all carry the same weight. But they don’t. Some tasks are urgent but create little long-term value. Some are not urgent today, but they may shape your career. Some look like they should be done, but should actually be deleted. And some are simply someone else’s urgency.</p><p>Good time management is not about doing more things. It is about knowing what to consciously say no to.</p><h3>1. Direction: First, define where you are going</h3><p>One of the first principles we can take from Atatürk’s way of thinking is this:</p><blockquote><em>The larger objective comes first.</em></blockquote><p>Daily tasks only become meaningful when they are connected to a bigger direction. This is true in life, and it is also true in an engineering career.</p><p>“I want to become a better developer” is a good intention, but it is not enough to guide daily decisions. A better question is:</p><blockquote><em>In the next three months, in which area do I want to create visible progress?</em></blockquote><p>Instead of saying:</p><blockquote><em>I want to get better at backend development.</em></blockquote><p>We can make it more concrete:</p><blockquote><em>In the next 12 weeks, I want to improve my system design, clean code, and production problem-solving skills.</em></blockquote><p>That goal should also have concrete outputs:</p><ul><li>Write 2 technical articles</li><li>Build 1 small project</li><li>Prepare 1 architecture decision document</li><li>Do 2 deep work sessions every week</li><li>Turn what I read into short technical notes</li></ul><p>The real difference is this:</p><blockquote><em>We are not talking about intention. We are talking about output.</em></blockquote><p>Because in engineering, learning does not happen only by reading. It becomes lasting when you turn what you read into a decision, a piece of code, a document, a design, or an explanation.</p><h3>2. Discovery: Understand before you rush</h3><p>Many people confuse time management with speed. But working quickly on the wrong thing is still a waste of time.</p><p>When we face a problem, it is tempting to jump straight into solving it. But good engineering usually starts with understanding the problem properly.</p><p>We need to ask questions such as:</p><ul><li>Why is this feature being requested?</li><li>What does the user actually need?</li><li>Why did this bug happen?</li><li>Why has this system become complicated?</li><li>Does this task really need to be done today?</li><li>What decision will this reading help me make?</li></ul><p>That is why the discovery phase matters. A weak study plan looks like this:</p><blockquote><em>This week, I will read about microservices.</em></blockquote><p>A better version is:</p><blockquote><em>This week, I will understand when microservices are useful and when they create unnecessary complexity. At the end, I will write a one-page note.</em></blockquote><p>In the first version, you consume a topic. In the second version, you produce thought.</p><p>The output does not have to be big. Sometimes it is a note, a diagram, a small code example, or even a simple decision like:</p><blockquote><em>This technology is not necessary for my current problem.</em></blockquote><p>That is still an output. Because it saves you from spending time in the wrong place.</p><h3>3. Classification: Not every front can be the main front</h3><p>My favorite idea in this model is the concept of a “front.”</p><p>In life and career, many areas can be important: technical growth, work performance, health, English, networking, family, finance, writing, building projects… But they cannot all be the main front at the same time.</p><p>Trying to improve everything at once usually means making real progress in nothing. So for each period, we should ask ourselves:</p><blockquote><em>What is my main front right now?</em></blockquote><p>For example:</p><ul><li>Main front: Strengthening my software engineering fundamentals</li><li>Supporting front: Writing technical articles</li><li>Protected front: Health and sleep</li></ul><p>This simple distinction reduces distraction. Now, whenever a new task appears, you can ask:</p><blockquote><em>Does this serve my current main front?</em></blockquote><p>If it does not, maybe it should be postponed, delegated, reduced, or removed completely.</p><p>At this point, the <a href="https://thedecisionlab.com/reference-guide/management/the-eisenhower-matrix"><em>Eisenhower Matrix</em></a> can also help:</p><ul><li>Urgent and important tasks should be handled immediately.</li><li>Important but not urgent tasks should be scheduled.</li><li>Urgent but low-value tasks should be reduced when possible.</li><li>Neither urgent nor important tasks should be removed.</li></ul><p>Career growth is often hidden inside the “important but not urgent” area:</p><ul><li>Reading books</li><li>Learning to write better code</li><li>Practicing system design</li><li>Improving English communication</li><li>Writing technical articles</li><li>Completing a project from beginning to end</li></ul><p>If you don’t do these today, nobody will call you and ask why. But months later, these are often the things that create the biggest difference.</p><h3>4. Execution: If it is not on the calendar, it is still just an intention</h3><p>The easiest way to understand whether a goal is real is to look at your calendar. If you say, “I will write this week,” but there is no time reserved for writing, it is not yet a plan. If you say, “I will study system design this month,” but you have not decided which day, which time, and which topic, it is still only a wish.</p><p>The execution step is simple:</p><blockquote><em>Put important work on the calendar.</em></blockquote><p>For example:</p><ul><li>Monday, 20:30–21:30: Read a technical topic and take notes</li><li>Wednesday, 20:30–22:00: Work on a project</li><li>Saturday, 10:30–12:00: Draft a blog post</li></ul><p>But be careful: the goal is not to fill every empty space in your calendar. Life does not follow the plan perfectly. Work takes longer than expected. Energy drops. Something urgent appears. An unexpected problem interrupts your day. That is why a good plan leaves space.</p><p>Another important point is that not every task needs the same working style.</p><p><a href="https://www.todoist.com/tr/productivity-methods/pomodoro-technique"><em>Pomodoro</em></a> can be useful for:</p><ul><li>Small tasks you struggle to start</li><li>Editing</li><li>Short reviews</li><li>Replying to emails</li><li>Simple task cleanup</li></ul><p>But some work requires longer focus:</p><ul><li>Writing a technical article</li><li>Understanding a difficult bug</li><li>Thinking through architecture</li><li>Learning a new topic deeply</li><li>Making meaningful progress on a project</li></ul><p>These usually work better with 60–90 minute focus blocks. So the point is not just to divide time. The point is to choose the right focus format for the nature of the work.</p><h3>5. Reflection: You cannot improve what you do not write down</h3><p>Written reflection had an important place in Atatürk’s way of working. I think this is just as critical for modern knowledge workers. Because the human mind is not very good at objectively measuring its own progress.</p><p>Sometimes you feel like you did very little, but you actually crossed an important threshold. Sometimes you feel like you worked a lot, but produced very little concrete output. That is why a short daily reflection helps.</p><p>At the end of the day, four questions are enough:</p><ul><li>What moved forward today?</li><li>Where did I get stuck?</li><li>What is the first thing I will do tomorrow?</li><li>What was the most important thing I learned today?</li></ul><p>At the end of the week, we can zoom out a little:</p><ul><li>What did I produce this week?</li><li>Which tasks served my goal?</li><li>Which tasks consumed time but created little value?</li><li>What will I change next week?</li></ul><p>The purpose of this reflection is not to judge yourself. The purpose is to improve the system. Saying “I am lazy” is easy, but not very useful. A better question is:</p><blockquote><em>Where did my system break?</em></blockquote><p>We can unpack that question like this:</p><ul><li>Was my goal unclear?</li><li>Did I start too many things at once?</li><li>Did I fail to leave realistic space in my calendar?</li><li>Did my phone and notifications break my focus?</li><li>Did I connect my reading to output?</li><li>Did I spend energy on the wrong front?</li></ul><p>These questions do not blame you. They improve your working system.</p><h3>Why this model matters from an engineering perspective</h3><p>Good systems in software and data need three things:</p><ul><li>They should be reliable.</li><li>They should be able to grow.</li><li>They should be maintainable.</li></ul><p>A personal working system is similar. It should be reliable; it should not collapse completely when motivation drops. It should be able to grow; it should not overwhelm you as your responsibilities increase. It should be maintainable; it should not be so complicated that you abandon it after two weeks.</p><p>That is why a good time management system does not need to be fancy. In fact, it should not be. It should be simple, written, repeatable, realistic, and easy to improve week by week. This is the strength of the Strategic Time System. It does not depend on a temporary burst of motivation. It creates a working structure.</p><h3>A simple weekly practice</h3><p>At the beginning of the week, one page is enough.</p><p><strong>Main front: </strong>What is the main area I want to move forward this week?</p><p><strong>Supporting front: </strong>What is the second area that will support this week?</p><p><strong>Three outputs of the week: </strong>Which three concrete outputs do I want to produce?</p><p><strong>Protected time blocks: </strong>Which days and hours will I protect for these outputs?</p><p><strong>Tasks to reduce: </strong>Which tasks will I reduce, postpone, or remove this week?</p><p><strong>Weekly reflection: </strong>What did I learn? What did I produce? What did I plan poorly? What will I improve next week?</p><p>That is enough. The system should stay simple. Because a system that cannot be sustained is not a good system.</p><h3>Final thought: We are not managing time. We are managing direction.</h3><p>Time management is not really about controlling time.</p><p>Time passes anyway. What we can control is how we design our attention, decisions, priorities, and order of work.</p><p>One of the strongest lessons we can take from Atatürk is this:</p><blockquote><em>Working hard is not enough. We need to work toward the right goal, in the right order, with discipline.</em></blockquote><p>In modern engineering terms:</p><ul><li>First, strategy.</li><li>Then, discovery.</li><li>Then, prioritization.</li><li>Then, focused execution.</li><li>Then, regular reflection.</li></ul><p>The Strategic Time System is not just a productivity method. It is a work architecture for long-term growth. For an engineer, time management is not about filling the calendar. For an engineer, time management is designing the system of your own career.</p><p>Mustafa Kemal Atatürk’s words in the Tenth Anniversary Speech, known in Turkish as 10. Yıl Nutku, capture the spirit of this article beautifully:</p><blockquote>“Bunun için bizce zaman ölçüsü, geçmiş yüzyılların gevşetici düşünüş biçimine göre değil, yüzyılımızın hız ve hareket kavramına göre düşünülmelidir. Geçen zamana oranla daha çok çalışacağız. Daha az zamanda daha büyük işler başaracağız.”</blockquote><blockquote><em>“For us, the measure of time must not be shaped by the complacent mindset of past centuries, but by the sense of speed and movement of our own age. Compared with the time that has passed, we shall work more. We shall accomplish greater things in less time.”</em></blockquote><blockquote><em>— Mustafa Kemal Atatürk, Tenth Anniversary Speech</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=04f39ccd48de" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[0. Why Data-Intensive Systems Matter in the Age of AI]]></title>
            <link>https://kmlisler.medium.com/why-data-intensive-systems-matter-in-the-age-of-ai-8455f9dc745f?source=rss-15df87d1d0f------2</link>
            <guid isPermaLink="false">https://medium.com/p/8455f9dc745f</guid>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[big-data]]></category>
            <category><![CDATA[apache-kafka]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Kamil İşler]]></dc:creator>
            <pubDate>Mon, 18 May 2026 10:23:19 GMT</pubDate>
            <atom:updated>2026-05-19T09:42:39.635Z</atom:updated>
            <content:encoded><![CDATA[<p>0. Why Data-Intensive Systems Matter in the Age of AI</p><p><em>A practical introduction to the engineering foundations behind reliable AI products.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/1*5zwPxoMzWitgAvwA7vX4HA.png" /></figure><p>AI is moving fast. But production systems still need foundations.</p><p>Technology is moving very fast.</p><p>Every day, we see new AI models, agents, developer tools, coding assistants, and new workflows around tools like Claude, Codex, OpenAI, and many others.</p><p>These tools already make our work easier. They help us write code, analyze data, search knowledge, debug problems, and build products faster.</p><p>But I think we also need to look at the layer behind these tools.</p><p>A good AI product is not only about using a strong model or writing a better prompt. AI works much better when it is built on reliable data systems, well-designed pipelines, good data quality, low latency, scalable architecture, and clear domain understanding.</p><p>That is the main idea behind this series.</p><h3>AI does not work in isolation</h3><p>In real products, AI is not just a model running in a clean environment.</p><p>It depends on many things around it: databases, APIs, pipelines, events, caches, queues, schemas, monitoring, business rules, and domain knowledge.</p><p>If the data is stale, AI works with stale context. If the pipeline is broken, AI may generate answers from broken data. If the same event is processed twice, downstream results may become inconsistent. If the meaning of a metric is unclear, AI may explain it confidently but incorrectly.</p><p>So the problem is not only: Which model should we use?</p><p>The better question is: <strong>What kind of system are we building around the model?</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QPbFuk6DYukBzKkQ8jZqYg.png" /><figcaption><em>Figure 1: The model is only the visible layer. A reliable AI product depends on the systems around it.</em></figcaption></figure><p><strong>Why data-intensive systems matter</strong></p><p>A system becomes data-intensive when the main challenge is not CPU power, but data itself.</p><p>The problem may be the amount of data, the complexity of the data, the speed of change, or the need to keep data correct, fresh, and usable.</p><p>Most modern systems are built by combining multiple components. A database stores operational data. A cache improves read performance. A message broker moves events. A batch job recomputes historical data. A stream processor reacts to changes. A warehouse supports analytics.</p><p>Each component solves a different problem. But each component also introduces trade-offs.</p><p>This is where system design becomes important. Architecture is not just drawing boxes and arrows. It is deciding how the system behaves under load, under change, and under failure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cT51RuhGWisnTDzeMMqZhA.png" /><figcaption><em>Figure 2: The AI layer is one step in a larger production data flow.</em></figcaption></figure><p><strong>AI makes weak architecture more visible</strong></p><p>Before AI, weak data systems already caused problems.</p><p>Dashboards showed wrong numbers. Reports were delayed. Pipelines failed silently. Teams used different definitions for the same metric. Nobody knew the real source of truth.</p><p>With AI, these problems can become more serious because AI can turn weak data into confident explanations.</p><p>That is why reliability, scalability, and maintainability matter even more now.</p><p>A reliable system keeps working correctly when things go wrong. A scalable system can handle more users, more events, more data, and more use cases. A maintainable system can be understood, operated, and changed by people over time.</p><p>These are not abstract engineering terms. They are the foundation of production systems.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uFy76o0QZV5AfAss6tMVsg.png" /><figcaption><em>Figure 3: Reliability, scalability, maintainability, and domain clarity shape trust.</em></figcaption></figure><p><strong>Distributed systems are already part of our daily work</strong></p><p>Today, even a normal backend or data platform can include many distributed parts: services, cloud databases, Kafka topics, external APIs, object storage, scheduled jobs, data warehouses, and monitoring tools.</p><p>So distributed systems are not only a big tech topic anymore.</p><p>The network can fail. Requests can timeout. Messages can be duplicated. Events can arrive late or out of order. Retries can create unexpected side effects. A small failure can trigger a bigger failure.</p><p>This is why topics like idempotency, replication, partitioning, consistency, retry policies, circuit breakers, monitoring, and observability are not just theory.</p><p>They are practical engineering problems.</p><h3>Data architecture also needs domain thinking</h3><p>There is one more important point: a table is not just a table. A Kafka topic is not just a stream. An API response is not just JSON. A column is not just a field.</p><p>They all represent something in the business domain: customer, order, payment, product, session, inventory, campaign, recommendation, risk score.</p><p>If these concepts are not modeled clearly, the system becomes harder to understand over time. And if the system is hard to understand, the AI layer built on top of it will also be harder to trust.</p><p>This is why domain modeling is part of good data architecture.</p><h3>What this series is about</h3><p>In this series, I want to write about data-intensive applications, distributed systems, system design, and domain modeling from a practical data engineering perspective.</p><p>This will not be a chapter-by-chapter book summary. I will use several strong engineering books as my foundation, but I will focus on the ideas that are useful in real systems.</p><p>Systems with Kafka. Systems with Airflow. Systems with BigQuery. Systems with CDC pipelines. Systems with batch and stream processing. Systems with schema changes, data quality issues, retries, failures, and monitoring needs.</p><p>And more importantly, systems where AI is becoming part of the product.</p><p>My goal is simple: to explain deep engineering concepts in a clear and practical way. Not too theoretical. Not too shallow. Not tool marketing. Just the fundamentals we need to design better systems.</p><h3>Final thought</h3><p>AI is changing how we build software. But the fundamentals are not disappearing.</p><p>Better data systems mean better context. Better pipelines mean fresher information. Better domain models mean clearer reasoning. Better observability means faster debugging. Better reliability means more trust.</p><p>So the real question is not only: How can we use AI?</p><p>It is also: <strong>What kind of systems do we need so AI can work well in production?</strong></p><p>That is the question I want to explore in this series.</p><p>Because in the age of AI, designing data-intensive systems is not a backend detail. It is one of the foundations of building intelligent software.</p><h3>Further reading</h3><p>· Designing Data-Intensive Applications — Martin Kleppmann</p><p>· Understanding Distributed Systems — Roberto Vitillo</p><p>· Domain-Driven Design — Eric Evans</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8455f9dc745f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>