Stories by Muhammad Hamza on Medium

<figure><img alt="Hamza explains the importance of HIPAA and GDPR compliance for healthcare businesses." src="https://cdn-images-1.medium.com/max/1024/1*TxecQ0cWHg06TuVI-juq5g.png"></figure>Story time.
Meet Dr. Oops.
He runs FixYou Wellness, a fast-growing healthcare startup in NYC.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yb7grT8wpuhYbhVr-eL4Mg.jpeg"></figure>Business was booming, and he needed software to manage sensitive patient data — securely, efficiently, and professionally.
But Dr. Oops had a problem.
He wanted the software fast and cheap.
Enter CrapSoft, a software company that promised everything he asked for.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wd0edz-CheQDNrdk5t-pNQ.jpeg"></figure>Fast? Check.
Cheap? Double-check.
Secure? Well, Dr. Oops didn’t think to ask.
CrapSoft didn’t bring it up either.
Everything seemed fine when the software launched.
Patients were happy. Processes were smoother.
Dr. Oops thought he’d hit the jackpot.
Until the breach happened.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/626/1*_mO0U0kPbY65QS7TPHBQzg.png"></figure><h3>The Breach That Changed Everything:</h3>
A data breach exposed thousands of patient records.
Medical histories, billing information, and personal details — all out in the open.
The fallout was massive.
→ For Dr. Oops and FixYou Wellness
$500K in HIPAA fines.
€200K in GDPR penalties for EU patients.
Patients lost trust and switched to competitors.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lk2X5KidCVa62mnSyWN41A.jpeg"></figure>→ For CrapSoft
Dr. Oops fired them immediately.
FixYou Wellness sued them for damages.
Other clients dropped CrapSoft after hearing about the breach.
They spent months (and tons of money) trying to fix their broken processes.
What started as “fast and cheap” ended up being slow, expensive, and damaging for everyone involved.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L98jjHkSbg73WieUV1j45A.jpeg"></figure><h3>Where CrapSoft Went Wrong:</h3>
CrapSoft made some big mistakes that could have been avoided:
→ They ignored compliance
HIPAA and GDPR rules weren’t even on their radar.
→ They skipped basic security measures
Encryption, access controls, and breach protocols were missing.
→ They didn’t hire experts
No one on their team understood compliance requirements.
→ They failed to train their staff
Developers didn’t know how to build secure, compliant systems.
<h3>Why Compliance Matters for Software Companies</h3>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZaweOp_fcZg-3zgJZRnXrw.jpeg"></figure>Here’s why software companies like CrapSoft need to take compliance seriously:
→ Win big clients Healthcare businesses only trust agencies that understand HIPAA and GDPR.
→ Avoid lawsuits Building compliant software prevents legal and financial disasters.
→ Protect your reputation One breach can destroy years of hard work and trust.
→ Stay competitive Delivering HIPAA- and GDPR-compliant solutions makes you a market leader.
<h3>Why Compliance Matters for Healthcare Businesses</h3>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u7TnG_eRerLEGY11Lt_s0Q.jpeg"></figure>Dr. Oops’s mistake was hiring the wrong agency. Here’s why compliance should be your top priority:
→ Build patient trust Patients expect their sensitive data to stay private.
→ Deliver better care Secure data-sharing improves treatment and outcomes.
→ Avoid penalties HIPAA and GDPR fines can reach millions.
→ Keep operations running Breaches and audits can disrupt your business.
<h3>How to Build Compliant Software?</h3>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K0Q0g623nk8--qzcGEiK4Q.jpeg"></figure>If you’re building or using software, here’s how to prioritize compliance:
→ Encrypt all data: Protect sensitive information in storage and transit.
→ Control access: Limit data access to authorized users only.
→ Conduct audits: Regularly review systems to fix vulnerabilities.
→ Minimize data collection: Only collect what’s absolutely necessary.
→ Appoint a DPO: A Data Protection Officer ensures compliance oversight.
<h3>For Health Care Businesses: Choose the Right Agency.</h3>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/626/1*p1q-RJmBbbeUQi7ECsJucw.png"></figure>Don’t make Dr. Oops’s mistake.
→ Hire a HIPAA- and GDPR-compliant agency Work with experts who know the laws inside and out.
→ Ask the right questions Does the agency encrypt data? Conduct audits? Have compliance certifications?
→ Make compliance a priority Include it as a requirement in contracts with vendors.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aDbj4ceVMqzlglWINiPGZw.jpeg"></figure><h3>💡 Let’s build something amazing together!
</h3>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*grlt35xwFWfaiWApD-OZZw.png"><figcaption>Turned off my devices, went to the Pakistan-China border. Work can wait!</figcaption></figure>Hi, I’m Hamza.
I help healthcare businesses build secure and innovative software.
Here’s what I do:
→ Healthcare software development Building HIPAA-compliant systems that deliver results.
→ AI, ML, and GenAI solutions Turning smart ideas into smarter tools.
→ Web development Creating fast, secure, and user-friendly websites.
→ Personal branding Helping you and your business stand out and shine online.
I’ve been working in this industry for over 6 years, mostly with US businesses.
And when I’m not working?
→ I’m a fitness and healthcare enthusiast. → I love traveling the world. → And sometimes, I write content just for fun.
If you’re ready to create something great—or just want to chat—let’s connect!
👉 Reach out here: <a href="http://mhamza.site/contact">contact.</a>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=048dbac68efe" width="1" height="1" alt="">

