I’m restarting my blog. It’s been 10 years since I last updated, and things have changed considerably. As a result I’m just going to start fresh. I may republish some items, I may not.

Right now I really want to work on a new experiment. Based on two influences and an idea I’ve had I’m going to try learning in public.

The first influence is a blog post by Martin Fowler. In it he talks about what he learned recently from Xu Hao, Thoughtworks’s Head of Technology for China. The discussion talks about using ChatGPT to architect a system. There are a bunch of interesting ideas, and it gets me in the mind to try ChatGPT out in anger instead of just playing with it.

The second influence is a series of blog posts from Juraj Majerik. “a software engineer based in Amsterdam.” In his blog posts he develops a model ride sharing app. I like how he builds up the app slowly, even going over old ground on occasion as he changes his mind or technology.

I want to tie a bunch of concepts that I’ve been exposed to recently together. These are things that I want to know more about but haven’t had a reason to dig in. They are:

  • micro-services
  • container services
  • Slack bots and the API
  • managerial blind-spots
  • Digital Ocean

I’ll share the prompts and chat I have with ChatGPT as well as the code I develop over time. To start, I start my chat session with

I'm building a service to provide to remind managers about blind-spots 
in their thinking and behavior. The system will be very basic from the
start. It will run in a single Digital Ocean instance within Docker. 
The database will be a postgresql container. The business logic layer 
will be an API written using an API gateway. The presentation layer will 
be done as a Slack bot. I would like you to act as the architect. 
Provide an overall solution following the guidance mentioned above. 
Don’t generate code. Describe the solution, and breaking the solution 
down as a task list based on the guidance mentioned above. And we will 
refer this task list as our master plan.

I get the response

As the architect, I can help you design the overall solution for your 
service to remind managers about blind spots in their thinking and
behavior. Based on the guidance you provided, here's an overview of
the solution along with a task list, which we'll refer to as the
master plan:

1. **Infrastructure Setup:**
   - Set up a Digital Ocean instance to host your application.
   - Install Docker on the instance to manage containers.
   - Create a Docker container for running your application.

2. **Database Setup:**
   - Use a PostgreSQL container to host your database.
   - Configure the PostgreSQL container with the necessary environment
   variables (e.g., database name, username, password).

3. **Business Logic Layer:**
   - Build an API layer to handle the business logic of your application.
   - Use an API gateway to manage and route incoming requests.
   - Define the API endpoints and their corresponding functionalities.
   - Implement data validation and error handling mechanisms.

4. **Integration with Slack:**
   - Develop a Slack bot as the presentation layer.
   - Configure the Slack bot to interact with users and receive commands.
   - Integrate the Slack bot with your API layer to fetch and process data.
   - Implement appropriate authentication and authorization mechanisms 
   for the Slack bot.

5. **Reminder Functionality:**
   - Design a mechanism to identify and remind managers about blind
   spots.
   - Implement a scheduling system to trigger reminders at specified
   intervals.
   - Define the criteria for identifying blind spots (e.g., predefined
   rules, user input, data analysis).
   - Send reminders to managers through the Slack bot based on the
   identified blind spots.

6. **User Management:**
   - Implement user management functionality to handle manager accounts.
   - Develop features for user registration, login, and authentication.
   - Design user roles and permissions as per your application's requirements.
   - Implement mechanisms to manage and update user profiles.

7. **Data Persistence and Storage:**
   - Design the database schema for storing manager profiles, reminders,
   and blind spot information.
   - Implement the necessary database operations for CRUD (Create, Read,
   Update, Delete) functionality.
   - Ensure data integrity and implement appropriate indexing for efficient
   querying.

8. **Monitoring and Logging:**
   - Set up monitoring tools to track the health and performance of your application.
   - Implement logging mechanisms to record important events and errors.
   - Configure alerts and notifications for critical issues.

9. **Deployment and Scaling:**
   - Prepare a deployment strategy to automate the deployment process.
   - Configure scaling options to handle increased load and user demand.
   - Test the deployment process and ensure the application runs smoothly
   in the production environment.

10. **Security and Compliance:**
    - Implement security measures to protect sensitive data and prevent unauthorized access.
    - Follow best practices for secure coding, input validation, and data sanitization.
    - Regularly update dependencies and apply security patches.
    - Comply with relevant data protection and privacy regulations.

11. **Testing and Quality Assurance:**
    - Develop unit tests, integration tests, and end-to-end tests for your application.
    - Establish a continuous integration and continuous deployment (CI/CD) pipeline.
    - Perform regular testing and quality assurance to ensure the stability
	and reliability of your application.

12. **Documentation and Support:**
    - Create comprehensive documentation for your service, including API
	documentation, deployment instructions, and troubleshooting guides.
    - Set up a support system to address user inquiries, issues, and feature requests.
    - Provide regular updates and improvements based on user feedback.

Remember that this master plan serves as a high-level outline for your project.
Each task can be broken down further into smaller sub-tasks based on your
specific requirements and implementation details.

As expected, there is a lot to unpack here, but it’s a little generic. It also assumes that you build each area completely before moving to the next. I’d like to build it in small functional pieces.

Currently the master plan has each component built top to bottom 
before moving to the next. Rewrite the master plan so that it's 
built in small increments where each step provides customer value.

The value breakdown would be:

1/ customers can signup for the service and get day of the week
messages on Slack about a blind-spot topic. 

2/ customers can respond to the bot messages with action items 
they plan to take on the blind-spot.

3/ customers are reminded at intervals about the feedback they 
provided about the blind-spot and are asked if they completed the
action item or not.

