Diogo Moutinho

[Paweł Huryn @PawelHuryn]

As a PM, you need to remember that every product serves two purposes:

- Creating value for the customers
- Capturing some part of that value for the business

But many product teams struggle with the latter.

(1/9)

[Alex Brogan @alexbrogan]

Most companies suck at setting goals.

But Google, Amazon, and Microsoft figured it out ages ago.

Here’s their simple but powerful goal-setting framework (that you can use personally too):

[Bytebytego @bytebytego]

A nice cheat sheet of different monitoring infrastructure in cloud services.

This cheat sheet offers a concise yet comprehensive comparison of key monitoring elements across the three major cloud providers and open-source / 3rd party tools.

Let's delve into the essential monitoring aspects covered:
- Data Collection: Gather information from diverse sources to enhance decision-making.
- Data Storage: Safely store and manage data for future analysis and reference.
- Data Analysis: Extract valuable insights from data to drive informed actions.
- Alerting: Receive real-time notifications about critical events or anomalies.
- Visualization: Present data in a visually comprehensible format for better understanding.
- Reporting and Compliance: Generate reports and ensure adherence to regulatory standards.
- Automation: Streamline processes and tasks through automated workflows.
- Integration: Seamlessly connect and exchange data between different systems or tools.
- Feedback Loops: Continuously refine strategies based on feedback and performance analysis.

Over to you: How do you prioritize and leverage these essential monitoring aspects in your domain to achieve better outcomes and efficiency?

–
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://t.co/FIzCeaWsZV

[Alex Xu @alexxubyte]

A nice cheat sheet of different cloud services.

[Bilgin Ibryam @bibryam]

40 Must Read Engineering Blogs in 2024
https://t.co/GPkMnrG4WU

[Dr Milan Milanović @milan_milanovic]

𝗠𝗼𝘀𝘁 𝗖𝗼𝗺𝗺𝗼𝗻 𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗦𝘁𝘆𝗹𝗲𝘀

Software architecture styles are the foundational blueprints for constructing various software systems, ensuring they meet specific requirements and quality attributes.

An architectural pattern, on the other hand, communicates a fundamental organizational structure for software systems. By selecting the appropriate patterns for your issue, you can avoid creating anything from scratch and potentially dangerous traps that might arise if you try to devise a novel solution.

Here are the most common architectural styles: 🧵

#softwarearchitecture #softwaredesign #programming

[Neo Kim @systemdesignone]

How to start with [system design].

Read these articles:

[Bytebytego @bytebytego]

Have you heard of the 12-Factor App?

The "12 Factor App" offers a set of best practices for building modern software applications. Following these 12 principles can help developers and teams in building reliable, scalable, and manageable applications.

Here's a brief overview of each principle:

1. Codebase:
Have one place to keep all your code, and manage it using version control like Git.

2. Dependencies:
List all the things your app needs to work properly, and make sure they're easy to install.

3. Config:
Keep important settings like database credentials separate from your code, so you can change them without rewriting code.

4. Backing Services:
Use other services (like databases or payment processors) as separate components that your app connects to.

5. Build, Release, Run:
Make a clear distinction between preparing your app, releasing it, and running it in production.

6. Processes:
Design your app so that each part doesn't rely on a specific computer or memory. It's like making LEGO blocks that fit together.

7. Port Binding:
Let your app be accessible through a network port, and make sure it doesn't store critical information on a single computer.

8. Concurrency:
Make your app able to handle more work by adding more copies of the same thing, like hiring more workers for a busy restaurant.

9. Disposability:
Your app should start quickly and shut down gracefully, like turning off a light switch instead of yanking out the power cord.

10. Dev/Prod Parity:
Ensure that what you use for developing your app is very similar to what you use in production, to avoid surprises.

11. Logs:
Keep a record of what happens in your app so you can understand and fix issues, like a diary for your software.

12. Admin Processes:
Run special tasks separately from your app, like doing maintenance work in a workshop instead of on the factory floor.

Over to you: Where do you think these principles can have the most impact in improving software development practices?

--
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://t.co/FIzCeaWsZV

[Bytebytego @bytebytego]

Top 12 Tips for API Security

