But today, I want to write about the topic of “quitting” a job - We often tend to remain in jobs for a long time even when we know it’s time to move on. Sometimes, it’s a matter of not trusting our own instincts, and sometimes it’s a matter of colluding our thoughts with what we hear from others - “Maybe things will turn around, Maybe I need to stick around, Maybe I am not worthy”. So I want to lay out somethings which have helped me make decisions in the past, and hope it would help you if you are on a similar path.

Whenever I feel like quitting a job, it usually starts as a “feeling” - not some clean spreadsheet-based decision. But every time I’ve dug into those feelings, I’ve found that they’re based on real signals. My brain just takes time to catch up. In these past few months that I was away, I quit my current job to pick up a better paying job in FAANG. In this market, it was a mix of both effort and serendipity, but today, I want to talk about how I decide to change my job, every time I do so.

To help me make sense of it, the PM in me came up with a framework. It’s not perfect. But it helps.

I use one thing to rationalize:
Time.

Time is the commodity I’m offering my company. And that time is made up of:

• Experience

• Skills

• Judgment

• Focus

• Emotional bandwidth

It’s not free. So every year, I ask:
Is the return I’m getting worth the time I’m giving?

⏳ Time = Money

Let’s start with the obvious.

You're giving your literal hours, your late nights, your weekend Slack checks. In return, you're being paid.

So the question is:
Is the money fair for what I’m doing, and the level I’m operating at?

Don’t just look at your title. Look at:

• The scope you're handling

• The impact you’re driving

• The expectations placed on you

• The skills you’ve built that no one’s even acknowledged yet

Check externally. Use:

• Levels.fyi

• Blind (with caution)

• Conversations with peers

If you’re consistently underpaid and the system won’t budge, you’re being undervalued. Staying will only make you resentful.

📌 Money isn’t greedy. It’s acknowledgment.

⏳ Time = Current Opportunities

Even if the pay isn’t ideal, is the work you’re doing right now worth it now?

Ask:

• Is your work visible to leadership?

• Is it in a growth area (GenAI, monetization, platform strategy)?

• Or are you in legacy clean-up duty with no future?

Not all work is equal.

Some jobs are “milk the cow” - steady, but flat.
Some are “build the future” - messy, but full of upside.

Also ask:

• Am I learning to handle cross-functional chaos?

• Am I improving at influence, customer thinking, or storytelling?

• Am I finally in rooms I used to be shut out of?

📌 Current opportunity sharpens your edge. It builds your next move.

⏳ Time = Future Growth Potential

This is the tricky one.

Sometimes you stay not for what the job is - but what it’s supposed to become.

Maybe your manager says, “We’re planning something big for you.”
Or, “This project will get you noticed.”
Or, “Promo’s coming next cycle.”

Cool. But is it real?

Look for signs:

• Are people around you being rewarded - or just strung along?

• Is leadership consistent with follow-through?

• Are you being brought into planning - or just kept in delivery mode?

📌 Hope is not a strategy. If there’s no signal, don’t wait in silence.

⏳ Time = Comfort

Sometimes you stay because the job is... manageable.

You’re recovering from burnout.
You’ve just had a baby.
You’re caring for family.
You don’t have the energy to start fresh.

That’s completely valid.

But here’s the catch:
Comfort is not neutral.

Stay in it too long, and:

• Your skills dull

• Your ambition fades

• You lose touch with the market

📌 Use comfort as a pit stop, not your final destination.

⏳ Time = Relationships & Reputation

Sometimes you stay because you’re building career equity - the kind that doesn’t show up on a payslip.

• Your manager champions you

• Leadership trusts you

• You’re the person people go to when things break

• People say your name when you’re not in the room

This compounds. It gets you your next big scope or referral. But if you’re being passed over, sidelined, or excluded from ownership - even when you're delivering - then you’re not building any equity at all.

📌 You don’t need to be liked by everyone. You just need the right people to bet on you.

⏳ Time = Learning & Intellectual Satisfaction

Is your brain still in the game?

Ask yourself:

• Am I solving new problems?

• Am I learning better judgment, better product taste?

• Or am I just becoming really good at navigating Jira?

If you’re checked out mentally, but still working long hours, you’re not learning. You’re just draining time.

📌 Your brain wants to grow. Feed it something worth staying for.

📉 But First: Market Reality Check

Before you jump ship, pause.

We’re not in a 2021 market anymore. We’re in a cycle of:

• Layoffs and hiring freezes

• Backfills on hold

• PMs fighting over fewer open roles

Even great PMs are underplaced - not because they aren’t good, but because the market isn’t moving.

So before you quit, ask:

• What’s the actual market appetite for your skillset?

• Can you grow quietly for a few months while the dust settles?

• Are you jumping into a better role - or just escaping this one?

📌 Sometimes, staying is not settling. It’s your smartest option in a bad market.

🔁 If You Decide to Stay…

Sometimes, staying is strategic. Not weak.
But don’t use that as an excuse to stagnate.

You don’t need to “crush it.” You just need to move one or two small levers, depending on your bandwidth.

1. Skill Up - Quietly

Pick a new trend that aligns with your work.

• GenAI tools in your domain

• Better async writing or stakeholder storytelling

• Watch teardown videos during lunch - no pressure to “finish”

🎯 1 hour a week adds up. Compound slowly.

2. Be Slightly More Visible

Not performative. Just clear.

• Send a short monthly impact email

• Share 1 lesson on LinkedIn every 2 weeks

• Give feedback on a doc others are ignoring

🎯 You don’t need to go viral. You just need to be remembered.

3. Explore Through Side Projects

If you have energy - and only if.

• Try building a tool in your space

• Play with an old pain point from your job

• Write a 300-word blog post. No pressure to launch a personal brand.

🎯 You don’t need a portfolio. You just need a signal.

3. Build your brand

I cannot stress on this enough. In this market, where the supply is more than the demand, it is really important to stand out. Post on linkedin, write on substack, anything. There is such high value to being visible in this market, I will follow up with a post on this.

🔁 Put It All Together

This isn’t a formula. It’s a gut-check.

Every year, I sit with this:
What am I giving - and what am I getting?

If it’s off, I speak up. I ask for more. Or I quietly start prepping to leave.

Not because I’m trying to get ahead.
But because I’ve learned to respect my time.

By the end of this guide, you’ll understand:

• How to set up a project in Bolt

• How to integrate OpenAI’s DALL·E API for AI-generated images

• How to debug and optimize AI-generated code

• Best practices for structuring AI-generated projects

This step-by-step guide is designed for beginners looking to explore AI-powered app development without writing complex code.

AI coding tools have fascinated me for a while. As a Principal PM, I don’t code daily, but I understand logic and system design. When I came across Bolt, an AI-powered coding tool, I wanted to test whether I could build a working app from scratch—without writing a single line of code.

For this experiment, I decided to build a custom storybook app for toddlers (ages 1-2). The goal was to let parents generate personalized stories with their child’s name, pet’s name, and AI-generated images.

This post will walk through:

• How I built this app using Bolt

• How I integrated OpenAI’s DALL·E API for AI-generated images

• Common challenges & how to fix them

• Tips to make AI-generated code work better

By the end, you should be able to replicate this process and build your own AI-powered app, even if you have no coding experience.

Step 1: Define What We Want to Build

The custom storybook app should:

1. Let parents enter their child’s name, pet’s name, and pet type.

2. Generate a simple, engaging story using these inputs.

3. Fetch a DALL·E-generated illustration that matches the story.

4. Display everything in a clean, responsive UI.

Since this was an MVP (Minimum Viable Product), I constrained the scope:

• Only five pre-written stories (to prevent overcomplication).

• Simple UI with text-based input (no need for fancy animations).

• AI-generated images for each story (instead of manually adding them).

Step 2: Tools Used

To build this, I used:

1. Bolt – The AI Coding Assistant

🔗 Bolt is an AI-powered coding tool running on Claude Sonnet 3.5 that generates functional code based on natural language instructions. Instead of manually writing code, you just describe what you want, and Bolt generates it. To build this app, we need to purchase a $20 monthly subscription, and I think it’s worth it. (I am not affiliated to Bolt)

2. OpenAI’s DALL·E API

🔗 OpenAI provides an image generation API that allows us to create AI-powered illustrations based on text descriptions. This was used to generate custom images for each story. I had purchased about $10 worth of credits.

Step 3: Setting Up the Project in Bolt

1. Create a New Project

• Go to Bolt.new and create a new project.

• Select React as the framework or specify in the prompt that you want a web app.

2. Give an Initial Prompt to Bolt

Since AI-generated code can get messy, I started with a very clear, constrained prompt to ensure Bolt doesn’t overcomplicate things.

Prompt:

"Create a simple responsive web app that displays short children's stories. The user should enter the child’s name, pet’s name, and pet type in a form. The story should be generated using these inputs. There should be five predefined stories, and each story should have a matching AI-generated image."

📌 Tip: Keep your AI prompts clear and structured. Here's an example:

❌ Vague Prompt: "Create a storybook app."

✅ Better Prompt: "Create a simple responsive web app that allows users to input a child's name, pet’s name, and pet type. The app should generate a predefined short story using these inputs and display a matching AI-generated image.". Bolt tends to over-engineer solutions if you give vague instructions.

I am asking only for 5 stories in the beginning so that it is simple. If I don’t specify, there is a chance that Bolt may overcomplicate.

Step 4: Bolt Generates the Base App

After running the prompt, Bolt generated a basic web app with:

• A form for child’s name, pet name, and pet type

• Predefined five short stories

• A simple page navigation structure

🚨 What went wrong?

• Bolt generated functional code but with several limitations.

  • Static images were hardcoded instead of being dynamically generated.

  • The form design was too basic and lacked interactivity.

  • There was no error handling or validation for user inputs.

  • Navigation between stories wasn't smooth, making the UX clunky.

Fixing the UI

I asked Bolt to improve the form:

Prompt:

"Make the form more interactive. Add icons for pet types. Ensure text boxes are visually clear as input fields."

✔ Now, the form looked better. But still, the images weren’t dynamic.

Step 5: Integrating DALL·E for AI-Generated Images

Since the hardcoded images didn’t match the stories, I had to integrate OpenAI’s DALL·E API.

1. Creating an OpenAI API Key and .env File

Before using the OpenAI API, you need to generate an API key to authenticate requests securely. Storing API keys directly in your code is a security risk, so it's best practice to use a .env (environment) file to keep sensitive information separate.

Steps to Generate and Store an OpenAI API Key Securely

1. Generate an API Key:

   • Go to OpenAI’s API dashboard.

   • Log in or create an account.

   • Navigate to the API Keys section and generate a new secret key.

2. Ask Bolt to Create a .env File:

   • Instead of manually adding the key to your code, store it securely in a .env file.

   • Use the following prompt to instruct Bolt:

     Prompt:

"Create a .env file to store the OpenAI API key. Update the code to fetch the key from the .env file instead of hardcoding it."

1. Manually Add the API Key:

   • Once Bolt generates the .env file, open it and paste your API key in the following format:

OPENAI_API_KEY=your_api_key_here

1. • Ensure your application reads the API key from the .env file instead of storing it in the main codebase.

By following this method, you enhance security and prevent exposing API keys in public repositories. This is a best practice when working with external APIs like OpenAI’s DALL·E.

Before using the OpenAI API, I needed to create an API key:

• Go to OpenAI’s API dashboard

• Create an account or log in

• Navigate to the API Keys section and generate a new secret key

Once I had the key, I asked Bolt to create a .env file to securely store it:

Prompt:

"Create a .env file to store the OpenAI API key. Update the code to fetch the key from the .env file instead of hardcoding it."

After Bolt generated the file, I manually copied the API key into it to ensure security.

2. Generating Images Dynamically

I gave Bolt a new prompt:

Prompt:

"For each story, fetch an AI-generated image from OpenAI’s DALL·E API. The image should include the child, the pet, and a scene from the story. The API key should be stored in the .env file."

Bolt created the necessary API call to OpenAI, but there were some issues:
🚨 It didn’t generate new images for each story change.
🚨 There was a delay in fetching images, making the UI feel slow.

Since the hardcoded images didn’t match the stories, I had to integrate OpenAI’s DALL·E API.

Step 6: Debugging and Optimizing the App

1. Fixing the Image Issue – Ask AI to Explain Before Fixing

Before making any changes, always ask Bolt to explain the issue first. This ensures you understand the logic behind its decisions before modifying the code.

Prompt:

"Before making any code changes, explain why the image is not changing for each story. What part of the logic is causing this issue?"

✔ Bolt analyzed the issue and explained that the app was reusing the same image across all stories because it wasn’t fetching a new one when navigating between them.

By confirming the logic first, we ensured that any fixes wouldn’t introduce unnecessary complexity. Once satisfied with the explanation, we applied the fix.

Before making any changes, I first asked Bolt to explain the issue to ensure we understood the root cause. This is an important step because AI-generated code can sometimes overcomplicate solutions if we start fixing things without fully diagnosing the problem.

Fix:

"Ensure each story fetches a fresh image when navigating to a new story. Debug the logic if needed before making code changes."

✔ This helped, and Bolt correctly updated images for each story.

Bolt kept using the same image for all stories.

Fix:

"Ensure each story fetches a fresh image when navigating to a new story. Debug the logic if needed before making code changes."

✔ This helped, and Bolt correctly updated images for each story.

2. Reducing Latency in Image Loading

To fix the delay in fetching images, I added a loading animation:

Prompt:

"Add a loading animation when generating the AI image to improve the user experience."

✔ Now, the app didn’t feel unresponsive while images loaded.

3. Ensuring Character Consistency Across Stories

Each story’s image looked different (the kid and pet had no visual continuity).

Fix:

"Ensure the same child and pet character style is maintained across all stories."

✔ Now, the experience felt seamless.

Final Thoughts: AI Can Help You Build Apps, But we need to polish

This experiment showed me that AI can generate 70% of the code, but the last 30% (debugging, optimizing, refining) still needs human intervention.

Would I recommend this approach? Absolutely—for MVPs, quick hacks, or learning projects. For production-level apps, you’ll still need human oversight.

Key Takeaways & Next Steps

✅ AI tools can speed up development, but debugging and optimizations are still necessary.

✅ Structured prompts help AI generate cleaner and more functional code.

✅ Testing and iteration are essential—AI-generated code isn't always perfect.

✅ Bolt is great for MVPs, but production apps require human oversight.

If you enjoyed this tutorial and want to explore more AI-powered product development, follow my Substack for more in-depth insights! 🚀

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

As Product Managers, we constantly identify problems and think of solutions. But how often do we take those solutions from ideation to execution? For many PMs, the technical barrier stops them in their tracks. I’ve been there too. Without a solid programming background (though I understand system design), the idea of building an app seemed intimidating.

But recently, I challenged myself to build a solution to a recurring problem I’ve seen in the PM community: interview anxiety. Many aspiring PMs struggle to practice for interviews, even mock sessions with peers, fearing judgment or not receiving actionable feedback.

That’s when I thought of creating a safe space for PMs to practice interviews. An AI-powered app that would:

• Provide a comprehensive question bank covering key PM skills.

• Allow users to record their answers for realistic practice.

• Offer specific, actionable feedback to help them improve.