Importance of HIPAA and GDPR compliance for healthcare businesses.

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DCzZzRZ8HoB7lxmnK4ZTnA.png"></figure>Running a business and managing customer feedback can be tough, especially when you’re receiving reviews daily and need to quickly identify which customers are satisfied and which need attention.
That’s why I built a sentiment analysis tool that goes beyond just reading reviews — it can analyze any text to capture sentiment and emotions.
While I used it for movie reviews, it’s easily adaptable for any scenario. It instantly identifies positive or negative feedback, helping you spot recurring issues or praise from happy customers.
By understanding what people are saying, you can refine your service and keep customers even more satisfied. Whether it’s feedback, social media comments, or product reviews, this tool is ready for any sentiment analysis task. Let’s jump right in!
<h3>Tutorial Introduction:</h3>
This guide is designed for beginners and intermediate learners who want to understand the complete process of building a machine learning model, deploying it as a web app, and testing it with real user inputs.
<h3>Table of Contents:</h3>
- Introduction - Project Overview - Data Preprocessing - Model Selection and Training - Handling Class Imbalance - Evaluating Model Performance - Using Unlabeled Data for Testing - Testing User Input Reviews - Deploying the Sentiment Analysis App with Streamlit - Conclusion
<h3>Project Overview</h3>
In this project, I’ll show you how to develop a sentiment analysis system that classifies movie reviews as either positive or negative. We’ll train multiple machine learning models using a popular movie review dataset and then evaluate their performance to select the best model for our final application.
<h3>Our journey involves:</h3>
1. Data Preprocessing: Cleaning and transforming text data. 2. Model Selection: Experimenting with Logistic Regression, SVM, and XGBoost. 3. Handling Class Imbalance: Ensuring the models fairly treat both positive and negative reviews. 4. Using Unlabeled Data: Testing the model’s robustness on unseen data. 5. User Input Testing: Evaluating the model’s predictions on live user inputs. 6. Deploying with Streamlit: Making the project accessible as a web app.
<h3>Data Preprocessing</h3>
Preprocessing is key to achieving accurate results. Here’s how I handled the data:
<pre># Load the dataset def load_data(data_dir): data = [] labels = [] for label in ['pos', 'neg']: labeled_data_dir = os.path.join(data_dir, label) for file in os.listdir(labeled_data_dir): if file.endswith(".txt"): with open(os.path.join(labeled_data_dir, file), 'r', encoding='utf-8') as f: data.append(f.read()) labels.append(label) return pd.DataFrame({'review': data, 'sentiment': labels})</pre>
<h4>Steps:</h4>
1. Loading the Dataset: The dataset contains 50,000 labeled movie reviews (25k positive, 25k negative) and 50,000 additional unlabeled reviews for unsupervised learning.
2. Text Cleaning: I removed stop words, punctuation, and applied lemmatization using NLTK.
<pre># Preprocess text data def preprocess_text(text): text = text.lower() text = text.translate(str.maketrans('', '', string.punctuation)) words = word_tokenize(text) lemmatized_words = [lemmatizer.lemmatize(word) for word in words if word not in stop_words] return ' '.join(lemmatized_words)</pre>
3. Feature Extraction: Using TF-IDF with 5000 features, I transformed the text into numerical data suitable for training.
<pre> # Convert text data to numerical features using TF-IDF vectorizer = TfidfVectorizer(max_features=5000) X_train = vectorizer.fit_transform(train_df[‘review’]) X_test = vectorizer.transform(test_df[‘review’]) </pre>
<h3>Model Selection and Training</h3>
I experimented with three machine learning models:
<h4>1. Logistic Regression:</h4>
This simple model performed quite well after applying class weights to handle imbalance.
<pre> # Train Logistic Regression model log_reg = LogisticRegression(class_weight=’balanced’) log_reg.fit(X_train, y_train)</pre>
<h4>2. Support Vector Machine (SVM):</h4>
The SVM model showed excellent results, balancing accuracy and efficiency.
<pre> # Train SVM model svm = SVC(class_weight=’balanced’) svm.fit(X_train, y_train) </pre>
<h4>3. XGBoost:</h4>
Despite being a powerful boosting algorithm, it under performed due to potential overfitting and insufficient hyper-parameter tuning.
<pre> # Train XGBoost model with class weights xgb = XGBClassifier(scale_pos_weight=class_weights[1]) xgb.fit(X_train, y_train)</pre>
<h3>Handling Class Imbalance</h3>
Class imbalance can skew predictions, so I implemented strategies to address it:
<ol><li>
Class Weights: For Logistic Regression and SVM, I used balanced class weights to adjust for the frequency of each class.</li></ol>
2. Scale Pos Weight in XGBoost: I applied `scale_pos_weight` to correct the imbalance, but it still required further fine-tuning.
<h3>Evaluating Model Performance</h3>
I evaluated each model using the following metrics: - Accuracy - Precision - Recall - F1 Score
<h3>Results:</h3>
<h4>Logistic Regression:</h4>
Accuracy — 87.95% | Precision — 87.86% | Recall — 88.07% | F1 Score — 87.97%
<h4>SVM:</h4>
Accuracy — 88.02% | Precision — 88.09% | Recall — 87.93% | F1 Score — 88.01%
<h4>XGBoost:</h4>
Accuracy — 85.44% | Precision — 84.26 | Recall — 87.16% | F1 Score — 85.69%
Here’s a visual comparison:
<pre> # Plotting model metrics comparison plt.figure(figsize=(10, 5)) plt.bar(r1, accuracy, color=’b’, width=barWidth, edgecolor=’grey’, label=’Accuracy’) plt.bar(r2, precision, color=’g’, width=barWidth, edgecolor=’grey’, label=’Precision’) plt.bar(r3, recall, color=’r’, width=barWidth, edgecolor=’grey’, label=’Recall’) plt.bar(r4, f1_score, color=’y’, width=barWidth, edgecolor=’grey’, label=’F1 Score’) plt.xlabel(‘Models’, fontweight=’bold’) plt.xticks([r + 1.5*barWidth for r in range(len(models))], models) plt.ylabel(‘Scores’, fontweight=’bold’) plt.title(‘Comparison of Evaluation Metrics for Different Models’) plt.legend() st.pyplot(plt) </pre>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1010/1*rqgfmkerEcG3KObqPnIj2Q.png"></figure>The SVM model outperformed the others, making it the ideal choice for our web app.
<h3>Using Unlabeled Data for Testing</h3>
To further test the models, I used the 50,000 unlabeled reviews:
1. Preprocessing: Applied the same cleaning and transformation steps as for the labeled data. 2. Prediction: Used the trained models to predict sentiments for the unlabeled reviews. 3. Analysis: This step helped me understand how consistent and reliable the models were when exposed to unseen data.
<h3>Testing User Input Reviews</h3>
<pre> # Function to preprocess and predict sentiment for user input review def predict_user_input_review(model, review, model_name): review_preprocessed = preprocess_text(review) X_sample = vectorizer.transform([review_preprocessed]) prediction = model.predict(X_sample)[0] prediction_text = “Positive 😊” if prediction == 1 else “Negative 😢” print(f”{model_name} Prediction: {prediction_text}”) </pre>
I tested the models with live user inputs to see how they handled ambiguous or tricky sentiments. For instance:
<pre>"It was just okay, I've seen better movies."</pre>
<pre>Result: Negative</pre>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eMN9RWqftrXBlxmjoqSl2Q.jpeg"><figcaption>models testing with live user inputs</figcaption></figure>All models correctly classified this review as negative, showing that they could handle real-world inputs effectively.
<h3>Deploying the Sentiment Analysis App with Streamlit</h3>
To make the sentiment analysis system accessible, I built a Streamlit app that allows users to enter reviews and instantly get sentiment predictions.
Here’s the code to create the Streamlit app:
<pre> import streamlit as st import joblib # Load pre-trained model and vectorizer model = joblib.load('svm_model.joblib') vectorizer = joblib.load('vectorizer.joblib') st.title("Sentiment Analysis App") st.write("Enter a movie review to see if it's positive or negative.") review_text = st.text_area("Type your review here…", height=150) if st.button("Analyze Sentiment"): if review_text: review_preprocessed = vectorizer.transform([review_text]) sentiment = model.predict(review_preprocessed)[0] sentiment_text = "Positive 😊" if sentiment == 1 else "Negative 😢" st.write(f"The review sentiment is: **{sentiment_text}**") #COMPLETE CODE IS IN GITHUB REPOSITORY</pre>
<a href="https://medium.com/media/02b489bbe21e65a18fe3cce3ce87df16/href">https://medium.com/media/02b489bbe21e65a18fe3cce3ce87df16/href</a>You can test the <a href="https://sentiment-ml.streamlit.app/">Live App here.</a>
<h3>Conclusion</h3>
This project demonstrates the full process of developing a machine learning model for sentiment analysis, from data preprocessing to model selection and deployment. The SVM model delivered the best results, making it suitable for real-time applications.
<h3>What’s Next?</h3>
In future iterations, I plan to explore advanced models like LSTM and BERT, fine-tune hyper-parameters, and integrate semi-supervised learning techniques to improve performance.
<h3>Links:</h3>
The complete code and detailed technical report are available on my <a href="https://github.com/thehamzza/Sentiment-Analysis-of-Movie-Reviews-with-ML/">GitHub repository</a>
You can also test the <a href="https://sentiment-ml.streamlit.app/">live app here.</a>
Enjoy building your own sentiment analysis system, and happy coding! 🎉
Reach out to me if you need any guidance. Happy coding :)
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=88ba2c298ad0" width="1" height="1" alt="">

