So if you run a WordPress site, you’ll need to make sure it’s secure. And this isn’t just a technical task, but is also a key responsibility from several points of view such as brand reputation, data breach, and business continuity.

One tool that stands out in the WordPress ecosystem is WPScan. It’s a security scanner that’s specifically designed for WordPress. It comes with both a paid and free license, according to your needs. It is also pre-installed in Kali Linux distributions.

So whether you’re a seasoned website admin or a website owner looking to improve your site's security, WPScan can help you identify vulnerabilities before attackers exploit them.

Before going ahead, one very important thing: the purpose of this article is to help individuals and organizations strengthen the security of their WordPress websites by effectively utilizing WPScan.

While this tool is incredibly powerful in identifying vulnerabilities, it’s important to emphasize that any unauthorized use of WPScan—such as scanning websites without proper permission—is not only unethical but also illegal.

My goal in sharing this information is to empower site administrators and developers to proactively secure their websites, safeguard their data, and create a safer online environment for everyone.

What we’ll cover:

1. What is WPScan?

2. How to Scan Your WordPress Site Using WPScan

3. What to do with WPScan Results

4. Limitations of WPScan

5. Best Practices for Using WPScan

6. How to Monitor Results Effectively

7. Conclusion

What is WPScan?

WPScan is a command-line tool that helps you identify potential vulnerabilities in your WordPress installation. It’s like a security guard for your website, keeping an eye on outdated plugins, misconfigurations, and other common issues.

What makes WPScan unique is its focus on WordPress. It uses a database maintained by security experts, which is updated regularly to track thousands of known vulnerabilities in WordPress core, plugins, and themes.

What Can WPScan Do?

Here are just a few things WPScan can help you with:

• Detecting outdated WordPress core versions.

• Identifying vulnerabilities in plugins and themes.

• Enumerating users (for example, discovering usernames).

• Testing for weak passwords (using a dictionary attack).

• Finding exposed sensitive files (like backups or debug logs).

Let’s see now the most common commands you can use.

How to Scan Your WordPress Site Using WPScan

1. Basic Scan

A basic scan provides an overview of your WordPress site's security by identifying key vulnerabilities or misconfigurations. It can detect the WordPress core version and flag it if it's outdated, highlighting potential risks like SQL injection or cross-site scripting (XSS) vulnerabilities associated with older versions.

The scan might also reveal publicly accessible backup files (for example, .sql or .zip) or debug files like debug.log, which could expose sensitive information such as database credentials or server paths.

It can flag missing or improperly configured HTTP security headers, such as Strict-Transport-Security (HSTS) or Content-Security-Policy (CSP), which are critical for protecting against protocol downgrade attacks and unauthorized script execution.

Open directories that expose your site's file structure and potentially vulnerable plugins or themes may also be flagged if they are identified in public metadata.

These findings provide a starting point to address fundamental security gaps.

wpscan --url http://yourwebsite.com

This is what you’ll see on your terminal when you run this command:

2. Enumerating Users

User enumeration is a process of identifying usernames on your WordPress site. Knowing these usernames can help attackers target specific accounts for brute-force attacks.

To enumerate users, run:

wpscan --url http://yourwebsite.com --enumerate u

The output will show usernames:

If you find default usernames like admin, you should replace them with something unique and secure.

Here are some best practice for usernames:

• Avoid default names: Replace default usernames like admin or user with something unique and not easily guessable.

• Rename vulnerable usernames: To change a username, you can create a new user with administrator privileges, transfer ownership of posts or content, and then delete the old user.

• Use role-based usernames carefully: Avoid naming accounts after their roles (for example, editor, manager), as these can be easy targets.

• Implement login lockouts: Combine secure usernames with plugins that lock accounts after repeated failed login attempts.

• Enable Two-Factor Authentication (2FA): Adding 2FA ensures that even if a username is guessed, the account remains secure.

3. Checking Plugins and Themes

Plugins and themes can have security issues. WPScan can list all installed plugins and themes, along with any associated vulnerabilities.

For plugins, run this:

wpscan --url http://yourwebsite.com --enumerate p

It’ll have an output like this:

For themes, run this:

wpscan --url http://yourwebsite.com --enumerate t

It’ll have output similar to this:

Look for outdated versions or known vulnerabilities in the results, and update or replace those components immediately.

Let’s look at some common security issues in plugins and themes.

First, we have Cross-Site Scripting (XSS). Insecure input handling in plugins or themes can allow attackers to inject malicious scripts, potentially stealing user information or taking over admin sessions. A poorly secured WordPress site with an XSS vulnerability can allow attackers to steal session cookies, potentially gain unauthorized admin access, inject malicious redirects, take users to phishing sites, display deceptive content, tricking users into providing sensitive information.

There’s also SQL Injection. Poorly written plugins or themes can enable attackers to manipulate database queries, exposing sensitive data or damaging your site. SQL injection vulnerabilities can be exploited to dump sensitive data, bypass authentication, and modify or delete data

Some plugins or themes might include malicious code—intentionally or due to poor security—that grants attackers unauthorized access to your site, known as backdoors. Once installed, a backdoor can grant persistent access, enable arbitrary file uploads, undermine site integrity, and steal sensitive data.

There’s also Remote Code Execution (RCE) – vulnerabilities that allow attackers to execute arbitrary code on your server, often leading to full control of your site or server. Once attackers gain RCE access, they can create admin users, exfiltrate data, launch further attacks, and privilege escalation.

Best Practices:

• Always keep plugins and themes updated to the latest versions.

• Remove any unused or inactive plugins and themes, as these can still pose a risk.

• Ensure plugins and themes are downloaded from trusted, reputable sources and have a history of active maintenance.

• Consider using security plugins to monitor changes to plugin or theme files and detect suspicious activity.

4. Password Testing

WPScan can test for weak passwords by attempting a brute-force attack using a wordlist:

wpscan --url http://yourwebsite.com --passwords /path/to/passwords.txt

and this is the output on your command line:

What is Brute-Forcing?

Brute-forcing is a method attackers use to guess passwords by systematically trying every possible combination until the correct one is found. When combined with a wordlist—a file containing a collection of commonly used passwords—brute-forcing becomes much faster and more efficient.

A typical wordlist might include:

• Simple passwords like 123456, password, and qwerty.

• Common patterns such as Spring2024! or welcome123.

• Leaked passwords from previous data breaches.

By simulating this type of attack, WPScan can identify accounts that use weak passwords, allowing you to address vulnerabilities proactively.

Weak passwords make brute-forcing easier and faster. A short or predictable password might be guessed in seconds, while a longer, complex password with unique elements is exponentially harder to crack.

How to Create Strong Passwords

Strong passwords are your first line of defense against brute-force attacks. Here are key characteristics of strong passwords:

• Length: At least 12–16 characters long.

• Complexity: Use a mix of uppercase and lowercase letters, numbers, and special characters.

• Uniqueness: Avoid reusing passwords across multiple accounts.

• Unpredictability: Avoid dictionary words, common phrases, or personal information like birthdays.

Strategies for Generating Strong Passwords

There are various measures you can take to create strong passwords. First, use a password generator. Tools like LastPass and Bitwarden can create and store highly complex passwords for you.

You should also use pass phrases (instead of just regular passwords). Combine random, unrelated words with numbers and symbols, such as Sky#Tree!Motorbike12.

Finally, avoid patterns that might be easily guessed by an attacker. Don’t use sequential or keyboard patterns like abcdef or qwerty.

Use Tools to Manage Passwords

Managing strong passwords can be challenging. Password managers simplify this by securely storing and autofilling your credentials. Popular options include:

• Bitwarden

• LastPass

These tools also have features like password auditing to detect reused or weak passwords.

Use Two-Factor Authentication (2FA)

Two-factor authentication (2FA) adds an additional layer of security by requiring users to verify their identity through a second factor beyond the password. This can include:

• One-time codes sent via email or SMS.

• App-generated codes from tools like Google Authenticator or Authy.

• Biometric verification, such as fingerprints or facial recognition.

Even if an attacker guesses your password through brute-forcing, 2FA prevents them from accessing your account without secondary verification. This additional step makes brute-forcing impractical, as attackers would also need to compromise your 2FA device or method.

How to Implement 2FA in WordPress

1. Install a WordPress plugin such as Google Authenticator.

2. Require all user accounts, especially administrators, to enable 2FA.

3. Offer backup codes or recovery options in case users lose access to their 2FA device.

4. Test and make sure that 2FA works reliably for all user roles before making it mandatory.

The Importance of Password Hygiene

By using strong passwords and implementing 2FA, you can significantly reduce the effectiveness of brute-force attacks.

WPScan’s password testing feature can help you identify weak credentials. It also underscores the critical need for proactive password hygiene and additional security layers to keep your WordPress site secure.

What to Do with WPScan Results

WPScan reports provide actionable insights into your site’s security. Here’s what you can do with the information:

First, update WordPress core, plugins, and themes: Keep everything updated to patch vulnerabilities.

Second, address configuration issues: Fix misconfigured file permissions, insecure HTTP headers, and other warnings.

Here are a couple of remediation examples you can apply:

• Directory indexing: If WPScan detects open directories, disable directory browsing by adding this line to your .htaccess file:

    Options -Indexes
  

• File permissions: Ensure critical files like wp-config.php are read-only by setting permissions to 440 or 400 using the command:

    chmod 400 wp-config.php
  

You should also harden all user accounts. You can do this in several ways:

• Update weak passwords: Use strong, unique passwords for all user accounts (refer to the password testing section for tips).

• Remove unused accounts: Delete inactive accounts, especially those with administrator privileges.

• Rename predictable usernames: Change usernames like admin to something less obvious.

Make sure you also secure any sensitive files: If WPScan finds exposed files like debug.log, delete or secure them. Delete unnecessary files or old backups.

For files you need to keep, move them to a directory outside the web root. You can also protect files with .htaccess, by blocking access to sensitive files using Deny and Allow rules:

<Files wp-login.php>
    Order Deny,Allow
    Deny from all
    Allow from 123.456.789.000
</Files>

Limitations of WPScan

WPScan is a powerful too, but it does have some limitations. Just be aware of them so you can take other measures to protect your WP sites.

1. Known Vulnerabilities Only

WPScan relies on its database of known vulnerabilities, so it won’t catch zero-day exploits or custom vulnerabilities.

Here are some tips on how you can mitigate this issue:

• Stay informed: Monitor WordPress security blogs, vulnerability databases like CVE or WPVulnDB, and community forums for emerging threats.

• Use a Web Application Firewall (WAF): Tools like Cloudflare or Sucuri can block suspicious activities and attempts to exploit unknown vulnerabilities.

• Conduct manual security reviews: Periodically review your site for unusual behavior or unauthorized changes, particularly in critical files like wp-config.php or your database.

2. No Real-Time Protection

WPScan a diagnostic tool, not a firewall or intrusion detection system. For real-time protection, it’s a good idea to combine WPScan with other tools.

Some steps you can take are:

• Install security plugins: Use specific security plugins to provide continuous monitoring, malware scanning, and firewall protection.

• Monitor activity logs: Set up activity tracking to identify suspicious login attempts, file changes, or unauthorized user actions.

3. Resource-Intensive

Scanning large sites with many plugins and themes can be time-consuming and may impact server performance.