I had this vision, and to bring it to life, I turned to Bolt.new—a platform that lets non-programmers like me build functional apps without losing our sanity. After some trial and error (and a few “what the hell is this error?” moments), I built a fully functional PM Interview App. It took me about 10-12 hours in total, spread over a few days—partly because I kept tweaking ideas, and partly because Bolt had a habit of throwing unexpected errors every time I changed a component.

Here’s how I did it and how you can too.

What’s the App About?

I wanted the app to be a place where users can practice mocks without anxiety and get actual contextual feedback.

Comprehensive Question Bank: It includes categories like Product Sense, Strategy, Estimations, and Stakeholder Management to ensure holistic interview preparation.

Voice Recording for Realism: Users can record their answers, simulating the actual interview environment.

Actionable AI Feedback: The app provides detailed, specific suggestions to improve performance.

With this setup, candidates can build confidence and refine their answers before moving to peer mocks or real interviews. It’s fully functional and can be used

How I Built the App Using Bolt.new

1. Starting with the Idea

The first step was translating my idea into a prototype. Bolt makes this easy: you describe your vision, and it generates a functional skeleton of the app. I outlined the app’s purpose and key features, and Bolt quickly gave me a basic working version.

The core idea was to get a PM interview question, user would answer via voice preferably, and they would get tailored feedback as if it were a regular interview.

Once the idea was in place, I give bolt the prompt to create the app, something like “Create a mock interview app for Product Managers with questions from different categories - Product Sense, Estimations, Stakeholder management and Strategy. Allow them to choose questions from any category. They can answer through voice or typing, and then the answer is passed to open AI API to get relevant feedback”. This creates a basic app flow, which can be further tweaked by giving similar prompts.

2. Setting Up Integrations

To make the app functional, I had to have a relevant question, voice input for user, and contextual feedback for the answer provided by the user. I wanted to generate the questions using the app itself, however, I didnt want it to hit the api everytime because it would be costly. So, I pre-generated 50+ questions. I wanted the answer, however, to get contextual feedback which meant that every answer is hitting the Open AI api. Because I wanted to open it up for free to other users, I wanted to limit the tries to 3.

I had to have a question bank which I generated using prompts, to get the feedback, I had to pass it to Open AI API which and structure the prompt to give proper structured feedback. Then used netlify to deplot the app. So, all these needed have some integrations set up - Thankfully, Bolt has all these built in.

To make the app functional, I did these integrations:

• OpenAI API: This powers the feedback system, generating actionable insights based on user responses.

• Supabase: An open-source backend-as-a-service platform that provides a database solution, making it easy to store user responses and track activity. Supabase simplifies backend setups and offers real-time capabilities, allowing me to store and retrieve practice session data effortlessly.

• Netlify: A powerful platform for deploying and hosting web apps. It automates builds, integrates seamlessly with Git repositories, and ensures fast, reliable performance through its built-in global Content Delivery Network (CDN). Using Netlify, I could share the app quickly without worrying about server management or downtime.

Bolt’s built-in integrations for these tools made setup straightforward. All I had to do was:

• Configure my OpenAI API keys.

• Connect Supabase for backend tracking and data storage.

• Deploy the app on Netlify for a professional-grade hosting solution.

3. Iterating and Refining

The initial prototype worked well, but I wanted to enhance the user experience. Here’s how I iterated:

• UI Improvements: Bolt did give me a 60% ok prototype, but there were a lot of things that I adjusted, so that the layout and design looked more intuitive.

• Feedback Quality: The AI’s feedback is the app’s core feature. To improve it, I refined the prompts, ensuring the suggestions were actionable and relevant.

During this phase, I used ChatGPT extensively to tackle several aspects of the app’s development process. Here’s how it helped me:

• Debugging Minor Issues: For example, when my OpenAI API key wasn’t being accepted due to formatting errors, ChatGPT provided clear explanations and solutions, which I then implemented in Bolt.

• Improving Prompts: Crafting effective prompts is key to getting high-quality output from AI. ChatGPT helped me rework and refine prompts for Bolt, ensuring the system produced accurate and actionable results.

• Refining Requirements: The feedback feature is the heart of the app, and I needed it to be as specific and actionable as possible. I used ChatGPT to brainstorm and define the exact requirements, which improved the clarity and usability of the feedback system.

I think my familiarity with chatgpt more than Claude maybe the reason why I used it more.

Building the app wasn’t entirely smooth sailing. Here are the key challenges I faced and how I overcame them:

1. Code Overwrites

Bolt sometimes rewrote entire files for small changes, which could disrupt functionality. For instance, while trying to adjust a minor UI element, the platform rewrote critical sections of the feedback logic, creating bugs. To avoid setbacks, I made it a habit to take regular backups and carefully review changes before deploying.

2. Debugging Loops

At times, Bolt got stuck in loops trying to fix issues. For example, when I attempted to enhance the voice recording functionality, Bolt repeatedly generated conflicting code snippets. Using console logs helped me pinpoint where the logic was failing. I also guided Bolt with alternative prompts to change its approach, breaking the loop effectively.

Another trick that is very helpful is to tell Bolt explicitly “Don’t code, just analyse and tell” - it helped me understand the logic and suggest steps to perform, instead of it going in a loop and changing things. I saw that repeatedly it would take more complex logic steps to solve easy problems instead of using a straight-forward easy way.

3. AI Understanding

A lot of times because of Bolt going around in circles trying to fix or change code, I began prefacing my queries with “Don’t code yet, just explain” - This helped me understand the code better - Sometimes, I found that it was taking complicated routes for simple changes, and I brought it back to the right direction, It was either because I was not verbose enough, or it just made some assumptions and ran with it.

Despite these hurdles, the process was incredibly intuitive for someone with no programming experience. With a combination of persistence, creative prompting, and external tools, I was able to overcome these challenges.

Key Learnings for PMs Who Want to Build Apps

Overall, at this stage I think AI is like a Junior Developer, than a Mid or Senior Developer. At many times during my experience, it was picking complicated paths to solve simple problems. I had to stop, ask and redirect.

Somethings I understood:

1. You Don’t Need to Be a Programmer: Tools like Bolt lower the technical barrier, allowing PMs to focus on the user problem rather than the technical implementation. However, if we don’t understand basic system design or programming logic, it becomes tough to debug after a while.

2. Leverage AI for Iteration: ChatGPT and Bolt can work together beautifully. Use one for refining ideas and the other for execution.

3. Backup Your Work: AI platforms can be unpredictable, so regular backups are a lifesaver.

4. Prioritize the User Experience: Even in a prototype, usability and clarity matter. Small details, like actionable feedback, can make a big difference.

Why PMs Should Try Prototyping

Prototyping isn’t just for engineers or designers. As PMs, we’re closest to the problem and its potential solution. Building prototypes allows us to:

• Test ideas quickly.

• Communicate better with stakeholders.

• Develop a deeper understanding of the product development process.

With platforms like Bolt, the barriers to entry have never been lower. Whether you’re a seasoned PM or just starting out, building your ideas has never been more accessible.

From Idea to Execution

Building this app was an eye-opening experience. It showed me that the biggest limitation is often our own hesitation. With tools like Bolt and a bit of perseverance, anyone can bring their ideas to life.

If you’re a PM with an idea you’ve been sitting on, why not give it a try? Bolt.new might just be the launchpad you need.

Let’s democratize app-building and empower PMs to create impactful solutions. 🚀

Get Access to the App by Subscribing

I will share free early access to the app to 50 of my subscribers, who I will pick randomly. Please subscribe below to get access.

Subscribe now

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

Writing a PRD can sometimes feel mechanical. Many PMs start with a template and fill it out as if it’s a checklist: "Onboarding? Okay, we need a progress bar, some user flows, and something about reducing friction." Then there’s a vague section about "why this is important," but it often feels disconnected from what’s being built.

The result is a PRD that’s full of features but fails to inspire. It doesn’t convince stakeholders of the urgency, it doesn’t rally the team, and—most importantly—it doesn’t make the reader feel the connection between the problem, the solution, and the value it delivers.

If you’ve felt this way before, you’re not alone. Writing a PRD that truly resonates isn’t easy, but it’s a skill you can build. And the key lies in telling a story.

Why PRDs Need to Tell a Story

A great PRD doesn’t just describe features; it explains why those features matter. It walks the reader through a journey:

1. What’s happening? What problem are we solving?

2. Why does it matter? Why is this worth solving, and why now?

3. What will we do about it? What’s the solution, and how does it address the problem?

4. How will we measure success? How will we know we’ve solved the problem?

5. What happens next? What are the contingencies if the problem persists?

This narrative doesn’t just help others understand your product vision—it helps you refine your thinking. By connecting every decision to the underlying "why," you ensure that your PRD is focused, actionable, and aligned with your goals.

Why PRDs Are Hard

Writing a good PRD is tough. If you’re new to product management, it can feel overwhelming to articulate problems, tie them to solutions, and anticipate every question your team might have. Even seasoned PMs sometimes fall into the trap of overloading a PRD with information or skipping the "why" in favor of jumping straight to the "what."

A PRD is not just about documentation. It’s about alignment. A well-written PRD ensures that everyone—designers, developers, QA, stakeholders—understands the problem and believes in the solution. If people aren’t aligned, execution suffers. And when execution suffers, so does the product.

So, if you’re struggling with PRDs, don’t be hard on yourself. Let’s walk through a practical, step-by-step process to make them better.

No BS Guide to Writing a Great PRD

1. Start With the Problem (The "What’s Happening?")

   • Be specific and grounded. Use data and anecdotes to paint a clear picture of the problem.

   • Example: “Cart abandonment rates have increased by 20% in the past quarter, resulting in a loss of $X in revenue.”

   • Tip for beginners: If you’re unsure what the problem is, spend more time talking to users, reviewing analytics, and collaborating with your team before starting the PRD. The clarity of your problem statement will make or break your PRD.

2. Explain the Why (The "Why Does It Matter?")

   • Connect the problem to its broader impact. Why should the company care? Why should your team prioritize this now?

   • Example: “This trend poses a significant risk to our revenue targets for the quarter and negatively impacts customer trust when they encounter friction at checkout.”

3. Propose a Solution (The "What Will We Do About It?")

   • Outline the solution in clear, actionable steps. Avoid feature dumping—each feature should directly address part of the problem.

   • Example: “To reduce drop-offs, we will:
     a) Consolidate redundant form fields,
     b) Add progress indicators to reduce anxiety, and
     c) Implement autofill suggestions to speed up data entry.”

   • Be transparent about trade-offs and scope. If a feature won’t solve the problem fully, acknowledge it and explain why you’re starting here.

4. Define Success Metrics (The "How Will We Measure Success?")

   • This step is often overlooked, but it’s critical. Success metrics ensure your PRD is outcome-driven, not output-driven.

   • Example: “We will consider this successful if cart completion rates increase from 60% to 75% within 90 days of release.”

5. Address Contingencies (The "What Happens Next?")

   • Show that you’ve thought about what happens if the solution doesn’t work as expected. This builds confidence in your plan.

   • Example: “If completion rates don’t improve by at least 15%, we will run additional A/B tests on alternative form designs and explore adding a guest checkout option.”

Common Pitfalls to Avoid

1. Overloading With Detail: Avoid the temptation to document everything. Focus on what’s essential to align your team. If it doesn’t help someone make a decision or understand the problem, leave it out.

2. Skipping the "Why": This is the most common mistake. If the PRD doesn’t explain why a feature matters, it’s just a checklist.

3. Unclear Metrics: If you don’t define success, you’ll have no way to know if your solution worked—or how to iterate if it didn’t.

It’s Okay to Iterate

If this feels like a lot to take in, remember that writing great PRDs is a skill that improves with practice. Your first draft might not be perfect, and that’s okay. Share it with your team early, get feedback, and refine it. The process of writing and revising is just as important as the final document.

As you gain experience, you’ll notice that writing PRDs becomes less about following a rigid structure and more about shaping the narrative that your product needs. You’ll develop your own style, but the principles will remain the same: start with the problem, explain why it matters, and connect every decision to that context.

Write With Purpose, Build With Confidence

A PRD isn’t just a document—it’s your product’s blueprint for success. Done well, it inspires trust, aligns teams, and ensures everyone is working toward the same goal.

So, the next time you sit down to write a PRD, take a deep breath and remember: your job isn’t to list features. It’s to tell a story. A story about a problem that matters, a solution that makes sense, and a plan that will deliver value.

And trust me—when your PRD tells that story clearly and thoughtfully, people will not only read it, but they’ll act on it.

Every aspiring PM has read about frameworks. CIRCLES, AARM, GLEe—whatever acronym you choose, they all serve the same purpose: giving structure to your thinking. And while structure is useful, blindly following a framework is the fastest way to fail a PM interview.

I recently conducted a mock interview where I asked the candidate to design a solution for a new pet owner. His response? Textbook perfect. He started with defining the problem, identifying user personas, mapping out pain points, and slowly building his way to a solution. It was smooth, logical, and well-structured. But there was one glaring problem—I could tell from the first five minutes that he had already thought of the solution beforehand. Every step of his framework execution was a carefully engineered justification for an answer he had pre-determined.

And here’s the thing: any experienced interviewer can spot this instantly.

Why Frameworks Alone Won’t Get You Hired

Frameworks are tools, not rules. They help you structure your thought process, but the real test in an interview is how deeply and uniquely you think. If your answer sounds like something the interviewer has heard before, you won’t stand out. If you’re too focused on following a formula, you’ll miss the most important part: actually solving the problem in an original way.

Here’s what most candidates don’t realize: PM interviewers have short attention spans. They aren’t grading you on whether you’ve checked all the boxes of a framework. They want to see how you approach a problem, how you empathize with users, and whether your insights are actually valuable. If your answer feels overly structured but lacks fresh thinking, they’ll mentally check out within the first two minutes.

How to Use Frameworks the Right Way

Instead of using frameworks as a script, use them as an aid. Here’s how:

1. Start with genuine curiosity. Forget the framework for a moment. Think deeply about the user and their pain points before you jump to structuring your answer.

2. Ask yourself: What’s different about this problem? If you’ve seen a similar question before, resist the urge to reuse an old answer. Instead, look for new angles or hidden complexities.

3. Use the framework as a sanity check, not a crutch. Once you’ve explored the problem thoroughly, then use a framework to ensure your answer is structured and logical.

4. Engage the interviewer in your thinking. Don’t just present a rehearsed answer—talk through your thought process naturally. Make it feel like a conversation, not a script.

Example: Designing a Smart Fridge Feature Using CIRCLES Framework

Imagine you're asked: "How would you design a new feature for a smart fridge?"

Answer Using a Framework as a Crutch (Poor Approach)

1. Comprehend the Situation

• Smart fridges help users manage food and reduce waste.

2. Identify the Customer

• Personas: busy professionals, families, and health-conscious individuals.

3. Report Customer Needs

• Pain points: forgetting expiry dates, overbuying groceries, and meal planning challenges.

4. Cut Through Prioritization

• Focusing on expiry tracking as the key feature.

5. List Solutions

• An automated system that tracks expiration dates and suggests recipes.

6. Evaluate Trade-offs

• Pros: reduces waste; Cons: might not work for all food types.

7. Summarize Recommendation

