<?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 Yoihenba Kongbam on Medium]]></title>
        <description><![CDATA[Stories by Yoihenba Kongbam on Medium]]></description>
        <link>https://medium.com/@ykongbam?source=rss-a1e0f22548b1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*R5ghgQg-Yrx2PXib</url>
            <title>Stories by Yoihenba Kongbam on Medium</title>
            <link>https://medium.com/@ykongbam?source=rss-a1e0f22548b1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 22:46:00 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ykongbam/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[What should a Product Manager know about Software Design and Architecture]]></title>
            <link>https://medium.com/swlh/what-should-a-product-manager-know-about-software-design-and-architecture-a5ec92dddfe7?source=rss-a1e0f22548b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/a5ec92dddfe7</guid>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[software-design]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Yoihenba Kongbam]]></dc:creator>
            <pubDate>Wed, 29 Apr 2020 11:37:09 GMT</pubDate>
            <atom:updated>2025-12-13T14:33:25.704Z</atom:updated>
            <content:encoded><![CDATA[<h4>Contributing to software design and architecture as a Product Manager</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DyATB04JsQoed3F53v0l6g.jpeg" /><figcaption>Photo by <a href="https://www.pexels.com/@startup-stock-photos?utm_content=attributionCopyText&amp;utm_medium=referral&amp;utm_source=pexels">Startup Stock Photos</a> from <a href="https://www.pexels.com/photo/ideas-whiteboard-person-working-7369/?utm_content=attributionCopyText&amp;utm_medium=referral&amp;utm_source=pexels">Pexels</a></figcaption></figure><p>Being the bridge between the business, customer, operations and the tech, a PM has a unique perspective on system design. As a product manager, you don’t need to have an extensive knowledge about system design or system architecture. Engineers and architects are better equipped to do that. I won’t go into the details of what you should specifically learn, but a more general approach to deciding what to learn and how you can contribute to the design.</p><h3>How do System Design Choices affect the Product</h3><p>PMs should be able to understand the ramifications of software design to the product and future growth of the product. An engineer usually only has the context of the requirement which is provided to them. So they will solve the problem with those constraints in mind. They might not have an insight on the long term goal.</p><p>Design is an iterative process, you can’t have a perfectly designed system which solves for everything. That’s just not practical. There will be design trade-offs which you might be taking implicitly. Any choice taken in the design has implications.</p><p>Your awareness of the following concepts will help you make informed decisions and help you contribute better in the design process.</p><h4>System design</h4><p><strong>Consider the following example<br></strong>An order management system, where you have order details which has customer details, product details and payment details. You can put everything in a single system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/261/1*KMkCRi7cgUL5comPCCHBTA.png" /><figcaption>Monolithic System</figcaption></figure><p>As the system grows, this will become a monolith. Any feature deployment, for example, a new feature in payments would require a deployment for the whole system. Since everything is in a single system, there is also a chance that the system becomes tangled in all the inter-dependencies, making it harder to change anything.</p><p>You would want to break it down and bring in <strong>Separation of Concerns. </strong>Maybe a sub-system which handles payments, another which maintains customers’ information, and one for product information.</p><p>Deciding which functionality/data goes into which sub-system can be done by following the principle of <strong>High Cohesion Low coupling.</strong></p><p><strong>High cohesion</strong> means having all the closely related data and functionality in a module with a well defined role. This also leads to less duplication. <strong>Low coupling</strong> means less inter-dependency between modules. Changes made in a module shouldn’t require substantial changes in other modules.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/681/1*_eM3kB94a8-lq7-xckvD1A.png" /><figcaption>System broken down into components</figcaption></figure><p>As you can see in the example, customer management module could handle all the functionalities related to a customer. Like adding customers, removing customers, managing logins, storing customer details etc. Making it highly cohesive. Other systems would probably reference an id like customer_id to interact with this system.</p><p>Let’s say you wanted to add a feature to search for customers, you can add that feature in customer manager, it would have a minimal impact on other systems. Hence, low coupling.</p><p>These can be submodules in a single system or can be separate systems of their own.</p><p><strong>What to look out for?</strong></p><ul><li>These abstractions would be analogous to how organisations are broken down into smaller teams for increased efficiency. See if any feature/functionality seems out of place by imagining these modules as teams with the same responsibility.</li><li>Look out for too many functionalities in a component. They could be separated out into further modules.</li><li>See if there are redundant functionalities across components. Have the functionality at only one place and make the other components interact with it. Duplicate data/functionalities are more costly to maintain and susceptible to bugs.</li><li>To represent how data is flowing through the system, an engineer might come up with a Data Flow diagram.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yYvuqDtjkLiCuf2fmMfRfA.png" /><figcaption>Source: Lucidchart. <a href="https://www.lucidchart.com/pages/data-flow-diagram">Learn more about DFD at Lucidchart</a></figcaption></figure><ul><li>Assess the data flow diagram and see that relevant data is available at all the stages/components with respect to the requirements. Think of requirements which could span across multiple stages/components and ask how that would be solved.</li><li>Another way of representing the interactions could be a Sequence Diagram</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4DDJssjSMUTRmEzbWCiO-Q.png" /><figcaption>Source: <a href="https://creately.com/diagram/example/i4l2b24v2/Sequence%20Diagram%20for%20Order%20Processing">Creately</a>. <a href="https://creately.com/blog/diagrams/sequence-diagram-tutorial/">Sequence Diagram Tutorial</a></figcaption></figure><ul><li>Think of use cases for which the flow might not work. If there is no sequence diagram, ask the engineer to do a walkthrough of some of the flows through the components so that you understand the flow. Check if the flows don’t conflict with the business process and workflows.</li></ul><h4>Understanding of architectural components and patterns</h4><ul><li>You should have a basic understanding of components like Databases, In-memory data stores, Caches, queues, load balancer and patterns like server-client, model-view-controller, micro-services, message brokers, layered architecture etc. You don’t need to know all of them, or have extensive knowledge.</li><li>Try making an explicit attempt to understand them whenever you’re exposed to them, ask the engineer W<em>hy have they gone with a certain architecture? </em><strong><em>What is it good at, What is it not good at?</em></strong></li><li>So that whenever you see those same patterns again, you’d be better informed.<br><br>Reference: <a href="https://en.wikipedia.org/wiki/List_of_software_architecture_styles_and_patterns">List of Architectural styles and patterns.</a></li></ul><p><strong>Functional and Non Functional Requirements</strong></p><ul><li>Ask a lot of questions to ensure that all your use cases are solved. <strong>Explicitly ask about the limitations of the system</strong> so that you can understand it better and resolve any mismatch with the requirements.</li><li><strong>Ask and try to understand how the non functional requirements are being solved. </strong>You might also have implicitly assumed a non-functional requirement or missed something. Examples could be scalability, portability, extensibility etc.</li></ul><blockquote>Here’s a Comprehensive <a href="https://en.wikipedia.org/wiki/List_of_system_quality_attributes"><strong>List of System Quality Attributes</strong></a>. You can use this as a reference for coming up with Non Functional Requirements and deciding what questions to ask.</blockquote><p><strong><em>Consider a scenario of selecting a data store.</em></strong></p><ul><li>An in-memory datastore like Redis would be used for storing data which needs to be accessed quickly while a traditional RDBMS like mysql might be slower but provide better tools for querying data.</li><li>You would have the context of what features would be built later, <strong>try to bring up those use cases and ask how they could be solved so that options are considered.</strong></li><li><strong>Think of unseen requirements which could come up later like analytical use cases, ad-hoc queries.</strong> To what extent can the datastore design solve for it.</li><li>Some questions could be, <em>How fast would the database be, will it be able to function under this specific SLA? Can I query this specific information? Can it support complex analytical queries? How is it scalable?</em></li></ul><blockquote>There are so many datastores in the market now. This site <a href="https://db-engines.com/en/ranking">DB Engines</a> might help you understand their features better. They have a ranking of datastores based on their popularity and classified by database model. You can also compare their features.</blockquote><h4>Domain related concepts</h4><p>Engineers try to map business use cases to design as they best understand. Your role would be to bridge that gap. If there is a mismatch between how business understands a concept and how the engineering understands it, it can lead to confusion and a steeper learning curve on both sides in the long run. On the contrary, if the concepts and abstractions are aligned, there is lesser cognitive overhead in understanding them.</p><p>Make sure to review all the entities, workflows and components.</p><p>If your organization has standard definitions and conventions followed for entities. Make sure you follow the same. Not doing so, can lead to problems integrating with the larger tech ecosystem in the org.</p><h4>Translating design to effort</h4><p>While assessing a design ask about how long it would take to build the feature and what tradeoffs can you take. Make sure alternatives are considered.</p><p><strong>PM</strong>: <em>Let’s build a search functionality on this entity. </em><br><strong>Engineer</strong>: Sure. <em>We can set up ElasticSearch/Solr and set up a pipeline to index all the attributes. We’ll get a rich set of filtering options. It would scale well. <br></em><strong>PM: </strong><em>How long will that take?<br></em><strong>Engineer: </strong><em>That can be up and running in a month’s time.</em><strong><br>PM</strong>: <em>Can we do it in a shorter time?<br></em><strong>Engineer</strong>: <em>If we just implement the search only on the the name of the entity, we can have a simpler implementation. We could directly query the mysql db with a simple sql query. That’ll take maybe just a couple of days.<br></em><strong>PM:</strong> <em>What limitations will we have?<br></em><strong>Engineer: </strong><em>A couple of them. If the scale grows we might have performance issues. If we want to introduce complex filters, we might need a separate system for search.<br></em><strong>PM: </strong><em>Since we don’t need to solve for scale right now and can live with searching just by the name. Let’s do that.<br></em><strong>Engineer: </strong><em>Cool. The proper search feature will be a tech debt, and we would need to solve that later when scale grows and need advanced search features.<br></em><strong>PM: </strong><em>Alright. I’ll keep that in mind and consider that in my product roadmap.</em></p><p>As you can see from this imaginary conversation, you will have better visibility of the design options and the efforts required. This will help you breakdown and prioritize features.</p><p>Develop a mental model to map feature/design to the time taken to implement. With experience, you will be able to intuitively estimate how long a certain component or design will take to implement. This will help you plan your product roadmap better.</p><h3>Provide the problem not the solution</h3><p>Some product managers unknowingly tend to provide a solution instead of presenting the problem first. If you don’t have an in-depth knowledge of the system, you might end up providing a suboptimal solution. Make sure you explain the problem first to the engineer so that you get to hear their point of view. Then offer the solution.</p><p>You should consider it your responsibility to share the long term problem statement and the reasons why the problem needs to be solved, irrespective of whether you are explaining it to a Junior engineer or an Architect. It gives the engineers more context which can lead to better design in the first place. You’ll generally end up with more interesting ideas and new perspectives to the problem.</p><blockquote><strong>Sharing the ownership of solving the problem will result in better synergy, as you work together towards a common goal.</strong></blockquote><p>Another important aspect of the problem which needs answering is “<em>Why now</em>?” and “<em>What part of the problem needs to be solved now</em>?”.</p><p>This will force you to structurally break down the long-term problem statement and identify priority, giving you more clarity.</p><p>Answering these questions will give more visibility and enable the engineer to make independent judgements on how much effort needs to be invested in various aspects of the design. Whether something needs to be solved now or it can be taken on as a tech debt.</p><h3>Understanding Tech Debt</h3><p>Tech debt is defined as the implied cost of additional rework caused by choosing an easy (limited) solution now instead of using a better approach that would take longer.</p><p>For the product, tech debt translates to:</p><ul><li><strong>Development costs</strong>. Pace of execution is slowed.</li><li><strong>Operational costs</strong>. Time lost in debugging and fixing issues.</li><li><strong>Opportunity costs</strong>. Time lost in releasing a feature which could have improved business. Bugs leading to lost profits.</li><li><strong>Business costs</strong>. Outages leading to loss of revenue.</li></ul><p><strong>These factors should be considered while prioritizing tech debts</strong>. If you want to identify tech debts, these costs should ideally be tracked and measured.</p><p>Another way you could identify tech debt is the time required to onboard a feature. This goes hand in hand with the design-effort translation. If a specific feature took <em>x days</em> and a similar feature is taking significantly longer than <em>x days</em>, that could be a sign of a tech debt.</p><p>Work with the engineers to identify and fix tech debts as required keeping business goals in mind.</p><p>p.s. Interesting read on <a href="https://medium.com/all-things-product-management/conceptual-debt-is-worse-than-technical-debt-5b65a910fd46#.32rrordg9">Conceptual Debt</a>.</p><h3>Ask a lot of Questions</h3><p>I think, in general if you keep the above points in mind and ask a lot of questions and do research as required, you’ll learn a lot about the software design process and understand it better.</p><blockquote>When you ask questions, you ensure that the product and the tech is on the same page, reduces risks. As your knowledge grows, you’ll learn to ask the right questions. Which in turn will help you build better products faster.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a5ec92dddfe7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swlh/what-should-a-product-manager-know-about-software-design-and-architecture-a5ec92dddfe7">What should a Product Manager know about Software Design and Architecture</a> was originally published in <a href="https://medium.com/swlh">The Startup</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Planning your Programming Project]]></title>
            <link>https://medium.com/@ykongbam/planning-your-programming-project-a77fc9aaa804?source=rss-a1e0f22548b1------2</link>
            <guid isPermaLink="false">https://medium.com/p/a77fc9aaa804</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[computer-engineering]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Yoihenba Kongbam]]></dc:creator>
            <pubDate>Wed, 11 Dec 2019 17:17:57 GMT</pubDate>
            <atom:updated>2020-09-09T10:57:54.642Z</atom:updated>
            <content:encoded><![CDATA[<h4>How to plan your project and avoid common pitfalls</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*98-ps55_ENp314YOHC5M9Q.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@epicantus?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Daria Nepriakhina</a> on <a href="https://unsplash.com/s/photos/agile?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p>This article is primarily aimed at beginner programmers who want to build their own apps and software engineers who have recently started their career. This could also help experienced engineers in augmenting their process.</p><p>You have an idea for an app. You start building it straightaway.</p><ul><li>You’re making progress, then you realize you’re not moving as fast as you want.</li><li>Bugs creep in which slow you down, you’re not able to re-prioritize tasks. You lose sight of the overall goal.</li><li>It gets overwhelming after a point and you give up on the project, or you burn yourself out trying to get it done.</li><li>You are not able to meet any deadlines you have set.</li></ul><p>If any of the problems above seem familiar to you, the following process could help you overcome them.</p><p>These problems could stem from unclear requirements, bad estimation, not understanding priority, bad planning etc.</p><p>I will be covering the various phases you might go through and how to tackle them. Mainly exploring the planning aspect of the process, which spans over the following steps:</p><ul><li><strong>Requirements</strong></li><li><strong>Estimation</strong></li><li><strong>Planning</strong></li><li><strong>Execution</strong></li></ul><h3>Requirements</h3><p>You need to have a clear idea about what you are building. There can be unknown requirements, sure. But you should have a clear idea of the scope of what needs to be built in the immediate future. As you grow with experience, you’ll start having increased visibility.</p><p>Requirements can keep changing as you progress, and it is okay to change the original requirement as long as its implications are considered.</p><p>If you’re in an organization, there might be a Product Manager who defines the requirements. The process of product definition and prioritization is out of the scope of this article.</p><p>I’ll briefly gloss over defining a <strong>Minimum Viable Product(MVP). </strong>This can apply to iterative improvements to your product also.</p><p>This can be defined by the following criteria:</p><ul><li>What is the bare minimum required to make the product functional?</li><li>In how much time do you need the product?</li></ul><p>To ensure focus, make sure the MVP is well defined and not very ambitious.</p><p>A simple way to define the MVP could be to:</p><ul><li><strong>List out all the features</strong> of the app and <strong>order them by priority</strong> of how important they are. What are the must-haves and what are the good-to-haves.</li><li><strong>Prioritize your riskiest assumption! </strong>Don’t waste your time in thinking about things which could work better with something else. Try to isolate and <strong>prioritize the core solution</strong>.</li><li>Learning to understand priority and building the core solution is important because even if you miss a deadline, you have something usable. Let’s say you’re trying to build a photo sharing website and you spend too much time on building the comments system. But didn’t invest enough time in the photo rendering system. You end up with an app which has low quality photo sharing with amazing commenting capabilities. Which defeats the whole purpose of the app.</li><li>Make sure <strong>the features are granular and independent</strong>. Reduce overlap between all the features being defined.</li><li><strong>Define a tentative deadline</strong>. Define a Cut-line which seems reasonable for the deadline you have set. Everything above the cutline needs to be executed. Don’t be too ambitious with this because features will creep in later(which weren’t considered before) and you’ll have to re-prioritize.</li><li><strong>Define stretch goals</strong> from this list. Pick the next few features as a stretch goal, if you are able to achieve the first cut.</li></ul><blockquote>For defining the cut-line the next important part is estimation.</blockquote><h3>Estimation and Scoping</h3><p>This is a necessary and critical step in the planning phase which people generally overlook. Understanding how much time implementing a certain feature takes.</p><h4>Why is estimation important?</h4><p>Even if you don’t know how long it will take for implementing a certain feature. You should still estimate before implementing anything. The estimate doesn’t have to be very accurate.</p><p>After completing a task, <strong>you will have an idea of how far you were off the estimate and adjust</strong>. This will help you <strong>understand and define your pace. </strong>You can re-adjust your plans as required to meet a deadline/milestone.</p><h4>How do you estimate?</h4><p>Let’s say you have to build an app. How do you even start estimating?</p><p><strong>Learn to break down tasks</strong></p><p>You need a UI, a back-end, a database. Estimate how much time each will it take. Then break down each task.</p><p>UI might need 15 pages. Estimate for each of the 15 pages how long it will take. Maybe one page needs 3 days to implement. Now work upwards to come up with an estimate for the whole project.</p><blockquote><strong>Estimate! Estimate! Estimate! </strong><br>You should always estimate pro-actively before picking up any task however small it is. With experience, you will be able to intuitively gauge how much work is required for any feature.</blockquote><blockquote><strong>This is important because knowing how long something will take to do is a prerequisite for any planning.</strong></blockquote><h3>Planning</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e0bHdIVIEOqpC9calIQV2g.jpeg" /><figcaption>Photo by <a href="https://www.pexels.com/@suzyhazelwood?utm_content=attributionCopyText&amp;utm_medium=referral&amp;utm_source=pexels"><strong>Suzy Hazelwood</strong></a><strong> </strong>from <a href="https://www.pexels.com/photo/notebook-1226398/?utm_content=attributionCopyText&amp;utm_medium=referral&amp;utm_source=pexels"><strong>Pexels</strong></a></figcaption></figure><p>List out your tasks. Get a calendar and plan out. Make sure the tasks are granular enough. Your tasks for the day should be very clear and detailed, future tasks can be approximate. Next week’s task could be at a higher level and not very granular. Next month’s task can even be more vague.</p><p><strong>But do have a high level plan around weekly and monthly tasks.</strong></p><p>Have some time out, maybe an hour or two at the beginning of every week to re-assess and plan.</p><h4>How much should I plan?</h4><p><strong>Don’t waste time</strong> planning for the next month until you have reached the next month.</p><ul><li>If you planned in detail for the next month and you are not able to meet this month’s target. <strong>That time</strong> could have been better spent in <strong>doing SOMETHING, than planning!</strong></li><li>You might also discover something which renders the whole next month’s plan useless. Like deciding to not implement the feature or you had made assumptions which conflicts with what you are actually building right now!</li></ul><blockquote>Just keep the estimations and future features with a high level plan so that you can re-adjust as required, and keep track of!</blockquote><h4>Prioritization</h4><p>Try to plan your tasks in accordance to the priority defined in the requirements.</p><p><strong>Understanding Dependencies<br></strong>Try to come up with a dependency tree of all the tasks you have planned. Doing a specific task before another task might make the second task easier to implement. This will help you zero in on the optimal order to execute your tasks.</p><h4>Define milestones</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/266/1*O8k1C7gYRZJE_kvemFJ5zA.jpeg" /><figcaption><strong>Image courtesy of </strong><a href="http://www.freedigitalphotos.net/images/view_photog.php?photogid=2280"><strong>digitalart</strong></a><strong> at FreeDigitalPhotos.net</strong></figcaption></figure><ul><li><strong>Having milestones/deadlines help you look at the bigger picture</strong>. This is required for you take a step back and look at the reality from a different perspective.</li><li>If multiple people are working on the project, a chance to sync, reset and move to the next milestone together.</li><li>It also gives a sense of achievement which is important for the morale for yourself and for your team.</li></ul><h4>Planning with a team</h4><ul><li>Make sure the timelines are matching for testing and integration for independent features.</li><li>This gives an opportunity to understand dependencies within and outside your or your team’s work.</li></ul><h4>Testing</h4><ul><li>Your plans should also include time for testing and you should be prepared for time spent in fixing bugs.</li><li>As mentioned above, integrating with external systems or other teams might require coordination.</li></ul><h3>Execution</h3><p>Try to execute according to plan. Make sure it doesn’t deviate a lot. Here are some tips for better execution and navigating road-blocks.</p><h4>Prototyping</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jRbEr_DnvT2xuLq5YZrqnA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@nicolasthomas?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Nicolas Thomas</a> on <a href="https://unsplash.com/s/photos/prototype?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><ul><li>Prototyping is an important tool for early feedback and proof of concept. Prototypes can be for any component of the system.</li><li>A UI prototype might give you early feedback about usability, you might discover user patterns which you might have missed in your initial design.</li><li>You could discover engineering complexities while building the prototype for the back-end which might lead you to go back to the drawing board to re-design the whole system.</li><li>The prototype can also work as a skeleton to base your complete system on.</li></ul><blockquote><strong>Have some time dedicated for prototyping in the early phase for all the components you decide to build. It might also lay the foundation for the components and their interactions.</strong></blockquote><h4>Design trade-offs</h4><p>Understand that what you’re trying to build and what you have defined in the requirements. Over-engineering is one of the pitfalls which is hard to overcome.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/550/0*y5C41u9EMb3eBJoC.png" /><figcaption><a href="https://xkcd.com/974/">https://xkcd.com/974/</a></figcaption></figure><p><strong>Build what is needed</strong>, don’t try to solve for the future.</p><p>One common misconception is that,</p><blockquote>by solving for all the future features you make future implementation simpler.</blockquote><p>It’s usually the other way round (and counter-intuitive),</p><blockquote><strong>by not solving for the future, it actually gives you more flexibility in the future</strong></blockquote><p>For instance, if you have a function doSomething() and you see a future use case doSomethingSimilar(). Don’t implement the logic yet for the later use case or even the mechanism to select the implementation which let’s say could be a switch case.</p><pre>switch(implementationSelector):<br>case 1: doSomething()<br>case 2: doSomethingSimilar()<br>case 3: doSomethingSimilar2()</pre><p>It could actually makes your system <strong>inflexible</strong>.</p><ul><li>You could be wrong about the design, maybe doSomethingSimilar() is not actually similar, you would have to rewrite the code anyway.</li><li>Or maybe you might not actually need the generalized implementation.</li></ul><blockquote><strong>The time spent in doing any extra optimization(Which is not needed right now) could have been better used in actually building something which is required now.</strong></blockquote><p>Unless you are very sure about your design and have thought through all the possible cases by scoping the role of every function. Defer the decision to when it is actually required and move on.</p><p><strong>This still doesn’t mean you should write bad code or not invest in proper design. Make the code modular so that whatever happens in the future, you can use it.</strong></p><h4>Bugs and new features</h4><p>As your code-base grows, the number of bugs will increase. These could be functional bug or an edge case which wasn’t considered before.</p><ul><li><strong>Functional bugs (Defined in the requirements) should ideally be fixed immediately.</strong></li><li>In case of unforeseen edge case, it should be re-prioritized. Don’t try to fix everything, the system doesn’t have to be perfect. Look at the requirement feature list and <strong>add the solution for the bug as a Tech Debt</strong>. Make a judgement whether to fix it or not based on the timeline and the cutline you have set. Tech debts should be tracked and managed. Consider the tech debts as features when planning for subsequent releases.</li><li>Similar to the unforeseen engineering challenges, you might also discover new features you might want in your product. Again, <strong>don’t try to pick it up immediately. Merge it to the plan.</strong></li></ul><blockquote><strong>Pro-actively try to understand the increase in workload because of new features and bug.</strong></blockquote><blockquote>It can contribute to major delay if you choose to immediately fix them without re-prioritizing.</blockquote><h3>Retrospect, Re-assess, Re-iterate</h3><p><strong>Retrospection</strong> is crucial in learning from experience. Try to plan and log everything you do, mentally or in writing. See how much you had planned and executed, what you could have done better, what you did well.</p><p>This will help you <strong>Re-assess </strong>your overall plan and make adjustments. Have either a weekly or a daily retrospection plan. Not just the quantitative aspect of the plan but also the qualitative aspect. How good were your engineering designs, how was the code quality. How much did bugs slow you down? Account for that in your future estimates.</p><p><strong>Re-iterate</strong> this whole process occasionally so that you can meet your targets. If there is any change in plan, re-estimate and plan again.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a77fc9aaa804" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>