Building a Sentiment Analysis System with Machine Learning and Streamlit

<figure><img alt="Making Business Smarter with Python: Easy Data Tricks for Everyone" src="https://cdn-images-1.medium.com/max/1024/1*u9hiNLXESjQdbjIzzSfD8Q.png"></figure><blockquote>“Data is the new oil. It’s valuable, but if unrefined, it cannot really be used. It has to be changed into gas, plastic, chemicals, etc., to create a valuable entity that drives profitable activity. So, too, with data.” — Clive Humby</blockquote>
In today’s world, data is everywhere. Every time we shop online, chat with friends, or even just walk down the street, we’re part of a huge wave of information. But here’s the catch: all this data can be hard to understand and use, especially for businesses trying to make smart decisions.
That’s where Python, a super-friendly computer language, comes into play, along with some cool tools called <a href="https://www.snowflake.com/en/data-cloud/overview/streamlit-in-snowflake/">Snowflake</a> and <a href="https://streamlit.io/gallery?category=snowflake-powered">Streamlit</a>.
<a href="https://medium.com/media/51252ba2b34478c1aa3a975806afe24a/href">https://medium.com/media/51252ba2b34478c1aa3a975806afe24a/href</a>Bridging the Gap: From Data to Decisions
Imagine you’re trying to read a book written in a language you don’t understand. That’s how most businesses feel about their data. It’s there, but it’s confusing. On the flip side, we have data scientists, kind of like language experts, who understand all this data but struggle to explain it in a simple way. We need something like a magic translator that can turn data language into action language — easy and clear.
Why Python is Awesome for Data
Python is like the Swiss Army knife for working with data. It’s easy to learn, and with it, you can sort, analyze, and make sense of information. Think of Python as your smart friend who helps you find the hidden stories in your data, turning numbers and facts into insights you can actually use.
Snowflake and Streamlit: The Dynamic Duo
Now, let’s talk about <a href="https://www.snowflake.com/en/data-cloud/overview/streamlit-in-snowflake/">Snowflake</a> and <a href="https://streamlit.io/gallery?category=snowflake-powered">Streamlit</a> — they’re not winter weather terms, but tools that work with Python to make data even easier to handle. Snowflake is like a massive library where you can store all your data books, and Streamlit turns those books into fun, interactive stories that anyone can understand. Together, they make a great team for helping businesses make better decisions with less headache.
Real-Life Magic: Turning Data into Decisions
Here’s where the real fun begins. With Python, Snowflake, and Streamlit, you can take all that confusing data and turn it into something useful, like a dashboard that shows you how well your products are selling or a tool that predicts what your customers will want next. It’s like turning raw ingredients into a delicious meal — it takes some practice, but the results are worth it.
Overcoming Challenges: Tips and Tricks
Of course, learning to use these tools can be a bit like learning to ride a bike — there might be a few bumps along the way. But don’t worry, everyone starts somewhere, and there’s plenty of help available. The key is to keep trying and not be afraid to ask for help when you need it.
Wrapping Up: Your Data, Your Decisions
By now, you can see how Python, Snowflake, and Streamlit can help turn the data jungle into a walk in the park. It’s all about making informed decisions faster and easier. So why not give it a shot? Dive into the world of data with these tools, and start making smarter decisions today.
Remember, in the land of data, being able to make sense of the numbers is like having a superpower. So gear up, get your Python on, and start turning data into action!
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Mt-t0Lg5VVAdohlCxvpVOg.png"></figure><h4>Prerequisites</h4>
To effectively create applications using Python, Snowflake, and Streamlit, the following prerequisites are recommended:
<ol>
<li>
Basic Python Knowledge: Familiarity with Python syntax and concepts, as Python is the primary language used for demonstration and application development within the guide.</li>
<li>
Understanding of Data Science Concepts: Basic knowledge of data manipulation, analysis, and visualization techniques would be beneficial.</li>
<li>
Familiarity with Machine Learning: An understanding of basic machine learning concepts and workflows since the guide seems to cover deploying ML models and transforming them into interactive apps.</li>
<li>
Experience with Development Environments: Experience using integrated development environments (IDEs) or notebooks for coding in Python.</li>
<li>
Knowledge of Snowflake and Streamlit: While not a strict prerequisite, having some prior understanding or willingness to learn about these tools would be helpful, as they are central to the guide’s content.</li>
</ol>
<h4>Learning Material</h4>
This Python Tutorial is perfect for beginners. It covers basic syntax, advanced concepts, and offers interactive examples. Start learning at <a href="https://www.w3schools.com/python/">W3Schools Python Tutorial</a>
If you want to learn Streamlit the easy way, check out this L<a href="https://30days.streamlit.app/">ink</a>.
It’s set up so you can learn a little bit every day for 30 days. This makes it simpler to understand how to use Streamlit without feeling overwhelmed. The site has lots of examples and small projects you can do to practice. It’s great for beginners or anyone who wants to get better at making web apps with Streamlit.
<h4>More information</h4>
For more information on utilizing Streamlit and Snowflake to create impressive data-driven web applications, please explore the following resources:
<ul>
<li><a href="https://streamlit.io/gallery?category=snowflake-powered">App Gallery * Streamlit</a></li>
<li><a href="https://www.snowflake.com/en/data-cloud/overview/streamlit-in-snowflake/">Streamlit in Snowflake</a></li>
</ul>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=70142a64784d" width="1" height="1" alt="">

