The Foundation

I am not starting from scratch.
I have 8 years of professional experience in IT Operations and VIP Support. I know what happens when servers crash.

I know the pressure of being an IT Admin in a high-demand environment where every second counts.
I have “Battle Scars.”

But now, I am pivoting.

My goal is fixed:
Cloud Security Architect.

The challenge?

Moving from “Fixing Systems” to “Designing Systems.”

Moving from the How to the Why.

This is where AI stops being just a code-generator and starts being a career-accelerator.

It’s the “guy” riding shotgun—the „navigator“ in the passenger seat while I drive the car.

1. The Strategist, Not Just the Coder

I don’t use ChatGPT or an AI of your choice just to write Python scripts or read about how to build in Terraform.

I use it to calibrate my trajectory.
I tell the AI:

“Here is my background (8 years IT-Ops).
Here is my goal (Security Architect).
Here is my current plan for the next 6 months. Challenge it.

Where are the gaps?

What would a Senior Architect advise me to skip?”

The AI becomes my sparring partner. It helps me see the chessboard from above, while I’m still busy moving the pawns on the ground.

2. “The End Result Can’t Change”

I live by a simple rule: The plan can change, but the result cannot.

In the past, if I hit a wall, I might have stopped. Now, brick walls no longer stop me in my tracks. They are walls that are there for a reason. The reason? To prove how badly I want to get to the other side. Overcome the walls, shatter every single barrier.
Be brave, be bold. Be fearless.

In Short: don’t be afraid to try something and break something, because learning how to fix your own mistake makes you better.

Don’t know the answer?

Try giving it your “best guess,” trust your gut, and see what happens. You will learn more by attacking the problem than by giving up because you just hit a snag.

It is not a show-stopper.
It is just a detail.

When I get stuck, we (the AI and I) brainstorm alternatives. We pivot the tactic, but we never touch the objective.

• If a certification path is blocked, we find a project-based alternative.

• We write about it on dev.to.

• We message people in my network (like experts on AWS Guardrails) to get real-world feedback.

• If a technical concept
(like MCP) clicks, we double down.
We don’t just “understand it”—
we draft, examine, and publish a deep-dive article immediately.
(Typing this on my phone)

The AI allows me to be agile without losing focus.

** 3. Simulating the “Senior” Mindset**

The biggest gap between an Engineer and an Architect isn’t technical knowledge— it is decision making.

I use AI to simulate this. When I design a solution, I paste it into the prompt and say:

“Act like a harsh Senior Architect.
Where is the flaw in my plan? Where do you see gaps in my understanding?
Find the security flaw in this design that I missed.”

It forces me to think about risks I haven’t experienced yet. It helps me “download” the perspective of the role I want, before I even have the job title.

Hint:

You don’t need the job title, the certification, or the pat on the back.

What you need instead:

The mindset. Think like an architect before you are the architect on paper.

** Conclusion: Becoming “Complete”**

I am building a more complete version of myself, day by day.
Like laying bricks to build a wall. Then another , then another.

I am building my own foundation. I am not waiting
Not applying to jobs I don’t want or to jobs I am not qualified for…just to have a job.

I take my 8 years of hard-earned Ops experience, mix it with the strategic insights from my AI dialogues or sometimes with real people, and apply it to the Cloud world.

AI doesn’t replace the hard work.

But it ensures that every drop of sweat pushes me in the right direction.

I’ve been working on a small project called Hova.

Hova is a DSL focused on** describing game worlds, entities and universe structures** in a clean and declarative way.

It is not a game engine, and it doesn’t execute logic or handle rendering.

Its only goal is to describe what exists in a universe — not how it run.

Why I built it

When building games or tools, I often felt that world design ended up mixed with engine code, scripting logic or implementation details.

I wanted something that:

• stays engine-agnostic
• focuses only on world structure and meaning
• can be consumed by different tools or pipelines

That’s where Hova came from.

How it works

You write Hova source code describing your world, and it gets converted into a neutral format (currently JSON).

This output can then be consumed by:

• game engines
• custom tooling
• build pipelines
• converters

Hova doesn’t decide how the world is used — it only describes it.

A small example

anvil Shapes 

    atomic 
        atom visual : "minimal"
        atom hideConfig : "on"
    end

    ore Square 
        spark sides : 4
    end

    ore Triangle
        spark sides : 3
    end

end

Which converts to:

{
    "Shapes": {
        "atomic": {
            "emit": "json"
        },
        "Square": {
            "sides": 4
        },
        "Triangle": {
            "sides": 3
        }
    }
}

Current state

Hova is still an early project.

Documentation is a work in progress, so the /examples folder is currently the main reference to understand the language.

The language itself is evolving, and feedback at this stage is extremely valuable.

What I’m looking for

I’d love feedback on:

• the language design
• syntax clarity
• whether this kind of DSL could be useful in real game or tooling workflows