- Use HTTPS
- Use OAuth2
- Use WebAuthn
- Use Leveled API Keys
- Authorization
- Rate Limiting
- API Versioning
- Whitelisting
- Check OWASP API Security Risks
- Use API Gateway
- Error Handling
- Input Validation

–
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://t.co/FIzCeaWsZV

[Alex Xu @alexxubyte]

Top Architectural Styles.

The method to download the high-resolution image is available at the end.

In software development, architecture plays a crucial role in shaping the structure and behavior of software systems. It provides a blueprint for system design, detailing how components interact with each other to deliver specific functionality. They also offer solutions to common problems, saving time and effort and leading to more robust and maintainable systems.

However, with the vast array of architectural styles and patterns available, it can take time to discern which approach best suits a particular project or system. Aims to shed light on these concepts, helping you make informed decisions in your architectural endeavors.

To help you navigate the vast landscape of architectural styles and patterns, there is a cheat sheet that encapsulates all. This cheat sheet is a handy reference guide that you can use to quickly recall the main characteristics of each architectural style and pattern.

–
Subscribe to our newsletter to download the 𝐡𝐢𝐠𝐡 𝐫𝐞𝐬𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐢𝐦𝐚𝐠𝐞. After signing up, find the download link on the success page: https://t.co/ito2aWqd62

[Bandan (Productify) @bandanjot]

10 dashboards and metrics that every Product Manager should know and use:

[Alex Xu @alexxubyte]

Explaining Sessions, Tokens, JWT, SSO, and OAuth in One Diagram. The method to download the high-resolution PDF is available at the end.

Understanding these backstage maneuvers helps us build secure, seamless experiences.

How do you see the evolution of web session management impacting the future of web applications and user experiences?

Subscribe to our newsletter to download the 𝐡𝐢𝐠𝐡-𝐫𝐞𝐬𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐏𝐃𝐅 𝐨𝐟 𝐭𝐡𝐢𝐬 𝐝𝐢𝐚𝐠𝐫𝐚𝐦. After signing up, find the download link on the success page: https://t.co/65PhIVlGbS

[Dr Milan Milanović @milan_milanovic]

𝗖𝗮𝗽𝘁𝘂𝗿𝗶𝗻𝗴 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗗𝗲𝗰𝗶𝘀𝗶𝗼𝗻𝘀 𝘄𝗶𝘁𝗵 𝗔𝗗𝗥𝘀

There are several ways to 𝗱𝗼𝗰𝘂𝗺𝗲𝗻𝘁 𝘀𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲, such as UML, 4+1 view model, C4 model, and 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗗𝗲𝗰𝗶𝘀𝗶𝗼𝗻 𝗥𝗲𝗰𝗼𝗿𝗱𝘀 (𝗔𝗗𝗥𝘀).

ADRs document the decisions made during the design and implementation of a software system or application. An ADR is a brief document that captures the rationale behind a particular architectural decision, the alternatives that were considered, and the trade-offs involved.

ADR represents 𝗮 𝗹𝗼𝗴 𝗲𝗻𝘁𝗿𝘆 about an architectural decision that has been made that led to the state of architecture then (the why). Typical 𝗔𝗗𝗥 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 consists of:

 🔹 𝗧𝗶𝘁𝗹𝗲. A short descriptive title that summarizes the decision being documented.  

 🔹 𝗦𝘁𝗮𝘁𝘂𝘀. Proposed, Accepted, etc.

 🔹 𝗖𝗼𝗻𝘁𝗲𝘅𝘁. A description of the technical, business, or organizational context that led to the need for the decision.

 🔹 𝗗𝗲𝗰𝗶𝘀𝗶𝗼𝗻. A statement that describes the decision made, along with any relevant details or options considered.

 🔹 𝗖𝗼𝗻𝘀𝗲𝗾𝘂𝗲𝗻𝗰𝗲𝘀. A description of the potential consequences of the decision, including any trade-offs or risks involved.

 🔹 𝗔𝗹𝘁𝗲𝗿𝗻𝗮𝘁𝗶𝘃𝗲𝘀. A list of considered alternative options, along with their pros and cons.

 🔹 𝗚𝗲𝗻𝗲𝗿𝗮𝗹 𝗶𝗻𝗳𝗼, such as date and authors.