There are various strategies you can adopt to mitigate this such as scheduling scans during low-traffic periods to minimize disruption to site visitors. You can also perform scans on a staging copy of your site rather than directly on the live environment.

4. Learning Curve

As a command-line tool, WPScan can be intimidating for less technical users. However, the documentation is excellent, and with practice, you’ll become proficient.

If the CLI is overwhelming for you, try pairing WPScan with security plugins that offer GUI-based scanning and reporting.

Best Practices for Using WPScan

To get the most out of WPScan, you’ll want to to tailor its usage to your site’s specific needs and establish a robust strategy for monitoring results. Here’s how you can maximize its effectiveness:

Choose the Right Scans for Your Site

WPScan offers a variety of scan options, from basic scans to targeted vulnerability checks for plugins, themes, and user accounts. Choosing the right scans depends on the type of site you manage and the sensitivity of the data it handles.

For small, low-traffic sites:

• Prioritize basic scans to check WordPress core, plugins, and themes for updates and vulnerabilities.

• Run scans monthly or after major updates.

• Use user enumeration (--enumerate u) if you suspect weak passwords or default usernames.

For medium-sized business sites:

• In addition to basic scans, include plugin and theme enumeration (--enumerate p,t) to ensure all components are secure.

• Weekly scans to stay ahead of emerging threats.

• Combine WPScan with activity log plugins to track user actions and file changes.

For high-traffic or e-commerce sites:

• Perform comprehensive scans, including user enumeration (--enumerate u), file enumeration (--enumerate f), and password brute-force testing (if allowed).

• Daily or weekly scans to minimize risk.

• Implement additional measures like 2FA for admin accounts, a web application firewall (WAF), and security headers to reinforce your site.

For sites handling sensitive data:

• Prioritize all available scans, including those for exposed files and configuration vulnerabilities.

• Weekly scans with real-time monitoring via a security plugin.

• Use staging environments to test security settings without affecting production.

Should You Use All Scans?

While it may seem beneficial to use every scan WPScan offers, there are various factors to consider.

First, think about your site’s size and your resources. For smaller sites, running all scans can be overkill and resource-intensive.

You’ll also want to focus on scans that address your site's most likely vulnerabilities. For example, an e-commerce site should prioritize user and payment security over exhaustive file enumeration.

Compliance requirements are also important to take into consideration. If you’re subject to regulations like GDPR, ensure you scan for and address vulnerabilities related to data protection.

How to Monitor Results Effectively

Monitoring WPScan results is important. It helps you fix vulnerabilities, of course, but it also helps you create a system to track changes over time and stay vigilant.

Set Up Reporting

You can save scan results to files using the --output flag:

wpscan --url http://example.com --output /path/to/report.txt

Then review the reports regularly and compare them to previous scans to identify recurring issues or new vulnerabilities.

Create an Action Plan

It’s a good idea to categorize vulnerabilities based on severity (for example, critical, moderate, low).

This allows you to address high-severity issues (like outdated plugins with known exploits) immediately. Then you can schedule lower-priority tasks, such as file permission adjustments or minor configuration changes, for routine maintenance.

Track Trends Over Time

Use tools like spreadsheets or a project management app (for example, Trello, Asana) to log vulnerabilities, fixes, and follow-up actions.

Make sure you analyze recurring issues to identify patterns, such as frequent plugin vulnerabilities, and consider replacing problematic components.

Automate Notifications

If you schedule scans using cron jobs, set up email alerts or notifications to review results without delay.

Use security plugins with real-time monitoring to notify you of suspicious activities in between WPScan checks.

Communicate with Your Team:

You’ll want to make sure you share reports with relevant team members, such as developers or site administrators, so everyone is aware of potential vulnerabilities.

It’s also a good idea to establish protocols for immediate action if critical vulnerabilities are discovered.

By choosing scans based on your site’s specific needs and implementing a structured approach to monitoring results, you can ensure WPScan is used effectively. Also, make sure you tailor the tool to your risk profile, track vulnerabilities over time, and integrate its findings into a broader security strategy.

This approach not only improves your site’s security posture but also minimizes resource use and effort while delivering maximum protection.

Conclusion

WPScan is an invaluable tool for anyone managing a WordPress site. It simplifies the process of identifying vulnerabilities and provides clear, actionable recommendations to strengthen your site’s security.

By integrating WPScan into your workflow and following best practices, you can reduce the risk of attacks and keep your WordPress site safe. Security is a continuous journey, and tools like WPScan make it easier to stay ahead of potential threats.

One effective way to achieve this is by generating comprehensive financial press reviews based on current news. This is where my Python script comes into play—a tool that automates gathering and analyzing news related to specific queries, enabling businesses to stay up-to-date with their niche and make informed decisions about their next steps. Of course, this script does not replace the work of experts who will then verify and deepen the information found.

This is what we'll cover:

• The Importance of Staying Informed

• Overview of the Python Script

• How the Script Works

• 1. How to Set Up the Environment

• 2. How to Fetch Relevant News

• 3. How to Prepare the Prompt for AI Analysis

• 4. How to Generate the Press Review

• 5. How to Save the Report

• Error Handling and Logging

• Conclusion

The Importance of Staying Informed

For any business, being informed about the latest news in their industry is more than just a good practice. It's a necessity. Key news events can impact markets, influence consumer behavior, and affect supply chains.

By regularly monitoring relevant news, businesses can:

• Identify Emerging Trends: Spotting trends early can give a business a competitive edge, allowing it to adapt and capitalize on new opportunities.

• Monitor Competitors: Understanding what competitors are doing helps refine strategies and stay ahead in the market.

• Mitigate Risks: By staying informed about potential risks, such as regulatory changes or economic downturns, businesses can proactively adjust their operations to minimize impact.

• Plan Strategic Moves: With a clear understanding of the market landscape, businesses can plan their next steps with greater confidence.

This Python script automates this process, allowing businesses to generate detailed financial press reviews based on specific queries, helping them to understand the market better and plan their next moves effectively.

Overview of the Python Script

This Python script is designed to fetch news articles from the web, analyze them using a large language model (LLM), and generate a structured press review that businesses can use to inform their strategies. The script is built using Python, leveraging two powerful libraries:

1. Requests Library: This is used to make HTTP requests to the News API, retrieving news articles based on the specified query.

2. Anthropic Library: This library is used to interact with the Claude AI model, which processes the news data and generates a comprehensive analysis.

The generated press reviews are then saved in a text file, which businesses can review at their convenience.

How the Script Works

Let’s break down how the script operates, step by step:

1. How to Set Up the Environment

Before running the script, ensure that you have Python installed on your system. Additionally, you will need to install the necessary Python libraries:

pip install requests anthropic

2. How to Fetch Relevant News

The script starts by declaring the generate_report function. Inside the function, I made a GET request to the News API, using the requests library to retrieve the latest news articles related to a specific query. Here’s the relevant code snippet:

response = requests.get('https://newsapi.org/v2/everything?q=' + query + '&apiKey=YOUR_API_KEY')
response_data = response.json()

In this part of the script:

• query: This is the keyword or phrase related to the niche or topic you want to monitor. For example, a company might use the query "finance" to fetch news related to the finance industry.

• response_data: The news data is fetched in JSON format, which is then parsed into a Python dictionary for further processing.

3. How to Prepare the Prompt for AI Analysis

Once the news data is retrieved, the script prepares a prompt to feed into the Claude AI model. The prompt is designed to instruct the model to generate a detailed press review focusing on the impact of the news on financial markets and specific industries. Here’s how the prompt is constructed:

prompt = (
    "You are a senior financial journalist tasked with writing a comprehensive press review. "
    "Focus on the key news provided and analyze their potential impact on the financial markets, "
    "specific industries, or relevant companies. Ensure the press review is structured and concise. "
    "Start the paragraph with the sentence 'This is the press review about " + query + "'. "
    "You'll find the key news in the following json file: " + response_data_to_str
)

The prompt includes:

• Role Specification: The AI is instructed to act as a senior financial journalist.

• Task Description: The AI is asked to analyze the news and its impact, ensuring the output is structured and concise.

• News Data: The retrieved news articles are passed to the AI in JSON format, providing the context needed for analysis.

4. How to Generate the Press Review

With the prompt ready, the script interacts with the Anthropic Claude AI model to generate the press review. The anthropic library is used for this interaction:

message = client.messages.create(
    model="claude-3-5-sonnet-20240620",
    max_tokens=1000,
    temperature=0,
    system="You are a senior financial journalist. Provide thorough insightful financial press review and advice. Use technical language where appropriate, and consider the broader economic context in your responses.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": prompt
                }
            ]
        }
    ]
)

In this part of the script:

• client.messages.create: This method sends the prompt to the AI model and retrieves the generated text.

• plain_text: The resulting press review is stored as plain text, ready to be saved or further processed.

5. How to Save the Report

Finally, the generated press review is saved to a text file:

with open("report.txt", "a") as file:
    file.write(plain_text + "\n")

This ensures that each generated report is appended to the report.txt file, making it easy to access and review multiple reports over time.

Error Handling and Logging

Robust error handling is crucial to ensure the application runs smoothly. The script includes basic error handling using try-except blocks to catch and log any errors that occur during execution:

except requests.exceptions.RequestException as e:
    logging.error(f"An error occurred during the HTTP request: {e}")
except Exception as e:
    logging.error(f"An unexpected error occurred: {e}")

Errors are logged in an error.log file, which helps to fix issues without interrupting the main functionality of the script.

Don't forget to call the function, passing the topic you want information about as a parameter:

generate_report("finance")

And here's the full code:

import requests
import anthropic
import logging

# Set up logging to capture errors in a file named "error.log"
logging.basicConfig(filename="error.log", level=logging.ERROR)

def generate_report(query):
    try:
        # Step 1: Make a GET request to the news API with the given query
        response = requests.get('https://newsapi.org/v2/everything?q=' + query + '&apiKey=<YOUR_API_KEY>')

        # Step 2: Parse the JSON response from the API into a Python dictionary
        response_data = response.json()

        # Convert the JSON data to a string format for use in the prompt
        response_data_to_str = str(response_data)

        # Step 3: Initialize the Anthropic client
        client = anthropic.Anthropic()

        # Step 4: Create a prompt for the AI model to generate a financial press review
        prompt = (
            "You are a senior financial journalist tasked with writing a comprehensive press review. "
            "Focus on the key news provided and analyze their potential impact on the financial markets, "
            "specific industries, or relevant companies. Ensure the press review is structured, and concise. "
            "Start the paragraph with the sentence 'This is the press review about " + query + "'. "
            "You'll find the key news in the following json file: " + response_data_to_str
        )

        # Step 5: Use the prompt to create a message with the AI model
        message = client.messages.create(
            model="claude-3-5-sonnet-20240620",
            max_tokens=1000,
            temperature=0,
            system=(
                "You are a senior financial journalist. Provide thorough insightful financial press review and advice. "
                "Use technical language where appropriate, and consider the broader economic context in your responses."
            ),
            messages=[
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "text",
                            "text": prompt
                        }
                    ]
                }
            ]
        )

        # Step 6: Extract the generated text from the message response
        plain_text = message.content[0].text

        # Step 7: Append the generated report to a file named "report.txt"
        with open("report.txt", "a") as file:
            file.write(plain_text + "\n")

    except requests.exceptions.RequestException as e:
        # Log any HTTP request errors to "error.log"
        logging.error(f"An error occurred during the HTTP request: {e}")
    except Exception as e:
        # Log any unexpected errors to "error.log"
        logging.error(f"An unexpected error occurred: {e}")