Making Business Smarter with Python: Easy Data Tricks for Everyone

<figure><img alt="Host a Python Script on AWS EC2 Server Written By Muhammad Hamza Shakoor Graysol.co" src="https://cdn-images-1.medium.com/max/1024/1*9ZLz2FO-KLZ0DOjesza9fw.png"></figure>If you have a Python script that needs to run regularly on an online server, you may want to host it on an EC2 server and run it automatically on a cronjob.
This allows you to easily automate tasks without having to manually run your script every time. In this article, we’ll go through the steps to host a Python script on an EC2 server and run it automatically on a cronjob.
Before we get started, you’ll need to have an EC2 instance set up.
For EC2 instance setup, follow this <a href="https://www.youtube.com/watch?v=3sQhVKO5xAA&amp;list=LL&amp;index=36">youtube tutorial</a>. I will write a detailed article about it soon.
Now these are prerequisites for the instance:
<ul>
<li>An SSH client installed on your local machine to connect to the EC2 instance. This could be key-value pair file that you will get while creating an EC2 instance.</li>
<li>Python and any necessary libraries installed on the EC2 instance</li>
<li>A Python script that you want to run automatically</li>
</ul>
With that out of the way, let’s get started!
<h3>Step 1: Connect to your EC2 instance using SSH</h3>
First, you’ll need to connect to your EC2 instance using SSH. You can do this by opening a terminal or command prompt on your local machine and entering the following command:
<pre>ssh -i &lt;path-to-aws-ec2-private-key&gt; ec2-user@&lt;public-ip-address&gt;</pre>
Replace &lt;path-to-aws-ec2-private-key&gt; with the path to your AWS EC2 private key file, and &lt;public-ip-address&gt; with the public IP address of your EC2 instance.
For example:
<pre>ssh -i "insta-reels.pem" ec2-user@ec2-3-108-42-252.ap-south-1.compute.amazonaws.com</pre>
<h3>Step 2: Install Python and any necessary libraries</h3>
Once you’re connected to your EC2 instance, you’ll need to install Python and any necessary libraries that your script requires. You can do this using the package manager for your Linux distribution. For example, on Amazon Linux 2, you can use the following commands to install Python 3 and pip:
<pre>sudo yum update -y sudo yum install -y python3 sudo yum install -y python3-pip</pre>
You can then use pip to install any necessary Python libraries. For example, to install the requests library, you can run the following command or also install the requirements.txt file:
<pre>sudo pip3 install requests</pre>
<h3>Step 3: Upload your Python script to the EC2 instance</h3>
Next, you’ll need to upload your Python script to the EC2 instance. You can do this using GitHub.
Host your code on GitHub repository and then install git on EC2 instance
<pre>sudo yum update sudo yum install git</pre>
To pull a project from GitHub using Git in the terminal, follow these steps:
<ol>
<li>Change your working directory to the location where you want to clone the repository. You can use the cd command to navigate to the desired directory.</li>
<li>Copy the URL of the repository you want to clone from the GitHub website.</li>
<li>Run the following command in your terminal, replacing</li>
</ol>
&lt;repository-url&gt; with the URL you just copied:
<pre>git clone https://github.com/pallets/pythonproject.git</pre>
If the repository is private, you’ll be prompted to enter your GitHub username and password.
Wait for the cloning process to complete. Once it’s finished, you’ll see a new directory in your current working directory with the same name as the repository you cloned.
You can then pull the latest repo as well.
<h3>Step 4: Set up a cronjob to run your script automatically</h3>
Now that your Python script is uploaded to the EC2 instance, you can set up a cronjob to run it automatically at your desired intervals. To set up a cronjob, you can use the crontab command. For example, to run your script every day at 3:00am, you can run crontab -e to edit your crontab file and add the following line:
<pre>0 3 * * * /usr/bin/python3 /home/ec2-user/myscript.py</pre>
This will run your script every day at 3:00am. Make sure to replace /home/ec2-user/myscript.py with the actual path to your Python script.
<h3>Step 5: Save your crontab file and exit the editor.</h3>
Once you’ve added your cronjob to the crontab file, save the file and exit the editor.
<ul>
<li>Type this to save and exit vim editor:wq</li>
<li>To check running cronjobs on the server crontab -l</li>
<li>To check log of cronjobs:</li>
</ul>
<pre>cat /var/spool/mail/ec2-user</pre>
<h3>Just in case if your python code is written using selenium and it uses chrome browser, follow this tutorial to install chrome driver on linux terminal:</h3>
<a href="https://www.cyberciti.biz/faq/howto-install-google-chrome-on-redhat-rhel-fedora-centos-linux/">Install Google Chrome On a RHEL/CentOS 7/8 and Fedora Linux 34 Using Yum Command</a>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=5f1e33b0047d" width="1" height="1" alt="">