• A recipe-suggestion feature based on expiry tracking.

Sounds structured, right? But it's also predictable and generic—an answer anyone could give after reading a PM interview book.

Answer That Shows Deep Thinking (Better Approach)

1. Comprehend the Situation

• I'd explore how people currently interact with smart fridges. Do they trust automated tracking? Do they even use it?

2. Identify the Customer

• Instead of just broad personas, I’d explore behavioral patterns:

  • Are they proactive planners or last-minute shoppers?

  • Do they rely on a grocery list or buy on impulse?

  • How much do they trust technology with food decisions?

3. Report Customer Needs

• Instead of just expiry tracking, users might struggle with:

  • Forgetting what’s already in their fridge

  • Not knowing when to restock essentials

  • Not trusting an AI to determine food freshness accurately.

4. Cut Through Prioritization

• Rather than focusing on expiry dates, I’d prioritize reducing manual effort in tracking what’s available and predicting future needs.

5. List Solutions

• Instead of just expiry tracking, what if we used weight sensors and vision AI? The fridge could detect consumption patterns and predict restocking needs before an item runs out.

6. Evaluate Trade-offs

• Pros: reduces both waste and manual tracking; Cons: may need user calibration initially.

7. Summarize Recommendation

• Instead of only focusing on expiry dates, I’d suggest a dynamic inventory system that learns from user habits and nudges them to restock essentials before they run out.

This answer still follows a structured approach, but it challenges assumptions, digs deeper into user behavior, and presents a unique, compelling idea.

The Bottom Line

If you treat PM interviews like a checklist of frameworks, you’ll blend into the crowd. If you focus on deep thinking, user empathy, and original insights, you’ll stand out.

So next time you step into an interview, don’t let the framework lead—you lead, and let the framework follow.

When done right, a roadmap keeps teams focused, aligns stakeholders, and provides a reference point for decision-making. But in reality, things often get messy. Instead of being driven by business needs, customer problems, and user insights, roadmaps frequently get hijacked by internal politics, leadership whims, and department-level turf wars. High-level ambitions from leadership may clash with the day-to-day realities of execution, leaving teams stuck between bold vision statements and real-world constraints.

The challenge is to cut through the noise. A strong roadmap isn’t just a feature list—it’s a strategic tool that balances stakeholder input, customer impact, and business priorities while staying grounded in execution realities. And if you don’t actively manage this, your roadmap will manage you.

Before You Start: Gather the Right Inputs

Before jumping into a roadmap, the first step is to bring all stakeholders together and collect diverse perspectives. This means understanding:

• Sales feedback – What are customers asking for the most? Where are we losing deals?

• Customer Success insights – What pain points cause churn or dissatisfaction?

• User reviews & research – What are users loving? What’s frustrating them?

• Executive & leadership vision – What direction do the HiPPOs (Highest Paid Person’s Opinions) want to go in?

• Market & competitive analysis – Where are we lagging? Where are the opportunities?

What You’ll Actually Do with This Information

👉 Don’t take feedback at face value. Instead of listing requests as they come, look for common themes.
Example:

• Sales says, “We need Feature A because our competitors have it.”

• Customer Success says, “Users complain about Feature B being slow.”

• User feedback highlights, “Feature B is confusing.”

🔍 Pattern: The real issue might not be the lack of Feature A, but that Feature B needs optimization—which could drive more retention than blindly copying a competitor.

How to Synthesize Data Effectively

1. Categorize all incoming feedback (Growth blockers, churn issues, UX friction, new opportunities).

2. Identify patterns & overlaps rather than treating each input as separate.

3. Validate through data – Are users actually dropping off because of this, or is it just loud feedback?

Step 1: Define a Vision That’s Acceptable to All

Your roadmap needs to be a strategic narrative, not a wishlist of features. A poor roadmap might simply list feature requests from various stakeholders without any alignment to business goals or user needs. It becomes a scattered collection of desires without a clear strategy.

In contrast, a well-structured roadmap prioritizes initiatives based on impact, feasibility, and alignment with the product vision. It tells a story of how the product will evolve, why certain trade-offs are made, and how each step contributes to long-term success. The vision must be directionally sound and broadly accepted, even if not everyone is fully satisfied. Not all stakeholders will get what they want, but a strong product vision should balance user needs, business goals, and execution realities.

How to Craft a Roadmap Vision That Survives Stakeholder Scrutiny

• Should be aspirational but grounded – Something teams can rally around, but not a vague “North Star” that doesn’t translate to action.

• Must be tied to business objectives – If leadership is focused on ARR growth, your roadmap should reflect that.

• Should set boundaries – It’s not just about what’s included, but also what’s explicitly NOT a priority.

👉 Example of a Weak Roadmap Vision:
"We aim to be the best collaboration platform." (Too vague, doesn’t guide execution.)

👉 Example of a Strong Roadmap Vision:
"Our goal is to improve team productivity by reducing task-switching by 30% within 12 months."

✅ Why this works: It’s specific, measurable, and connects to real user and business needs.

Step 2: Prioritize by Impact

One of the most common struggles for early PMs is defining impact. To assess impact effectively, you need a deep understanding of your product, the key metrics that drive it, and the features that influence those metrics. Impact should be tied to measurable outcomes—whether it’s improving retention, increasing revenue, reducing churn, or enhancing user engagement.

Consider reach as well. An impactful feature isn't just about moving a key metric—it’s also about how many users it affects. A minor improvement to a widely used feature can be more valuable than a major overhaul of something few users touch.

👉 Prioritization Framework: If you struggle to define impact, ask:

1. Does this directly ladder up to a key business metric?

2. How many users will benefit (reach)?

3. How painful is the problem (urgency)?

4. Does fixing this unlock future growth?

With this understanding in mind, the first filter for prioritization should always be impact—rank items from highest to lowest impact. But here’s the reality check: Not everything that is high impact can (or should) be built. Impact alone doesn’t guarantee execution.

Here’s where alignment matters:

• Does everyone agree on what “high impact” means?

• Your opinion might differ from engineering leadership, design, or other teams.

• Use data to tell the story – Back up your prioritization with competitive benchmarks, market trends, product metrics, and user feedback.

Step 3: Factor in Resourcing Constraints

Making Trade-Offs in Resourcing

• If engineering bandwidth is limited, consider reducing scope or breaking large initiatives into phases.

• If design resources are stretched, explore whether existing design patterns can be leveraged instead of creating new ones.

• Be proactive in assessing resourcing gaps and discussing potential reallocations early in the planning process.

The second layer of prioritization is feasibility:

• Do you have enough engineering & design bandwidth?

• Do you need to secure more resources?

• Do you have more resources than needed, leading to potential inefficiencies?

• High-impact, high-effort items might need de-prioritization due to time/resource limitations.

👉 How to Handle Pushback:
📌 Eng: “This will take 6 months.” PM: “Can we phase it? What’s the smallest version we can ship to validate first?”
📌 Leadership: “We need this feature now.” PM: “Here’s the trade-off. To do this, we’ll need to de-prioritize X. Is that acceptable?”

The key is to prioritize by impact first and then adjust based on execution feasibility.

Integrating the RICE Framework Into Prioritization

The RICE (Reach, Impact, Confidence, Effort) framework is a useful guideline for prioritization, but it shouldn’t be treated as an absolute decision-making tool. It helps quantify decisions by assigning scores based on:

• Reach – How many users will be affected by this initiative?

• Impact – How significant is the effect on those users?

• Confidence – How certain are you about the impact estimate?

• Effort – How much time and resources will it take?

Rather than using RICE scores in isolation, apply them alongside other qualitative factors. For instance, even if an initiative scores well, ask whether it aligns with your product vision and strategic objectives. A high-scoring RICE item may need to be deprioritized if it conflicts with long-term goals, or a lower-scoring item may be prioritized due to competitive pressure or dependencies.

A pragmatic way to use RICE is to compare high-priority initiatives with stakeholders and ensure alignment. Instead of treating it as an absolute ranking, use it to facilitate conversations about what should be built next.

Step 4: Drive Alignment

Bringing stakeholders together for alignment, not approval, is key. There will always be pushback, but the goal is to ensure clarity and collective understanding, not universal agreement. A roadmap is a guiding document, not a legally binding contract.

Handling Stakeholder Conflicts

• When HiPPOs push for initiatives that don’t align with data, present clear, evidence-backed alternatives.

• Facilitate discussions that frame decisions around product vision and business objectives, rather than individual preferences.

• Create a structured decision-making process so that disagreements can be resolved objectively, rather than through influence or hierarchy.

Step 5: Roadmaps Are Living Documents – Expect Change

Mid-cycle shifts happen no matter how perfect your roadmap is.

How to Handle Changing Priorities

• Build Buffer Capacity: Plan for 15-20% of roadmap items to change based on new learnings.

• Regular Checkpoints: Monthly roadmap reviews ensure execution stays on track.

• Stakeholder Buy-in: Keep leadership updated so changes aren’t a surprise.

A great roadmap is not just about listing features; it’s about telling a compelling, data-backed story that aligns stakeholders and sets the product up for success. If you keep your vision clear, prioritization disciplined, and execution flexible, you’ll create a roadmap that actually delivers results—not just a fancy slide deck for leadership meetings.

Every week, I tackle common challenges that PMs face by sharing straightforward advice, actionable tips, and proven strategies to navigate tough situations, win over stakeholders, and elevate your PM skills.

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

As a PM, you’re not just steering the development of products; you’re also bearing the weight of everyone’s emotions—your own included. Unlike other roles, where emotional challenges might be a side note, emotions are front and center for us. Stakeholders have opinions, team members have frustrations, customers have expectations, and all of it somehow lands in your lap. The truth is, PMs often end up absorbing the emotional fallout of every hiccup, decision, or disagreement. It’s not fair, but it’s the reality of the job.

Navigating this emotional rollercoaster isn’t just about staying calm under pressure. It’s about managing the feelings of others while ensuring the work gets done. If you can handle these dynamics well, you’ll earn the respect and trust that make you a great PM. But let’s not sugarcoat it: this takes practice. Let’s break down five of the most common conflicts PMs face and, more importantly, how to deal with them effectively.

Top 5 Conflicts and How to Manage Them

1. Misalignment Between Stakeholder Expectations and Product Vision

Scenario: Stakeholders have conflicting ideas about what the product should deliver, and everyone seems to think their priority is the most important.

Why It Happens: Misalignment creeps in when stakeholders don’t share a clear understanding of the product’s goals or when communication gaps leave room for misinterpretation.

How to Handle It:

1. Facilitate Open Dialogue: Regularly bring stakeholders together to align on the product vision and priorities. Make sure everyone’s working from the same playbook.

2. Document Agreements: Keep a clear, accessible record of decisions and priorities. When disagreements resurface, you’ll have something to refer back to.

3. Mediate with Context: When opinions clash, anchor discussions in customer needs and business goals to refocus the conversation on what truly matters.

2. Team Burnout Due to Resource Constraints

Scenario: Your team is juggling too much, and you can see the stress building. Deliverables are slipping, and morale is tanking.

Why It Happens: Startups, big companies, doesn’t matter—resources are always limited, and the backlog is always full.

How to Handle It:

1. Prioritize Ruthlessly: Work with your team to focus on the most impactful tasks. Anything that doesn’t move the needle can wait.

2. Set Realistic Expectations: Keep stakeholders in the loop about what’s feasible with the current resources. Over-promising will only make things worse.

3. Advocate for Your Team: If the workload is unsustainable, push for more resources. Show leadership the risks of not addressing the problem.

3. Resistance to Change Within the Team

Scenario: You’re introducing a new process, tool, or way of working, and the team isn’t having it. The pushback is real.

Why It Happens: Change is hard, especially when people are comfortable with the status quo. It’s easier to stick with what you know.

How to Handle It:

1. Bring Them In Early: Involve the team in shaping the change from the start. When people feel ownership, they’re more likely to buy in.

2. Offer Support: Don’t just drop new tools or processes on the team and hope for the best. Provide training and be available to answer questions.

3. Show the Value: Be explicit about how the change will make their lives easier or their work better. If they see the benefit, they’ll come around.

4. Conflicting Feedback from Stakeholders

Scenario: One stakeholder wants X, another wants Y, and they’re both convinced they’re right. You’re stuck in the middle.

Why It Happens: Different stakeholders have different priorities—and sometimes, they just don’t get along.

How to Handle It:

1. Consolidate Feedback: Gather input from all sides and look for common ground. Often, there’s overlap that can guide the solution.

2. Focus on Impact: Frame decisions around the customer and the business. What’s going to deliver the most value?

3. Get Agreement in the Room: If conflict persists, bring stakeholders together to hash it out. Your job is to facilitate, not to take sides.

5. Customer Escalations

Scenario: A customer is furious about a bug, a missing feature, or an unmet expectation, and they’re letting everyone know about it.

Why It Happens: Customers are emotionally invested in your product. When it doesn’t meet their needs, they feel frustrated—and that frustration lands on you.

How to Handle It:

1. Acknowledge Their Frustration: Start with empathy. Let them know you hear them and that their concerns are valid.

2. Act Quickly: Even if you don’t have a full solution yet, show that you’re on it. A temporary fix or clear next steps can go a long way.

3. Follow Up: Close the loop by sharing what you’ve done to address the issue. It shows you care and builds trust.

Being a PM means constantly walking the tightrope of emotions—yours, your team’s, your stakeholders’, and your customers’. It’s not easy, but it’s also what makes this role so impactful. By managing these conflicts thoughtfully and leading with empathy, you’ll not only navigate the emotional chaos but also earn the trust and respect that drive great products forward.

Every week, I tackle common challenges that PMs face by sharing straightforward advice, actionable tips, and proven strategies to navigate tough situations, win over stakeholders, and elevate your PM skills.

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

Layoffs are never easy. When industry leaders like those in FAANG announce sweeping job cuts, it shows the volatility of the tech industry and leaves a lasting impact on employees and teams across the board. Combine that with the swift rise of Gen AI that’s already automating tasks once considered human—and it’s no wonder so many of us feel like the ground is shifting beneath our feet. The uncertainty isn’t just in our minds —it’s evident in the workplace, in our conversations with stakeholders, and in the dynamics of our teams.

If you’re a Product Manager, this season feels especially loaded. You’re likely juggling your own anxieties while being the one expected to provide clarity and direction. This post is about acknowledging that reality and offering practical ways to navigate it.

When Work Becomes a Source of Anxiety

For many of us, work has become a significant source of stress. You find yourself replaying conversations in your head, wondering if you’re doing “enough” to stay relevant. Every decision feels like it’s under a microscope, every roadmap scrutinized for value. And then there’s the lingering question: could my role be replaced by AI?

The layoffs have compounded these feelings. Stakeholder relationships feel heavier, more guarded. Team dynamics aren’t just about collaboration anymore; they’re about redistributing the workloads of those who’ve left, while addressing the unspoken tensions that remain. These pressures don’t stay confined to the workplace—they spill into your personal life, straining relationships and making it harder to disconnect and recharge.

The AI Question: Friend or Foe?

Gen AI sparks both excitement and existential dread, a duality that’s hard to ignore. On one hand, its potential is undeniable— they can streamline workflows, speed up research, and even spark creative solutions. On the other hand, it’s natural to wonder: where does this leave us as PMs? If machines can ideate and automate, what’s left for us to do?