# Generate reports for the needed queries
generate_report("finance")

After running the script, you should get the report.txt file looking like this:

This is the press review about finance:

The financial markets are digesting several key developments this week:

1. Economic Data: The latest jobs report showed unemployment increased slightly, sending markets into a tailspin initially. However, experts caution against overreacting, noting the economy is not "falling off a cliff." The Federal Reserve is getting closer to cutting interest rates, with investors betting the first cut could come as soon as September if inflation continues moderating.

2. Corporate Earnings: Company XXX reported disappointing Q2 earnings, with losses more than tripling to $1.4 billion amid increased scrutiny of its safety and quality control. The Company YYY also named a new CEO who received early praise from key customers. Meanwhile, Company warned of slowing growth and weakening U.S. demand in its Q2 report.

3. Banking & Fintech: Company ZZZ has become Europe's most valuable private tech company at a $45 billion valuation following an employee share sale. This intensifies the neobank challenge to traditional finance. The company also recently obtained its long-awaited UK banking license.

4. Regulatory Developments: The Central Bank is considering creating a strategic Bitcoin reserve, to be partly financed by revaluing gold certificates held. This represents a potential major shift in cryptocurrency policy.

5. Personal Finance: Experts continue to warn about common money mistakes, even among financially savvy individuals. These include waiting too long to start investing and not properly planning for retirement.

The overall market sentiment remains cautious amid mixed economic signals and geopolitical tensions. Investors are closely watching central bank policies and corporate earnings for further direction.

Conclusion

In a business environment where staying informed is key to success, this Python script offers an automated solution to generate financial press reviews based on the latest news. By leveraging AI, businesses can quickly gain insights into market trends, monitor competitors, and make informed strategic decisions. While the script is already functional and useful, with further enhancements, it can evolve into a powerful tool for business intelligence, helping companies stay ahead in their industry.

By automating the process of news analysis, this script not only saves time but also provides a structured approach to understanding the ever-changing business landscape, empowering companies to take the next steps with confidence.

It is important to remember that this is a tool to support analysts who'll have to verify and evaluate the information available in the report.

If you liked this post, please star my repo here, can't wait to approve your PR!

For new developers – and sometimes even seasoned professionals – this phenomenon can be particularly challenging as you navigate a fast-paced and ever-evolving industry.

But it's possible to overcome these feelings by building a strong support network, learning to accept compliments, and fostering a growth mindset.

In this guide, we'll go through these strategies with a positive attitude, aiming to help you embrace your true self and step into your power confidently.

My Story: From Marketing and Sales to Tech

Before diving into the strategies, I want to share a bit of my journey. A while ago, I started my professional career in marketing and sales, a field quite different from tech.

After spending a few years in the job market, I decided to switch to tech, driven by my passion for technology and innovation.

The transition was not easy. There were countless moments when I felt like an impostor, doubting my skills and wondering if I had made the right choice. But through perseverance and the strategies I’m about to share, I learned to manage and eventually overcome these feelings.

This personal experience has deeply shaped my understanding of impostor syndrome and I want to share it with you. I hope it will help you face any imposter syndrome feelings you have and get the most from your career.

The Power of Sharing in the Tech World

As a new developer, the tech industry can often seem intimidating and competitive, which can increase feelings of impostor syndrome. One of the most effective ways to combat these feelings is to talk about them. Sharing your experiences and feelings with trusted colleagues or friends within the industry can provide immediate relief and validation.

Start by choosing the right people to trust: those who are supportive, empathetic, and likely to understand the unique pressures of the tech world. You may find that many of them have experienced similar thoughts and emotions. Knowing you are not alone can be incredibly comforting and empowering.

When you vocalize your self-doubts, you take the first step toward pulling down the isolation that impostor syndrome often brings. Your peers can offer new perspectives and constructive feedback, helping you see your achievements and potential more clearly. This collective support fosters a culture of openness and continuous learning, which is essential in the dynamic field of tech.

Turn this weakness into a strength for you and your team: opening up about your struggles with impostor syndrome not only helps you but also contributes to a more empathetic and supportive workplace for everyone.

Mentors Can Help

A robust support network is a crucial asset in overcoming impostor syndrome, especially in the tech industry where collaboration and innovation are key. So it can help to create relationships with mentors who inspire and guide you.

In the tech world, mentors can offer valuable advice on career progression, skill development, and navigating workplace challenges. They can share their own experiences with impostor syndrome, providing a sense of relatability and encouragement. And they can help you set realistic goals and celebrate your progress, reinforcing your sense of competence and achievement.

Finding a mentor can be particularly impactful. Start by identifying individuals who inspire you—these could be senior colleagues, industry leaders, or even peers with specific expertise.

Look for mentors who are not only knowledgeable but also approachable and willing to share their experiences. You can find mentors through networking events, online communities, professional organizations, or social networks.

When you find a potential mentor, approach them respectfully and express your admiration for their work and your desire to learn. It’s important to be clear about what you hope to gain from the mentorship and be open to feedback.

Being a good mentee involves being proactive, respectful of your mentor’s time, and showing appreciation for their guidance. Keep the lines of communication open and seek their advice on specific issues or general career guidance.

Remember, mentorship is a two-way street: as you grow, find ways to give back, whether by offering your insights or mentoring others.

Maintaining and cultivating the relationship requires consistent effort. Regularly update your mentor on your progress, seek their advice on new challenges, and show gratitude for their support. This relationship can give you the confidence and knowledge to navigate your career path.

Share Your Path with Other People

Join professional groups, online forums, or tech meetups where you can share your experiences and learn from others. Engaging with a community of like-minded individuals can provide a sense of belonging and mutual support. Platforms like GitHub, Stack Overflow, or local coding bootcamps can be great places to find this community.

When considering what to share, think about your career journey, the challenges you’ve faced, and your successes, no matter how small they may seem. Being open about your insecurities and the steps you’ve taken to overcome them can resonate with others who may feel similarly.

Just remember that it’s essential to find a balance between seeking support and being a supportive member of your community. Engage actively in discussions, offer constructive feedback, and encourage others to share their experiences as well. Make people feel comfortable and not judged while talking about their experiences. They'll do the same with you.

I've given talks at local tech meetups many times, it was always nerve-wracking but incredibly rewarding. Preparing for and delivering talks helped me consolidate my knowledge and communicate my passion for technology. It also provided a platform for networking and receiving positive feedback, which boosted my confidence.

Building a support network takes time and effort, but the benefits are immeasurable. When you know that others believe in you, it becomes easier to believe in yourself.

Me having a talk at a local meetup

Accept Positive Feedback

Instead of deflecting praise, it’s essential to practice accepting it. Learning to embrace positive feedback is a critical step in recognizing your worth and achievements.

When someone compliments you on your coding skills, problem-solving abilities, or a successful project, resist the urge to downplay your accomplishments or attribute them to luck. Instead, just reply with a simple “thank you.” This acknowledgment not only shows appreciation but also helps internalize the positive reinforcement.

Accepting compliments can feel uncomfortable at first, but with practice, it becomes easier. Start by reflecting on the feedback you receive. Consider why the compliment was given and how it aligns with your efforts and skills. Over time, this practice helps to build a more accurate and positive self-perception.

In addition to verbal compliments, pay attention to other forms of positive feedback, such as positive code reviews, successful project completions, or praise from clients and managers. These are tangible reminders of your capabilities and contributions. Keep a journal or a digital folder of these affirmations and revisit them whenever self-doubt creeps in.

Remember, accepting compliments doesn’t mean you’re arrogant. It just means you’re recognizing your hard work and achievements. Embrace the positive feedback as a reflection of your true self.

Focus on a Growth Mindset and Don't Fear Mistakes

A growth mindset, a concept popularized by psychologist Carol Dweck, is the belief that abilities and intelligence can be developed through effort, learning, and perseverance. Adopting this mindset is a powerful tool in overcoming impostor syndrome, especially in the rapidly changing field of tech.

Instead of being obsessed with the fear of failure or the need for perfection, focus on your growth and development. View challenges as opportunities to learn and improve rather than threats to your competence. Embrace mistakes as part of the learning process: every setback is a step toward mastery.

To cultivate a growth mindset, start by setting realistic and attainable goals. Break down larger tasks into manageable steps, and celebrate your progress along the way. This approach not only makes goals more achievable but also reinforces a sense of accomplishment and progress.

Engage in continuous learning and self-improvement. Seek out new knowledge, skills, and experiences that align with your interests and career aspirations. This commitment to growth helps build confidence and resilience, reducing the impact of impostor syndrome.

You can also enroll in online courses, attend workshops, or participate in hackathons to enhance your skills and stay updated with industry trends.

Surround yourself with people who embody a growth mindset. Their positive attitudes and resilience can inspire and motivate you. Learn from their experiences and apply their strategies to your journey.

Also, don't forget that growth is a continuous process, and everyone’s journey is unique. Be kind to yourself and recognize that it’s okay not to have all the answers. What matters is your willingness to learn and improve.

Conclusion

Overcoming impostor syndrome as a developer is a journey that requires time, effort, and a lot of self-reflection. By talking about your feelings, building a support network, accepting compliments, and focusing on growth, you can gradually diminish self-doubt and embrace your true potential.

Remember, you are not alone in this struggle, and with the right strategies and support, you can overcome impostor syndrome and thrive in the tech industry. Embrace your journey, celebrate your progress, and believe in your ability to grow and succeed.

This article is a result of my own experiences transitioning from sales and marketing to tech. If you ever feel overwhelmed or feel the need for additional support, don't hesitate to talk to a specialist. Seeking professional help can provide personalized strategies to help you navigate and overcome impostor syndrome effectively.

This tutorial will show you a solution that leverages Google Sheets as a makeshift database and React to build the frontend. This will let you effectively bypass the need for a dedicated server or traditional database system.

This approach not only reduces the overhead costs associated with web development, but also simplifies content updates and management. It's an ideal solution if you're looking to launch your own simple CMS without substantial investment.

This solution is suitable for freelancers at the beginning of their career and for clients who cannot invest much in their website.

Why Google Sheets?

Opting for Google Sheets as the backbone of your CMS comes down to its simplicity, flexibility, and cost-effectiveness.

Traditional web development requires a backend server to process data, a database to store information, and a frontend to display content. But each layer adds complexity and cost.

Google Sheets, on the other hand, acts as a highly accessible and intuitive interface that eliminates the need for a server and a database. It lets your users update content in real-time, much like any CMS, but without the usual setup and maintenance costs. This makes it an excellent choice for individuals, small businesses, or anyone looking to deploy a web application quickly and with minimal expense.

Getting Started

Before diving into the code, ensure you have Node.js and npm installed on your system. These tools will allow us to create a React application and manage its dependencies.

Let's start with Google Sheets now.

Step 1: Set Up Your Google Sheets

1. Go to your Google Sheets
2. Open the sheet you want to use or create a new one
3. Click on Extensions in the menu
4. Then click on Apps Script