If you’re interested, here’s the repository:
👉 https://github.com/G4brielXavier/Hova

THANKS FOR READING.

I’ve been working on a small project called Hova.

Hova is a DSL focused on** describing game worlds, entities and universe structures** in a clean and declarative way.

It is not a game engine, and it doesn’t execute logic or handle rendering.

Its only goal is to describe what exists in a universe — not how it run.

Why I built it

When building games or tools, I often felt that world design ended up mixed with engine code, scripting logic or implementation details.

I wanted something that:

• stays engine-agnostic
• focuses only on world structure and meaning
• can be consumed by different tools or pipelines

That’s where Hova came from.

How it works

You write Hova source code describing your world, and it gets converted into a neutral format (currently JSON).

This output can then be consumed by:

• game engines
• custom tooling
• build pipelines
• converters

Hova doesn’t decide how the world is used — it only describes it.

A small example

anvil Shapes 

    atomic 
        atom visual : "minimal"
        atom hideConfig : "on"
    end

    ore Square 
        spark sides : 4
    end

    ore Triangle
        spark sides : 3
    end

end

Which converts to:

{
    "Shapes": {
        "atomic": {
            "emit": "json"
        },
        "Square": {
            "sides": 4
        },
        "Triangle": {
            "sides": 3
        }
    }
}

Current state

Hova is still an early project.

Documentation is a work in progress, so the /examples folder is currently the main reference to understand the language.

The language itself is evolving, and feedback at this stage is extremely valuable.

What I’m looking for

I’d love feedback on:

• the language design
• syntax clarity
• whether this kind of DSL could be useful in real game or tooling workflows

If you’re interested, here’s the repository:
👉 https://github.com/G4brielXavier/Hova

THANKS FOR READING.

After years of using our command-line tools to track CVEs, we built CVE-Alert – a free web-based platform that monitors security vulnerabilities and sends email alerts for the vendors and products you actually use.
Introducing CVE-Alert: Free Real-Time Vulnerability Tracking
After years of using our command-line tools to track CVEs, we built CVE-Alert – a free web-based platform that monitors security vulnerabilities and sends email alerts for the vendors and products you actually use.

The Problem

Running an MSP means keeping track of security vulnerabilities across dozens of different clients. Each one has their own tech stack, and new CVEs drop every day. Manually checking CVE databases to see what’s relevant is a pain in the ass and it’s way too easy to miss something important.

I’ve been using command-line scripts for this for years. They worked fine for me, but nobody else on the team could use them and there was no way to share them with clients.

What We Built

CVE-Alert connects directly to CVE.org and pulls in new vulnerabilities as they’re published. You tell it what vendors and products you’re running, and it emails you when something relevant shows up.

That’s pretty much it. No complicated setup, no expensive licensing.

What it does:

• Subscribe to the vendors and products you actually use
• Set severity filters if you only want critical alerts
• Get emails with the full vulnerability details
• Search through all CVEs if you need to look something up

Who Should Use It

We built this for ourselves first – MSPs juggling multiple client environments. But it works for anyone who needs to stay on top of vulnerabilities:

• IT teams running enterprise software
• Security folks monitoring their infrastructure
• Developers tracking dependencies

Why Free?

Honestly? It helps promote Dataforge. But also, we’re already using it internally. Making it available to the community doesn’t cost us anything extra, and security information should be accessible to everyone. I hope people enjoy it and it brings them value.

Try It Out

Head over to cve-alert.app.dataforgecanada.com and create an account.

In the previous article, we plotted a surface using inputs related to Petal Width and Sepal Width to predict whether the species is Setosa or not.

Let’s continue with the remaining steps.

After plotting the bent surface, we need to multiply all the points by -0.1.

import numpy as np
import matplotlib.pyplot as plt

# Create a grid of dots across the entire bottom plane
p_dots = np.linspace(0, 1, 6)
s_dots = np.linspace(0, 1, 6)
P_grid, S_grid = np.meshgrid(p_dots, s_dots)

# Calculate surface values
Y_grid_dots = np.maximum(
    0,
    (P_grid * -2.5) + (S_grid * -0.6) + 1.6
)

# Scale the bent surface
Y_grid_dots = Y_grid_dots * -0.1

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

ax.plot_surface(
    P_grid,
    S_grid,
    Y_grid_dots,
    alpha=0.7
)

ax.set_xlabel('Petal Width')
ax.set_ylabel('Sepal Width')
ax.set_zlabel('Setosa Output')

plt.show()

Now we do the exact same thing for the bottom node in the hidden layer.

We apply ReLU to this and then multiply the result by 1.5 to get the final orange bent surface.

import numpy as np
import matplotlib.pyplot as plt