The answer is clear: lean in, don’t retreat. I’ve found that exploring AI tools—even building quick prototypes using no-code platforms helps me understand how these technologies can enhance what I bring to the table. Sharing these learnings with my team isn’t just about showcasing expertise; it’s about fostering collective growth. When you become the person who demystifies AI and applies it thoughtfully, you’re not just staying relevant—you’re becoming indispensable.

Lessons from the Chaos

1. It’s Okay to Feel the Weight

Acknowledging anxiety isn’t a weakness; it’s a strength. These are not normal times, and pretending otherwise doesn’t help. Start by accepting that it’s okay to feel uneasy, then focus on what you can do about it. A good first step is seeking support from peers or mentors—having someone to talk through your concerns with can make a world of difference.

2. Control What You Can

Layoffs and industry shifts are beyond your control, but your response isn’t. This could be the perfect time to refine your LinkedIn profile, update your portfolio, or actively network within your industry. Taking proactive steps like these helps you stay visible and ready for opportunities, even in uncertain times. Upskilling in AI tools and strategies is a non-negotiable in this climate. Try to build prototypes using Bolt.new or Vercel V0 to get confidence on the tools. This newsletter by Colin Matthews is a great place to learn.

3. Communicate, Even When It’s Hard

Anxiety is contagious, but so is calm. Stakeholder relationships might feel strained, but maintaining open and honest communication can help rebuild trust. Instead of pushing for decisions or overloading others with updates, focus on clarity and reassurance. Admit when you don’t have all the answers, and explain changes transparently. A composed approach can turn tense conversations into collaborative problem-solving.

4. Support Your Team and Yourself

Your team feels the weight too. Regular check-ins, both on work and emotional well-being, can go a long way. For example, you can structure these check-ins by starting with a quick pulse on how everyone is feeling, followed by a review of key priorities. Wrap up by asking if there are blockers or concerns that need addressing. Keeping the tone supportive and collaborative ensures these meetings provide clarity and comfort. At the same time, set boundaries for yourself. Protecting your mental health isn’t just about survival—it’s about ensuring you can lead effectively.

Finding Purpose in Uncertainty

This season isn’t just about survival; it’s about growth. Gen AI isn’t a threat—it’s a powerful tool that, when wielded correctly, can elevate your impact and transform how you work. By leaning into new skills, educating your team, and approaching challenges with empathy, you can redefine what it means to be a PM in this era.

Your value isn’t tied to a job title or a specific skill. It’s in your ability to adapt, to lead, and to guide others through change. If you’re feeling the weight of uncertainty, take heart: the work you’re doing matters, and so do you.

How Are You Managing?

How are you navigating these challenges? Share your thoughts in the comments—let’s figure this out together.

Let’s take a step back and talk about how we can better navigate this dynamic, what we might be doing wrong, and how we can improve—not just for the sake of harmony, but to truly elevate our products and teams.

Recognize the Reality: Engineers Do the Heavy Lifting

First, let’s acknowledge the obvious: engineers are the ones turning ideas into reality. They’re debugging errors at 3 AM, dealing with edge cases no one thought of, and ensuring the product doesn’t crumble when users inevitably behave unpredictably. Their work is tangible, measurable, and often the backbone of a successful release.

As PMs, our work is less visible. This creates a natural tension because what we bring to the table—prioritization, stakeholder management, strategy—is harder to quantify. But here’s the thing: we’re in this together. Recognizing their contributions isn’t just polite—it’s necessary.

Why They Might Hate Us

Here’s a harsh truth: sometimes, their frustration with us is justified. Let’s break it down:

• Vague Requirements: When we don’t understand the technical nuances or fail to provide clear acceptance criteria, it leaves engineers feeling unsupported and frustrated.

• Unrealistic Timelines: Whether it’s market pressure or leadership demands, asking for the impossible without a discussion signals a lack of empathy.

• The Credit Gap: Engineers often feel that PMs get the limelight for their hard work. If we’re not proactively crediting them, that’s on us.

• Bad PM Behavior: Let’s admit it: there are bad PMs who coast on ambiguity, give vague presentations, and take credit for work they didn’t do. They’re rare, but their existence hurts all of us.

How to Be the PM Engineers Respect

So, how do we build trust and ensure we’re viewed as allies rather than adversaries? Here are actionable steps:

• Seek Clarity Beforehand: Before presenting requirements, take the time to collaborate with stakeholders to refine them. Use frameworks like user stories or acceptance criteria to provide clear, actionable guidance. If you don’t understand something technical, ask early and often—engineers value curiosity and effort over guesswork.

• Advocate for Realistic Timelines: When you’re asked to deliver by an unrealistic date, don’t accept it at face value. Consult with your engineering team to understand what’s feasible. Use past project data, risk assessments, or dependency breakdowns to make a case for adjustments. Stand firm when necessary—it’s better to negotiate upfront than deal with burnout later.

• Give Credit Publicly and Specifically: During leadership meetings, team updates, or all-hands, call out specific contributions from individual engineers or the team as a whole. Go beyond generic acknowledgments—mentioning specific challenges they solved or innovative approaches they took can make your appreciation feel more genuine.

• Learn the Basics of Technology: While you don’t need to code, having a working knowledge of your product’s tech stack can dramatically improve communication. Take time to understand concepts like APIs, databases, or system architecture. Shadow your engineers during debugging sessions or ask them to explain technical constraints—this shows respect for their work and helps you make better decisions.

• Build a Continuous Feedback Loop: Create regular opportunities for engineers to share feedback about how you’re supporting them. Use retrospectives, anonymous surveys, or informal 1:1s to ask questions like: “What blockers can I help remove?” or “Is there anything I’m doing that’s making your work harder?” Act on this feedback consistently to show that their input matters.

• Document and Communicate Decisions: Engineers appreciate transparency. When you make a prioritization or strategy decision, document the reasoning and share it openly. For instance, explain why a particular feature is being prioritized over another and what trade-offs were considered. This reduces frustration and fosters alignment.

• Be Proactive About Dependencies: Engineers often feel blindsided by external dependencies or last-minute changes. Stay ahead by mapping out dependencies early and regularly checking in with external teams. Keep engineers updated on changes that might affect their timelines or workloads.

The Power of Transparency

One of the biggest sources of friction is the perception that PMs are decision-making in a black box. To counter this:

• Explain the Why: When you’re making a decision or setting priorities, share the reasoning behind it. Engineers are less likely to see a decision as “dumb” if they understand the context.

• Be Honest About Constraints: If leadership is driving a tough timeline or prioritization, don’t pretend it’s your idea. Transparency builds trust.

What Aspiring PMs Should Know

If you’re new to product management, building a good rapport with engineers is one of the fastest ways to succeed. Here’s what to focus on:

• Empathy First: Take time to understand their challenges before diving into strategy and roadmaps.

• Stay Curious: Attend engineering standups or ask them to walk you through the tech stack. Showing interest demonstrates respect.

• Over-Communicate: Ambiguity is your enemy. Clear, detailed communication helps everyone stay aligned.

Let’s Build Great Products—Together

Being a PM isn’t about controlling the process; it’s about enabling the team to do their best work. Engineers are your greatest allies in that mission. So, let’s ditch the stereotypes, acknowledge the frustrations, and commit to mutual respect and collaboration. After all, when PMs and engineers work well together, the result isn’t just great products—it’s a great team.

Every week, I tackle common challenges that PMs face by sharing straightforward advice, actionable tips, and proven strategies to navigate tough situations, win over stakeholders, and elevate your PM skills.

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

Let’s face it—being a Product Manager can feel like walking a tightrope while juggling flaming torches. It’s 3 AM, and you’re staring at the ceiling, replaying that meeting where you presented the perfect, data-backed solution, only to have it ignored for a flashy, unfounded idea. Your calendar is a graveyard of unnecessary meetings, your inbox is overflowing, and you can’t shake off the feeling that while everyone else is building something tangible, you’re stuck chasing alignment and fighting fires. Sound familiar?

And then there’s the frustration—watching obvious problems get sidelined for shiny distractions, dealing with stakeholders who treat your roadmap as a suggestion box, or trying to push back diplomatically when leadership insists on their “vision” despite all evidence to the contrary. It’s exhausting. And let’s not forget the sheer volume of people you have to deal with daily—stakeholders, engineers, designers, executives, customers. You’re the bridge, but sometimes it feels like everyone is stomping on it.

Even when you’re not actively firefighting, the ambiguity can be paralyzing. You step into the role expecting to create order and strategy, but more often than not, you’re faced with chaos. Priorities shift. Goals are unclear. Deadlines are arbitrary. And all the while, you’re trying to balance the pressure of delivering value without actually holding the reins to execute anything yourself.

The life of a PM is rife with moments of frustration and self-doubt. Engineers can point to the code they’ve shipped. Designers can showcase sleek prototypes. But your work? It often feels invisible, a never-ending quest for consensus, clarity, and progress. You’re the glue, the translator, the decision-maker—but where’s your win? The truth is, the very nature of our role sets us up for these struggles. It’s the mental tax we pay for being PMs.

Accepting the Role’s Reality

Before we dive into solutions, let’s call it what it is: the stress, the ambiguity, the invisible workload—it’s all baked into the PM role. We’re not here to sugarcoat it or pretend there’s a magical fix. What we can do is acknowledge these challenges for what they are: a side effect of being the person who stands at the intersection of business, technology, and design. Until you internalize and accept this, the mental toll will only grow heavier.

But acceptance doesn’t mean resignation. It’s about understanding the rules of the game so you can play it better. One way to navigate the chaos is to define your unique strengths and approach as a PM. While the role can feel nebulous, grounding yourself in your strengths allows you to find clarity amidst the uncertainty.

The Struggles and How to Cope

1. The Invisible Workload

You spend weeks aligning teams, creating roadmaps, and putting out fires. But unlike your peers, your work doesn’t manifest as a tangible product. It’s easy to feel like you’re not contributing enough—even when you’re the one keeping the ship afloat.

How to Deal:

• Shift Your Perspective: Measure success by outcomes, not outputs. Did your strategy drive user engagement? Did your roadmap prevent chaos? That’s your impact.

• Lean Into Your Strengths: Reflect on the unique value you bring to the team—whether it’s strategic thinking, storytelling, or execution. Use these strengths as your compass to focus on the right priorities.

• Keep a Journal: Maintain a log of your contributions. Seeing a list of fires extinguished and initiatives driven can be a powerful reminder of your value.

2. The Pain of Being Ignored

You’ve done the research, gathered the data, and presented a rock-solid plan. And yet, the decision-makers go for something flashy and impractical. In startups, this often looks like the CEO playing PM. In big tech, it’s leadership chasing shiny objects.

How to Deal:

• At Startups: Present your data in a way that aligns with the CEO’s vision. If your insights are ignored repeatedly, recognize that this is a survival risk—for both the company and your career. Know when it’s time to leave.

• In Big Tech: Share your data-backed opinion and step back. If leadership chooses otherwise, disagree and commit. Execute with excellence, but keep a contingency plan in mind if things go south.

3. Meeting Overload

Your calendar looks like a game of Tetris gone wrong. While engineers and designers can carve out focus time, you’re bouncing from one meeting to another, barely catching your breath.

How to Deal:

• Audit Your Calendar: Ruthlessly cut or decline meetings where your input isn’t critical. You’d be surprised how often no one notices.

• Protect Your Time: Block out focus time and treat it like a sacred appointment. Use this time for deep work or strategic thinking—not catching up on emails.

4. The Emotional Toll of Constant Interaction

PMs deal with people—a lot of people. Stakeholders, leadership, customers, and cross-functional teams all demand your attention. The emotional labor of mediating conflicts and driving accountability can leave you drained.

How to Deal:

• Set Boundaries: Not every Slack message or email needs an immediate response. Train your stakeholders to respect your time by setting clear expectations.

• Recharge With Purpose: Define what works for you when it comes to decompressing. Whether it’s taking a walk, journaling, or venting to a trusted peer, lean on strategies that resonate with your PM persona.

5. The Chaos of Ambiguity

You walk into the role, and it’s a mess. No clear goals, shifting priorities, and deadlines that make no sense. Welcome to product management.

How to Deal:

• Create Your Own Clarity: If priorities are unclear, draft them yourself. Propose a roadmap or a north star metric and rally your team around it.

• Leverage Your Persona: If you’re a strategic thinker, lead with a vision. If you’re detail-oriented, focus on untangling the execution. Play to your strengths to make sense of the chaos.

• Focus on What Matters: Accept that you can’t fix everything. Prioritize the areas where you can drive the most impact and let the rest go.

Thriving Through the Chaos

Being a PM isn’t for everyone. It’s a role that demands resilience, adaptability, and emotional intelligence. The mental tax is real, but so is the impact you can make. By accepting the inherent chaos and learning to navigate it, you can not only survive but thrive.

Defining your PM persona is not about adding labels; it’s about understanding what makes you tick. Whether you’re the strategist, the data-driven optimizer, or the empathetic team builder, knowing your strengths helps you stay grounded amidst the chaos. Remember, you’re not just a cog in the machine—you’re the one steering the ship. And that’s a responsibility worth taking pride in.

Every week, I tackle common challenges that PMs face by sharing straightforward advice, actionable tips, and proven strategies to navigate tough situations, win over stakeholders, and elevate your PM skills.

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

Product design interview questions are notoriously tricky. They’re open-ended, require a blend of creativity, structure, and user-centric thinking, and are often delivered in high-pressure situations. For many aspiring PMs, these questions feel like a test of their very essence: “Are you PM material?”

But here’s the secret: you don’t need to reinvent the wheel every time. With the right structure—and a little help from AI-powered prompting—you can craft responses that are thoughtful, creative, and impressively polished.

In this guide, we’ll break down how to structure your answer to ensure it’s clear, user-focused, and actionable—even without relying entirely on AI.

Why Structure Matters in Product Design Questions

Interviewers aren’t looking for random ideas or a flurry of features. They’re evaluating:

1. Problem Understanding: Do you grasp the user’s pain points and context?

2. Creativity: Can you propose innovative yet practical solutions?

3. Prioritization: Do you know what matters most and why?

4. Practicality: Can your solution be implemented within constraints?

A structured response ensures you hit all these notes. AI prompts can help guide your thinking and refine your answer—but only if you know how to ask the right questions.

Before You Start Prompting: A Framework for Thinking

Before jumping into prompts or ideation, you need to lay the groundwork. This framework ensures your answer is cohesive and targeted.

1. Break Down the Question

• What is the problem being asked? Identify the core user, their challenge, and the desired outcome. Make reasonable assumptions and state them upfront.

  Example: For a question on designing a mental health feature, clarify: "Who is the user? Is the focus on busy professionals, students, or caregivers? What’s their main pain point?"

2. Understand the Goal

• What is the broader goal of the solution? Is it to improve user retention, drive engagement, or solve a specific pain point? Align your answer with the desired impact.

3. List Down Personas

• Identify multiple personas who might face the problem. For example:

  • Busy professionals needing quick stress-relief tools.

  • Students balancing academics and mental health.

  • New parents dealing with sleeplessness and stress.

4. Prioritize a Persona