In the Apps Script editor, you can write a script to serve as your endpoint. Here's a script that returns the contents of a Google Sheet in JSON format:

function convertRangeToJson(data) {
  var jsonArray = [];

  // Check if data is empty or doesn't contain enough rows for headers and at least one data row
  if (!data || data.length < 2) {
    // Return an empty array or a meaningful message as needed
    return jsonArray; // or return 'No data available';
  }

  var headers = data[0];
  for (var i = 1, length = data.length; i < length; i++) {
    var row = data[i];
    var record = {};

    for (var j = 0; j < row.length; j++) {
      record[headers[j]] = row[j];
    }

    jsonArray.push(record);
  }

  return jsonArray;
}

Then:

1. Click File > Save, and give your project a name
2. Click on Deploy > New deployment.
3. Click on Select type and choose Web app.
4. Fill in the details for your deployment. Under Execute as, choose whether the script should run as your account or as the user accessing the web app. Under Who has access, choose who can access your web app.
5. Click Deploy.

You may be asked to authorize the script to access your Google Sheets. Follow the prompts to do so.

After deploying, you'll be given a URL for your web app. This is your API endpoint.

To give you an idea of what you have done so far, this is your sheet structure:

How your sheet should currently look

And this is the JSON you get when you call the endpoint:

JSON

Step 2: Create Your React App

With your Google Sheets API ready, it's time to create the React app that will fetch and display this data.

First, go ahead and create a React app. Run the following command in your terminal to create a new React application:

npx create-react-app google-sheets-cards
cd google-sheets-cards
npm start

You can also use modern build tools like Vite for this purpose, as CRA is no longer the recommended way of building a React app.

Next, create the card component. Inside the src directory, create a file named Card.js. This component will be responsible for displaying each data record:

// src/Card.js
function Card({ title, content }) {
  return (
    <div className="card">
      <h1>{title}</h1>
      <p>{content}</p>
    </div>
  );
}

export default Card;

Now it's time to fetch and display your data in App.js. Modify the App.js file to include logic for fetching the data from your Google Sheets API and using the Card component to display it:

// src/App.js
import React, { useEffect, useState } from 'react';
import Card from './Card';
import './App.css'; // Make sure to create some basic styles for the cards in App.css

function App() {
  const [data, setData] = useState([]);

  useEffect(() => {
    fetch('YOUR_ENDPOINT_URL') // Replace with your actual endpoint URL
      .then(response => response.json())
      .then(data => setData(data))
      .catch(error => console.error('Error fetching data:', error));
  }, []);

  return (
    <div className="App">
      <h1>Data from Google Sheets</h1>
      <div className="cards-container">
        {data.map((item, index) => (
          <Card key={index} title={item.Title} content={item.Content} />
        ))}
      </div>
    </div>
  );
}

export default App;

Next, you can style your cards. Go ahead and add the below CSS in App.css for basic card styling:

.card {
  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
  margin: 10px;
  padding: 10px;
  display: inline-block;
  background: #f9f9f9;
}

.cards-container {
  display: flex;
  flex-wrap: wrap;
  justify-content: center;
}

Step 3: Run Your React App

With everything set up, you can now run your React application and see the data from Google Sheets displayed in your browser. To do this, follow these steps:

First, start the React app. In your terminal, navigate to the root directory of your React app if you're not already there. Run the following command to start the development server:

npm start

This command compiles your React application and opens it in your default web browser. You should see a webpage with a title "Data from Google Sheets", and below that, a series of cards, each displaying a title and content fetched from your Google Sheets data.

Here's, in fact, what we get:

Data from Google Sheets and Card 1, Card 2, and Card 3 displayed on the screen

Now you can view your data. Each card on the page corresponds to a row in your Google Sheets, with the title and content fields displayed as specified in your Card component. If you make any updates to your Google Sheets data, you can refresh the web page to see the changes reflected immediately.

You can deploy your React app to one of the many services you can find online such as Github Actions or Netlify. This is a simple and effective way to host your frontend application for free with significant performance.

Conclusion

Congratulations! You've created a dynamic web application that fetches data from a Google Sheet and displays it using React.

This approach offers a flexible and straightforward way to manage your application's content without needing a backend server or database.

Google Sheets serves as an accessible and collaborative platform for managing data, while React allows you to build a responsive and interactive user interface. Together, they provide a powerful combination for creating web applications that can be quickly updated and easily maintained.

This article provides an overview of WP-CLI, focusing on its capabilities to create, modify, and delete users, as well as handle plugins with ease. This article will show you how WP-CLI can significantly elevate your WordPress management experience.

What is WP-CLI?

WP-CLI is a command-line tool designed for managing WordPress installations. It empowers developers, administrators, and site owners to interact with their websites directly from the command line, bypassing the need for manual interventions through the web interface.

It's built on PHP, and offers a wide range of commands that you can execute right from the terminal.

By using WP-CLI, you'll be able to manage your WordPress sites much more efficiently. Let's see a few examples of how WP-CLI commands can simplify your workflow:

WP-CLI Commands

Site Information Retrieval

The wp site info command provides a quick overview of your WordPress site's important details, including the site's URL, the number of posts and pages, the active theme, and more.

For instance, by running wp site info, you can promptly gather essential information about your site without navigating through the WordPress admin dashboard.

Database Management

WP-CLI allows you to manage your WordPress database seamlessly. Use the wp db export command to create a database export file, ensuring a backup of your site's data.

If you need to import data, the wp db import command facilitates this process. For example, if you have a database backup named backup.sql, executing wp db import backup.sql restores the database to a previous state.

Theme Manipulation

Manipulating themes is extremely efficient with WP-CLI. For example, the wp theme install command lets you install a theme directly from the official WordPress theme repository. To install the "Twenty Twenty-One" theme, you can use the command wp theme install twentytwentyone.

Post and Page Creation

Generating new content is made easier using WP-CLI. The wp post create and wp post generate commands enable you to create and populate posts and pages with content.

For example, wp post create --post_type=post --post_title="New Post" creates a new post with the specified title.

These examples illustrate the versatility and power of WP-CLI in managing various aspects of your WordPress site. By harnessing its capabilities, you can enhance your efficiency, reduce manual tasks, and gain greater control over your website's management.

How to Install WP-CLI

Before diving into more features of WP-CLI, let's understand the installation process.

You can install WP-CLI globally on your system, making it accessible from any directory.

To install WP-CLI, make sure you have PHP installed, along with a compatible version of WordPress. Download the Phar archive, place it in a directory reachable through your system's PATH, and you're ready to go.

You can verify the installation by typing wp --info in your terminal. Here you can find the doc with the URL to download WP-CLI with a wget.

How to Manage Users with WP-CLI

Managing users is a fundamental task when overseeing a WordPress site. WP-CLI simplifies user management with various commands that make creating, modifying, and deleting users much easier.

How to Create Users

The wp user create command lets you quickly create users directly from the command line.

To illustrate, let's create a new user named "Alice" with the email address "alice@example.com" and the role of editor. Simply enter:

wp user create alice alice@example.com --role=editor

How to Modify Users

WP-CLI also streamlines user modifications. Use the wp user update command to adjust a user's details.

For instance, let's change Alice's display name to "Alice Johnson" using the following command:

wp user update 123 --display_name="Alice Johnson"

In this example, "123" is Alice's ID.

How to Delete Users

When user accounts become obsolete or require removal for security reasons, WP-CLI simplifies the process.

To delete a user, use the wp user delete command. To remove Alice's account, simply execute:

wp user delete 123 --reassign=567

In this case, again "123" is Alice's ID and "567" is the ID of the user you want to assign Alice's content to (for example posts, pages, and so on).

How to Manage Plugins with WP-CLI

Plugins play a crucial role in enhancing WordPress websites. WP-CLI extends its capabilities to manage plugins, making tasks such as installation, activation, deactivation, and updates incredibly efficient.

How to Install Plugins

Use the wp plugin install command to seamlessly install plugins from the WordPress repository.

For instance, let's install the "Akismet" anti-spam plugin:

wp plugin install akismet

How to Activate and Deactivate Plugins

Managing plugin status is quite easy with WP-CLI. Activate or deactivate plugins using the wp plugin activate and wp plugin deactivate commands respectively.

To activate the "Akismet" plugin, type the following command:

wp plugin activate akismet

How to Update Plugins

Keeping plugins up to date is vital for security and performance. The wp plugin update command makes updates hassle-free.

To update all installed plugins, simply run:

wp plugin update --all

How to List Installed Plugins

WP-CLI offers an overview of installed plugins with the wp plugin list command. This provides a quick snapshot of each plugin's status, version, and available updates:

wp plugin list

Conclusion

WP-CLI is an invaluable asset in the world of WordPress management. Its extensive command set helps you manage users and plugins – and much more – with remarkable ease. This saves you time and minimizes manual interventions.

By harnessing the power of WP-CLI, administrators and developers can streamline workflows, improve security, and ensure their WordPress websites operate seamlessly.

I wrote this tutorial using PHP, but you can set cookies also by using other popular programming languages such as Java, Python, and others.

Before going deep with the details, let's go through a brief introduction and some recommendations.

What are Cookies?

Cookies play a vital role in how websites function. They can also enhance a user's browsing experience.

In simple terms, a cookie is a small file that websites store on a user's computer or device while they navigate through various web pages. These files contain data that are utilized by websites to remember certain information and settings, ultimately improving the performance and customization of the website for the user.

When a user visits a website, the site's server sends a cookie to the user's browser, which then stores it on their computer or device. The next time the user visits the same website, the browser sends the stored cookie back to the server. This enables the website to recognize the user, remember their preferences, and provide personalized content.

Cookies serve various functions, such as remembering login information, language preferences, and shopping cart contents.

For example, when you visit an online shopping website and add items to your cart, cookies help in retaining those items even if you navigate to other pages. Cookies can also remember your login details, so you don't have to re-enter them every time you visit a website.

Cookies can also be used for tracking user behavior and gathering information about website usage. This information is often anonymous and helps website owners analyze traffic patterns, identify popular pages, and improve their website's design and functionality.

Advertisers also use cookies to deliver targeted advertisements based on users' browsing habits and interests. This enables them to show relevant ads that are more likely to be of interest to the user.

A Note about Cookies and User Privacy

Cookies are designed to be a tool for enhancing user experience and improving website functionality. But concerns about privacy and security have led to the development of regulations and guidelines for using cookies. Many websites now provide cookie consent notices, allowing users to choose whether they want to accept or reject cookies.

Over the past few decades, the use of cookies has been subject to extensive discussion by regulatory bodies, emphasizing the significance of ensuring users are fully informed about their implementation.

Progress has been made in this direction, including the introduction of the General Data Protection Regulation (GDPR) by the European Union (EU). For more comprehensive information, you can get detailed insights from the official web portal of the EU.

If you are considering the integration of cookies into your application, I highly recommend discussing the implications with the legal department of your company or consulting with legal professionals who possess expertise in this domain. By doing so, you can ensure compliance with the legal and regulatory frameworks governing the use of cookies, safeguarding user privacy in the process.

Let’s Get Started

Let’s assume I’m running a pet lovers e-commerce site, and I’m implementing a content marketing strategy to attract new customers.

I create one informational page for cats lovers and another one for dogs lovers. Both pages point to the same page where I give further details about having pets.