How to Host a Python Script on AWS EC2 Server and Run it Automatically.

These are my thoughts after dealing with a difficult client, who could not understand that his “proposed-solution” was technically not possible.
Software development is not just sitting in front of a computer and writing some lines of code and expecting from the computer to magically do what we intend it to do. Unfortunately, this is how most of the clients and business people think, who have no technical knowledge of software development process.
While developing a software program, much of the time is spent planning how exactly to implement a given feature, thinking about how it will interact with the rest of the codebase, considering which algorithm will have the best performance in this case, and so on.
The main reason is that computers are dumb, really dumb. They can be dumb extremely fast, but they are dumb nonetheless. The only reason your computer might not appear dumb to you is because dozens of thousands of programmers put immense amounts of work into making it so. In their natural state, computers are as dumb as a brick.
As a result, no matter how specific you think the requirements and specifications you gave your programmers for the new project are, they are certainly not specific enough for a computer. That’s because when non-technical people describe things they always do it with the unspoken assumption that the recipient of their descriptions is a human, i.e. a person with common sense and a certain minimum set of knowledge about the world. Computers don’t have common sense. As a result, much of the programmer’s job is in translating the business’s relatively vague requirements into extremely specific instructions for the computer.
Let me know what you think about this behavior of clients who don’t value programmer’s hard work and think they can find a better person who will deliver them the magical piece of code they want, for 10 bucks, in just 1 day. Lol. And don’t get me started about Chat-GPT users.
This comic is a great illustration of the problem:
<figure><img alt="" src="https://cdn-images-1.medium.com/max/650/1*r1DSkvGoZFV9Ttu5D8CeOg.jpeg"></figure><img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=c4f47763f596" width="1" height="1" alt="">

Informative

Recent Articles