<?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 Mansi Kodgire on Medium]]></title>
        <description><![CDATA[Stories by Mansi Kodgire on Medium]]></description>
        <link>https://medium.com/@mansikodgire?source=rss-6266e33b47fd------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by Mansi Kodgire on Medium</title>
            <link>https://medium.com/@mansikodgire?source=rss-6266e33b47fd------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 02:02:47 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@mansikodgire/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[Spring Boot Microservices: Mistakes I Made So You Don’t Have To]]></title>
            <link>https://medium.com/@mansikodgire/spring-boot-microservices-mistakes-i-made-so-you-dont-have-to-eb969996d65a?source=rss-6266e33b47fd------2</link>
            <guid isPermaLink="false">https://medium.com/p/eb969996d65a</guid>
            <category><![CDATA[rest-api]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[spring-boot-microservice]]></category>
            <category><![CDATA[java]]></category>
            <dc:creator><![CDATA[Mansi Kodgire]]></dc:creator>
            <pubDate>Sat, 05 Sep 2026 08:10:39 GMT</pubDate>
            <atom:updated>2026-09-05T08:10:39.433Z</atom:updated>
            <content:encoded><![CDATA[<p>Microservices sound amazing when you’re reading architecture blogs.</p><blockquote>Independent deployments ✅</blockquote><blockquote>Better scalability ✅</blockquote><blockquote>Technology freedom ✅</blockquote><blockquote>Faster development ✅</blockquote><p>But when I started working on Spring Boot microservices, I quickly realized that building microservices and maintaining microservices are two completely different things.</p><p>I made several mistakes that looked harmless during development but turned into major challenges in testing, deployment, debugging, and maintenance.</p><p>In this article, I’ll share the biggest mistakes I made while working with Spring Boot microservices and what I’d do differently today.</p><p>If you’re planning to build your first microservices-based application, these lessons might save you weeks of frustration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cFhQ_MA1t-b5MD0ipAi56Q.png" /></figure><h3>1. Splitting Everything Into Microservices Too Early</h3><p>One of the biggest mistakes I made was assuming:</p><blockquote><em>If microservices are good, then more microservices must be better.</em></blockquote><p>So, I started creating separate services for almost everything.</p><pre>User Service<br>Order Service<br>Product Service<br>Notification Service<br>Review Service<br>Payment Service<br>Cart Service</pre><p>At first, it felt like a clean architecture.</p><p>Then reality hit. A simple user action required communication across multiple services.</p><p>Debugging became difficult.</p><p>Deployment became slower.</p><p>Managing APIs became painful.</p><h4>What I learned</h4><p>Not every application needs microservices from day one.</p><p>Start with a modular monolith if:</p><ul><li>The team is small</li><li>Requirements are evolving</li><li>Traffic is manageable</li></ul><p>Move to microservices only when there is a clear business need.</p><h4><strong>Better Question</strong></h4><p>Instead of asking:</p><blockquote><em>“How can I build microservices?”</em></blockquote><p>Ask:</p><blockquote><em>“Do I actually need microservices?”</em></blockquote><h3>2. Ignoring Service Boundaries</h3><p>Initially, I designed services around database tables.</p><p>For example:</p><pre>users table -&gt; User Service<br><br>orders table -&gt; Order Service<br><br>products table -&gt; Product Service</pre><p>Looks logical, right? Not really.</p><p>Services should be based on business capabilities, not tables.</p><p>Because of poor boundaries:</p><ul><li>Services became tightly coupled</li><li>Frequent API calls were needed</li><li>Business logic became scattered</li></ul><h4>Better Approach</h4><p>Design services around domains.</p><p>Example:</p><pre>Customer Management Service<br><br>Inventory Service<br><br>Order Management Service<br><br>Billing Service</pre><p>This approach reduces dependencies and improves maintainability.</p><h3>3. Sharing a Database Across Multiple Services</h3><p>This was a mistake that caused countless headaches.</p><p>We had multiple services accessing the same database.</p><pre>Service A<br>       \<br>        Shared Database<br>       /<br>Service B</pre><p>Initially it looked efficient, but eventually:</p><ul><li>One service changed a schema</li><li>Another service broke</li><li>Database dependencies increased</li><li>Service ownership became unclear</li></ul><h4>Correct Approach</h4><p>Each microservice should own its data.</p><pre>User Service<br>      |<br> User DB<br><br>Order Service<br>      |<br> Order DB</pre><p>Yes, data duplication may happen, but the benefit is independence. And independence is the whole point of microservices.</p><h3>4. Making Too Many Synchronous API Calls</h3><ul><li>One request triggered another.</li><li>That service called another service.</li><li>That service called another service.</li></ul><p>Eventually:</p><pre>Client<br>  |<br>Service A<br>  |<br>Service B<br>  |<br>Service C<br>  |<br>Service D</pre><p>If Service D was slow, the entire request became slow.</p><p>If Service D was down, everything failed.</p><h4>Example</h4><p>Bad Design:</p><pre>Order order = orderService.getOrder(id);<br><br>Customer customer =<br>    customerService.getCustomer(order.getCustomerId());<br><br>Payment payment =<br>    paymentService.getPayment(order.getPaymentId());<br><br>Shipping shipping =<br>    shippingService.getShipping(order.getShippingId());</pre><p>One user request may trigger 4–5 network calls.</p><h4>Better Approach</h4><p>Use:</p><ul><li>Event-driven architecture</li><li>Message queues</li><li>Asynchronous processing</li></ul><p>Tools such as:</p><ul><li>Kafka</li><li>RabbitMQ</li><li>Azure Service Bus</li></ul><p>can significantly reduce service dependencies.</p><h3>5. Poor Logging Practices</h3><p>When everything runs locally, debugging seems easy.</p><p>In production?</p><p>Not so much. I remember spending hours tracing a single request across multiple services.</p><p>The reason?</p><p>Poor logging. We were logging messages like:</p><pre>log.info(&quot;Error occurred&quot;);</pre><blockquote>Which error?</blockquote><blockquote>Which user?</blockquote><blockquote>Which request?</blockquote><blockquote>Which service?</blockquote><h4>Better Logging</h4><pre>log.info(<br>    &quot;Order Created | OrderId={} | UserId={} | Status={}&quot;,<br>    orderId,<br>    userId,<br>    status<br>);</pre><p>Also include:</p><ul><li>Correlation IDs</li><li>Request IDs</li><li>Service names</li><li>Timestamps</li></ul><p>Future you will be grateful.</p><h3>6. Neglecting Centralized Configuration</h3><p>Initially we stored configuration separately inside every application.</p><pre>application.properties</pre><p>for each service we had:</p><pre>Database URLs<br>Port Numbers<br>Secrets<br>API Endpoints<br>Environment Variables</pre><p>duplicated everywhere and updating configuration became a nightmare.</p><h4>Better Approach</h4><p>Use:</p><pre>Spring Cloud Config<br>Azure App Configuration<br>AWS Parameter Store</pre><p>Centralized configuration reduces maintenance significantly.</p><h3>7. No Circuit Breaker Strategy</h3><blockquote>One service failed.</blockquote><blockquote>Then another.</blockquote><blockquote>Then everything started timing out.</blockquote><blockquote>This is called the domino effect.</blockquote><p>Example:</p><pre>Payment Service Down<br><br>↓<br><br>Order Service Waiting<br><br>↓<br><br>Request Timeout<br><br>↓<br><br>Application Slow</pre><h4>Solution</h4><p>Implement Circuit Breakers.</p><p>Using Resilience4j:</p><pre>@CircuitBreaker(<br>    name = &quot;payment-service&quot;,<br>    fallbackMethod = &quot;fallbackResponse&quot;<br>)<br>public Payment getPayment(Long id) {<br>    return paymentClient.getPayment(id);<br>}</pre><p>Fallbacks help maintain partial functionality even when a dependency fails.</p><h3>8. Skipping Proper Monitoring</h3><p>My assumption:</p><blockquote><em>If the application is running, everything is fine.</em></blockquote><p>Wrong.</p><p>Applications can be “running” and still have serious issues.</p><p>Examples:</p><ul><li>High response time</li><li>Memory leaks</li><li>Slow database queries</li><li>Failed background jobs</li></ul><p>Users notice these problems before developers do.</p><h4>Essential Monitoring Stack</h4><p>For Spring Boot:</p><pre>Spring Boot Actuator<br><br>Micrometer<br><br>Prometheus<br><br>Grafana</pre><p>Useful metrics:</p><ul><li>CPU Usage</li><li>Memory Usage</li><li>Response Time</li><li>Error Rate</li><li>Request Count</li></ul><p>If you can’t measure it, you can’t improve it.</p><h3>9. Not Writing Enough Integration Tests</h3><blockquote>I wrote many unit tests.</blockquote><blockquote>Everything passed.</blockquote><blockquote>I shipped confidently.</blockquote><blockquote>Then production failed.</blockquote><p>Why?</p><blockquote>Because services communicate with other services.</blockquote><blockquote>Unit tests don’t validate those interactions.</blockquote><h4>Example</h4><p>Unit Test:</p><pre>@Test<br>void shouldCreateOrder() {<br>    assertNotNull(orderService.createOrder());<br>}</pre><p>Passes successfully.</p><p>But what if:</p><ul><li>Customer Service is unavailable?</li><li>Payment API returns an error?</li><li>Network latency occurs?</li></ul><p>Unit tests won’t catch these issues.</p><h4>Better Strategy</h4><p>Use:</p><ul><li>Integration Tests</li><li>Contract Tests</li><li>End-to-End Tests</li></ul><p>For example:</p><pre>@SpringBootTest<br>@Testcontainers<br>class OrderIntegrationTest {<br>}</pre><p>Always test the communication between services.</p><h3>10. Forgetting That Distributed Systems Are Hard</h3><p>This is probably the most important lesson.</p><p>Many developers think:</p><blockquote><em>“We’re just splitting a monolith.”</em></blockquote><p>Actually, we’re creating a distributed system.</p><p>And distributed systems introduce new challenges:</p><ul><li>Network failures</li><li>Retry strategies</li><li>Eventual consistency</li><li>Message ordering</li><li>Service discovery</li><li>Fault tolerance</li></ul><p>These challenges don’t exist inside a traditional monolith.</p><p>Microservices solve some problems, but they also create new ones.</p><h3>Key Takeaways</h3><p>If I were starting over, these would be my golden rules:</p><p>✅ Start simple</p><p>✅ Don’t split services too early</p><p>✅ Define clear service boundaries</p><p>✅ Avoid shared databases</p><p>✅ Reduce synchronous dependencies</p><p>✅ Invest in logging and monitoring</p><p>✅ Implement resilience patterns</p><p>✅ Write integration tests</p><p>✅ Automate everything possible</p><p>✅ Remember that microservices are a business decision, not a trend</p><h3>Final Thoughts</h3><p>Microservices are powerful, but they aren’t magic. The goal isn’t to have 50 services running in production. The goal is to build software that is reliable, maintainable, and scalable.</p><p>Looking back, most of my mistakes happened because I was focused on architecture diagrams rather than operational reality.</p><p>Today, whenever I design a new system, I ask one question first:</p><blockquote><em>“Will this make life easier for the team six months from now?”</em></blockquote><p>If the answer is no, it’s probably the wrong design choice.</p><p>Microservices should simplify growth, not create complexity. And sometimes, the smartest microservice architecture is not using microservices at all.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eb969996d65a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Prompt Engineering Mistakes Developers Make (And How to Avoid Them)]]></title>
            <link>https://medium.com/@mansikodgire/prompt-engineering-mistakes-developers-make-and-how-to-avoid-them-2c4f80b844b9?source=rss-6266e33b47fd------2</link>
            <guid isPermaLink="false">https://medium.com/p/2c4f80b844b9</guid>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Mansi Kodgire]]></dc:creator>
            <pubDate>Mon, 24 Aug 2026 08:06:23 GMT</pubDate>
            <atom:updated>2026-08-24T08:06:23.488Z</atom:updated>
            <content:encoded><![CDATA[<p><em>After spending months working with AI tools like ChatGPT, GitHub Copilot, and other coding assistants, I realized something interesting: most poor AI outputs are not caused by bad models. They’re caused by bad prompts.</em></p><p>Developers often expect AI to “just understand” what they want. When the result is inaccurate, incomplete, or completely off-track, they blame the AI. In reality, prompt engineering has become a critical skill for modern software engineers.</p><p>In this article, I’ll share some of the most common prompt engineering mistakes developers make and how to avoid them.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3kHpx48eYSQQG0vOYX0Pnw.png" /></figure><h3>Why Prompt Engineering Matters</h3><p>Think of AI as a very intelligent but literal junior developer.</p><p>If you provide vague requirements, you’ll get vague solutions.</p><p>If you provide detailed requirements, context, constraints, and expectations, the quality of the output improves dramatically.</p><p>The difference between a mediocre answer and an excellent answer often comes down to how the prompt is written.</p><h3>Mistake #1: Being Too Vague</h3><p>One of the most common mistakes is giving AI almost no context.</p><p><strong>Bad Prompt</strong></p><pre>Create a login API.</pre><h4>The AI has no idea:</h4><ul><li>Which language you’re using</li><li>Which framework you’re using</li><li>Security requirements</li><li>Database preferences</li><li>Authentication method</li></ul><h4>Better Prompt</h4><pre>Create a Spring Boot REST API for user login using JWT authentication.<br>Use MySQL as the database.<br>Follow industry security practices and include exception handling.</pre><h4>Lesson</h4><p>The quality of output is directly proportional to the quality of context you provide.</p><h3>Mistake #2: Assuming AI Knows Your Project</h3><p>Many developers continue asking questions without explaining the existing project structure.</p><h4>Bad Prompt</h4><pre>Add caching to this application.</pre><h4>Caching where?</h4><ul><li>Service layer?</li><li>Database layer?</li><li>API responses?</li><li>Redis?</li><li>Local cache?</li></ul><p>AI cannot read your mind.</p><h4>Better Prompt</h4><pre>I have a Spring Boot microservice that retrieves customer information from MySQL.<br>The customer records rarely change.<br>Suggest a Redis caching implementation to reduce database calls.</pre><h4>Lesson</h4><p>Always explain the current state before asking for changes.</p><h3>Mistake #3: Asking Multiple Things in One Prompt</h3><p>Developers often dump an entire list of requirements into a single prompt.</p><h4>Example</h4><pre>Create APIs, add authentication, optimize performance,<br>write unit tests, review security, and deploy to AWS.</pre><p>This usually produces shallow results.</p><h4>Better Approach</h4><p>Break complex tasks into smaller prompts.</p><pre>Step 1: Design the API architecture.<br><br>Step 2: Implement authentication.<br><br>Step 3: Generate unit tests.<br><br>Step 4: Review security concerns.</pre><h4>Lesson</h4><p>Treat AI interactions like an engineering process, not a magic command.</p><h3>Mistake #4: Not Defining Constraints</h3><p>Without constraints, AI makes assumptions.</p><h4>Bad Prompt</h4><pre>Optimize this code.</pre><h4>Optimize for what?</h4><ul><li>Speed?</li><li>Memory?</li><li>Readability?</li><li>Cost?</li></ul><h4>Better Prompt</h4><pre>Optimize this Java code for readability while maintaining the same functionality.<br>Avoid introducing additional libraries.</pre><h4>Lesson</h4><p>Clearly define what success looks like.</p><h3>Mistake #5: Ignoring Role-Based Prompting</h3><p>One powerful technique many developers don’t use is assigning a role.</p><h4>Normal Prompt</h4><pre>Review this code.</pre><h4>Better Prompt</h4><pre>Act as a Senior Software Architect.<br><br>Review the following code for:<br>- Performance issues<br>- Security vulnerabilities<br>- Scalability concerns<br>- Maintainability</pre><h4>Lesson</h4><p>Tell the AI who it should act as before asking questions.</p><h3>Mistake #6: Accepting the First Answer</h3><p>Many developers treat the first response as the final solution.</p><p>This is a mistake. Experienced engineers iterate.</p><h4>Follow-Up Questions</h4><pre>Can you simplify this solution?<br><br>What are the drawbacks?<br><br>Can you improve performance?<br><br>Show a production-ready version.</pre><p>The real power of AI comes from refinement.</p><h4>Lesson</h4><p>The first response is often a draft, not the final answer.</p><h3>Mistake #7: Not Providing Examples</h3><p>AI performs significantly better when examples are included.</p><h4>Without Example</h4><pre>Generate a JSON response.</pre><h4>With Example</h4><pre>Generate a JSON response matching this structure:<br><br>{<br>  &quot;userId&quot;: 101,<br>  &quot;name&quot;: &quot;John Doe&quot;,<br>  &quot;status&quot;: &quot;Active&quot;<br>}</pre><p>The AI now understands the expected format.</p><h4>Lesson</h4><p>Examples reduce ambiguity and improve consistency.</p><h3>Mistake #8: Blindly Trusting AI Output</h3><p>This is perhaps the most dangerous mistake.</p><p>AI can:</p><ul><li>Generate outdated code</li><li>Invent APIs</li><li>Misinterpret requirements</li><li>Produce insecure implementations</li></ul><p>Never assume AI-generated code is production-ready.</p><h4>Best Practice</h4><p>Always:</p><p>✅ Review code</p><p>✅ Run tests</p><p>✅ Validate security</p><p>✅ Verify dependencies</p><p>✅ Check documentation</p><h4>Lesson</h4><p>AI is an assistant, not a replacement for engineering judgment.</p><h3>Mistake #9: Forgetting to Ask for Explanations</h3><p>Many developers only ask for code.</p><h4>Better Prompt</h4><pre>Generate the solution and explain:<br><br>1. Why you chose this approach.<br>2. Alternative approaches.<br>3. Potential limitations.</pre><p>This turns AI into a learning tool instead of just a code generator.</p><h4>Lesson</h4><p>Use AI to improve knowledge, not just productivity.</p><h3>Mistake #10: Not Iterating on Prompts</h3><p>Prompt engineering is an iterative process.</p><p>A weak prompt might generate a weak result.</p><p>Instead of giving up, improve the prompt.</p><h4>Example Evolution</h4><p><strong>Version 1</strong></p><pre>Build a dashboard.</pre><p><strong>Version 2</strong></p><pre>Build an Angular dashboard.</pre><p><strong>Version 3</strong></p><pre>Build an Angular dashboard for monitoring application health.<br>Include charts, KPI cards, dark mode support, and responsive design.<br>Use ApexCharts.</pre><p>Notice how each iteration improves the outcome.</p><h4>Lesson</h4><p>Better prompts create better outputs.</p><h3>A Simple Prompt Template for Developers</h3><p>Whenever I work with AI tools, I try to follow this structure:</p><pre>Role:<br>Who should the AI act as?<br><br>Context:<br>What project/problem are you working on?<br><br>Task:<br>What exactly needs to be done?<br><br>Constraints:<br>What rules must be followed?<br><br>Output Format:<br>What should the final response look like?</pre><p>Example</p><pre>Act as a Senior Angular Developer.<br><br>I am building an enterprise dashboard application.<br><br>Create a reusable KPI card component.<br><br>Use Angular 19 and TypeScript.<br><br>Follow clean coding practices.<br><br>Return code with explanations.</pre><p>This simple framework consistently produces better results.</p><h3>Final Thoughts</h3><p>Prompt engineering is quickly becoming one of the most valuable skills for software engineers. The goal isn’t to learn clever tricks or complicated prompt formulas. It’s about communicating requirements clearly, providing context, and iterating intelligently.</p><p>The developers who get the most value from AI are not necessarily the ones using the best tools. They’re the ones asking the best questions.</p><p>As AI becomes a permanent part of software development, prompt engineering will feel less like a special skill and more like an essential engineering practice.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2c4f80b844b9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>