I want this page to show specific (targeted) ads according to the page the user comes from: if they visited the page about cats, I want them to see ads about cat food. If they visited the one about dogs, I want them to see ads about dog food.

Let’s Code

I’m building three pages:

1. Cat's lovers page: mainPageCat.php (screenshot below)

2. Dog's lover page: mainPageDog.php

3. The target page: cookieTest.php

While building pages 1 and 2, I set cookies using the PHP setcookie() function. For the page about cats, I pass the function these parameters:

<?php
$cookie_name = "cat";
$cookie_value = "catFoodAds";
setcookie($cookie_name, $cookie_value, time() + (86400 * 30), "/"); // 86400 = 1 day
?>

For the page about dogs, I pass these parameters:

<?php
$cookie_name = "dog";
$cookie_value = "dogFoodAds";
setcookie($cookie_name, $cookie_value, time() + (86400 * 30), "/"); // 86400 = 1 day
?>

For the “further information” page I add some logic. If the cat cookie is stored, I add a CSS class to the dog ads card to hide it. I do the same with the cat ads card if the cookie stored is the one from the dog page.

<div class="row">
            <div class="col-md-3">
                <div class="card <?php if(isset($_COOKIE['dog'])) echo ' cookieClass'; ?>" style="width: 18rem;">
                    <img class="card-img-top" src="https://images.unsplash.com/photo-1518791841217-8f162f1e1131?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1yZWxhdGVkfDl8fHxlbnwwfHx8fA%3D%3D&w=1000&q=80" alt="Card image cap">
                    <div class="card-body">
                        <h5 class="card-title">Buy Food for Cats</h5>
                        <h6 class="card-subtitle mb-2 text-muted">Excellent Food</h6>
                        <p class="card-text">Don't know what else I could say about cat food.</p>
                        <a href="#" class="card-link">Buy</a>
                    </div>
                </div>
            </div>
            <div class="col-md-3">
                <div class="card ml-5 <?php if(isset($_COOKIE['cat'])) echo ' cookieClass'; ?>" style="width: 18rem;">
                    <img class="card-img-top" src="https://images.unsplash.com/photo-1561037404-61cd46aa615b?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxjb2xsZWN0aW9uLXBhZ2V8MXwxMTU1Mjc2N3x8ZW58MHx8fHw%3D&w=1000&q=80" alt="Card image cap">    
                    <div class="card-body">
                        <h5 class="card-title">Buy Food for Dogs</h5>
                        <h6 class="card-subtitle mb-2 text-muted">Excellent Food</h6>
                        <p class="card-text">Don't know what else I could say about dog food.</p>
                        <a href="#" class="card-link">Buy</a>
                    </div>
                </div>
            </div>
        </div>

Let’s see how it works

I test the flow as a user who wants to visit the page about cats. I type in my browser URL bar:

https:///mainPageCat.php

As you can see, I see the page I built and the cookie is stored in my browser

If I click the call to action (blue button), I see the further details page with cat food ads only:

Let’s now test the flow for dog lovers. First I delete cookies from my browser (or use the incognito mode) and then I visit this URL:

https:///mainPageDog.php

This is what I see:

As we can see again, I see the page I built and the cookie is stored in my browser

If I click the call to action (blue button), I see the further details page with dog food ads only.

Done! This is a simple and quick example of how you can use cookies to customize the content of your web pages. You can find the Github repo here with the full code.

But these often repetitive tasks can be time-consuming and leave room for errors. Some of these errors can cost your company money, reputation, and time.

Luckily, Python and APIs can help you prevent such mistakes as well as save time and money. Your team can then invest that time and money in other activities like developing new strategies or methods to be more efficient.

You May Have Heard of APIs Before

If you work in the tech industry, you've likely heard of APIs at least once in your life. If you have never heard of it, don't worry – I'll give you a brief explanation here.

"API" stands for Application Programming Interface. They help services or applications communicate with each other.

Just to give you an example, if you are a frontend developer you'll be asked to call a backend service via its API to retrieve the information you want to print on the screen. This is how the backend and the frontend send and receive data. When you call an API you get a JSON or XML file as a response.

APIs can be also "RESTful", which stands for Representational State Transfer. Rest is a set of architectural constraints that help you design efficient and safe APIs.

If you'd like to know more about REST APIs, I recommend that you read this article by Ihechikara here on freeCodeCamp's publication.

How Can APIs Help You Get Work Done?

As I said, APIs are about exchanging information. Even if you're not developing a frontend application, you can retrieve the data you need and manipulate or handle them to get the information you need. Then you can ask another service to perform the action you want it to perform.

I'll give you an everyday-life example to show you how you can use APIs to automate tasks to help implement your business strategy.

API Use Case Example

Let's say our company sells umbrellas and we want to update our price list according to the weather of the city where our store is located. When it rains, we want the umbrellas' price to be raised, while we want it to decrease when the weather is good. In any other case, we want to leave the price as it is.

Of course, this is an over-simplified scenario, but I think it is a good fit to show how powerful APIs can be to help you automate your business strategies online.

Without any automation, you would have to check the weather forecasts every day and manually update the item's price. As I said at the beginning of this article, this type of manual process can be time-consuming and leave room for errors. Also, don't forget you would need somebody to perform these tasks 365 days a year.

Thankfully, we can automate this process. This is what we need:

