<?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 Melek Bilgin Tamtürk on Medium]]></title>
        <description><![CDATA[Stories by Melek Bilgin Tamtürk on Medium]]></description>
        <link>https://medium.com/@melek.tamturk?source=rss-b7dbca5c9e0a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*uMfgeI-4dXgDlRWVYuKr8w.jpeg</url>
            <title>Stories by Melek Bilgin Tamtürk on Medium</title>
            <link>https://medium.com/@melek.tamturk?source=rss-b7dbca5c9e0a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 02:53:11 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@melek.tamturk/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[Implementing CQRS With CBES]]></title>
            <link>https://medium.com/trendyol-tech/implementing-cqrs-with-cbes-8113733853a9?source=rss-b7dbca5c9e0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/8113733853a9</guid>
            <category><![CDATA[connector]]></category>
            <category><![CDATA[couchbase]]></category>
            <category><![CDATA[elasticsearch]]></category>
            <dc:creator><![CDATA[Melek Bilgin Tamtürk]]></dc:creator>
            <pubDate>Fri, 27 Aug 2021 07:00:47 GMT</pubDate>
            <atom:updated>2021-08-27T07:01:40.208Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/830/0*IChIKyq67dtid-3K.jpeg" /></figure><p>Hello everyone, <a href="https://medium.com/u/a0f7b709dac">Emrah Kurman</a> and I want to share our story of how we implement CQRS with <a href="https://docs.couchbase.com/elasticsearch-connector/current/index.html">CBES</a>(Couchbase Elasticsearch Connector). Also, we will talk about what CBES is, why we use it, how we implement it and customize it. If you’re ready, let’s start.</p><p>Before explain what CBES is and how we use it let’s talk about our problem. As we all know, the best solutions are always found when solving difficult problems. We also found the solution of CBES while dealing with such a difficult problem.</p><p>As Trendyol OMS Team, we manage our customers’ and sellers’ orders, packages, and claims. A while ago we have decided to re-platform one of our microservices to reduce response time.</p><p>As we all know, it is necessary to change an architectural structure rather than a tool or technology to scale. At this point, we have decided to separate our read and write API with CQRS. For those who don’t know, CQRS is an architectural design pattern that isolates read and writes operations from each other, giving us the opportunity to scale on the write and read side, and data source independence.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bI3buDMbZCotnczM.png" /></figure><p>We have decided to use NoSQL DB on the Read side and our choice here was Couchbase. However, in complex queries or deep searches within a document, the index nodes were overloaded, and unfortunately, we could not get the results we wanted. At this point, we have decided to use the search and query power of Elasticsearch. We sent the queries to Elasticsearch and pulled the Couchbase data using the document IDs returned from the query. But there was a big problem here. How would the synchronization between Cocuhbase and Elasticsearch be? We could provide synchronization by connecting a connector from Couchabse to Kafka and a connector from Kafka to Elasticsearch (source and sink connector). However, since the transfer of data went through two different stages, latency would occur, and we would have to intervene.</p><p>This is where CBES comes into play. CBES was already a technology used by many teams in Trendyol, but as the OMS team, we were going to use it for the first time in our tech stack.</p><p>After implementing CBES our architecture turned into a structure as seen in the image below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/0*7hTNy3MFa03EeKgg.png" /></figure><p>As seen in the figure, our listener consumes domain events from The Write API and populates our Couchbase. Then CBES comes into play and indexes Elasticsearch the data written to Couchbase. After that when Read Api processes a request, it first searches Elasticsearch, then pulls the data from Couchbase in the form of key values with the ids it finds in Elasticsearch.</p><h3>What Is CBES &amp; How Does It Work?</h3><p>Let’s take a deep dive into the <a href="https://docs.couchbase.com/elasticsearch-connector/current/index.html">CBES</a>, CBES stands for Couchbase Elasticsearch Connector. According to its official documentation, The Couchbase Elasticsearch Connector(CBES) replicates your documents from Couchbase Server to Elasticsearch in near real-time. The connector uses the high-performance Database Change Protocol (DCP) to receive notifications when documents change in Couchbase.</p><p>Let’s take a deep dive into the DCP protocol that Cbes uses in the background. As most of us know, databases are not just repositories that store data. Especially in a distributed cluster, there is a continuous data stream for data synchronization between nodes so a cluster can be viewed as an ongoing stream of changes. When Couchbase requests a change to a document, it doesn’t go and modify it directly on disk, instead, it only appends to a log and keeps moving so writing operations happen quickly. DCP’s approach is somewhat similar to the <a href="https://www.postgresql.org/docs/9.1/static/wal-intro.html">write-ahead logging</a> you see in other software. Couchbase already has many available connectors. You can easily use them in your production environment. With this connector, you can sync an Elasticsearch cluster and index your data in Couchbase to this Elasticsearch cluster. The connector is fed by DCP that keeps Elasticsearch up to date.</p><h3>How Did We Use &amp; Customize CBES?</h3><p>While Cocuhbase was the database to keep our documents, we wanted to benefit from the search capabilities of Elasticsearch, we learned of the existence of CBES, and the first hurdle was overcome. The second hurdle was whether it was really necessary to keep the same data in two different places. If we indexed all the fields in our document in Elasticsearch, we would have to keep the same data in two places, and our number of operations would have doubled anyway. If there were 100 fields on the document, we were performing all our queries using 15 of them. Indexing all fields meant detecting and applying the mutation of 100 fields to check just 15 fields. For this reason, we have decided to index only the fields that we will use in the query by Elasticsearch. The CBES provided this, but some of the fields we would use were inside an object, while others were on the top of the node.<strong> </strong>We previously used Elasticsearch as our main data source. However, the size of the document and the presence of nested objects caused our query performance to be bad because Elasticsearch evaluates the aggregate and nested documents separately when searching for nested documents. Based on our previous experience, we have noticed that when we normalize data, we get performance gains, and data size is reduced. The CBES could not denormalize the nested object field. That’s why we have customized CBES according to our own needs. In addition, we shortened the indexing time of CBES as we made the data smaller.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5ef9805a01be91fc79b5c16e611f90b6/href">https://medium.com/media/5ef9805a01be91fc79b5c16e611f90b6/href</a></iframe><p>The CBES served us filterFieldesDocumentTransformer to index specified fields on a document. But as we mentioned above, we also need fields like wandMaker’s id. So we added a new field called denormalized fields to example.toml file.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/71d1400f17606b7a3069a030a38e0362/href">https://medium.com/media/71d1400f17606b7a3069a030a38e0362/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2f0eb4977dda4c173fd1d2707c29fea4/href">https://medium.com/media/2f0eb4977dda4c173fd1d2707c29fea4/href</a></iframe><p>To take and map denormalized fields we changed CBES source code a little bit, thanks to our teammate <a href="https://medium.com/u/9d4cf4c00371">Coşkun Bıdıcı</a></p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9bd018fb5674b7188d3185bf68242142/href">https://medium.com/media/9bd018fb5674b7188d3185bf68242142/href</a></iframe><p>Three different chains extend TransformerChain class.</p><ul><li>EmptyTransformer: which is used for indexing whole documents.</li><li>FilterTransformer: used for indexing filter fields.</li><li>DenormalizedTransformer: used for indexing inner fields.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4af6ee4c85d364f2e2aaceef9d4d7188/href">https://medium.com/media/4af6ee4c85d364f2e2aaceef9d4d7188/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fee0c053e24937cff3aed8e711aad319/href">https://medium.com/media/fee0c053e24937cff3aed8e711aad319/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0d7ec83b7519a6b6aaef54e82248f0f8/href">https://medium.com/media/0d7ec83b7519a6b6aaef54e82248f0f8/href</a></iframe><p>We added transformerChain as a new field to DefaultDocumentTransfer and initialized it in the constructor, then called the transformerChain to do its mapping before indexing the document. After customization, we dockerize the CBES project and push the image.</p><p>To deploy a CBES project to Kubernetes, you need YAML files containing service, stateful set, config, and secret types. We have created two different YAML files for these.</p><ol><li><a href="https://github.com/couchbase/couchbase-elasticsearch-connector/blob/master/examples/kubernetes/elasticsearch-connector.yaml">elasticsearch-connector.yml</a> contains service and stateful set types. Customized CBES image used it as statefulSet’s image.</li><li>On the other hand, elasticsearch-connector-configuration.yml file contains secrets and configs.</li></ol><p>Since we use GitLab as our repository, we created a gitlab-ci.yml file and at a deployment stage, applied kubectl apply -record.</p><h3>Our First Migration Adventure</h3><p>We weren’t sure the migration would be started from the beginning when we deployed the CBES. Right after the deployment, CBES started to migrate all data from the beginning, and it was marvellous to watch how fast migration was. Not so later, we realized that the CPU and Memory limit was not enough for migration, for this reason, we increased the limits until migration speed slowed. The CBES migrated more than 300 million documents in a day.</p><p>After our first CBES trial, we noticed the difference between the response times of our service before and after CBES. There was a critical decrease. So, we decided to use CBES for our other services. Unfortunately, CBES consumes a lot of resources. To overcome this issue, we distributed CBES services to three different clusters instead of deploying them to one cluster. If you are going to set up CBES for different buckets as we do, we recommend that you make sure you have enough resources.</p><h4><strong>In conclusion, CBES</strong></h4><ul><li>is customizable since it is open source.</li><li>migrated more than 300 million documents in a day.</li><li>pushed the limits of both CPU and Memory, don’t forget that.</li><li>uses a lot of resources, distribute different CBES services to different clusters if you can.</li></ul><p>PS: Don’t hesitate to contact our beloved HR team for tempting <a href="https://jobs.lever.co/trendyol">career</a> opportunities.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8113733853a9" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trendyol-tech/implementing-cqrs-with-cbes-8113733853a9">Implementing CQRS With CBES</a> was originally published in <a href="https://medium.com/trendyol-tech">Trendyol Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why should you give a try to Test Driven Development?]]></title>
            <link>https://medium.com/@melek.tamturk/why-should-you-give-a-try-to-test-driven-development-db7ca13b0ab7?source=rss-b7dbca5c9e0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/db7ca13b0ab7</guid>
            <category><![CDATA[test-driven-development]]></category>
            <category><![CDATA[tdd]]></category>
            <dc:creator><![CDATA[Melek Bilgin Tamtürk]]></dc:creator>
            <pubDate>Mon, 02 Aug 2021 08:05:33 GMT</pubDate>
            <atom:updated>2021-08-02T08:05:33.125Z</atom:updated>
            <content:encoded><![CDATA[<p>Hello! This article will talk about Test Driven Development method that I’ve experienced throughout a sprint. For any task to be acceptable, it must pass its tests successfully and to increase the quality of the test we should enhance the coverage. As the test coverage increases the number of problems that may occur decreases. However, while writing our tests we can’t get rid of the feeling that says “let’s quickly get the tests done and move on”. At least that’s how I feel and I know there are a lot of developers like me, and who knows maybe you’re one of us. Then maybe, you may think of giving TDD a try.</p><p>Writing tests is an inevitable step in creating a quality product. It provides both continuity, quality, and documentation. As Trendyol Technology Team, we took this, one step ahead and try to follow Test-Driven Development as the Extreme Programming methodology suggests.</p><p>I met the Test-Driven development at the time of my internship at Trendyol. I’ve heard about this method earlier in my university lectures and read some articles but I’ve never implemented it myself. During my internship, I was requested to make a project with my teammate. At that time, our mentor mentioned to us that both pair programming and Test Driven Development are involved in Trendyol culture and trained us with this approach. By the end of the project, we started to work full-time. Since we were busy catching up with the sprint tasks, we used the TDD less and less.</p><p>Last month, as the Order Management System team we realized that we omit the benefits of the TDD just because it is out of our comfort zone. After we decided to use TDD again, we started to question whether we’ll be able to finish our tasks with close deadlines or not. Also, there was prejudice on whether the TDD will be beneficial for us or not. So, we decided to use TDD not for a whole team at the same time but as a single pair each week. And that restarted my journey with TDD.</p><p>Test-Driven Development is a method where the first step of development is writing the tests beforehand. It has an easy-to-understand cycle.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*S9STD-zsw54Fj29e.gif" /></figure><ol><li>Test scenario is written for only one method. Only that test is executed and we make sure it did not pass.</li><li>Code is written only to pass the test. Only that test is executed and we make sure that it is successfully passed.</li><li>Code is refactored.</li></ol><p>It may seem easy at first glance, but it may get complicated quite easily if you don’t have enough experience. But don’t be afraid, it’s pretty normal.</p><p>When we first started to work on it, we (as pairs) started to write the whole scenario at once and that was what’s making the TDD complicated. However, we should’ve chosen a single scenario and move step by step. For example, writing the whole request and waiting for the correct response was not the right way to do it. First of all, we had to make sure that the method we wrote the script was called with the request we wanted. We created an empty request class. In the test, we checked that the method related to this request was called, so the test failed. We went to the code side, we gave a request from the class we created as a parameter to the method. And we made sure that the test passed. Then we refactored. Throughout this cycle, we did each step according to the method called ping-pong. So I wrote a little test, it was my friend who gave the parameter to the method to pass the test. Neither I have always written a test nor he. We were both idle for only a few minutes. Ping-pong kept us both active.</p><h4>Benefits of TDD:</h4><ol><li>Since we code the test and the task logic simultaneously, we didn’t feel the obligation to rush while writing tests to finish the task. TDD made us understand writing tests is not a burden but is the task itself.</li><li>Because it now doesn’t feel like a burden, we get rid of the feeling “let’s get the tests done quickly” and to get the job done each scenario develops the code. If you understand the task correctly, the possibility of forgetting a scenario decreases.</li><li>If you implement TDD as pairs and making ping-pong, it’s easier to fully focus on the task and none of the developers becomes idle. Especially in current days when we work remotely, we aim to work in pairs and communicate better. Doing that requires one person to share the screen(driver) and the other to watch(observer). If the timing is not controlled properly, the driver may get tired and the observer can lose focus. Making ping-pong prevents that situation and both of the developers stay sharp and focused on the job.</li><li>If you aim for the best code at one time and this usually makes you slower, you can work faster by leaving the cleaning code part to the refactoring. For example, naming variables and dividing methods into smaller ones make me confuse and may lose my focus on the necessary logic. Now, I know that I’m going to refactor that afterwards that way I can focus on writing correct logic.</li></ol><p>Some of our teammates didn’t found TDD as beneficial as I did. That’s why I can’t claim that TDD is the best for everyone. Maybe you’re writing all scenarios perfectly even though you don’t write the tests beforehand or you don’t lose your focus while refactoring. I just think that TDD makes these steps a template, and helps people who use that template. Even though I feel like working slower than I used to do, I believe as I practice more I will get faster.</p><p>Long story short, I liked TDD and I will continue to practice. If you want to make writing the tests fun, give TDD a try! I hope it helps you as it did to me.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db7ca13b0ab7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Event Storming for Order Management System]]></title>
            <link>https://medium.com/trendyol-tech/event-storming-for-order-management-system-e6f82fbcd3ad?source=rss-b7dbca5c9e0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e6f82fbcd3ad</guid>
            <category><![CDATA[domain-driven-development]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[eventstorming]]></category>
            <dc:creator><![CDATA[Melek Bilgin Tamtürk]]></dc:creator>
            <pubDate>Mon, 27 Jan 2020 13:04:19 GMT</pubDate>
            <atom:updated>2020-01-27T13:07:53.568Z</atom:updated>
            <content:encoded><![CDATA[<p>In this article, I’m going to explain our event storming experience briefly.</p><p>As the Trendyol Order Management System team, we decided to re-platform our Order and Fulfillment services. Using Domain-Driven Design principles while doing so seemed perfect since we had already experienced DDD when we re-platformed Claim service.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*Ey2Uf69HBVB-bCfU.jpeg" /></figure><blockquote>“The heart of the software is its ability to solve domain-related problems for its user.”</blockquote><blockquote>-Eric Evans</blockquote><p>Let’s start by explaining the basic concepts of DDD. Domain-Driven Design aims to create an environment where software meets the exact needs of the business domain. I can hear you say “Huh, it is already known!”. I know how it sounds but in the real world, it isn’t as easy as it sounds. We, developers, are filled with excitement to code when we start a new project. We start to code, and day by day our project gets bigger and more complex. When a problem occurs, a typical developer tries to solve it with new technology since it excites him/her to do. But in fact, most of the problems are caused by the lack of domain knowledge, not the technology. Eric Evans, who is the writer of the Domain-Driven Design-Tackling Complexity in the Heart of Software, claims that the problem is hidden somewhere in the domain and it should be solved by understanding the domain better.</p><p>To understand the Domain-Driven design better, you should know some terms like Ubiquitous Language, Bounded Context, Aggregate Roots, etc.</p><p>Ubiquitous Language is the common language spoken between Domain experts and developers who work in the same domain. DDD suggests that everybody who works in the same business domain should speak the same language. That language is our ubiquitous language and that domain where the language is meaningful is our bounded context. To be more clear we can simply look into real-life examples: In Italy(bounded context), everyone speaks Italian(ubiquitous language) and any Italian can be understood.</p><p>Unfortunately, I’m not going to explain each term and concept of Domain-Driven Design since it is not the subject of this article. But if you’re interested in learning more about DDD I recommend you to look at Domain-Driven Design Distilled, a book written by Vaughn Vernon.</p><h3>What is Event Storming?</h3><p>We decided on applying DDD, that’s good, we already have done it, we could do it again. But could we do it better? That was the question in our minds. Both Order and Fulfillment services were more complex than Claim service. There were newbies to the domain including me and we weren’t able to participate as needed when a decision about re-platforming was made. As a team, we wanted to ensure that each team member has nearly the same domain knowledge. We had to model our domain to understand it better. Even though there are a lot of modeling techniques, none of them was simple enough for domain experts to participate in the modeling phase. To create a ubiquitous language we need domain experts and domain experts need a better modeling technique. These main problems lead us to use a different domain modeling technique and Event storming was the answer.</p><blockquote><strong>EventStorming</strong> is a flexible workshop format for collaborative exploration of complex business domains.</blockquote><blockquote>-Alberto Brandolini</blockquote><p>Event storming is a fun way to increase the knowledge of business domains. It requires the collaboration of everybody in the business.</p><h4>The things you need for an event storming session</h4><ul><li>Lots of different colored post-its or sticky notes or some paper to put on a wall.</li><li>A marker, a big roll paper or a whiteboard or a wall.</li><li>The development team, QAs, product managers or product owners, stakeholders, etc. Briefly, people who can ask the right questions and who can answer right must attend the session.</li></ul><p>The most beautiful part of event storming is that it has more than one form. We used even storming to see our domains clearly, was it the only and perfect way of event storming? Of course, not. That’s why we did it twice. I will tell you both the first and the second sessions and I hope you will understand it is beneficial when exercised correctly.</p><p>First, we started the session by differing the post-its according to their colors. Although all colors for events, aggregates and commands have specific colors in event storming book, we didn’t want to spend time to find the right colors. We used dark pink for events, green for commands, yellow for aggregates in the first event storming sessions.</p><ul><li>Event: A message is sent asynchronous which is recognized by the software.</li><li>Command: An action that causes the event to occur.</li><li>Aggregate: Much like domain objects.</li><li>Policy: A business rule that invokes a command to an event.</li></ul><p>The event storming session started by writing events to post-its one by one. Since it was our first event storming session, everyone was feeling a little bit nervous but eventually, someone took the step and attached post-it to the wall. Then the team followed. The biggest challenge of our first event-storming session was name conventions and trying to catch the perfect design at a glance. Everybody was trying to write events according to their occurrences in the timeline. So it was hard to participate in the session for newbies. In the end, there was someone in front of the wall, he was writing events and attaching post-its to the wall while others telling which events should be written. Even writing the events took one and a half hours, and yet there were still some questions about the names of events and also their necessities. The session was tiring and confusing for all of us. We attached some alarming post-its to confusing parts and decided to wait until the next day. A day later, the team was ready to write commands. To understand where user interaction occurs in our domain, we attached post-it with a little man on it to the commands. The final step of our storming session was deciding the aggregates which related to which commands.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I__bwlFFx9gMg5u4Ss9-dA.jpeg" /><figcaption>The roadmap we achieved after our first event storming session.</figcaption></figure><p>After the first event-storming session, we had a clue what event storming is. Yet we weren’t satisfied enough with the session and we want to try again. Before repeating the session, we wanted to clarify that everybody understood why we need an event storming session again and what our faults were in the previous session.</p><ol><li>The lack of participation.</li><li>Focusing the whole domain at once.</li><li>Trying to catch the perfect design at once.</li><li>Not limiting the time to debate on something.</li></ol><p>These mistakes kept away from the real domain problems in the previous session. We promised ourselves not to repeat these mistakes and decide to do another session.</p><p>The second session started by writing the events again. The rule was simple. Everybody could write any event in any order for the first ten minutes. In the beginning, each event was acceptable whether it is related to our domain, or not. It didn’t need to be written only once. Everybody can write the event even though it is already on the board. No one was allowed to remove an event from the board in the first ten minutes. The aim was to recognize the domain knowledge of ours without any interrupting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rwzw3mnVlBmwtjAe1mp-SQ.jpeg" /><figcaption>Events without any order.</figcaption></figure><p>After ten minutes, we ordered the events according to their occurrence in the timeline and removed the repeated events from the board. Some sticky notes with different names were pointing to the same events. In that situation, a sticky note with a more appropriate naming was chosen to represent that event and the other ones were removed from the board.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A97IqTJ24zCzuHmiwEDWQw.jpeg" /><figcaption>Ordered events.</figcaption></figure><p>Since we already have the minor information about our domain from the previous session, we wanted to focus on the pivotal events. We divided the timeline to three-part. The first part was starting the pre-order creation process, the second was starting the order processes and the third one was starting the fulfillment process. The pivotal events were the event which is occurred in the timeline where the one part has ended but the other has just started. These pivotal events lead us to commands and policies. In what circumstances these events could occur? With policies, we could define our happy paths and opposites. When a different thought about some path came to mind, the team discussed it in a limited time. When we couldn’t agree on something, we put some pink sticky notes on it to decide about it afterward. That way we didn’t spend all of our energies on one thing.</p><p>In the end, the deeper problems of our domain got a little bit clear.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NZc5-FhWSSOI0smiodqg4w.jpeg" /><figcaption>Blue stickies are the commands, orange ones are the policies.</figcaption></figure><p>To sum up, In the first session, we had a different superficial outlook on our domain. We didn’t reach most of the problematic parts of the domain. In the second session, we asked different questions, thought the edgy scenarios and collaborate. Focusing on the deeper level of problems gave us a deeper outlook, hence it brought its solutions.</p><p>There were newbies in the team and with these sessions they could have a greater knowledge of the domain. So, we could say it was a pretty good orientation :) And for the last, we decided using design level event storming in groomings. I’m going to tell you how we applied design level event storming in another article.</p><p>I hope you enjoy the event storming as much as we did. Thanks for reading :)</p><p>PS: Don’t hesitate to contact our beloved HR team for tempting <a href="https://jobs.lever.co/trendyol">career</a> opportunities.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e6f82fbcd3ad" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trendyol-tech/event-storming-for-order-management-system-e6f82fbcd3ad">Event Storming for Order Management System</a> was originally published in <a href="https://medium.com/trendyol-tech">Trendyol Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>