the result is

Based on the value breakdown you provided, here's an updated master
plan that focuses on delivering customer value in small increments:

1. **Initial Setup:**
   - Set up a Digital Ocean instance.
   - Install Docker on the instance.
   - Create a Docker container for running your application.

2. **User Registration and Slack Integration:**
   - Develop user registration functionality.
   - Allow customers to sign up for the service.
   - Integrate with Slack to send day-of-the-week messages about
   blind-spot topics.

3. **Blind-Spot Topic Management:**
   - Implement a system to manage blind-spot topics.
   - Allow administrators to define and update the blind-spot topics.
   - Ensure that customers receive Slack messages related to the
   chosen blind-spot topic of the day.

4. **Customer Action Item Submission:**
   - Enable customers to respond to the Slack bot messages with action
   items they plan to take on the blind-spot.
   - Implement functionality to receive and store customer action
   items in the database.

5. **Reminder and Follow-Up System:**
   - Design a system to remind customers at specified intervals about
   the action items they provided.
   - Send reminders through the Slack bot, asking if the customers
   completed their action items or not.
   - Store the responses in the database for further processing.

6. **Customer Feedback Tracking:**
   - Implement mechanisms to track customer feedback about the
   blind-spot and their action item completion status.
   - Store the feedback and completion status in the database
   associated with each customer.

7. **Admin Dashboard:**
   - Develop an admin dashboard to manage blind-spot topics, view
   customer feedback, and monitor completion status.
   - Provide a user-friendly interface for administrators to
   perform necessary actions.

8. **Refinement and Enhancements:**
   - Gather customer feedback and iterate on the existing features.
   - Refine the Slack bot messages and communication flow for a better
   user experience.
   - Implement any additional features or enhancements requested by customers.

9. **Scaling and Performance Optimization:**
   - Monitor the application's performance and scalability.
   - Identify and address any bottlenecks or performance issues.
   - Optimize the system to handle increased user load and ensure a
   seamless experience.

10. **Documentation and Support:**
    - Create documentation for customers on how to sign up, interact with
	the Slack bot, and manage their account.
    - Provide support channels for customers to seek assistance or report
	issues.
    - Continuously improve documentation and support based on customer
	needs and feedback.

By following this updated master plan, you can deliver customer value
at each step while incrementally building your service to remind managers
about blind spots in their thinking and behavior.

This is a little better. The tasks are broken down into layers now. There are new bits about “Blind-Spot Topic Management” and “Admin Dashboard” which are not things I asked for. It also dropped the requirement for “Monitoring and Logging”. I really want that.

In the second version you dropped the requirement for monitoring and
logging. I need this functionality, even in a basic way. Please integrate
monitoring and logging into this existing master plan.

Which gives me the result

Apologies for the oversight. Monitoring and logging are indeed important
for the proper functioning and maintenance of your service. Here's an
updated master plan that includes monitoring and logging alongside the
previous steps:

1. **Initial Setup:**
   - Set up a Digital Ocean instance.
   - Install Docker on the instance.
   - Create a Docker container for running your application.

2. **User Registration and Slack Integration:**
   - Develop user registration functionality.
   - Allow customers to sign up for the service.
   - Integrate with Slack to send day-of-the-week messages about
   blind-spot topics.

3. **Blind-Spot Topic Management:**
   - Implement a system to manage blind-spot topics.
   - Allow administrators to define and update the blind-spot topics.
   - Ensure that customers receive Slack messages related to the chosen
   blind-spot topic of the day.

4. **Customer Action Item Submission:**
   - Enable customers to respond to the Slack bot messages with action
   items they plan to take on the blind-spot.
   - Implement functionality to receive and store customer action items
   in the database.

5. **Reminder and Follow-Up System:**
   - Design a system to remind customers at specified intervals about
   the action items they provided.
   - Send reminders through the Slack bot, asking if the customers
   completed their action items or not.
   - Store the responses in the database for further processing.

6. **Customer Feedback Tracking:**
   - Implement mechanisms to track customer feedback about the blind-spot
   and their action item completion status.
   - Store the feedback and completion status in the database associated
   with each customer.

7. **Admin Dashboard:**
   - Develop an admin dashboard to manage blind-spot topics, view
   customer feedback, and monitor completion status.
   - Provide a user-friendly interface for administrators to perform
   necessary actions.

8. **Monitoring and Logging:**
   - Set up monitoring tools to track the health and performance of
   your application.
   - Configure logging mechanisms to record important events and errors.
   - Monitor system resources, such as CPU and memory usage.
   - Implement log aggregation and analysis for easier troubleshooting.

9. **Refinement and Enhancements:**
   - Gather customer feedback and iterate on the existing features.
   - Refine the Slack bot messages and communication flow for a better
   user experience.
   - Implement any additional features or enhancements requested by customers.

10. **Scaling and Performance Optimization:**
    - Monitor the application's performance and scalability.
    - Identify and address any bottlenecks or performance issues.
    - Optimize the system to handle increased user load and ensure a
	seamless experience.

11. **Documentation and Support:**
    - Create documentation for customers on how to sign up, interact with
	the Slack bot, and manage their account.
    - Provide support channels for customers to seek assistance or report issues.
    - Continuously improve documentation and support based on customer needs
	and feedback.

By incorporating monitoring and logging into the master plan, you can ensure
that you have visibility into your system's performance and can proactively
address any issues that arise.

Monitoring and logging are now included, but very far down the list. I’m going to stop here for now. In the next installment we’ll look at the first step, “Initial Setup”.