• Python (3.10 and above)
• A CMS/e-commerce exposing APIs (I'm using Woocommerce for this tutorial)
• Weather forecast APIs

How to Use Python and APIs to Automate Updates

We'll implement a batch written in Python – that executes every 24 hours – to update the price of the umbrellas according to the response of a weather forecast API we call.

Let's dive into the script and analyze it step by step.

First of all, I declare environment variables. This is the list:

API_BASEURL #The baseurl of the weather forecast service I'm calling

API_CITY #The city I want to get weather information about

API_COUNTRY #The country where API_CITY is located 

API_KEY # The secret Key I must pass to retrieve the weather information

CONSUMER_KEY #The key I need to work with Woocommerce APIs 

CONSUMER_SECRET #The secret I need to work with Woocommerce APIs

DOMAIN #The domain of my ecommerce

Then, I start importing the libraries I need:

import os
from dotenv import load_dotenv

I import os and I also import load_dotenv to work with environment variables.

Then I import requests and JSON to handle the API's response.

import requests
import json

Then I import the API module from Woocommerce Python library. You can find more information in its rich documentation.

from woocommerce import API

Once I imported all the libraries and modules I need, I'll instantiate the variables I'll use on my script:

load_dotenv()
product_to_sell_id = "1736" #The Id related to umbrellas in my e-commerce
raised_price = "12" #The price I want to set when it rains
lowered_price = "8" #The price I want to set when weather is good
regular_price = "10" #The regular price of the item

Then I declare the changePrice function:

def changePrice(price, idProduct):

    wcapi = API(
        url= os.getenv('DOMAIN'), 
        consumer_key= os.getenv('CONSUMER_KEY'), 
        consumer_secret= os.getenv('CONSUMER_SECRET'), 
        wp_api=True, 
        version="wc/v3" 
    )

    data = {
        "regular_price": price
    }

    wcapi.put("products/" + idProduct, data).json()

    print("New price set to " + data["regular_price"])

The function has two arguments: the price I want to set (price) and the id of the product I want to update (idProduct).

Inside the function I store in the wcapi variable the API method with the information I need to reach my e-commerce (baseurl, consumer key, and secret).

I store in the data variable the payload I want to pass: I want to update the value of the key "regular_price" with the value of the argument "price".

After that, I update the e-commerce database with the PUT method by passing the path of the product I want to update (it's a concatenation of the string "products/" and the value of the argument "idProduct") and the data variable value.

In the end, I print a success message.

Once the changePrice function is ready, I need to define a new one to make the script work. But before we go ahead, we need to see the data we get from our API call.

The JSON file we get back as a response returns a lot of information. But, as I said at the beginning, we just want to know what the weather is like.

We get this data with the "code" key. Every weather status is associated with a number. In our case, we focus on these two codes:

502 #rainy
800 #sunny

Now that we have what we need, we define the getWeather function:

def getWeather():

    url = os.getenv('API_BASEURL')

    headers = {
    "Accept": "application/json"
    }

    payload = {
    "key": os.getenv('API_KEY'),
    "city": os.getenv('API_CITY'),
    "country": os.getenv('API_COUNTRY')
    }


    response = requests.request(
    "GET",
    url,
    params=payload,
    headers=headers  
    )

    data = response.text

    parse_json = json.loads(data)

    get_parse_result = parse_json["data"][0]["weather"]["code"]

    match get_parse_result:
        case 502:
            changePrice(raised_price, product_to_sell_id)

        case 800:
            changePrice(lowered_price, product_to_sell_id)

        case _:
            changePrice(regular_price, product_to_sell_id)

In the url variable we define the base URL of the API we're calling. In the payload variable I pass our secret key, the city, and the country I want to get the weather about.

I perform my GET request by passing the URL, payload, and headers. Once I get the response, I parse it, and implement a switch statement with 3 cases:

• get_parse_result equals 502: we call the changePrice function passing as first argument the raised_price variable to increase the product price
• get_parse_result equals 800: we call the changePrice function passing as first argument the lowered_price variable to decrease the product price
• get_parse_result has a different value: we call the changePrice function passing as first argument the regular_price variable to keep the product price as it is

A the end of the script, I call the getWeather function:

getWeather()

And there you go – the prices will be automatically updated thanks to a little code.

Wrapping Up

So, this is just a quick example of how you can use APIs to automate your business strategies, save time, and avoid mistakes that can cost your company money.

It's a pretty basic example but I think it shows the potential of APIs and their benefits. Here you can find my repo with the full script.

WordPress is one of the most popular and widely-used tools to create blogs, e-commerce platforms, and websites.

In this article, I'll show you how to create content automatically and push it to your WordPress website with Python.

This is how it works:

• We'll get content from our source (for example, another website we run)
• We'll translate it into our language
• We'll choose a featured image already available on our website and finally publish it to our WordPress instance as a post.

The script we're about to develop can be useful if you want to create content in another language in a quick way to expand your audience.

Let's say you have a webzine with content written in English and you want Spanish-speaking users to start reading your posts. You can create a new blog and run your script to get your posts translated into Spanish and ready to read by your users.

Let's Get Started

This is the script we'll develop by the end of this article:

import requests
import json
import random
from googletrans import Translator
from requests.auth import HTTPBasicAuth

def post_creator(sourceURL, wpBaseURL, sourceLang, targetLang, postStatus):
    response_API = requests.get(sourceURL)
    data = response_API.text
    parse_json = json.loads(data)
    get_article_title = parse_json['title']
    get_article_content = parse_json['body']
    image_list = ["1689","1594","1612"]

    translator = Translator()

    title_translation = translator.translate(get_article_title, src=sourceLang, dest=targetLang)
    title_translation_text = title_translation.text 

    content_translation = translator.translate(get_article_content, src=sourceLang, dest=targetLang)
    content_translation_text = content_translation.text 

    random_image_list = random.choice(image_list)

    WP_url = wpBaseURL + "/wp-json/wp/v2/posts"

    auth = HTTPBasicAuth(<USERNAME>, <PASSWORD>)

    headers = {
    "Accept": "application/json",
    "Content-Type": "application/json"
    }

    payload = json.dumps({ 
        "status":postStatus,
        "title": title_translation_text,
        "content": content_translation_text,
        "featured_media": random_image_list
    })

    response = requests.request(
    "POST",
    WP_url,
    data=payload,
    headers=headers,
    auth=auth
    )

    print(response)
    print(random_image_list)


post_creator("https://jsonplaceholder.typicode.com/posts/5", "<BASE_URL>", "la", "en", "publish")

We'll break it into single parts and see, step by step, what we need to do.

Before that, we need to go to the dashboard of our WordPress website and create a new application password. We'll use it to build our basic authentication when pushing posts to our website.

If you've never done it before, you can check WordPress official documentation on how to do it. Once you'll create it, you'll see something like this:

Don't forget to save it, this is the only chance to get it!

Time to Code

Let's start checking out our code from the libraries we need. We'll use the googletrans library to translate our content with Google translate APIs. So, from the command line, I move to my project directory and type:

pip install googletrans

You could encounter this error when you run the script:

AttributeError: 'NoneType' object has no attribute 'group'

If you see this message error, you should install this version:

pip install googletrans==4.0.0-rc1

I found it on this StackOverflow article. If you want to know more about it, just have a look!

How to Get the Content Translated

Once we install googletrans, we define a new function and call it "post_creator":

def post_creator(sourceURL, wpBaseURL, sourceLang, targetLang, postStatus):

We pass this function five arguments:

• sourceURL: the URL of the website you get content from
• wpBaseURL: the URL of your new website where you want to import translated content
• sourceLang: the original language of the content
• targetLang: the language you want your content to be translated into
• postStatus: the status of your WordPress post: for example "draft", "published", and so on.

Inside the function, we declare six variables. Let's see them.

We use the GET method to call an API to get the content we want to translate:

response_API = requests.get(sourceURL)

Then we store in the "data" variable the text of the request:

data = response_API.text

We parse the JSON with the ".loads()" method to convert it into a Python dictionary:

parse_json = json.loads(data)

Then we store the value of the JSON key "title":

get_article_title = parse_json['title']

We do the same with the "body" key:

get_article_content = parse_json['body']

Finally, we store in a variable a list where we have the IDs of the media we want to use as "featured image":

image_list = ["1689","1594","1612"]

After we created the above variables, we instantiate Translator():

translator = Translator()

Now we can start translating content. We translate the title of the article we got from the previous API call and store it in the "title_translation" variable. We then get its text and store it in the "title_translation_text" variable:

title_translation = translator.translate(get_article_title, src=sourceLang, dest=targetLang)
title_translation_text = title_translation.text

We do the same with the content of the article:

content_translation = translator.translate(get_article_content, src=sourceLang, dest=targetLang)
content_translation_text = content_translation.text

We get a random image from the image IDs list we created before. Images must be already available in our WordPress instance. Then we pick one just by specifying its ID:

random_image_list = random.choice(image_list)

How to Create Our WordPress Blog Post

Now we set things up to push the content we have to our WordPress website. First, we store the URL we're calling to push the content in a variable:

WP_url = wpBaseUrl + "/wp-json/wp/v2/posts"

We store in a variable the credentials for our basic authentication: the username and the application password we created before. We use "HTTPBasicAuth" to handle our authentication:

auth = HTTPBasicAuth(<USERNAME>, <PASSWORD>)

We store in a variable the headers we want to pass. We set the output type to JSON and indicate that the request body format is JSON:

headers = {
    "Accept": "application/json",
    "Content-Type": "application/json"
    }

Time to define the payload. We use the dumps() function to convert the Python object we created into a JSON string and then we pass the data we need to create the blog post:

payload = json.dumps({ 
        "status":postStatus,
        "title": title_translation_text,
        "content": content_translation_text,
        "featured_media": random_image_list
    })

Then we use the request() method to make our API call:

response = requests.request(
    "POST",
    WP_url,
    data=payload,
    headers=headers,
    auth=auth
    )

At the end of the function, we print the response of the POST call and the ID of the media we'll use as the featured image:

print(response)
print(random_image_list)

Once we've completed our function, it's time to call it and pass the correct arguments:

post_creator("https://jsonplaceholder.typicode.com/posts/5", <BASEURL>, "la", "en", "publish")

• https://jsonplaceholder.typicode.com/posts/5: the URL we call to get the content we want to translate
• <BASEURL>: the base URL of our WordPress website
• la: the language code of the content we get from our API call. In this case, it is "Lorem Ipsum" content, so we set it to Latin
• en: the language code we want to translate our content into. We set it to English.
• publish: the status of the WordPress post we are creating

If we run the script via the command line, we see this message:

<Response [201]> 
1594

And if you visit the website, you can see the post:

Just to give you a complete overview, this is the JSON we got content from:

Final Thoughts

In this article, we saw how to automate posts in a few lines of code with Python. It can be run as a batch or when necessary.

Content is always a key point when you manage a website. I hope this article will help you translate content quickly and grow your audience even faster. Here you can find the repo on GitHub.

Enjoy and keep coding! :)

In this tutorial I'll share my experience with Azure Static Web Apps – Azure's PaaS solution. I'll show you how you can take advantage of its flexibility to deploy an Angular App just by pushing your code to a Git repository.

There’s a lot of literature about CI/CD on the web, and in this article, I want to focus on Azure Web Apps to show you how it can dramatically simplify your workflow.

If you want to know more about CI/CD, Atlassian’s blog has some good info. And here's a helpful in-depth and project-based guide on the subject.

What do we need for this project?

During this tutorial, we'll use the following technologies and tools:

• A GitHub account
• Node.js (you can download it here)
• Npm (Node.js package manager. Included with Node installation.)
• Angular CLI (a command-line interface tool to create, develop and maintain your Angular app. You can download it here.)
• Azure account (you can start for free by creating your account here. Once your free trial expires, have a look at the costs you are incurring. Cloud technologies are very powerful and can make your life easier. But they can be expansive if not well managed.)

If you want to follow along with me during this article and replicate what I’m building, you need to be all set with these tools.

What We'll Build Here – the Big Picture

Let’s see how to create our Angular App and deploy it with Azure Web App. We'll create our Angular app locally and push it to a GitHub repository we specifically create for this project.

The repository will have two branches: “main” and “develop”. We'll create a static web app on Azure and connect it to the “main” branch of the repository.

Back to your machine, edit the code and push it to the “develop” branch. Then you merge the “develop” branch with the “main” one and see the new version of your app online.

Just to be clearer, I think a quick list will help us recap every single step:

• You'll create your Angular app locally with Angular CLI
• You'll push it to a GitHub repository
• You’ll create a static web app on Azure and connect it to the “main” branch of the project’s repository
• You’ll create a “develop” repository
• You’ll edit the app code locally and push it to the “develop” repository
• You’ll create a pull request on your GitHub project from “develop” to “main” and merge it
• You’ll check if the new app version is available on the web app

Step 1 – Create the Angular App Locally

First, let's create a specific directory on your computer and move into it. I’m on Mac, so I'll open my terminal and type:

mkdir angular_azure
cd angular azure

Once there, create your new Angular app called “angular_app”:

ng new angular_app

Angular CLI asks you a few questions:

We want to add Angular router and we also want to use CSS for styling the app. Once you receive positive feedback from Angular CLI, start your app locally to see if everything is working fine:

ng serve —-open

The option “--open” tells Angular CLI that you want to open the application with your default browser. This means that you don’t need to copy and paste the URL into your browser’s address bar. So, this is what you should see:

Looks like everything is working fine. You can stop the application (Ctrl + C) and move to the next step

Step 2 – Push the Angular App to Your GitHub Repository

You should have created a new repository on your GitHub account dedicated to this project. I called mine “angular-app-with-azure”. If you don’t know how to create a new repository, you can read more about that here.

Once the repository is ready, push your Angular app from your machine to your repository. If you don’t add a README file when creating your repo, you should see the instructions on how to push your code directly on your repository page. However, I'll repeat these instructions also here:

git init
git add .
git commit -m "first commit"
git branch -M main
git remote add origin https://github.com/<REPO>.git
git push -u origin main

Once you run these commands successfully, you should see something like this:

Let’s go ahead now.

Step 3 – Time to Switch to Azure

Now you'll create a brand new Azure Static Web App and connect it to your repository. First of all, enter the Azure portal here, and go to your Resource Group. Then you'll see this:

Hit “create” and you'll see the list of resources available on Azure. Filter resources by “Static Web App” and select it.

Then move to Azure’s wizard to create the resource. Let’s see how you should fill it out.

First of all, choose the subscription and resource group. Then go with the Static Web App details: choose the name – “angular-app” – and stick with the Free plan. Then select your region – mine is “Central US”.

Then go ahead with a few more pieces of information:

You can synch your GitHub account in the “Deployment Details” section, and then specify the Organization, Repository, and branch you'll get your codebase from.

As I said at the beginning of this tutorial, I choose the “main” branch as the production one.

Now let’s focus on the “Build Details”. You'll choose “Angular” as “Build Presets”, and specify that the App is located at the root directory on “App Location”.

Then you'll type the path of the output location (“dist” directory plus name-of-project directory. In my case, it's “dist/angular-app”. This is where Angular CLI locates the build of your project. I spent a lot of time looking for this info and I think it’s good to share it with you).

So, now you're ready to create your Static Web App. Hit “create” and see what happens. This is the overview of my app:

Next, hit the “URL” link and this is what you should see:

Step 4 – Create a New Branch

So now you'll go back to your codebase locally and create your “develop” branch and check it out:

git checkout -b develop

Then go to:

src/app/app.component.html

Edit the code like this:

<p>Pushed to develop</p>
<router-outlet></router-outlet>

And then push the new branch to the remote repository:

git push origin develop

Step 5 – Time to Merge

Your angular App is still online with the old version. You need to merge your "develop" branch to "main" to see the changes online.

Create a pull request on GitHub and merge it. This is what you should see at the end:

Wait a couple of minutes and then you'll see the new version of your app online:

A Quick Recap and Useful Resources

I hope this tutorial showed you how you can easily deploy your code to a production environment with CI/CD and Azure Static Web App.

While practicing with these technologies, I found a lot of interesting content on the web about them. I thought it would be good for you to have all of them in one place:

• What is Git? A beginner's guide to Git version control
• How to use Git and Git Workflows – a practical guide
• GitHub Actions docs
• Angular docs
• My repo on GitHub

And don't forget... Keep learning, and keep coding!

There are hundreds – or maybe thousands – of WordPress plugins to retrieve and show data. But WordPress APIs can give us a hand if we want to build a custom dashboard with some specific information we want to get.

That's why today I want to share with you how to build a service that retrieves data from our WordPress instance and shows them on a table. To be more specific, I want to know the number the plugins I'm using and what plugins I've installed previously that I'm not using anymore.

Why should I know what WordPress plugins I'm using?

I always found this information to be very important. Especially at the beginning of your journey with WordPress, you might be tempted to install a plugin for every single functionality you want your websites to have.

Well, plugins may be easy to install but they also have some potential drawbacks:

• If not updated often, they can expose your website to attacks and vulnerabilities
• They can make the loading time of your website much longer than it should be
• Some of the plugins might conflict with each other

I'm not saying you shouldn't use or trust plugins. But it is something you have to pay attention to. So let's see how we can have some useful information about our plugins at our fingertips.