• Choose one persona based on:

  • Size: Which group has the largest potential user base?

  • Intensity: Which group faces the most critical pain point?

  • Alignment: Which group aligns best with the question context?

Example: For a time-sensitive solution, prioritize busy professionals as they’re more likely to value immediate, actionable tools.

5. Identify the Problems Faced by the Persona

• List the key challenges this persona encounters. E.g., for busy professionals:

  • Difficulty finding time for self-care.

  • Overwhelmed by complex apps.

  • Lack of consistency in mental health practices.

6. Prioritize the Problem to Solve

• Use criteria like:

  • Frequency: How often does this problem occur?

  • Severity: How deeply does it affect the user?

  • Impact: How significant would solving it be for the user and business?

Example: Consistency in mental health practices might rank highest, as it’s a foundational barrier to long-term improvement.

7. Ideate Solutions

• Generate a list of potential features or solutions for the prioritized problem.

• Focus on creative yet practical options that address the root cause.

8. Prioritize Solutions

• Use frameworks like:

  • Impact vs. Effort: Which solution delivers maximum value with minimal complexity?

  • Short-Term vs. Long-Term: Which solution addresses immediate needs while laying groundwork for future iterations?

9. Define Metrics

• Identify how you’ll measure success. Choose metrics that align with user behavior and business goals.

10. Address Edge Cases

• Think critically about potential risks or challenges the solution might face. Propose clear mitigations.

The Prompting Framework

Here’s how you can apply this thinking with AI prompts to enhance your responses.

Step-by-Step Framework

1. Break Down the Question Prompt: "What is the core problem for [target users] when [performing a task]? What assumptions can I make about their challenges?"

2. Understand the Goal Prompt: "What is the primary objective of solving [specific problem]? Focus on user and business outcomes."

3. List Down Personas Prompt: "Identify 3 personas who might face [specific challenge]. Include their demographics, goals, and frustrations."

4. Prioritize a Persona Prompt: "Which persona aligns most closely with the context of [problem or question]? Justify based on size, intensity, or alignment."

5. Identify Problems Faced by the Persona Prompt: "List the top 3 challenges [persona] faces related to [specific task]."

6. Prioritize the Problem to Solve Prompt: "Which of these problems should be prioritized based on frequency, severity, and impact?"

7. Ideate Solutions Prompt: "Suggest 5 creative features to solve [specific problem] for [target persona]. Highlight the value of each."

8. Prioritize Solutions Prompt: "Rank these features by impact and effort for a v1 release. Justify the prioritization."

9. Define Metrics Prompt: "What metrics would indicate success for [specific solution]? Include leading and lagging indicators."

10. Address Edge Cases Prompt: "What are potential risks of implementing [specific solution]? How can these be mitigated?"

Practical Example

Question: Design a feature to help users stay on top of their mental health using a mobile app.

Let’s apply the framework step-by-step:

1. Break Down the Question:

   • Core Problem: Users struggle to maintain consistency with mental health practices.

   • Assumptions: The app targets individuals who want quick, actionable tools for self-care.

2. Understand the Goal:

   • Goal: Increase user retention by creating a habit-forming, easy-to-use mental health tool.

3. List Down Personas:

   • Persona 1: Busy professionals juggling work and personal life.

   • Persona 2: Students managing academic stress.

   • Persona 3: New parents coping with sleep deprivation.

4. Prioritize a Persona:

   • Chosen Persona: Busy professionals, as their pain point aligns best with the prompt (need for consistency and quick tools).

5. Identify Problems Faced by the Persona:

   • Problem 1: Lack of time for self-care.

   • Problem 2: Overwhelmed by too many features in apps.

   • Problem 3: Difficulty maintaining consistent practices.

6. Prioritize the Problem to Solve:

   • Priority: Difficulty maintaining consistent practices, as solving this unlocks long-term value for the user.

7. Ideate Solutions:

   • Solution 1: Daily mood check-ins.

   • Solution 2: 2-minute guided breathing exercises.

   • Solution 3: Weekly progress dashboard.

   • Solution 4: Personalized tips based on user data.

   • Solution 5: Habit streak tracker.

8. Prioritize Solutions:

   • High Priority: Mood check-ins and guided breathing (high impact, low complexity).

   • Medium Priority: Progress dashboard (medium impact, higher complexity).

9. Define Metrics:

   • Metrics: Daily active users (DAU), completion rates for guided exercises, user satisfaction scores.

10. Address Edge Cases:

    • Risk: Users forget to log daily moods. Mitigation: Enable gentle reminders at set times.

    • Risk: Feature fatigue. Mitigation: Gamify streak tracking to maintain engagement.

Final Tips for Using AI in Interviews

1. AI Isn’t a Shortcut: It’s a tool to refine your thoughts, not replace your creativity.

2. Practice Beforehand: Experiment with these prompts to get comfortable with structured responses.

3. Personalize Your Approach: Tailor the framework to fit your style and the specific question.

So,

Acing PM interviews isn’t about memorizing answers—it’s about structured thinking and user empathy. With this framework, you’ll break down even the trickiest questions into manageable steps. Add AI prompting, and you’ve got a winning strategy.

Every week, I tackle common challenges that PMs face by sharing straightforward advice, actionable tips, and proven strategies from my own experience to navigate tough situations, win over stakeholders, and elevate your PM skills.

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

The earliest memory I have of dreaming about a career was to become a movie director. Growing up in a family of movie lovers, I watched at least two movies every week. Movies became so ingrained in my life that I couldn’t imagine doing anything else. I pictured myself as a big-shot director, creating stories that would captivate audiences.

Looking back, there were opportunities to step into the movie world—like the time I was offered a job at a news media agency, which could have been a stepping stone. But I didn’t take it, because I couldn’t afford to take the risk. Making money was non-negotiable, and I always chose the path that offered the highest probability of financial stability. Movies, with their uncertainty and low odds of success, simply didn’t fit into that equation.

And yet, I’ve never regretted that choice. When I reflect on why being a movie director appealed to me so much, it wasn’t just the art of storytelling. It was the idea of being “in control.” Growing up, my family faced significant financial troubles, and I often felt helpless. I promised myself that when I grew up, I’d never feel that powerless again. I would take control and ensure financial stability no matter what.

When my career began, that need for control showed up at work. As a developer, my role felt limiting—I was expected to stick to the scope, with little room for creativity or autonomy. It frustrated me deeply. Staying in that role was clearly not aligned with my personality. Working at an early-stage startup, however, gave me the flexibility to explore other paths. Whenever another team had a need, I’d jump in. That’s how I transitioned into a Presales Consultant role. Researching companies and tailoring sales pitches fascinated me. It helped me develop business intuition and broaden my understanding of industries. But even that role felt incomplete. I created the material for pitches, but it was the Sales team that delivered them. When they faltered, I’d think, “I could have done this better.” Once the material left my hands, it was out of my control—and that bothered me.

I felt lost. My career seemed like a haphazard mix of roles with no clear direction. I wanted to be an entrepreneur, to build something successful with my own hands. But without a financial safety net, that dream felt out of reach. A friend, listening to my frustrations, casually remarked, “This sounds like what Product Managers do at bigger companies.” I’d never heard of the role. No MBA, no exposure to larger companies—PM was a mystery to me. But when I started researching, it felt perfect. I could be the “CEO” without actually being the CEO. It sounded too good to be true.

I threw myself into preparation. I studied harder than I ever had in school. I solved problems, practiced mock interviews, and did everything possible to break into product management. Eventually, I made it.

The first two years were traumatic. I came in with a “CEO” mindset, eager to control everything. I wanted to do whatever it took to make the business successful. I hardly cared about people’s feelings. I bulldozed through, trampling on colleagues’ efforts, lecturing them on what it takes to succeed. I ignored my manager’s guidance, steering the product however I wanted. I even took on tasks outside my role, increasing others’ insecurities. I thought I was driving success, but in reality, everyone hated me.

It was an isolating time. I constantly wondered, “Why do they hate me when all I want is to make them succeed?” I fought with everyone, spiraling into frustration and depression. I often thought about quitting to start something on my own. It was one of the hardest periods of my life—but also a turning point.

I took a 15-day break and sought therapy. Those sessions were a revelation. I realized my control issues stemmed from childhood fears—a fear of failure, of becoming helpless again. My definition of success was skewed. I equated my success as a PM with business success, but that wasn’t sustainable, especially in a large company. Therapy helped me redefine success: My job as a PM wasn’t to control everything. It was to empower others, ensure my stakeholders—my first customers—were happy, and steer the product in the right direction.

With that clarity, I made changes that transformed both my career and personal life:

• I decided to let go. I accepted that I couldn’t control everything, and that was okay.

• I chose to listen. Instead of imposing my ideas, I started understanding others’ perspectives.

• I aligned with decisions. I stopped fighting exec decisions and instead strengthened them with my intuition.

• I prioritized people. I put relationships first, knowing that a collaborative team drives success better than any lone hero.

These shifts changed everything. My relationships with stakeholders improved. My influence grew. People wanted to work with me. And my career trajectory accelerated faster than I could have imagined. It also made me realize that these are essential changes that I needed to do if I wanted to succeed as an entrepreneuer.

Which brings me to my purpose with this newsletter: I want to help you become a better PM by sharing the lessons I’ve learned the hard way. Every misstep, every hard-fought realization, is an opportunity for you to navigate your journey with fewer obstacles and more clarity. While doing so, I also aim to lay the foundation for my journey as an entrepreneur.

So - Even though I never became the movie director I dreamed of as a child, I’ve realized that my role as a Product Manager allows me to create and lead impactful stories—not on the big screen, but through the products I build and the teams I collaborate with. The key isn’t control, but collaboration. It’s not about imposing your vision, but bringing everyone’s ideas together to create something meaningful. And that, for me, has been the most rewarding transformation.

Happy new year!

Every week, I tackle common challenges that PMs discuss on forums like Reddit and in product communities. I share straightforward advice, actionable tips, and proven strategies to navigate tough situations, win over stakeholders, and elevate your PM skills.

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

Read my previous post about improving your resume here.

Your resume isn’t just a document; it’s a product that markets you as a product manager. And like any good product, it needs iteration, clarity, and focus on the user—in this case, the hiring manager. So how do you take your resume from “meh” to “binge-worthy”? Let’s break it down with a practical Prompt Engineering Framework.

This framework will help you rewrite and refine your resume to align with hiring expectations, showcase your achievements, and make your application impossible to ignore. With 2025 around the corner, now’s the perfect time to polish your resume and land your dream job in the new year.

Prerequisites: Setting Yourself Up for Success

Before diving into the prompts, let’s get a few basics straight. If you’re new to leveraging tools like ChatGPT or feel overwhelmed by the process, these steps will ensure you’re ready:

1. Have Your Raw Data Ready

Gather all your career details in one place:

• List every role you’ve had with basic responsibilities.

• Note down key achievements, metrics, and outcomes (even if they’re rough).

• Include side projects, certifications, or technical skills.

2. Understand the Basics of Prompting

Prompting is all about asking the right questions. Here’s how to set yourself up for success:

• Be specific: Instead of “What should I write?” ask, “How do I describe launching a feature that improved retention?”

• Use context: Provide enough detail for the AI to generate tailored suggestions.

3. Start with a Draft

Your initial resume doesn’t have to be perfect. Think of it as a beta version you’ll iterate on.

• If you don’t have a resume draft, write a rough one with basic information.

• Don’t worry about structure or wording yet—just focus on getting everything down.

4. Familiarize Yourself with AI Tools

If you’re new to ChatGPT, experiment with simple prompts like:

• “Rephrase this sentence to sound more professional.”

• “Suggest bullet points for a Product Manager who launched a customer feedback tool.”

Once you’re comfortable, you’ll be ready to tackle the prompts in this framework.

1. Start with Your PM Narrative

Your story matters. Before you dive into bullet points, think about the bigger picture. What’s the overarching narrative of your career?

Prompts:

• What are the 3-5 key achievements or milestones that define my product management career?

• What unique angle do I bring as a PM (e.g., growth hacker, data-driven decision-maker, customer-obsessed)?

Output:

Write a professional summary that makes your PM story stand out right at the top of your resume.

Example:

• "Growth-focused Product Manager with 6+ years of experience driving 30%+ YoY user engagement growth through data-backed product strategies and cross-functional team leadership."

2. Rewrite Bullet Points Like a Pro

Your bullet points should be mini case studies. The key is to focus on actions and outcomes, not just responsibilities.

Prompts:

• What did I achieve in this role, and how did I measure success?

• What action did I take that directly impacted key metrics?

• What was the quantifiable result of my work?

Framework:

Action verb + what you did + quantifiable result/impact

Before: "Launched a new feature for user onboarding." After: "Launched a user onboarding feature that reduced drop-off rates by 35% and boosted first-week engagement by 50%."

3. Tailor Your Resume for Every Role

Hiring managers skim for relevance. Your job is to make their job easier by aligning your experience with the job description.

Prompts:

• What keywords and skills are emphasized in the job description?

• How does my experience match the key responsibilities of this role?

Pro Tip:

Mirror the language of the job posting (e.g., if they mention "growth metrics," use that phrase) to pass applicant tracking systems (ATS).

4. Show, Don’t Tell: Highlight Impact with Metrics

Numbers matter. They provide concrete evidence of your impact.

Prompts:

• How did my work improve business outcomes like revenue, retention, or engagement?

• What metrics can I point to that demonstrate success?

• How many users, customers, or teams were affected by my contributions?

Example:

• Before: "Improved conversion rates."

• After: "Redesigned pricing page, increasing conversion rates by 25% and generating an additional $500K in ARR."

5. Flex Your Leadership Skills

PMs are leaders, even without direct authority. Showcase how you’ve rallied teams, managed stakeholders, and driven alignment.

Prompts:

• How did I align cross-functional teams to achieve a shared goal?

• What leadership role did I take in launching a major product or feature?

• How did I resolve conflicts or build consensus?

Example:

• Before: "Collaborated with teams to deliver features."

• After: "Led cross-functional teams of 20+ engineers and designers to launch [Feature X], driving a 20% increase in user retention."

6. Don’t Shy Away from Technical Expertise

Even if you’re not writing code, technical fluency is a PM superpower. Highlight how you’ve leveraged tools, platforms, or technical knowledge.

Prompts:

• What technologies, tools, or platforms have I used to solve problems?

• How did I collaborate with engineers to tackle technical challenges?

Example:

• Before: "Worked with APIs."

• After: "Defined API requirements, enabling seamless third-party integrations and reducing integration time by 25%."

7. Structure Your Resume for Readability

Hiring managers spend less than 30 seconds scanning your resume. Make those seconds count.

Prompts:

• Are my bullet points concise and focused (1-2 lines each)?

• Is the formatting clean and consistent?

• Have I removed unnecessary jargon or filler words?

8. Leverage Side Projects and Passion Work

Side projects can showcase initiative, creativity, and a passion for building.

Prompts:

• What problem did I solve with this project?

• What skills or insights did I gain?

Example:

• Before: "Built a side project."

• After: "Designed and launched [Side Project Z], attracting 500+ users within the first month and validating demand for [specific feature]."

9. Get a Fresh Perspective

Like any good product, your resume needs user feedback.

Prompts:

• What’s the first impression you get from my resume?