A good recommendation is to store ADRs in your 𝗚𝗜𝗧 𝗿𝗲𝗽𝗼𝘀𝗶𝘁𝗼𝗿𝘆, close to your code, or on the Wiki page if you want to be visible to non-developers too.

One of the best uses of ADRs is the 𝗲𝗻𝘁𝗿𝘆 𝗽𝗼𝗶𝗻𝘁𝘀 𝗳𝗼𝗿 𝗱𝗶𝘀𝗰𝘂𝘀𝘀𝗶𝗼𝗻𝘀 𝗮𝘀 𝗮𝗻 𝗥𝗙𝗖 (Request for Comments). RFS represents an idea that can be reviewed by other team members with approval.

Some different templates and tools can be used for ADRs. Check them in the comments.

#technology #softwareengineering #programming #techworldwithmilan #softwarearchitecture

[javinpaul @javinpaul]

Top 10 System Software Concepts
➡️Load balancers
➡️APIs
➡️Caches
➡️Databases
➡️Network Protocols
➡️Message queues
➡️CDNs
➡️High-level details about ML and Big data
➡️CAP Theorem
➡️Monitoring and analytics
read - https://t.co/wR2asRpocW

[javinpaul @javinpaul]

Top 16 API Security Practices worth knowing
Credit - Brij Kishore Pandey

[Bandan (Productify) @bandanjot]

10 dashboards and metrics that every Product Manager should know and use:

(explained with graphs and examples)

[Bilgin Ibryam @bibryam]

10 NFRs to consider in your architecture
https://t.co/RFTDazCH8G

[Paweł Huryn @PawelHuryn]

Be careful. Most "products" are, in fact, projects.

9 red flags (and how it should work):

1. Large PRD: You start an initiative by documenting everything.

2. Feature factory: Implement the requirements. Don't ask why.

3. Waterfall: All the requirements are collected in the "initial phase."

4. Gatt roadmap: A time-based, feature-based roadmap.

5. No discovery: No need to validate ideas before implementing them.

6. No designer: There is no Product Designer on the team.

7. No analytics: You have no idea how people use your product.

8. Customer in charge: Powerful customer(s) make all the decisions.

9. No strategy: You try to maximize sales by satisfying all customers and grasping every opportunity.

-

Here is a better way:

1. Your cross-functional team is empowered to solve the problems.

2. PM, Product Designer, and Lead Engineer perform Product Discovery together. Continuously.

3. You have an outcome-based roadmap. Preferably Now-Next-Later.

4. If you commit to a date, you do it rarely and only after the Discovery. You never commit too early.

5. You manage the value, usability, feasibility, and viability risks by experimenting.

6. The riskiest assumptions are tested before the implementation.

7. Choosing, instrumenting, and tracking the right metrics is key.

8. You ship incrementally, measure the outcomes and learn from it.

9. Tradeoffs are essential. What you do, but also what you don't. You respect your market and the unique value proposition.

-

And if your product hasn't been launched yet:

1. Discover the market and define a unique value proposition, business model, initial vision, and strategy.

2. Test your business idea with the help of MVP prototypes. Before the implementation.

3. You define the go-to-market strategy and validate key assumptions. Messaging included.

4. You can't rely on product analytics before launching the product, so you rely more on customer interviews and data from your experiments.

5. The Product Trio performs the Initial Product Discovery, like in an existing product. You always need a Product Designer and Lead Engineer.

6. Once you ship, use product analytics and apply Continuous Product Discovery.

-

Hope that helps.

What are your thoughts?

-

P.S. It's just 1 of 6 free issues I published today in my newsletter. The link is under my profile: @PawelHuryn

[Carl Vellotti 🥞 @carlvellotti]

I love Spotify’s model of alignment vs autonomy

[Gartner @Gartner_inc]

89% of boards agree digital is an implicit part of growth strategy. The surprise? 81% have not made progress toward or achieved their digital business transformation goals. Get ready to face these challenges and drive growth for your business ➡ https://t.co/1FyWR5Rudv