What tools I'll be using

• WordPress APIs – I'll work with the "plugins" endpoint.
• React – I'll create a component to display data.
• Axios – I'll use it to call APIs easily.
• React-Bootstrap – I chose this library just to get a nice and easy-to-use table component quickly.
• Postman – This is the tool I always use to test APIs.
• Npm – I'll use it to create a React app and install packages.

WordPress APIs

As I said at the beginning of this article, I want to call a specific endpoint to get JSON with the information about the plugins I've installed on my instance. Precisely, I want to count the plugins I currently use ("active") and the plugins I don't use ("inactive").

The documentation about the APIs is very detailed and full of useful information and concepts. So I hit "Endpoint reference" on the sidebar and scroll to click on "Plugins".

Let's focus now on the "Schema" section. Here I find all the fields that exist in a plugin record. The list is quite long, but I need just one of these fields: "status". The documentation says it returns me a string with two possible values: "inactive" or "active".

So this is the API I'll call to retrieve the necessary data:

https://<BASE_URL>/wp-json/wp/v2/plugins

So far so good. There's one more thing we need to take into consideration. Some endpoints require basic authentication to return data. Our endpoint is one of those. Starting version 5.6, you can pass a username and an application password to call this endpoint.

If you want to know more about application passwords and how to generate them, I recommend you to check this article written by the WordPress community.

Time to Test the API

Once I know what endpoint I need to call and I generate my application password, I'm ready to test my API call with Postman. This is what I get:

As you can see, I get a JSON with the information I'm looking for: the "status" key. Now we are ready to create our React app!

Let's Code the React App

It's now time to create the front-end of our application. As I said before, I'll use React because of its flexibility, Axios to call APIs easily, and React-Bootstrap to get ready-to-use components with a nice design.

Before I start writing code, let's recap what I want to achieve: I want my front-end application to retrieve data from my WordPress instance about the status – active or inactive – of the plugins installed by calling the "Plugins" endpoint.

To do so, I want my script to perform the following actions:

1. Create variables to store the count of active and inactive plugins
2. Call the endpoint by an API call
3. Iterate through the JSON – the API call returns with the following logic: If the object key "status" equals "active" increase the related count by one, otherwise increase the count related to the inactive plugins by 1. Update the related states - previously defined in the constructor - accordingly
4. Render the table by using the "Table" component from React-Bootstrap and pass the states into the table component where I want data to be displayed with the count of active and inactive plugins

Enough talking. Time to code! :)

First things first, I create my React app like this:

npx create-react-app report

Then I install Axios and React-Bootstrap:

npm install axios
npm install react-bootstrap bootstrap@5.1.3

All set. Now, in my React app, I move to the /src directory and I create a new directory called "components":

/src/components

Then I move to the components folder and I create a "Report.jsx" file. This is how the file looks now:

import React from 'react';
import axios from 'axios';
import Table from 'react-bootstrap/Table'

class Report extends React.Component { 
  constructor(props) { 
      super(props); 
      this.state = { countActiveState: 0, countInactiveState: 0, };
  } 

  componentDidMount() {
  let countActive  = 0;
  let countInactive = 0;

  axios.get("https://<BASE_URL>/wp-json/wp/v2/plugins", {
    auth: {
      username: process.env.REACT_APP_USERNAME,
      password: process.env.REACT_APP_CLIENT_SECRET
    }
  })
  .then(res => {
      const plugins = res.data;
      for(let key in plugins) {
        if(plugins[key].status === "active") {
          countActive++;
          this.setState({countActiveState: countActive}); 
        }
        else{
          countInactive++;
          this.setState({countInactiveState: countInactive}); 
        }
    }
    })
    .catch(error => {
      alert("Something went wrong. Try again later.");
      console.log(error);
   })
  }

  render() { 
      return ( 
          <Table striped bordered hover >
              <thead>
                  <tr>
                  <th>Status</th>
                  <th>Plugin Amount</th>
                  </tr>
              </thead>
              <tbody>
                  <tr>
                  <th>Active</th>
                  <td>{this.state.countActiveState}</td>
                  </tr>
                  <tr>
                  <th>Inactive</th>
                  <td>{this.state.countInactiveState}</td>
                  </tr>
              </tbody>
          </Table>
      ); 
  } 
} 

export default Report;

Let's break it into smaller pieces and see what is going on:

import React from 'react';
import axios from 'axios';
import Table from 'react-bootstrap/Table'

I import Axios and the component "Table" from the React-bootstrap library.

constructor(props) { 
      super(props); 
      this.state = { countActiveState: 0, countInactiveState: 0, };
  }

In the constructor I define two states: countActiveState and countInactiveState. I set both of them to 0.

componentDidMount() {
    let countActive  = 0;
    let countInactive = 0;

I declare two variables and set them equal to 0: countActive to store the active plugin count and countInactive to store the inactive plugin count.

axios.get("https://<BASE_URL>/wp-json/wp/v2/plugins", {
      auth: {
        username: process.env.REACT_APP_USERNAME,
        password: process.env.REACT_APP_CLIENT_SECRET
      }
    })

I use Axios to perform a GET call to the "Plugins" endpoint. I also pass the credentials for the basic auth.

.then(res => {
      const plugins = res.data;
      for(let key in plugins) {
        if(plugins[key].status === "active") {
          countActive++;
          this.setState({countActiveState: countActive}); 
        }
        else{
          countInactive++;
          this.setState({countInactiveState: countInactive}); 
        }
    }
    })
    .catch(error => {
      alert("Something went wrong. Try again later.");
      console.log(error);
   })
  }

Then, after storing the response data in a variable called "plugins", I iterate through the JSON and say: "for each JSON object, check if the key "status" is equal to "active". If so, increase the countActive variable by 1 and set the countActiveState equal to countActive, else increase the countInactive variable by 1 and set the countInactiveState equal to countInactive".

render() { 
      return ( 
          <Table striped bordered hover >
              <thead>
                  <tr>
                  <th>Status</th>
                  <th>Plugin Amount</th>
                  </tr>
              </thead>
              <tbody>
                  <tr>
                  <th>Active</th>
                  <td>{this.state.countActiveState}</td>
                  </tr>
                  <tr>
                  <th>Inactive</th>
                  <td>{this.state.countInactiveState}</td>
                  </tr>
              </tbody>
          </Table>
      ); 
  } 
} 

export default Report;

Then I render the Table component and I pass the countActiveState and countInactiveState where I want data to be displayed.

Lastly, I go to the App.js file and I add the Report component:

import './App.css';
import Report from './components/Report';

function App() {

  return (
    <div className="App">
      <h1>WordPress Stats Dashboard</h1>
      <Report/>
    </div>
  );
}

export default App;

I start the app:

npm start

And the magic happens! :)

And there you have it!

So, this is just a quick example of how you can easily build your custom dashboard to retrieve and visualize data from your WordPress instance.

You can use any type of graphical data representation, such as bar or pie chart. It's all up to you!

Don't forget to have a look at my repo on GitHub. Feel free to share this article and your feedback. :)

You'll have various repetitive tasks you have to deal with, and you don’t want to waste your time doing something that can be done by a script.

Here are some great reasons to automate repetitive tasks:

• doing repetitive tasks doesn't help your career or develop your skillset at all
• there’s plenty of room for mistakes
• as I said before, you feel you’re wasting your time. And if you just asked someone else to do these tasks, so would they.

When is it time to automate a task?

Well, the more you advance along your career path, the more you'll understand when you can try to automate a process.

Based on my personal experience, you need to be able to answer these three questions:

1. How often do you perform this task?

Keep track of how many times you've performed the task during the last month. If it needs to be done every week or less, you should try to automate it

2. How long does this process take?

Try to estimate the average time you need to complete the task. If it is equal to or more than 30 minutes, I think it is worth thinking about how to automate it.

Just to give you an idea, let’s say you perform the task every day and it takes 30 minutes. That's 2.5 hours a week and 10 hours a month. Assuming you work eight hours per day you spend more than a day per month dealing with that task. When it comes to budgeting, that's a lot of money

3. How much does automation cost?

You need a cost estimation: how many hours do you need to develop the script? Do you need to use any third party services such as libraries, cloud services, and so on?

If you decide that the development is quick and not expensive, you can consider going ahead with the implementation.

How to Automate Tasks

Ok, let’s see now how you can automate a simple but frequent task.

When you work in IT operations, you'll need to generate reports or files with updated information for other departments quite often. Let’s say you’re asked to generate a file with some information about a specific GitHub profile.

GitHub offers APIs where you can get information about a single profile:

https://api.github.com/users/

We can write a quick script with Node.js and Axios to call the endpoint, get the information we need, and create a text file to store it in a specific directory.

This is our script:

const axios = require('axios');
const fs = require('fs');

axios.get('https://api.github.com/users/<USERNAME>')
  .then(response => {
    const file_text = response.data.login + " " + response.data.name
    const nome = Date.now()
    console.log(response.data.login);
    console.log(response.data.name);
    fs.writeFile('./fileCreated/' + nome + '.txt', file_text, err => {
      if (err) {
        console.error(err)
        return
      }
    })

  })
  .catch(error => {
    console.log(error);
  });

As you can see, once we call the endpoint, we log the username and name to the console. Then we print this information in a text file named by the timestamp, and save in a directory called “fileCreated”.

How to run the script periodically

There are tons of tools that help you run a script at any given time. For this tutorial, I decided to use Azure WebJobs.

It is a service included in Azure’s Pass solution, “Web App”, and it allows you to run scripts, manually or periodically, written with the world’s most popular languages such as Java, Python, .NET, and, of course, NodeJs.

You can find the full list here.

How to use Azure WebJobs

I assume you already created your Web App. Just consider that, at the time I’m writing this tutorial, Webjobs are available only on Windows Web Apps.

If you need help getting started, I suggest you check out this tutorial by Microsoft.

On the WebApp menu (left sidebar) I filtered options by typing “WebJobs” and clicking on it:

Once on the WebJobs panel, I clicked “Add” to add my script (I zipped my file with all its dependencies and called it “axiosexample”). Then,

• I entered the name
• I uploaded the zipped file
• I chose “triggered” since I don’t want this task to be performed continuously

On the “Triggers” option, I chose “Manual” because I wanted to run it now to show you the result for this tutorial. But you can schedule the WebJobs by choosing “Scheduled” and specifying the CRON expression. Check out this tutorial by Microsoft to see how to write a CRON expression.

If you want to learn more about CRON expressions, the internet is full of literature about it. You can simply start from the Wikipedia page, check out this tutorial on freeCodeCamp, and then continue with other useful content such as Cronitor.

Next, click “Ok”.

Once saved, hit “Run” to perform the task immediately. Then click “Logs” to see the results of our WebJobs.

Once on the “Logs” page, hit webjobs to get further details:

Next let's set the “Timing” of our WebJobs:

And we see the log messages, like this:

Now, by using the “Kudu” service available in our Web App, go to the directory where you saved your file via Powershell.

“Kudu” is a very useful service available on Azure’s Web Apps that allows you to get a lot of information about the Web App itself such as App settings, Run Commands, and much more. You can see the full list here.

You'll reach the directory you created. The path is:

\home\site\wwwroot\App_Data\jobs\triggered\webjob\axiosexample\fileCreated