• Are any sections or points unclear or underwhelming?

• Does this resume reflect the PM I aspire to be?

Action: Share your draft with trusted peers or mentors, iterate on their feedback, and refine your story.

Bonus Tip: Strengthen Your Resume with Gen AI Side Projects

Generative AI is one of the hottest topics in tech, and showcasing your understanding or application of it can make your resume stand out. Even simple Gen AI side projects can demonstrate initiative, creativity, and technical fluency.

Ideas for Gen AI Side Projects:

• Chatbots: Build a simple AI chatbot using tools like OpenAI’s API or Rasa to address a specific problem, such as customer support or onboarding.

• Content Generators: Create an AI tool that generates social media posts or product descriptions tailored to a specific audience.

• AI-Powered Analytics: Use AI to analyze customer feedback or user behavior and present insights visually.

• AI in Product Management: Develop a tool that helps PMs prioritize backlogs or generate user stories based on specific inputs.

Prompts to Get Started:

• "What is a simple problem I can solve using Generative AI in my domain?"

• "How can I showcase my PM skills through a project involving AI?"

• "What existing AI tools can I combine to create something new?"

Example to Include on Your Resume:

• "Developed an AI chatbot to assist with customer onboarding, improving response time by 40% and reducing support tickets by 25%."

• "Built an AI-powered tool to analyze 1,000+ customer reviews, uncovering insights that increased feature adoption by 15%."

By showcasing your ability to harness Gen AI, you not only strengthen your technical profile but also demonstrate that you’re forward-thinking and ready to tackle the challenges of 2024 and beyond.

10. Final Checklist Before Submitting

Prompts:

Before you hit send, ask yourself:

• Have I quantified my impact wherever possible?

• Are my accomplishments framed in terms of results, not responsibilities?

• Is my resume tailored to this specific role?

• Does my resume reflect my unique PM narrative?

• Are my technical skills and leadership abilities clear?

• Is my resume error-free and easy to skim?

By using this framework, you’ll craft a resume that doesn’t just tell your story—it proves your impact. With 2024 around the corner, there’s no better time to supercharge your resume with AI prompts and set yourself up to land your dream job in the new year. Remember, your resume is your product. Treat it like one: test, iterate, and deliver the best version of yourself. That’s how you get hiring managers to swipe right.

Every week, I tackle common challenges that PMs face by sharing straightforward advice, actionable tips, and proven strategies to navigate tough situations, win over stakeholders, and elevate your PM skills.

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

As product managers, one of the most common questions we face is: “What’s the ROI of this feature?” It’s a fair question—stakeholders need to know whether the resources invested in a feature will drive meaningful business outcomes. But for many PMs, especially those early in their careers, calculating ROI can feel like venturing into uncharted territory.

The good news? You don’t need perfect data or advanced analytics to get started. ROI modeling is less about math and more about thinking critically—understanding what your feature impacts, modeling its outcomes, and linking them to business value. Here’s how to approach it with confidence and clarity.

In this article, I focus on feature forward calculations, in order to explain how further calculations are made.

Step 1: Understand What the Feature Impacts

Every feature exists to solve a problem or drive a specific outcome. To model ROI, you first need to define what the feature impacts—and do so clearly. For example, if you’re building a feature to improve user engagement, ask yourself:

• What does “engagement” mean in the context of your product?

• How will this feature drive a measurable change in that engagement?

Engagement can mean different things depending on your product. It might be:

• Session Frequency: How often users open the app.

• Session Duration: How long they stay per session.

• Weekly Active Users (WAU): The number of users engaging with the app in a given week.

Let’s say your app is a habit-tracking app, and you’re introducing a daily reminder notification feature.

• Feature Goal: Increase user engagement by reminding users to log their habits daily.

• Likely Impacted Metrics:

  1. Session Frequency: The number of times users open the app per week.

  2. Daily Active Users (DAU): The percentage of users engaging with the app daily.

Here’s why:

• Session Frequency: The reminders encourage users to interact with the app more often, increasing their number of sessions each week.

• DAU: Users are more likely to log their habits on the day they receive a notification, boosting daily activity.

By focusing on these metrics, you define the primary ways the feature impacts user behavior. This clarity will guide your ROI modeling, as you’ll now assess how increased session frequency or DAU affects retention and, ultimately, revenue.

Step 2: Model the Impact, Step by Step

Once you’ve identified what the feature impacts, the next step is to map out the relationship between the feature, your chosen metrics, and broader business outcomes. Here’s a simple framework:

1. Define the Baseline:
   Start with the current state of the metric you’re trying to improve. For example:

   • Users currently open the app 2 times per week (baseline session frequency).

2. Estimate the Impact of the Feature:
   Use past data, user insights, or team expertise to estimate how the feature will change this metric. Example:

   • Adding personalized reminders will increase session frequency from 2 times per week to 3 times per week.

3. Link the Metric to Retention:
   Higher engagement often improves retention. If historical data shows that users with 3+ sessions per week retain 10% better than those with fewer sessions, you can estimate how the feature impacts retention.

4. Adjust the Retention Curve:
   Update your retention curve to reflect this impact. Example:

   • Current retention: 40% at Week 8.

   • New retention with feature: 50% at Week 8.

Step 3: Translate Retention into Revenue

Retention improvements directly affect revenue, especially in subscription or freemium models. To calculate this, you can:

1. Keep Installs and ARPU Constant:
   Assume that your user acquisition (installs) and average revenue per user (ARPU) stay the same.

2. Baseline Revenue:
   Multiply installs by retention and ARPU to calculate the baseline. Example:

   • Installs: 10,000/month.

   • Retention: 40%.

   • ARPU: $5/month.

   • Baseline revenue: 10,000×40%×$5=$20,000

3. New Revenue with Feature Impact:
   Update the retention rate and calculate again:

   • Retention: 50%.

   • New revenue: 10,000×50%×$5=$25,000

4. Calculate the ROI:
   Subtract the feature cost from the revenue increase, then divide by the cost. Example:

   • Feature cost: $2,000.

   • ROI: (25,000−20,000−2,000)/2,000=150%.

Actionable Takeaways for PMs

1. Start with a Hypothesis:
   Clearly define how the feature impacts key metrics before building it. Example: “If we increase session frequency, retention will improve by X%.”

2. Use Historical Data:
   Look at past user behavior to validate assumptions. Example: “Users with 3+ sessions/week have 10% higher retention than others.”

3. Simplify Metrics:
   Stick to metrics you can measure and connect directly to business outcomes. Example: “Retention improvements drive higher revenue.”

4. Iterate as You Learn:
   Your first model doesn’t need to be perfect. Treat it as a draft and refine it as more data becomes available.

5. Communicate Clearly:
   Share the logic behind your ROI calculations with stakeholders, even if the numbers are rough. Focus on the story, not just the math.

Common Pitfalls and How to Avoid Them

1. Overcomplicating the Model:
   Don’t try to account for every variable upfront. Start with the basics: baseline, projected impact, and business value.

2. Ignoring Data Validation:
   Always sanity-check your assumptions. Example: If you assume a 10% retention lift, ensure historical data supports it.

3. Focusing Only on Revenue:
   ROI isn’t always about dollars. For early-stage features, improving retention or engagement might be the bigger win.

Finally: A Mindset Shift

Modeling ROI isn’t about perfect math—it’s about thinking critically and connecting the dots between a feature and its business value. As PMs, our job is to make thoughtful decisions, align stakeholders, and prioritize features that truly move the needle.

The next time someone asks you, “What’s the ROI of this feature?” don’t panic. Define the goal, map the logic, and frame it as a clear, actionable story. It’s less about getting it “right” and more about showing the impact your work can have.

Every week, I tackle common challenges that PMs face by sharing straightforward advice, actionable tips, and proven strategies to navigate tough situations, win over stakeholders, and elevate your PM skills.

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

If you’ve been a product manager for more than five minutes, you’ve probably experienced this tension: PMs and designers don’t always see eye-to-eye. While product managers live in a world of trade-offs, deadlines, and business goals, designers tend to live in the realm of ideals—crafting beautiful, seamless user experiences without always worrying about technical constraints or business realities.

And to be fair, they have a point. Designers have an innate ability to sense what users feel while experiencing the product. But this idealism, when left unchecked, can often clash with the PM’s pragmatic approach to solving problems. It’s not that PMs and designers are at odds; it’s that they speak slightly different languages.

So how do you build a productive, respectful, and collaborative relationship with designers? The answer lies in context, alignment, and a dash of influence.

Why PMs and Designers Often Clash

To understand why PMs and designers don’t always see eye to eye, it’s helpful to step into both their shoes for a moment. While they share the same ultimate goal—building a great product—their priorities, mindsets, and approaches often differ.

The PM Perspective

Product managers live in the world of trade-offs. Their job is to balance user needs, business goals, and technical feasibility while managing deadlines and resources. PMs are pragmatists by nature—always asking:

• What’s the impact of this work?

• Can we build this within our timeline and budget?

• What’s the simplest solution to achieve the desired outcome?

To PMs, the focus is often on shipping a good-enough solution quickly, learning from user feedback, and iterating. They operate with constraints in mind, prioritizing outcomes over perfection.

The Designer Perspective

Designers, on the other hand, are the champions of the user experience. Their focus is on crafting interfaces and interactions that are intuitive, seamless, and delightful. They often think in terms of ideals:

• How does this design make the user feel?

• Does this interaction solve the problem beautifully?

• What’s the best experience we can create?

Designers tend to approach their work with a hypothesis-driven mindset, fueled by user empathy. They’re less concerned with deadlines or business constraints and more focused on solving problems “the right way.”

The Tension Between PMs and Designers

Designers are driven by the desire to craft delightful user experiences. They think deeply about aesthetics, interactions, and how the product feels to the user. Meanwhile, PMs juggle business impact, technical feasibility, and deadlines—essentially, the cold, hard realities of building products.

This disconnect often leads to frustration:

• PMs: “Why can’t we ship this faster?”

• Designers: “Why are you compromising the experience for speed?”

Add to this the fact that designers often work on hypothesis-heavy mindsets, and you’ve got two teams with very different operating principles. But the truth is, this tension doesn’t have to be destructive—it can actually be productive if approached the right way.

So how do we deal with this? Below are 5 tips from my career, which I have learnt the hard way:

1. Give Designers Business Context Early and Often

Designers need to understand why they’re solving a problem before they can care about how they solve it. Too often, PMs hand over requirements without giving enough context about the business goals or constraints. When designers don’t see the bigger picture, they default to idealistic solutions that may not align with your priorities.

What to do:

• Share the business context as early as possible: What are the goals? What’s at stake? Who are we designing for?

• Bring designers into roadmap discussions or problem definition sessions, not just execution phases.

For example, instead of saying, “We need to improve signup conversion by 20%,” frame it as:
“Right now, 40% of users drop off on the signup page because the flow feels clunky. If we fix this, we’ll unlock X more users per month, which feeds into our acquisition goals.”

When designers understand the why, they’ll focus their creative energy on solutions that balance experience and impact.

2. Collaborate Early with Engineers

Designers don’t always have the best sense of what’s technically feasible. They might propose a stunning idea that engineers know is weeks or months of work. This disconnect leads to late-stage rework, missed deadlines, and frustration for everyone.

The solution? Early tech reviews.

• Involve engineers early when reviewing design ideas so they can flag feasibility issues or offer alternatives.

• Make it clear that engineers aren’t there to “shoot down” ideas but to co-create solutions with designers.

For example, a designer might propose a new animation-heavy interaction. Instead of outright saying, “This won’t work,” engineers can explain the technical trade-offs and suggest simpler alternatives that still meet the design goals. This approach prevents last-minute clashes and builds trust between teams.

3. Influence Designers to Embrace Experimentation

Designers tend to approach problems with a high degree of confidence in their instincts—and to be fair, they’re usually pretty good at predicting what will work for users. But the best solutions often come from testing and iteration, not from perfect designs on the first try.

Encourage designers to view their work as hypotheses, not final answers. This mindset shift makes them more open to experimentation, faster iterations, and small wins.

What works:

• Use data to validate (or invalidate) design choices. For example, “Your idea for a cleaner homepage made sense in theory, but 60% of users now miss the CTA.”

• Frame experiments as opportunities to learn, not to prove anyone wrong.

One thing I’ve found helpful: when a designer is attached to a specific solution, say, “Let’s test it! If it works, great. If not, we’ll learn what doesn’t work and why.” This takes the pressure off their ideas and reinforces a culture of collaboration.

4. Speak Their Language (Hint: It’s Not Just Metrics)

Designers care deeply about users, so if you want to influence them, tie your arguments to user outcomes—not just business goals.

For instance, instead of saying, “We need to cut this feature for launch to meet the timeline,” say:
“If we simplify this feature, we can get it into users’ hands faster and gather real feedback to improve it in the next iteration.”

PMs who focus on both business impact and user experience earn far more credibility with design teams. Remember, designers are not anti-business—they just want to ensure users aren’t forgotten in the process.

5. Treat Designers as Partners, Not Vendors

Nothing kills collaboration faster than treating designers like “executors” of your vision. Good design doesn’t happen in isolation; it’s the result of ongoing dialogue between PMs, designers, and engineers.

• Ask for their input early and value their perspective.

• Recognize their strengths: Designers often notice details about user behavior that PMs might overlook.

Instead of saying, “Here’s what I need you to design,” try:
“Here’s the problem we’re trying to solve—how do you think we can approach this?”

This small shift in framing goes a long way in building mutual respect.

The PM-Designer Sweet Spot

At the end of the day, PMs and designers are two sides of the same coin. PMs bring pragmatism; designers bring idealism. When these two forces work together, you get solutions that are both beautiful and impactful.

The sweet spot lies in:

1. Giving designers the business context to solve the right problems.

2. Bringing engineers in early to balance creativity with feasibility.

3. Encouraging experimentation and iteration, not perfection on the first try.

4. Speaking to user outcomes, not just metrics.

5. Treating designers as equal partners in the product development process.

So..

If you’re a PM who’s frustrated with designers, pause and ask yourself: Am I giving them the tools they need to succeed? Designers don’t want to make your life harder—they want to make the product better. With a little empathy, clear communication, and collaboration, you can turn a strained relationship into one of your strongest partnerships.

After all, the best products happen when pragmatism and idealism work together.

Every week, I tackle common PM challenges while also sharing my knowledge. I offer straightforward advice, actionable tips, and proven strategies to navigate tough situations, win over stakeholders, and elevate your PM skills.

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

Games have long been masters of engagement, perfecting techniques to captivate players for hours. From classic games like Super Mario Bros. to cultural phenomena like Fortnite, the key to their success lies in their ability to create an experience that players want to return to again and again.

For me, as someone who was a Gaming PM, the parallels between game design and product management have always been fascinating. Games taught me early on that engagement isn’t about flashy features or gimmicks—it’s about understanding the core behaviors that drive people and designing around them. This is something every product manager can learn from, regardless of the industry.

What Is a Core Loop?

At the heart of every great game lies the core loop—a simple, repeatable action that forms the foundation of engagement. It’s the activity players perform repeatedly, and it’s designed to be both satisfying and rewarding.