# Create a grid of dots across the entire bottom plane
p_dots = np.linspace(0, 1, 6)
s_dots = np.linspace(0, 1, 6)
P_grid, S_grid = np.meshgrid(p_dots, s_dots)

# Bottom hidden node calculation
Y_grid_dots = np.maximum(
    0,
    (P_grid * -1.5) + (S_grid * 0.4) + 0.7
)

# Apply output weight
Y_grid_dots = Y_grid_dots * 1.5

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

ax.plot_surface(
    P_grid,
    S_grid,
    Y_grid_dots,
    color='orange',
    alpha=0.7
)

ax.set_xlabel('Petal Width')
ax.set_ylabel('Sepal Width')
ax.set_zlabel('Setosa Output')

plt.show()

Now we add the y-axis coordinates of the blue bent surface to the y-axis coordinates of the orange bent surface.

We do this for every single point, and we end up with this green surface.

import numpy as np
import matplotlib.pyplot as plt

# Create a grid of dots across the entire bottom plane
p_dots = np.linspace(0, 1, 6)
s_dots = np.linspace(0, 1, 6)
P_grid, S_grid = np.meshgrid(p_dots, s_dots)

# ----- Blue surface (top hidden node) -----
Y_blue = np.maximum(
    0,
    (P_grid * -2.5) + (S_grid * -0.6) + 1.6
)
Y_blue = Y_blue * -0.1

# ----- Orange surface (bottom hidden node) -----
Y_orange = np.maximum(
    0,
    (P_grid * -1.5) + (S_grid * 0.4) + 0.7
)
Y_orange = Y_orange * 1.5

# ----- Final output surface (sum) -----
Y_final = Y_blue + Y_orange

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

ax.plot_surface(
    P_grid,
    S_grid,
    Y_final,
    color='green',
    alpha=0.7
)

ax.set_xlabel('Petal Width')
ax.set_ylabel('Sepal Width')
ax.set_zlabel('Setosa Output')

plt.show()

At the end, we need to add the bias, which is 0.
This does not change the green surface, so this is the final output for Setosa.

From this, we can understand that the value for Setosa is highest when the petal width is close to 0.

Similarly, the value for Setosa is lowest when the petal width is close to 1.

In the next article, we will explore how to use this neural network to predict Setosa, Versicolor, and Virginica.

You can try the examples out in the Colab notebook.

Looking for an easier way to install tools, libraries, or entire repositories?
Try Installerpedia: a community-driven, structured installation platform that lets you install almost anything with minimal hassle and clear, reliable guidance.

Just run:

ipm install repo-name

… and you’re done! 🚀

🔗 Explore Installerpedia here

You’re invited to IntelliJ IDEA Conf 2026 – a free online conference for developers working across the JVM ecosystem. Join us for two days of in-depth technical talks, practical insights, and conversations with experts who build and shape modern Java and Kotlin development.

The conference will take place online on March 26–27, 2026, with sessions livestreamed directly from the JetBrains studios.

What to expect

IntelliJ IDEA Conf 2026 will feature live sessions from engineers and developer advocates representing JetBrains, Oracle, AWS, Broadcom, Docker, Gradle, and other organizations shaping the JVM ecosystem.

Across two days, speakers will cover a broad range of topics relevant to modern Java and Kotlin development, including language evolution, enterprise Java, Spring-based applications, build tooling, containerized workflows, JVM performance, and data access technologies.

Several sessions will explore the growing role of AI in Java development – from AI-assisted workflows and autonomous agents to practical use cases in everyday development. You’ll also hear about GraalVM and polyglot development, accelerating builds with Maven and Gradle, working effectively with Docker, and troubleshooting complex applications with IntelliJ IDEA.

In addition to deep technical talks, the program includes discussions on the developer experience, open source, and community-driven tooling, offering perspectives from people who actively influence the technologies and tools used by millions of developers worldwide.

All sessions are grounded in real-world experience and focused on practical insights you can apply in professional JVM projects.

Stay tuned for the full schedule and complete list of speakers!

Why this online event is special

IntelliJ IDEA Conf 2026 is fully virtual and free to attend, making it easy to join from anywhere in the world. All sessions will be streamed live with high-quality production, so you can follow along in real time or catch up later.

Live chat and Q&A are a core part of the experience. You’ll be able to ask questions during the sessions, engage directly with speakers, and connect with other developers attending the conference.

Every session will be recorded and published afterward, so even if you miss something live, you’ll still have access to all the content.

How to join

Registration is free and open to everyone.

When you sign up, you can choose whether you want to attend all sessions or focus only on the ones most relevant to you. Closer to the event, we’ll send you all the details you need to join the livestreams.

All sessions will be presented live, with time reserved for Q&A. We encourage you to participate, ask questions, and make the most of the opportunity to learn directly from the speakers.

After the conference, recordings will be available on the IntelliJ IDEA YouTube channel. Don’t forget to subscribe!

See you online!