Once you reach the file, just open it and this is what you should see:

Wrapping Up

So, this is a quick example of how you can simply automate a task with a few lines of JavaScript and Azure Webjobs.

Just look around you and see what you find repetitive and time consuming. Then, think how you could put those actions into a script and that's it!

Automation is all around you! 😀 Don't forget: the more you automate, the more time you have to think about more automations... Feel free to have a look at my repo on GitHub.

You might also want a static website for these reasons:

1. Speed: pages load quickly
2. Minimal skills required: Web developers who don't have much experience can easily work on the project
3. Hosting is easy: today's market offers a variety of options to host your static website (like AWS S3, Azure Storage, Netlify, and others)

So far we've talked about why you might choose a static website and what they're good at.

But what if you want to add content quickly to your website or update just a section of it? What if you want to add a blog to your website to get new visitors?

That's an issue I've had to deal with in the past several times: clients asked me to add dynamic content to their websites and they had no budget or time to create a new project. Fortunately, WordPress helped me find a solution. Let's see how.

How WordPress helped me

WordPress is the standard in the Industry for blogging and publishing content quickly. The dashboard is intuitive and easy to use. Admins can also add new users and specify – by selecting the appropriate role – their permissions.

WordPress exposes Rest APIs to help developers build integrations with WordPress itself and third parties services.

So I decided to integrate a WordPress blog with my client's static website by calling the /wp/v2/posts endpoint provided by WordPress APIs. In the next steps, I'll explain how I did it and why.

Project Setup

First of all, I want to share the website I'll work on during this article. Nothing too fancy: I picked this Bootstrap static template:

As you can see, we can divide the page into three different main sections:

1. Company's presentation (image + tagline)
2. A call to action card (the grey area in the middle)
3. A row with three cards

I'll integrate our WordPress blog in the third section.

Every post will be represented by a card, where users will be able to read the post title, the excerpt, and go to the post content by clicking the blue button "Read more". The button will open a modal where the post content will be displayed.

Let's see how our WordPress instance works

Let's have a look at our WordPress instance and see what we have. If I log into the dashboard and go to the posts section, I see that I've published three posts: Post No. 1, Post No. 2, and Post No. 3.

Every article has some "Lorem ipsum" content. So, at the end of this article, I expect these posts to be displayed in three different cards as mentioned above.

How to work with WordPress APIs

WordPress APIs are well documented and maintained by a huge and enthusiastic community. Let's see how I can handle posts with the APIs available.

So, once on the documentation page, I hit "Endpoint Reference" and then "posts". As I said before, I want to retrieve all the posts I published on my instance. I go to the "List Posts" and read "Query this endpoint to retrieve a collection of posts. The response you receive can be controlled and filtered using the URL query parameters below."

Sounds like this is what I'm looking for. According to the documentation, this is the request:

https://<BASE_URL>/wp-json/wp/v2/posts

Before starting the implementation, I test it using Postman. This is what I get:

As expected, I get a JSON with the information related to the posts I created on my WordPress instance.

Time to Code

To complete this implementation, I'll edit index.html and I'll create a new file called blog.js.

In index.html, I'll remove the static cards, add a loader to make it appear while waiting for the API call response and, and add an id – "wrapper" – to the DOM element I want the posts' cards to appear in. It looks like this:

<div id="wrapper" class="row gx-4 gx-lg-5">
    <div id=spinner class="text-center">
        <div class="spinner-grow spinner-grow-lg">
            <span class="visually-hidden">Loading...</span>
        </div>
    </div>
</div>

In the blog.js file I fetch the URL and the first .then() checks if the response is ok:

fetch('https://<BASE_URL>/wp-json/wp/v2/posts').then(function (response) {
    if (response.ok) {
        return response.json();
    } else {
        return Promise.reject(response);
    }
})

using a second then() I remove from the DOM the spinner and map both the card and the modal for each post I find in the JSON. I choose to display just the latest three articles of the blog. It looks like this:

.then(function (data) {
    spinner.remove()
    for (let i = 0; i < 3; i++) {

        cardCreation = '<div class="col-md-4 mb-5">'
        cardCreation += '<div class="card h-100">'
        cardCreation += '<div class="card-body">'
        cardCreation += '<h2 id="test" class="card-title">' + data[i].title.rendered + '</h2>'
        cardCreation += '<p class="card-text">' + data[i].excerpt.rendered + '</p>'
        cardCreation += '</div>'
        cardCreation += '<div class="card-footer"><button type="button" class="btn btn-primary btn-sm" data-toggle="modal" data-target="#modal-' + data[i].id + '">Read More</button></div>'
        cardCreation += '</div>'
        cardCreation += '</div>'

        modalCreation = '<div class="modal fade" id="modal-' + data[i].id +'" tabindex="-1" role="dialog" aria-labelledby="exampleModalLongTitle" aria-hidden="true">'
        modalCreation += '<div class="modal-dialog" role="document">'
        modalCreation += '<div class="modal-content">'
        modalCreation += '<div class="modal-header">'
        modalCreation += '<h5 class="modal-title" id="exampleModalLongTitle">' + data[i].title.rendered + '</h5>'
        modalCreation += '</div>'
        modalCreation += '<div class="modal-body">' + data[i].content.rendered + '</div>'
        modalCreation += '<div class="modal-footer">'
        modalCreation += '<button type="button" class="btn btn-secondary" data-dismiss="modal">Close</button>'
        modalCreation += '</div>'
        modalCreation += '</div>'
        modalCreation += '</div>'
        modalCreation += '</div>'

        document.querySelector("#wrapper").insertAdjacentHTML("beforeend",cardCreation)
        document.querySelector("#wrapper").insertAdjacentHTML("beforeend",modalCreation)
      }
})

In the end, I use the catch() method to handle errors. I decided to add a Bootstrap danger banner where I explain something went wrong and add a link to resources that users can find useful:

.catch(function (err) {
    spinner.remove();
    errorMsg = '<div class="alert alert-danger" role="alert">'
    errorMsg += 'Sorry, we can\'t retrieve posts at the moment. Please visit www.ourblog.com'
    errorMsg += '</div>'

    document.querySelector("#wrapper").insertAdjacentHTML("beforeend",errorMsg)

    console.warn('Something went wrong.', err);
});

I open the index.html file with my browser and now I see the cards displaying the posts from my WordPress blog

To test if everything is working fine, I add a new post to my blog. This is what I see on my static website:

And if I hit "Read more", I see the full content of the post in a modal:

This is how I integrated a static website and a WordPress blog. You can find the full code here. I hope you found this article useful. Feel free to share it! 😀

If you work in the Web department on a corporate level, you've probably heard this sentence hundreds of times. So, today I want to share how I solved this issue for a company I worked at.

What Was the Request?

We had an e-commerce app built with WooCommerce, that got thousands of orders every day worldwide. To register, users had to add their first name, last name, and email address.

Our marketing department asked my team to provide them with the email address and first names of all our customers to launch a new campaign.

I expected them to ask for a CSV file to upload contacts massively to their marketing platform. Instead, they told me they needed an Excel file since they had to edit it before going ahead with the campaign launch.

Once they assigned me the Jira issue, I was ready to start.

Analyzing the Problem

WooCommerce provides users with the export functionality to get customers' data but it doesn’t generate an Excel file. It generates a CSV or an XML file.

When you work with a tool like WordPress, the first option you think about is using a plugin and get what you need.

I found a few options on the WordPress plugin directory, but there is a lot to consider every time you install a new plugin in your instance. You have to think about maintenance costs (consider every time a developer works on it, they log hours that affect your budget), security vulnerabilities, and – last but not the least – purchase approval can take a long time.

I also considered a second option: downloading the CSV via the user interface and turning it into an Excel file by using one of the thousand services you can find online.

But using third parties services could break critical security and privacy policies and the final result is not always reliable. So I decided to go no further in this direction.

In the end, I thought developing a script was the best and fastest option to solve this task.

WordPress provides developers with APIs. Many other plugins from the WordPress system provide APIs as well, and WooCommerce is not an exception. The documentation is robust and it offers links to libraries for the most used languages such as Node.js, Python, PHP, and Ruby.

I decided to go with Python and use this technology to develop a script that generates an Excel file with the following structure:

• Two columns: first name and email
• One row per customer

I chose Python for several reasons: there are hundreds of libraries that can help you get get the job done, it is flexible, and it is very useful when it comes to handling data.

I also decided to use Pandas and Openpyxl to handle data and create the Excel file.

Before coding, let’s get what we need

To work with the WooCommerce API, I need to generate the APIs keys to work with. You can get more info on WooCommerce official documentation.

First, you need to log into your WooCommerce instance, and then go to WooCommerce > Settings > Advanced > REST API.

Then I'll give it a brief description, choose the user I want to generate the API for, choose the permissions granted (Read/Write or both), and then hit “Generate API key”.

Next, I’ll get the Consumer Key and the Consumer Secret:

How to Prepare the Environment

The very first thing I did was add the necessary libraries to develop my script. I started with the Python library for WooCommerce. To install it, I ran this command:

pip install woocommerce

Good. Now I'll go ahead and install Pandas, a data analysis and manipulation tool for Python:

pip install pandas

After that, I installed Openpyxl, a Python library to read and write Excel files:

pip install openpyxl

Let’s code

I made the API call using the API function provided by the WooCommerce Python library and I stored it in a variable. Then I passed the function the base URL of my WooCommerce website, the consumer key, the consumer secret, and the version.

wcdata = API(
    url='<BASE_URL>',
    consumer_key='ck_XXXXXXXXXXXXXXXXXXXX',
    consumer_secret='cs_XXXXXXXXXXXXXXXXXXXX',
    version='wc/v3'
)

Then I used the GET function to call the "customers" endpoint and I created locally a JSON file (“contacts.json”) with the data I got from the endpoint I called right before:

newJson = wcdata.get('customers').json()
with open('contacts.json', 'w') as f:
    json.dump(newJson, f, ensure_ascii=False, indent=4)

I converted it to a Pandas object and stored it in the "df_json" variable:

df_json = pd.read_json('contacts.json')

I used the to_excel() function to turn the object into an Excel file. I passed the function three arguments:

• The name of the file I was about to create
• The index, set to “false” since I didn't want the record id to be printed on my file
• The columns I wanted to print on my file (first_name and email)

df_json.to_excel('customers_contacts.xlsx', index=False, columns=('first_name', 'email'))

I ran the script and I got this:

That’s it. This is how I created an Excel file with customers' emails and first names with WooCommerce APIs and Python in less than 20 lines of code.

Of course, it is a script you can run via the command line when needed or you can also automate it to regularly generate reports about the e-commerce you and your team are running.

Final thoughts

I also wanted to share some other content I found on the web while studying to develop this script.

The first one is a Stack Overflow question. It helped me optimize my code while creating the JSON file. I really appreciated the chosen question, especially when it suggested how you can write a "nicer" JSON file on a modern system.

The second one is about Pandas. If you write Python code, one day or another, you'll have to deal with data and their manipulation. This article by Erik Marsja explains really well how you can convert your JSON file to Excel with Pandas. It provides readers with several tips on how they can use this powerful library to display the data they want in an efficient and effective way.

Feel free to share this post if you found it useful! You can also find the full code on this Github repo.