Take Super Mario Bros. as an example. The core loop is running, jumping, and progressing through levels. In Fortnite, the loop is landing, scavenging resources, and battling opponents. But this isn’t just about video games—it applies to classic childhood games too. Think of hide-and-seek. The core loop is hiding, searching, and discovering. It’s so engaging that kids can play it for hours without needing any other incentive.

Now, think about real-life products. The core loop is the repeated action that defines the user experience. For Amazon, it’s searching for and purchasing items. For Netflix, it’s selecting and watching content. For Instagram, it’s consuming and creating visual posts. Everything else in the product—the UX design, recommendation systems, and features—exists to make the core loop more seamless, engaging, and repeatable.

Designing the Core Loop for Your Product

Your core loop is the heartbeat of your product. To design a strong loop:

1. Identify the Key Action: What is the one activity users must perform repeatedly for your product to succeed? For Duolingo, it’s completing lessons. For Uber, it’s booking rides. For Spotify, it’s discovering and listening to music.

2. Make It Delightful: If the core loop feels like a chore, users will drop off. Think about the tactile satisfaction of swiping tiles in Candy Crush or the universal thrill of being "found" in hide-and-seek. Your loop should evoke a similar sense of ease and pleasure.

3. Focus on Efficiency: A great core loop minimizes friction. Amazon’s one-click checkout and Netflix’s autoplay feature are perfect examples of removing barriers to engagement.

Supporting the Core Loop: Lessons from Games

In games, the core loop doesn’t exist in isolation—it’s enhanced by features that add depth, variety, and rewards. These elements aren’t distractions; they’re carefully crafted to keep players invested.

Amazon:

Core Loop: Searching for and purchasing products.
Supporting Features:

• Personalized Recommendations: Keeps the experience fresh and engaging.

• Prime Membership: Reduces barriers like delivery costs, encouraging repeat purchases.

• Easy Returns: Builds user trust, ensuring they’re comfortable engaging in the loop.

Duolingo:

Core Loop: Completing short language lessons.
Supporting Features:

• Streaks and Rewards: Keeps users motivated to stay consistent.

• Gamified Feedback: Celebratory animations and progress tracking reinforce the habit.

• Daily Goals: Provides structure and focus, making the loop manageable.

Fortnite:

Core Loop: Landing, scavenging resources, and battling opponents.
Supporting Features:

• Cosmetic Rewards: Skins and emotes add personalization to the experience.

• Seasonal Challenges: Introduce variety and keep players coming back.

• Social Interaction: Playing with friends enhances the core loop.

Adding Depth: Secondary Loops and Progression Systems

The most engaging games go beyond the core loop by introducing secondary loops—optional activities that complement the main gameplay. In Zelda: Breath of the Wild, while exploration and combat form the core loop, secondary loops like cooking or solving puzzles provide variety and additional rewards.

Similarly, in products, secondary loops can add depth. For instance:

• Spotify: While the core loop is listening to music, creating playlists and following artists are secondary activities that deepen engagement.

• Amazon: Browsing reviews or creating wishlists enriches the shopping experience.

Another critical component is the progression system. Games like World of Warcraft or Fortnite use leveling up, unlocking abilities, or completing quests to give players a sense of growth. Products can mirror this by providing tangible markers of progress. For example:

• Duolingo: Tracks XP and levels, giving users a clear sense of accomplishment.

• LinkedIn: Uses the profile strength meter to nudge users toward completion.

These systems tap into a universal desire for achievement and growth, keeping users invested for the long term.

Feedback Mechanisms: Celebrate the Loop

Immediate feedback is a cornerstone of game design. Every action in a game is reinforced by visual, auditory, or even haptic cues. In Candy Crush, matching tiles triggers explosions and sound effects, making the loop inherently rewarding.

Products can adopt similar mechanisms. For instance:

• Uber: Real-time driver tracking gives users instant feedback and reduces anxiety.

• Slack: Witty loading messages make even mundane actions feel engaging.

• Duolingo: Playful animations celebrate user progress.

These feedback mechanisms ensure that users feel seen and rewarded for their efforts, creating a sense of delight that reinforces the core loop.

How to Apply This to Your Product

As a product manager, your role is to think like a game designer. Start by mapping out your product’s core loop. Ask yourself:

• Is this action intuitive and rewarding? If not, refine it.

• Do supporting features enhance the loop or distract from it? Remove anything that doesn’t align.

• Are we providing users with a sense of progress and accomplishment? Incorporate progression systems and feedback mechanisms where appropriate.

Finally, remember that even the best loops need to evolve. Games like Fortnite regularly introduce new mechanics, challenges, and rewards to keep players engaged. Similarly, your product should adapt based on user feedback and changing needs.

So…

Games have mastered the art of engagement, and their principles can transform how we think about products. By designing a strong core loop, supporting it with thoughtful features, and layering in progression systems and feedback, you’re not just creating a product—you’re creating an experience users will love.

So the next time you’re stuck, think about your product like a game. Ask yourself: What’s my core loop? And how do I make it irresistible? Get that right, and you’ll have something people won’t want to put down.

Share

Every week, I share straightforward advice, actionable tips, and proven strategies for Product Managers to navigate tough situations, win over stakeholders, and elevate their PM skills.

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

Product strategy often feels like one of those things everyone claims to know but few truly understand. You’ve sat through the workshops, read the books, and watched the frameworks get plastered on slides, but when it comes to actually making it work—things tend to fall apart. And the truth is, you’re not alone. Many of us stumble at the same hurdles, often for similar reasons.

Let’s talk about what might be going wrong and how you can start steering your strategy in the right direction.

Vision Isn’t Strategy

One of the most common mistakes I see is confusing vision with strategy. Vision is what you aspire to achieve; it’s the dream that inspires the team and keeps everyone aligned on the larger purpose. But strategy is the practical, often gritty path to get there. If your strategy feels like it could double as a motivational poster, it’s likely not a strategy.

For example, I once worked with a team that was determined to “empower Pharma companies globally.” Noble, yes, but when I asked them how they planned to do it, their roadmap was a mix of disconnected features targeting wildly different user segments. The vision was clear, but there was no strategy tying it all together. It’s like setting out to climb Everest without deciding on a route—you’re not going to get very far.

Prioritization: Less Is More

Another pitfall is the inability to prioritize. And I get it—everything feels important. But the hard truth is, if everything is a priority, nothing is. I remember a time when we had a laundry list of features on a roadmap, all marked “high priority.” Everyone was stretched thin, and none of the features were executed well enough to move the needle. That’s when I learned that prioritization is as much about saying no as it is about choosing what to do.

The reality is, your resources—time, people, money—are finite. Your strategy should reflect that. Focus on solving one meaningful problem at a time instead of trying to do it all. Trust me, your team will thank you for the clarity, and your users will notice the difference.

Beware of Overpromising

Another silent killer of strategy is the pressure to overpromise. I’ve seen this happen to even the best-intentioned teams. Whether it’s a well-meaning PM trying to keep stakeholders happy or a leadership team trying to appease investors, the temptation to promise the moon is real. The problem is, when you set unrealistic expectations, you’re setting yourself up for disappointment—not just for yourself, but for everyone involved.

A feature launch that doesn’t hit the mark isn’t just a setback; it erodes trust. It’s far better to take a step back, set achievable goals, and deliver them well. Your stakeholders might push back initially, but in the long run, consistent delivery will always win over flashy promises.

Root Your Strategy in Reality

Finally, strategy often stumbles when it’s detached from reality. If you’re building features because “it feels like a good idea” or “our competitor is doing it,” stop. Your users are your best source of truth. Are you listening to them? Are you testing your assumptions? A great strategy is always anchored in real insights, not guesswork.

I’ve seen entire quarters wasted chasing shiny trends without validating whether we solved a real problem. It’s tempting to jump on the AI, blockchain, or metaverse bandwagon, but remember: just because something is innovative doesn’t mean it’s useful. The best products solve problems that users care about—not ones your leadership team thought sounded cool.

The Path to a Stronger Strategy

Building a solid product strategy doesn’t require a PhD in business or a $100,000 MBA. It’s about clarity, focus, and adaptability. Here’s how you can ensure your strategy not only looks good on paper but also works in the real world.

1. Get Crystal Clear on Your North Star

Before anything else, define what success looks like. This isn’t just about your big-picture vision; it’s about measurable outcomes that your team can rally around. Your North Star metric should answer: What’s the one thing we need to achieve to know we’re on the right track?

Let’s say your product is an app for freelancers to manage their expenses efficiently. A meaningful North Star metric could be: “Reduce the time freelancers spend logging and categorizing expenses by 50% within three months of adoption.” , and set up the right metrics tracking to ensure this north star is properly calculated.

2. Ruthlessly Prioritize Your Goals

Once you’ve nailed your North Star, the next step is figuring out how to get there. This is where prioritization comes into play. Use a simple framework like RICE (Reach, Impact, Confidence, Effort) to evaluate ideas objectively. But here’s the real trick: resist the temptation to tackle too many things at once.

A good strategy is about focus. Choose one or two core objectives for a given period—ideally, objectives that are directly tied to your North Star. For instance, if increasing daily active users is the goal, your priority might be reducing friction in the onboarding process rather than launching flashy new features.

3. Validate Your Assumptions

Every strategy starts with assumptions: what your users want, what the market demands, and what your team can deliver. The danger lies in treating these assumptions as facts.

Invest in validation early and often. This doesn’t have to mean weeks of expensive user research. Quick experiments, like A/B tests, surveys, or even MVP launches, can help you gather critical insights. For example, before overhauling your onboarding flow, run a small click test with 10% of your users. Did completion rates improve? If yes, double down. If not, you’ve just saved yourself months of wasted effort.

4. Align Execution with Strategy

A well-defined strategy often fails in the execution phase because teams don’t connect the dots between the plan and the work. Avoid this by ensuring every project, task, and feature ties back to your strategy.

This might sound obvious, but you’d be surprised how often teams operate in silos. For instance, engineering might focus on tech debt while design experiments with a new UI. Both are valid priorities but can derail the overall strategy if not aligned. Regular check-ins, clear OKRs, and a single source of truth (like a roadmap or product brief) can keep everyone on the same page.

5. Communicate Early and Often

Even the best strategy can fail if it’s not communicated effectively. Your team and stakeholders should understand not just what the strategy is but why it exists. Why did you prioritize onboarding improvements over feature requests? Why are you focusing on retention over acquisition?

Take the time to tell this story—not just once in a kickoff meeting, but repeatedly throughout the project lifecycle. Use updates, demos, and metrics to reinforce the strategy and show progress. When people see the logic behind your decisions, they’re more likely to buy in and support the execution.

6. Be Ready to Pivot

The best strategies aren’t set in stone—they evolve as new information comes in. Maybe your early assumptions were off, or maybe the market shifted in an unexpected way. Instead of clinging to a failing strategy, embrace flexibility.

Think of your strategy as a living document. Revisit it regularly, and don’t be afraid to make adjustments based on what you’ve learned. For instance, if your North Star metric isn’t improving despite your efforts, it might be time to re-evaluate whether you’re solving the right problem.

Bringing It All Together

A strong product strategy is about more than just having a plan. It’s about making deliberate, informed choices and staying committed to solving real user problems. It’s about being clear on what matters most and having the discipline to focus your team’s efforts.

Most importantly, it’s about staying adaptable. The world doesn’t stand still, and neither should your strategy. When you’re clear about where you’re going and open to adjusting the route along the way, you’re already ahead of the game.

So take a deep breath, roll up your sleeves, and start building the kind of strategy that doesn’t just sound good in meetings but actually delivers results. Because at the end of the day, that’s what being a great PM is all about.

Subscribe for free to receive new posts and support my work.

Subscribe now

Every week, I tackle common challenges that PMs discuss on forums like Reddit and in product communities. I share straightforward advice, actionable tips, and proven strategies to navigate tough situations, win over stakeholders, and elevate your PM skills.

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

Let me start by saying this: most PM resumes don’t get rejected because the person isn’t qualified. They get rejected because they don’t land. The recruiter (or hiring manager, if you’re lucky) can’t see the impact you’ve had, or they’re left guessing what you even did. And let’s face it—if your resume doesn’t pass the “skimmable and relevant” test in 60 seconds, it’s over.

I am seeing a lot of candidates asking for Resume reviews, and most of them have the same mistakes. Writing a PM resume is like building a product. You need to know your audience, strip out the noise, and deliver value. If your resume reads like a list of tasks instead of a story of impact, it’s not doing its job.

Let’s fix that.

Number 1 Problem - Focus on the “So What”

This is where most PM resumes fail. They tell me what you did, but not why it mattered. For example:

❌ Responsible for roadmap planning and working with stakeholders.
Cool. That tells me nothing except that you showed up to work.

✅ Owned a $10M roadmap, prioritizing features that increased retention by 15%.
Now I know you delivered impact. Your roadmap wasn’t just a spreadsheet—it moved metrics.

Every bullet on your resume should answer the question, So what? If it doesn’t, rewrite it. Don’t tell me what you did. Tell me what changed because you did it.

Context Turns Numbers Into Stories

You’ve probably heard that numbers make resumes stronger. True. But they only work when they tell a story. Take this:

❌ Onboarded 30,000 accounts to the platform.
Okay… Is 30,000 good? Did it take a month or a year? Did it lead to anything meaningful?

✅ Onboarded 30,000 accounts in 3 months, driving a 20% increase in revenue.
That’s better. Now I know the scale, the timeline, and the business impact. Numbers without context are just noise. Always show why your metric matters.

You have done most of these, and your resume is still not being shortlisted? Connect with me for a 1:1 Resume Review. If you are not satisfied with the results, you can get a full refund

1:1 Expert Resume Review

Don’t Assume People Know Your Product

PMs love to name-drop products and features like everyone’s already familiar with them. But if your recruiter isn’t in your industry, you’re just confusing them.

❌ Drove integration of Airmeet into partner ecosystems.
Great for Airmeet, but no one outside your bubble knows what that means.

✅ Integrated a virtual event platform with a CRM, improving lead capture by 30%.
Now anyone can see what you did and why it mattered. Always assume the person reading your resume has no idea what your product is. Spell it out.

Don’t Write a Novel

Let me be blunt: your resume is not your life story. It’s not even your career story. It’s a highlight reel, and it should be short and sharp.

You don’t need to list every single feature or project you’ve touched. In fact, you shouldn’t. Focus on what aligns with the job you’re applying for and what had the biggest impact. Everything else? Cut it. If you feel bad leaving something out, remind yourself that resumes aren’t permanent. You can always add it back for another role.

Big vs. Small Companies: What They Care About

Your audience matters. A startup hiring its first PM wants something completely different from a team at Google or Microsoft.

• At big companies, they care about how well you work within complexity: stakeholder management, cross-functional collaboration, and scaling solutions.

• At small companies, it’s all about initiative: solving ambiguous problems, wearing multiple hats, and getting things done without much handholding.

Your resume should reflect what the company values. Don’t write about navigating a hundred stakeholders for a startup that just needs someone to ship fast. And don’t brag about wearing a dozen hats to a team looking for deep expertise in one area.

For Career Switchers: Play to Your Strengths

If you’re breaking into product management, don’t try to fake experience you don’t have. People can spot that from a mile away. Instead, lean into the skills you do have:

• Highlight leadership, problem-solving, or cross-functional collaboration from your current role.

• Talk about any PM-like work you’ve done—whether it’s leading a hackathon, owning a side project, or improving processes at your day job.

• Be upfront about transitioning. Show that you’ve done your homework and that your background brings unique value.

Hiring managers don’t need you to have everything figured out; they just need to see potential.

The 30-Second Rule

Let’s circle back to the brutal reality of resumes: you’ve got less than a minute to make an impression. A recruiter skims, looking for a few key things:

• What did you do?

• How well did you do it?

• Why does it matter?

If your resume doesn’t answer those questions immediately, it’s game over. No one’s going to dig through paragraphs to figure it out. Make it skimmable. Make it clear. Make it count.

Think of your resume as your first pitch—if they don’t buy in the first 60 seconds, they’re not reading the rest.

Your Resume is your Product!

A PM resume isn’t about looking impressive. It’s about being clear, direct, and outcome-focused. If your resume shows that you’ve made a difference—whether by improving metrics, solving problems, or driving results—you’ll stand out.

Go write something that works, and don’t forget: every resume, like every product, gets better with iteration.

Thank you for reading, Subscribe below for more such articles.

Subscribe now

Each week, I share no-nonsense advice, practical tips, and real-world strategies to help you handle tricky scenarios, impress your stakeholders, and level up your PM game.

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

Let’s rip off the Band-Aid right away: politics isn’t just a side effect of product management—it’s woven into the very fabric of the role. You can hate it. You can try to ignore it. But if you want to survive and thrive, you’ll need to embrace it.

I know this isn’t what you signed up for. You wanted to solve user problems, launch cool products, and be the hero who makes everything better. And you can still be that. But here’s the twist: product management is as much about managing people, egos, and priorities as it is about managing roadmaps. The sooner you accept this reality, the easier it becomes.

It’s not about “playing politics” in the shady, manipulative sense. It’s about understanding dynamics, building relationships, and influencing outcomes in a world where decisions aren’t always logical. And yes, it can be exhausting. But trust me, it’s part of the job—just like writing specs or running stand-ups.

The Unspoken Truth About Influence

Let’s talk about influence, the supposed crown jewel of a PM’s skill set. It’s a romantic idea, isn’t it? That you’ll walk into a meeting, present a perfectly crafted argument, and everyone will nod along in agreement because you’re that convincing.

The reality? Influence is messier than that. It’s about aligning people who often have conflicting priorities. And sometimes, your well-researched ideas will hit a brick wall because of decisions made far above your pay grade.

I remember one of my early projects where I poured my heart into building a roadmap. It was based on meticulous user research, competitive analysis, and every data point I could gather. I was sure it was bulletproof. But then leadership decided to pivot. It was like a slap in the face. I felt sidelined, almost betrayed.

What I didn’t realize back then was this: their decision wasn’t a rejection of my work. It was a reflection of broader strategic priorities I had no idea about. My mistake wasn’t in creating the roadmap—it was in failing to align my efforts with the bigger picture.

When Things Get Personal

And then there’s the dreaded blame game. Deadlines slip, priorities change, and fingers inevitably start pointing. Even when you’ve done everything right, you might find yourself in the crosshairs.

I’ve been there. The first time it happened to me, I was pissed. How could I be blamed for delays caused by unforeseen dependencies? But reacting emotionally only made things worse. Over time, I learned to lean into transparency.

Instead of getting defensive, I started laying out the facts calmly. I’d share what went wrong, why it happened, and what we were doing to course-correct to the management chain. Most of the time, that was enough to diffuse the situation. And if it wasn’t? I reminded myself to trust the process. Good managers will see through the noise.

A Lesson in Humility

One of my biggest political blunders came when I was building a 0-to-1 product in an industry I was completely new to. My first release saw moderate success—enough to build on incrementally. But I was eager to make a big splash, so I pushed for a bold pivot.

It was risky, and I didn’t have unanimous support. Still, I forged ahead, convinced that I knew best. The product didn’t crash and burn, but it didn’t take off either. Worse, I’d alienated key stakeholders in the process. The environment became so hostile that I eventually had to leave.

Looking back, I realize the pivot wasn’t the real issue. The problem was how I handled it. If I’d taken the time to collaborate, incorporate feedback, and bring people along for the ride, things might have turned out differently. Relationships are as important as results, if not more so.

So, What’s the Fix?

1. Build Relationships Before You Need Them

Why this matters: Trust and rapport are the currency of influence. When stakeholders trust you, they’re more likely to support your ideas—even in challenging situations.

How to do it:

• Don’t wait for a crisis to start conversations. Set up regular coffee chats or informal syncs with key stakeholders to understand their priorities and concerns.

• Make an effort to celebrate wins together, whether it’s completing a milestone or addressing a tricky problem.

• Treat your stakeholders as partners, not obstacles.

Pro tip: Always ask, “How can I help the team succeed?” Showing interest in shared goals strengthens your relationship.

2. Understand the Bigger Picture

Why this matters: Sometimes, your ideas clash with leadership decisions because they align with a vision you’re not fully aware of. Aligning your efforts with the organization’s strategy will make your work more impactful.

How to do it:

• Invest time in learning the company’s mission, long-term goals, and leadership priorities.

• Connect your product decisions to strategic outcomes. Frame your recommendations in terms of ROI, customer value, or alignment with leadership’s objectives.

• When possible, shadow senior leaders in key discussions to grasp their perspectives.

Pro tip: If you’re unsure about leadership’s priorities, don’t hesitate to ask your manager or trusted peers for guidance.

3. Communicate Transparently and Regularly

Why this matters: Lack of communication leads to misalignment, assumptions, and conflicts. Being proactive with updates can help you steer the narrative.

How to do it:

• Share status updates frequently through structured reports, dashboards, or short syncs.

• Highlight risks and blockers early, along with your plan to address them. This builds confidence in your problem-solving ability.

• Use storytelling to make dry updates engaging—talk about customer impact, progress against goals, or team wins.

Pro tip: In tough situations, focus on what’s next. Acknowledge what went wrong, but quickly pivot to solutions.

4. Pick Your Battles with Care

Why this matters: Not every conflict is worth escalating. Learning to prioritize where to push back and where to compromise is crucial for maintaining relationships.

How to do it:

• When faced with opposition, ask yourself: “Does this directly impact the product’s success or my team’s ability to deliver?”

• For low-stakes issues, compromise where possible. Save your energy for high-impact decisions.

• When you do push back, back your position with data and frame it in terms of shared success.

Pro tip: Sometimes, winning people over is as simple as framing your disagreement as a collaborative discussion: “How can we make this work together?”

5. Foster a Collaborative Culture

Why this matters: When people feel heard and valued, they’re more likely to align with your vision. Collaboration isn’t just good for morale—it’s good for outcomes.

How to do it:

• Facilitate workshops or brainstorming sessions where stakeholders can share input.

• Actively listen and integrate their feedback into the product where it makes sense.

• Show people how their contributions have shaped decisions.

Pro tip: Create a shared “north star” for your team and stakeholders—something everyone can rally around, like a key user outcome or a bold product vision.

6. Be Patient, but Stay Persistent

Why this matters: Navigating office politics isn’t a sprint—it’s a marathon. Relationships, trust, and influence take time to build.

How to do it:

• Take a long-term view. If a decision doesn’t go your way today, use the experience to better understand the dynamics for next time.

• Keep showing up with consistent effort and a positive attitude, even in challenging situations.

• Reflect on political setbacks as learning opportunities—ask yourself what you could have done differently and apply those lessons.

Pro tip: Remember, you’re playing the long game. Building a strong reputation as a fair, reliable PM will pay off in ways you can’t predict.

7. Use Data as a Neutral Ally

Why this matters: In political situations, emotions and opinions can cloud judgment. Data provides an impartial lens to refocus the conversation.

How to do it:

• Always have key metrics ready to back your arguments—whether it’s user research, customer feedback, or performance analytics.

• Use visualizations like charts or dashboards to simplify complex points.

• Avoid weaponizing data to “win” arguments. Instead, position it as a way to guide collaborative decisions.

Pro tip: When there’s a lack of clarity, propose small experiments to gather new data. It’s harder to argue against actionable insights.

8. Be Human

Why this matters: At its core, politics is about people. Showing vulnerability, empathy, and authenticity goes a long way in building goodwill.

How to do it:

• Admit when you don’t have all the answers—it’s okay to say, “I need time to think this through.”

• Show appreciation for others’ efforts, even if you don’t agree with their views.

• Share personal anecdotes or challenges to foster connection.

Pro tip: A little humor can diffuse tense situations. Use it sparingly but effectively to lighten the mood.

The Silver Lining

Here’s the thing about politics: once you learn to navigate it, it can actually become a strength. It teaches you empathy, sharpens your communication skills, and makes you a better collaborator.

And when you see it as part of the job—not an annoying side quest—it stops feeling so overwhelming. It’s not easy, but it’s worth it.

So the next time you’re caught in the middle of office politics, remember: this is just as much a part of product management as building roadmaps or launching features. Embrace it, learn from it, and let it make you stronger.

Because at the end of the day, being a great PM isn’t just about managing products. It’s about managing people, too.

If you think the article helped you, Please subscribe and help my voice reach other PMs.

Subscribe now

Each week, I share no-nonsense advice, practical tips, and real-world strategies to help you handle tricky scenarios, impress your stakeholders, and level up your PM game.

If you’re ready to stop guessing and start thriving in the world of product management, hit that subscribe button now! 🚀

Subscribe now

Agentic AI is the buzzword of the moment, and as a PM, chances are you’ve been asked, “When are we adding Agentic AI features to our product?” The pressure is real, but here’s the thing: rushing to sprinkle AI onto your product doesn’t solve real problems. It creates clutter, not value.

Let’s assume you’re managing an existing product, like a chat app. You’ve been tasked with introducing generative AI features. How do you approach this thoughtfully?

In this article, we’ll break down the step-by-step thought process of an AI PM, using a chat app as our anchor example.

Should I think Gen AI forward or User forward?

The temptation with AI is to jump straight to the tech—“Let’s add a fancy Gen AI or Agentic AI feature now!”—but great PMs know to start with their users. Your first step is to understand what users are doing in your product and where they might be struggling.

Decompose User Actions

Every product has a set of actions users perform, but not all actions are created equal. Some are high-value—the ones users care most about—while others are low-value, more transactional. For a chat app, here’s how that might look:

• High-value actions: Reading messages, responding to conversations, coordinating plans. These are why users engage with the app in the first place.

• Low-value actions: Deleting old chats, tweaking notification settings. Necessary but peripheral to the core experience.

Focus your attention on high-value actions. Generative AI should either enhance these actions or remove friction that prevents users from performing them.

Look for Pain Points Without Thinking AI Yet

Once you’ve mapped out user actions, identify pain points that naturally exist in the workflow. Let’s take group chats as an example. Imagine a group of friends trying to coordinate dinner plans. By the end of the day, the chat has hundreds of messages—restaurant suggestions, time proposals, back-and-forth confirmations.

What’s the real problem here? It’s not that users can’t read fast enough. It’s that coordinating decisions in a group setting is messy and time-consuming. This insight is critical: you’re solving a pain point, not just layering in AI for the sake of it.

Does this shift the user behaviour or the user itself?

AI doesn’t just enhance existing workflows—it often changes who your user is or how they interact with your product. Even within the context of a chat app, you need to anticipate how the introduction of AI might shift user dynamics.

An Example of User Shift

Right now, your primary users in a chat app might be individual participants actively engaging in conversations. But what happens when you introduce AI-driven features like automated summarization or intelligent decision-making? Suddenly, the user persona might expand to include passive participants—people who rely on the AI to keep them updated without having to dig into the conversation themselves.

For instance, a busy user who checks the chat late at night may rely entirely on AI to surface key decisions or action items. The app must adapt to these users by providing actionable insights, such as:

• Summarizing the conversation (e.g., “The group decided on 7 PM at The Olive Garden”).

• Offering proactive next steps (e.g., “Would you like to RSVP or suggest a different time?”).

Your design and workflows need to evolve to accommodate these new use cases.

Why would the user pay or be interested in my feature?

Even the smartest AI features won’t succeed if they don’t create clear value for the user. Here’s how to assess this:

1. Is the problem significant? Solving a minor annoyance might not move the needle for users.

2. Is there differentiation? If free tools like ChatGPT can solve the same problem, why would users choose your solution?

3. Is it worth paying for? If the AI feature doesn’t provide meaningful ROI (time saved, decisions simplified), monetization becomes a challenge.

Adding Real Value

Let’s return to the group chat scenario. A basic AI feature might summarize the chat, telling the user, “The group is discussing dinner plans.” Useful? Maybe. Memorable? Not really.

Now, imagine a more sophisticated workflow:

1. Extract key decisions: The group has decided on 7 PM at The Olive Garden.

2. Propose next steps: “Would you like to create a calendar invite for this plan?”

3. Automate integrations: Suggest making a reservation via OpenTable or Zomato, if applicable.

4. Provide real-time assistance: Notify the group to leave on time, factoring in live traffic data through Maps integration.

This isn’t just solving a pain point—it’s turning the app into a proactive assistant that simplifies the entire decision-making process. This level of automation feels magical, and users might even pay for it.

Embrace Agentic AI to Reimagine the Workflow

The biggest mistake PMs make with AI is solving point problems in isolation, rather than optimizing the user’s entire workflow. AI should act as an invisible enabler, streamlining the process from start to finish. This is where agentic AI shines. Instead of addressing individual pain points in isolation, agentic AI solves for the entire workflow by acting as a proactive assistant. It connects multiple actions and automates tasks to help users achieve their goals effortlessly.

Agentic AI in Action

Let’s revisit the dinner planning scenario. A basic AI feature might summarize messages and tell the user, “The group has decided on 7 PM at The Olive Garden.” That’s helpful, but it’s still task-based. Agentic AI would go further:

1. The AI highlights key conversation threads:

   • “Dinner plans finalized: 7 PM at The Olive Garden.”

   • “Team outing: decision still pending.”

2. It offers actionable next steps:

   • “Create a calendar invite for dinner?”

   • “Would you like to suggest a time for the team outing?”

3. It takes initiative:

   • “The Olive Garden tends to get crowded on Fridays. Shall I reserve a table for you?”

   • “Would you like reminders sent to the group an hour before the event?”

By solving for the user’s entire workflow, you’re delivering real value. AI stops being a gimmick and becomes a transformative part of the experience.

So what to takeaway from this..

1. Start with the user, not AI: Decompose user actions and focus on high-value pain points.

2. Anticipate user shifts: AI can change not just workflows but also user personas and needs.

3. Validate value: Make sure your AI solution addresses a real problem and stands out from generic tools.

4. Optimize workflows with Agentic AI approach: AI’s real power lies in creating seamless, end-to-end experiences.

Introducing AI into a product isn’t about chasing trends—it’s about rethinking how your product delivers value. When done right, AI becomes invisible, quietly enabling users to achieve their goals more effortlessly.

So, next time someone says, “Let’s add AI to this product,” take a step back. Map the user journey. Identify pain points. Then, and only then, ask: “How can AI truly transform this experience?”

By following this approach, you’re not just adding features—you’re building the future. Comment your thoughts below, would love to hear them :)

Leave a comment