To cure this chronic amnesia without setting up heavy RAG (Retrieval-Augmented Generation) pipelines, complex MCP servers, or relying on proprietary cloud chat histories, there’s a simple, universal, and incredibly effective approach: pairing a global AGENTS.md setup with the LLM Wiki pattern. This concept was popularized by Andrej Karpathy, former Director of AI at Tesla and co-founder of OpenAI.

The Trap of Disposable Context in PHP Development

When you ask an AI agent to implement a component—say, a caching system on an external HTTP client—your first instinct is to write a massive, detailed prompt. Without any existing context, you have to specify the PHP version, the dependency injection rules, the chosen Symfony cache component (cache.app, Redis, a custom Adapter), and how your PHPUnit tests should be structured.

Multiply that by dozens of daily interactions, and your productivity takes a massive hit. The goal is to give the agent persistent, portable memory that’s completely decoupled from the underlying LLM model.

Step 1: Structuring Instructions with a Dual-Layer AGENTS.md

The AGENTS.md file format has quickly become the go-to standard for guiding coding assistants right from your repo’s root. It defines your stack, your test commands, and your team’s guidelines. However, keeping this file strictly at the project level doesn’t solve the issue of your own personal developer context.

The first step is to leverage two distinct instruction layers:

• The project level (./AGENTS.md): Specific to the Symfony app you’re currently working on. It contains project conventions, language preferences, team CI/CD rules, etc.

Example:

## Stack
- Symfony 7, PHP 8.3, Doctrine, Twig, PostgreSQL.

## Conventions
- Skinny controllers, logic kept in autowired services.
- Doctrine migrations; never use schema:update.

## Quality
- Run everything through the Makefile: make test, make stan.
- PHPStan level 8, php-cs-fixer. Zero warnings.

• The user level (your agents global instruction files): Shared across all your projects. Every agent has its own entry point: ~/.codex/AGENTS.md, ~/.claude/CLAUDE.md, or ~/.gemini/GEMINI.md.

This is where you define your personal preferences. For example: using PHP 8 attributes, forcing strict types (declare(strict_types=1)), Git conventions, or requiring the agent to ask for confirmation before running destructive database commands like doctrine:schema:drop.

## About me
- Clément, Tech Lead. Reply to me in French.

## Defaults (Everywhere)
- Write code and documentation in English.
- PHP/Symfony, simple monolith. PHPStan level 4 minimum.
- Never push to git without my green light.

The best part? These files can all be symlinks pointing to a single source file that you only have to maintain once:

➜  ls -l ~/.codex/AGENTS.md ~/.claude/CLAUDE.md ~/.gemini/GEMINI.md

/Users/cb/.claude/CLAUDE.md -> /Users/cb/.config/AGENTS.md
/Users/cb/.codex/AGENTS.md  -> /Users/cb/.config/AGENTS.md
/Users/cb/.gemini/GEMINI.md -> /Users/cb/.config/AGENTS.md

However, you’ll quickly hit a technical ceiling: the context window. This is the limited amount of data an AI can hold in its active memory to process and respond to queries. Anthropic and OpenAI recommend keeping these AGENTS.md files under 200 to 300 lines to prevent model saturation or the risk of hallucination from instruction overload.

Step 2: Scaling Up with the LLM Wiki Pattern

To store a larger volume of knowledge without cluttering your main instruction file, Karpathy formalized the LLM Wiki pattern.

The core idea is simple: build a Markdown-based knowledge base structured like a Wiki, stored locally, and maintained/referenced by the agent itself. No new tools to install—just a clean folder structure of text files that you can track with Git.

This pattern works beautifully for a Symfony project, and it’s just as powerful for a developer’s personal knowledge base. It can be organized like this:

~/knowledge/
├── projects/      # App contexts (ProjetA, API-Core, Legacy-App)
├── tech/          # PHP 8 conventions, Symfony best practices, test patterns
├── people/        # Contacts, team members, stakeholder roles
├── index.md       # Global map and entry point
└── log.md         # Date-stamped changelog managed by the AI

Example index.md

# Personal Knowledge Index

Durable personal base, maintained as a lightweight LLM Wiki-style knowledge layer. **Do not load the whole directory** -- read this index, then open only the files relevant to the question.

## Profile
- `profile/about-me.md` -- who I am, background, side projects.
- `profile/roles-and-context.md` -- SensioLabs roles, client missions, mandates, durable context.

## Projects
- `projects/index.md` -- map of local projects and repositories, mostly under `~/Sites/`.

## People
- `people/contacts.md` -- durable professional relationship context, contact importance signals, and domain heuristics for calendar/mail prioritization.

## Tech
- `tech/php-symfony-style.md` -- durable PHP/Symfony preferences, patterns I like/refuse, architectural posture.
- `tech/code-review-preferences.md` -- recurring review criteria.
- `tech/makefile-task-runner.md` -- preference for self-documented Makefiles as project task runners and operational maps.
- `tech/docs-methodology.md` -- index of documentation surfaces (ADR, plans, audits, wiki, handoffs, articles) and where each goes; read this first, it points to the richer plan doc below.
- `tech/agent-executable-plans.md` -- global convention for where to store agent execution plans, how to number them, and how to track them with lightweight indexes.
- `tech/agentic-tools.md` -- cross-project inventory of agent-accessible tools, integrations, MCP endpoints, and usage conventions.
…

Orchestration: On-Demand Injection

To get your assistants to leverage this local Wiki, you only need a single line in your ~/.config/AGENTS.md file:

- Durable personal context: `~/knowledge/` (read the index before opening anything else).

When starting a new session, the agent reads the Wiki index (~/knowledge/index.md) first. Think of this index as a routing table. Depending on your current task, the agent only loads the two or three files it actually needs, rather than clogging its workspace memory with the entire folder.

Another massive benefit is maintenance. After a deep refactoring session or when nailing down a complex architectural fix, the agent can update the relevant tech doc in ~/knowledge/tech/ itself and log the change in log.md. You retain full control via simple Git commits.

In Practice: The Power of Minimalist Prompts

Once this setup is live, how you write prompts changes completely. A super concise prompt is now fully understood by your assistant:

The agent uses automatic navigation within your local Wiki to resolve each context. For each element in the prompt, the agent locates the relevant context in the specified file:

🔵 Project1/Project2 -> knowledge/projects/index.md

🟢 Symfony preferences -> knowledge/tech/php-symfony-style.md

🟡 todo -> knowledge/todo/index.md

🟣 my CTO -> knowledge/people/contacts.md

🔴 Jira -> shared configuration, skills and MCP

Tailored Memory for Cleaner Code

By pairing the clarity of a global AGENTS.md file with the flexibility of the LLM Wiki pattern, you give your coding assistants genuine long-term memory without compromising data sovereignty.

This approach perfectly aligns with the clean, maintainable philosophy of the Symfony ecosystem: no black boxes, no hidden dependencies—just plain, version-controlled text that’s human-readable and ready for any current or future LLM.

PakarPBN

A Private Blog Network (PBN) is a collection of websites that are controlled by a single individual or organization and used primarily to build backlinks to a “money site” in order to influence its ranking in search engines such as Google. The core idea behind a PBN is based on the importance of backlinks in Google’s ranking algorithm. Since Google views backlinks as signals of authority and trust, some website owners attempt to artificially create these signals through a controlled network of sites.

In a typical PBN setup, the owner acquires expired or aged domains that already have existing authority, backlinks, and history. These domains are rebuilt with new content and hosted separately, often using different IP addresses, hosting providers, themes, and ownership details to make them appear unrelated. Within the content published on these sites, links are strategically placed that point to the main website the owner wants to rank higher. By doing this, the owner attempts to pass link equity (also known as “link juice”) from the PBN sites to the target website.

The purpose of a PBN is to give the impression that the target website is naturally earning links from multiple independent sources. If done effectively, this can temporarily improve keyword rankings, increase organic visibility, and drive more traffic from search results.

Jasa Backlink

Download Anime Batch

View the video of this post here.

Managing your wealth involves much more than choosing investments.

Creative Planning brings financial planning, investment management, tax strategy, estate planning and insurance together under one roof, with a dedicated team focused on your unique goals.

At Creative Planning, we’re proud to help clients experience a richer way to wealth in all 50 states and abroad, with over $780 billion in assets under management and advisement. 

Click here to learn how our team at Creative Planning can help you today.

The most important charts and themes in markets and investing…

1) The Rate Hikes Are Coming

Kevin Warsh’s Jackson Hole speech was yet another reminder that he is not going to be the extremely dovish Fed chairman that President Trump was looking for.

Quite the opposite.

He reinforced the Fed’s 2% inflation target as a “firm, fixed target” and stated unequivocally that it was “the Fed’s job to deliver stable prices.”

Have they been delivering it?

Absolutely not, as Warsh plainly acknowledged in saying the Fed bears “responsibility for 65 months of sustained, elevated inflation.”

And unless they are confident that underlying inflation is moving back to 2% at “sufficient speed,” Warsh believes they “have work to do.”

Translation: the rate the hikes are coming. The market is now pricing in a 60% chance of a Fed hike at the September 16 meeting, with the odds going up to 70% by the October meeting and 85% by year-end.

Will the Fed stop after one hike?

That seems unlikely if they want to send the message that they are actually serious about fighting inflation. The 2-Year Treasury yield has been a pretty good leading indicator of the Fed Funds Rate over the last decade, and it currently sits at 0.74% higher than the Fed Funds Rate.

The bond market is currently pricing in 2-3 rate hikes over the next year, and with Fed set to update their projections for 2027 at the September meeting, that number could increase if the Fed raises their projections.

2) “Money Matters”

The US Money Supply (M2) increased by over $9 trillion during Jerome Powell’s tenure and there wasn’t a single mention by him on how that contributed to the 4% inflation we saw in the last 6 years under his leadership.

Which it was why it was encouraging to hear Kevin Warsh say the following at Jackson Hole:

“Money matters. It’s not fashionable these days, but my view is that money has something important to do with monetary policy. We should pay attention to money created by the central bank and money that comes from the banking and financial systems.”

What could the Fed do immediately?

End QE and stop expanding their balance sheet, a policy at odds with their stated desire to fight inflation.

After that, all of their mortgage bond holdings should be immediately sold and they should acknowledge the damage they caused: by artificially driving rates down to unnatural levels in 2020/2021, they artificially inflated home prices which effectively froze the housing market for a generation. Congress should pass a law to ensure the Fed is never again allowed to manipulate the mortgage market and engineer an affordability crisis.

3) The Iran War at 6 Months

We are now 6 months into the Iran war.

The impact on inflation has been felt by everyone around the world, with the prices of food and energy spiking since the start of the War.

In the US, we saw a painful new record for American drivers: for the first time in history, the national average price of gasoline was above $4.00/gallon every single day in August. And heading into Labor Day at $4.15 per gallon, this will be the highest level ever on the holiday (prior record was $3.82/gallon set in 2012).

So why was the stock market up 13% in the first 6 months of the war?

I’ll repost what I wrote at the start of the war and again at the 3-month mark…

The best we can say in studying past military conflicts is that with the passage of time, the stock market has tended to rise – and the more time that has passed, the more it has risen.

There’s two reasons for this: 1) all wars eventually come to an end, and 2) the economy and earnings, even if impaired in the short run, still tended to grow in the long run despite these conflicts.

4) Nvidia Caps off Historic Earnings Season

Once again, all eyes were on Nvidia when they reported earnings and once again, they didn’t disappoint.

In fact, this was the 16th straight quarter in which Nvidia surpassed analyst expectations. Which means that Wall Street has consistently underestimated its growth for four years.

The reason for that is simple: we’ve never in history seen a company grow this fast, and we may never see this type of exponential growth again in our lifetimes.

Nvidia Q2 revenues surged to a record $96 billion, up 106% over the prior year.

Their revenue projection for Q3 2026 is $108 billion, which would be an 89% YoY increase.

Net Income hit a record $59.7 billion, up 126% YoY.

And Nvidia’s net profit margin of 66% so far this year is another all-time high.

The AI capex boom has made Nvidia the largest company in the world, with a market cap of $5.6 trillion. That’s over $1 trillion more than the market cap of all the companies in Germany and Italy … combined.

As for the the S&P 500 as a whole, it was a historic quarter, with the biggest upside surprise in history (52% YoY earnings growth vs. 23% expected entering the quarter) and a new record high for net profit margins (17%).

At the start of the year, analysts were forecasting 15% earnings growth for the S&P 500 in 2026. The current project: a 34% increase, which would be unprecedented growth this far into an economic expansion (6 years).

And that’s it for this week. Thanks for reading!

Every week I do a video breaking down the most important charts and themes in markets and investing. Subscribe to our YouTube channel HERE for the latest content.

Disclaimer: All information provided is for educational purposes only and does not constitute investment, legal or tax advice, or an offer to buy or sell any security. Read our full disclosures here.

PakarPBN

A Private Blog Network (PBN) is a collection of websites that are controlled by a single individual or organization and used primarily to build backlinks to a “money site” in order to influence its ranking in search engines such as Google. The core idea behind a PBN is based on the importance of backlinks in Google’s ranking algorithm. Since Google views backlinks as signals of authority and trust, some website owners attempt to artificially create these signals through a controlled network of sites.

In a typical PBN setup, the owner acquires expired or aged domains that already have existing authority, backlinks, and history. These domains are rebuilt with new content and hosted separately, often using different IP addresses, hosting providers, themes, and ownership details to make them appear unrelated. Within the content published on these sites, links are strategically placed that point to the main website the owner wants to rank higher. By doing this, the owner attempts to pass link equity (also known as “link juice”) from the PBN sites to the target website.

The purpose of a PBN is to give the impression that the target website is naturally earning links from multiple independent sources. If done effectively, this can temporarily improve keyword rankings, increase organic visibility, and drive more traffic from search results.

Jasa Backlink

Download Anime Batch

The Case of the Self-Healing Device

The evidence board

• Apple’s Declarative Device Management (DDM) now extends to app deployment, letting devices detect and fix their own failed installs without a technician stepping in.
• Instead of a server repeatedly polling for status, the device compares itself against its own manifest and reports back the moment something changes.
• New Managed App Controls give admins auto-update, Wi-Fi-only or cellular-allowed installs, and lock/hide toggles, all from the same policy engine they already use.
• Auto Update set to “Always On” overrides the end user’s own device settings, so an app can’t drift out of date because of a personal preference.
• These capabilities require devices to be enrolled in DDM and running OS 26 or later; older devices keep working exactly as they do today.
• When a DDM declaration and a traditional MDM command conflict, the DDM declaration always wins.

Every IT administrator has had a similar case before. A policy pushes an app and somewhere between the command and the device, something goes wrong. Somewhere in transit, the trail goes cold: a dropped connection, a busy device, and the install never happens. No warnings or sirens, no whistles. The app is just not on the device and it sits quietly out of compliance until someone notices. It could be the end user filing a ticket, sending a chat, or an overworked IT admin noticing that some of the fleet is missing a critical app. However, it’s usually the user, so the IT admin has to reactively investigate in the console to see what happened.

Multiply that over thousands of devices in the fleet, with many different OS versions and apps and you don’t have a mystery anymore, you have a serious compliance drift which needs to be poked and prodded to get to the bottom of it. It’s a slow burn and nobody is watching, reactive IT detectives are on the case, hunting down the culprit to figure out why it’s not just “working” the way we asked. It’s not a detective movie, it’s 2026, and devices shouldn’t need a human standing over them to notice something’s wrong before they fix it.

NinjaOne has something new. Now the device can proactively solve its own case. It’s on the job.

The case for a new kind of detective work

To understand the change, you can look at how this process used to run.

Apple built Declarative Device Management (DDM) as an extension of the existing MDM protocol, not as a replacement. It works along with the device management that NinjaOne already does but the way it investigates is very different!

Previously, the “detective” was the MDM server. It would send a command, then poll the device. Over and over again. Asking and asking “Did it install?” “Did it install?” “What’s the status?” This is reactive behavior and creates heavy bandwidth over time with hundreds of devices. It’s an exhausting and unproductive process, occurring one check in at a time. With DDM, the device becomes the detective. It compares its own state to a manifest file and compares itself to what it should look like. If something doesn’t add up it picks up a dedicated “red phone” so to speak, and calls in along the dedicated status channel as soon as something changes to report to the MDM. Elementary, my dear Watson.

For apps, this means that the Apple DDM protocol is handling distribution and enforcement for every app that is defined in a NinjaOne policy on devices that support DDM. If the app install has failed, the device doesn’t wait. It’s on the case. The device reopens the files and tries again on its own. And if a traditional MDM command and a DDM declaration ever give conflicting instructions, there’s no ambiguity about who’s the senior detective on the case: the DDM declaration wins, every time.

The biggest break in the case, managed app controls

Every good detective story needs new tools, and this release hands the admins a few, including:

• Auto Update, so apps stay current without a technician pushing new versions. Set to “Always On,” it overrides even the end user’s own device settings, so the app can’t quietly slip out of date just because someone selected a personal preference.
• Wi-fi Only or Cellular-allowed installs will protect data plans on cellular devices
• Lock or Hide Toggles let the admin decide how much control end users have over managed apps.

The methods are simple. An admin sets the policy and configures these options. The device takes the case from there to reach the desired state. Failed installs will retry themselves, updates apply on schedule and compliance holds without anyone watching through a magnifying glass or checking in. If this section has a tagline, it’s that the device manages itself.

A quick note on requirements: these declarative capabilities require devices to be enrolled in DDM and running OS 26 or later. Devices on earlier versions keep working exactly as they do today, no disruption, they just don’t get the new self-healing behavior yet.

Three cases closed without a tech on the scene

Case 1 – The manual resync loop. Technicians used to be the entire detective office. Spot the out of compliance device, investigate the why, manually resync, hope it solves. Now the device wil catch its own failed install and retry, no follow up or prodding needed. The verdict: no manual resync required. This applies to new and modified app assignments going forward. Apps already installed before DDM was enabled still need a one-time policy resync to bring them under DDM management.

Case 2 – The app that never updates. The detective doesn’t have to remember or check in, Auto update keeps devices on the latest version as a matter of policy. That shrinks the window a device spends running outdated, potentially vulnerable software, and means fewer tickets that ask “Why is this still on an old version?” The verdict: fewer vulnerable devices, fewer tickets.

Case 3 – The MSP managing a dozen “crime” scenes at once. Every client environment has its own bandwidth reality. Wi-Fi-only installs protect cellular-connected devices from unusual data charges. Auto-retry keeps compliance consistent across every client without technicians canvasing the failed installs one-by-one or site-by-site. The verdict: consistent compliance, without the manual chase.

Where this all fits in the bigger investigation

These controls exist inside the same policy engine that admins already use for the rest of the Apple device management. No new console or workflows to learn. It’s one more bit of evidence pointing to the dotted line of where NinjaOne’s Apple management is leading, a model where devices increasingly investigate and resolve their own cases, and techs spend less time searching for clues about problems that already fixed themselves.

Case closed (for now)

Declarative Device Management doesn’t just push an app to a device and hope for the best. It hands the device a badge, a case file, and the authority to close its own investigations, no backup required.

App deployment is just the first case file. Stay tuned as Declarative Device Management opens more files across the Apple management experience.

Declarative Device Management available for NinjaOne MDM with the 15.0 Release.

PakarPBN

A Private Blog Network (PBN) is a collection of websites that are controlled by a single individual or organization and used primarily to build backlinks to a “money site” in order to influence its ranking in search engines such as Google. The core idea behind a PBN is based on the importance of backlinks in Google’s ranking algorithm. Since Google views backlinks as signals of authority and trust, some website owners attempt to artificially create these signals through a controlled network of sites.

In a typical PBN setup, the owner acquires expired or aged domains that already have existing authority, backlinks, and history. These domains are rebuilt with new content and hosted separately, often using different IP addresses, hosting providers, themes, and ownership details to make them appear unrelated. Within the content published on these sites, links are strategically placed that point to the main website the owner wants to rank higher. By doing this, the owner attempts to pass link equity (also known as “link juice”) from the PBN sites to the target website.

The purpose of a PBN is to give the impression that the target website is naturally earning links from multiple independent sources. If done effectively, this can temporarily improve keyword rankings, increase organic visibility, and drive more traffic from search results.

Jasa Backlink

Download Anime Batch

Going asynchronous sounds like a dream: decoupled processes, faster response times, and no more users staring at spinning wheels. But pretty quickly, reality hits — some messages take forever, others are way too important to be delayed, and suddenly you’re drowning in a swamp of priorities.

Whether you’re firing off password reset emails or triggering complex exports, you need to make sure the right messages get through at the right time. This article dives into the problems you’ll face — and how to solve them using Symfony Messenger, without rewriting your app from scratch or crying into your logs at 3 AM.

The problem: prioritize dynamically every message

When you start queueing messages in your Symfony app, one thing becomes obvious real fast: not all messages are equal. Some are critical and time-sensitive. Others… not so much.

Some transports already offer a way to handle priorities like:

🐰 RabbitMQ has x-priority

🌱 Beanstalkd has built-in tube priority

Nice — but what if I want to switch to another transport tomorrow without rewriting half my code?

Symfony Messenger has a way

The official documentation shows how to split messages into multiple transports based on priority. Think of it like assigning lanes on a highway: one for ambulances, one for scooters.

framework:
    messenger:
        transports:
            async_priority_high:
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
                options:
                    queue_name: high
            async_priority_medium:
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
                options:
                    queue_name: medium
            async_priority_low:
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
                options:
                    queue_name: low
            async_priority_very_low:
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
                options:
                    queue_name: very_low

        routing:
            'App\Message\ExportMessage': async_priority_low
            'App\Message\UpdateStateMessage': async_priority_high

💡 Note: The queue names are up to you — just make sure they reflect your actual use case. These are fictional examples.

Now that we’ve split messages by priority, consuming them in the right order is just as important. Thankfully, Symfony Messenger makes this super easy:

php bin/console messenger:consume async_priority_high async_priority_medium async_priority_low async_priority_very_low

The worker will first consume from async_priority_high. If it’s empty, it will try the next one. And so on. So even if there’s a backlog of non-urgent messages, high-priority ones don’t get stuck waiting behind them.

How do I choose the right queue?

This was honestly the trickiest part for me. There’s no one-size-fits-all formula, and this table is crucial — everything else in this article depends on it.

👉 It obviously needs to be filled with the client or the product owner and not just dev gut feelings.

The question you’re answering here is simple, but powerful:

“What’s the maximum acceptable delay (including queue time and actual handling) for each kind of message?”

And from there, you get your priority mapping:

Now that I’ve split the messages into queues, everything should be perfect, right?

Well… not quite.

🙃 One problem remains: message types can be too generic

Let’s say I have an EmailMessage. Sounds fine. But I might use it for:

• A password reset 🟥 High priority

• A delivery notification 🟨 Medium

• A “rate your purchase” ping 🟦 Low or very low

So… how do I assign a transport when the same message class can represent totally different levels of urgency?

Another problem : A message should be able to have more than one priority

Enter: TransportNamesStamp and our custom PriorityStamp

Luckily, Symfony Messenger already has a built-in way to force a message to go to a specific transport: TransportNamesStamp. But to make things cleaner (and more semantic), let’s introduce our own PriorityStamp:

namespace App\Messenger\Stamp;

use Symfony\Component\Messenger\Stamp\StampInterface;

readonly class PriorityStamp implements StampInterface
{
    public function __construct(private string $priority) {}

    public function getPriority(): string
    {
        return $this->priority;
    }
}

And now, a custom middleware to hook into the dispatch flow:

readonly class PriorityRoutingMiddleware implements MiddlewareInterface
{
    public function handle(Envelope $envelope, StackInterface $stack): Envelope
    {
        // Check if the message has a PriorityStamp
        $priorityStamp = $envelope->last(PriorityStamp::class);

        if ($priorityStamp instanceof PriorityStamp) {
            $priority = $priorityStamp->getPriority();

            // Determine the transport based on priority
            $transport = match ($priority) {
                'high' => 'high_priority',
                'medium' => 'medium_priority',
                'low' => 'low_priority',
                'very_low' => 'very_low_priority',
                default => throw new \RuntimeException('Unknow priority level')
            };

            // Add a TransportNamesStamp to redirect the message
            $envelope = $envelope->with(new TransportNamesStamp([$transport]));
        }

        return $stack->next()->handle($envelope, $stack);
    }
}

Then, don’t forget to add our new custom middleware to the messenger configuration:

framework:
    messenger:
      # ...
      buses:
        messenger.bus.default:
          middleware:
            - 'App\Messenger\Middleware\PriorityRoutingMiddleware'

Now, when sending a message, I can easily override its priority — no need to create a new message class or refactor everything.

$this->messageBus->dispatch(
    new SendEmailMessage($notificationEmail),
    [new PriorityStamp('medium')],
)

In this case, we’re saying:

“Hey, this email isn’t that urgent — 10 minutes is fine.”

This keeps critical messages flowing fast, without flooding your high-priority queue with lower-stakes noise.

So where are we now?

✅ I can dynamically choose the transport

✅ I can adjust the priority at dispatch time

❌ I can ensure every message is handled within its max allowed time ← Still not there yet.

So… what’s the problem now?

Let’s say I send a message to update the price of every product variant in my catalog — or a large subset.

Not a big deal if I’ve got a few product variants. But if I have 100,000 variants? 500,000 variants? A million ? And each one makes a remote API call to fetch the price?

Here what happens:

📨 A message enters the queue.

🧠 It starts processing.

⏳ It takes 5, 10, 30… 60 minutes.

🧵 Meanwhile, one PHP worker is stuck.

I could try to batch those API calls. Sure, that helps — but it only reduces the problem. It doesn’t solve it. Not in a way that truly scales.

And that’s a problem, even with all our beautiful prioritization logic — because long-running messages don’t play well in this model.

Last problem: Some messages take ages to be handled

Let’s say I have this message and corresponding handler in my project corresponding to the variant price update process:

readonly class UpdatePrices
{
    public function __construct(
        public array $filters,
    ) {
    }
}

#[AsMessageHandler]
readonly class UpdatePricesHandler
{
    public function __invoke(UpdatePrices $message): void
    {
        foreach ($this->productVariantRepository->findAllByRegex($message->filters) as $product) {
            $this->priceUpdater->updatePriceForVariant($variant);
        }
        
        $this->em->flush();
    }
}

Let’s be honest: the problem screams at us.

If 200,000 variants match this regex, and each update takes 0.1 second, that’s ~5 hours of processing in one go — way beyond our 1-hour limit.

To avoid jamming the queue, we’ll break this job into smaller messages. Let’s go to the extreme: one message = one variant update.

Keep the main message:

readonly class UpdatePrices
{
    public function __construct(
        public array $filters,
    ) {
    }
}

Add a unitary one:

readonly class UpdateVariantPrice
{
    public function __construct(
        public int $variantId,
    ) {
    }
}

Now change the handler to dispatch one message per variant:

public function __invoke(UpdatePrices $message): void
{
	foreach ($this->variantRepository->findByComplexQuery($message->filters) as $variant) {
        $this->messageBus->dispatch(new UpdateVariantPrice($product->getId()));
    }
}

Bonus: we can even plug in our dynamic priority logic:

public function __invoke(UpdatePrices $message): void
{
	foreach ($this->variantRepository->findByComplexQuery($message->filters) as $variant) {
    	if($variant->isSoldVeryOften()) {
        	$this->messageBus->dispatch(
            	new UpdateVariantPrice($variant->getId()),
            	[new PriorityStamp('medium')]
            );
        } else {
        	$this->messageBus->dispatch(new UpdateVariantPrice($variant->getId()));
        }
    }
}

And the new handler for the unitary message:

public function __invoke(UpdateVariantPrice $message): void
{
    $variant = $this->variantRepository->find($message->variantId);
    if (!$variant instanceof ProductVariant) {
        throw new UnrecoverableMessageHandlingException("Impossible to find the variant");
    }
    
    $this->priceUpdater->update($variant);
    $this->em->flush();
}

Sure, the total time may increase slightly, but the queue stays fluid. If a higher-priority message comes in, it’s picked up right away.

So what about now :

✅ I can dynamically choose the transport

✅ I can adjust the priority at dispatch time

❌ I can ensure every message is handled within its max allowed time ← Still not there yet.

…Wait. Nothing changed?

Let’s say I’ve sent:

Do we need to scale?

Probably. But that’s a topic for another article — others are way more qualified than me to go deep on scaling strategies.

Still, here’s my two cents:

• If you scale based on the number of pending messages, assign a weight per priority. (E.g. I count 1 high message as 1,200 very low ones.)

• It won’t be perfect at first. Monitoring is your friend.

• When downscaling, use hysteresis to avoid flapping between too many and too few workers.

Now we’re talking

Now I can finally say it, for real:

I am able to prioritize dynamically and ensure that every message is handled during a given time period.

Prioritization cheat sheet

You want your messages to be processed in time? Prioritize.

• Split your messages by priority: Define queues like high, medium, low, and very_low. Consume them in order.

• Route dynamically with a stamp: Using TransportNamesStamp or a custom one.

• Break big tasks into small ones: Don’t let a single message hog a worker for hours. Split it into smaller ones, and dispatch them.

In conclusion

Prioritizing messages in Symfony Messenger isn’t plug-and-play, but it’s not rocket science either. With a bit of planning, some custom code, and a mindset focused on time-to-handle (not just throughput), you can build a system where important things get done first — without choking the rest.

And once you’ve got that running? You’re not just dispatching messages anymore — you’re orchestrating flow.

PakarPBN

A Private Blog Network (PBN) is a collection of websites that are controlled by a single individual or organization and used primarily to build backlinks to a “money site” in order to influence its ranking in search engines such as Google. The core idea behind a PBN is based on the importance of backlinks in Google’s ranking algorithm. Since Google views backlinks as signals of authority and trust, some website owners attempt to artificially create these signals through a controlled network of sites.

In a typical PBN setup, the owner acquires expired or aged domains that already have existing authority, backlinks, and history. These domains are rebuilt with new content and hosted separately, often using different IP addresses, hosting providers, themes, and ownership details to make them appear unrelated. Within the content published on these sites, links are strategically placed that point to the main website the owner wants to rank higher. By doing this, the owner attempts to pass link equity (also known as “link juice”) from the PBN sites to the target website.

The purpose of a PBN is to give the impression that the target website is naturally earning links from multiple independent sources. If done effectively, this can temporarily improve keyword rankings, increase organic visibility, and drive more traffic from search results.

Jasa Backlink

Download Anime Batch

Many database (DB) queries rely on indexing, sorting, and temporary storage during query execution. These elements need to be well-aligned to ensure queries return results quickly and reduce unnecessary CPU, memory, and disk usage. For IT professionals managing production systems, understanding these metrics is a practical way to improve DB performance without needing to change the entire infrastructure.

Keep reading to learn more about how sorting, indexing, and temporary storage interact during database query execution, and how that should influence day-to-day decisions.

What role database indexing plays in query execution

Indexing is one of the main mechanisms that databases use to retrieve data efficiently. An index gives the database a faster path to the rows that it needs, as compared to reading through an entire table to find a specific entry.

Indexes function as lookup structures that help the database do several things:

• Quickly find records without scanning unrelated rows
• Cut down on the number of disk reads required
• Avoid some full table scans when a suitable index exists

When no index is available, the database must go through every single row in a table to find what it’s looking for, which can turn simple queries into slow and resource-heavy operations, especially for larger datasets.

How sorting affects performance

Databases constantly sort data to organize it into a specific order. This is a necessary operation when fulfilling an ORDER BY clause or grouping results for aggregation.

However, sorting is not a cheap operation, often putting strain on the system in a few key ways:

• It draws heavily on CPU and memory resources during execution.
• Processing time increases noticeably as the dataset size grows larger.
• Large sorts that exceed available memory spill over to disk, adding storage overhead.

However, sorting can be avoided if the data is already stored in the order a query needs, which makes index design and query patterns worth aligning early on.

When temporary storage is used

Temporary storage is used when query operations exceed available memory. In these situations, the database may move intermediate processing tasks to disk, which can increase query execution time.

Some common situations that push queries into temporary storage include:

• Sorting datasets that are too large to process in memory
• Running joins on tables that lack the right indexes
• Managing intermediate results as a query works through multiple stages

Once temporary storage kicks in, performance declines, usually resulting in:

• A shift from fast memory reads to slower disk operations
• Increased overall query execution time
• Rising I/O activity that puts additional load on the system

For these reasons, heavy reliance on temporary storage is generally considered a costly operation because it increases query execution time.

How indexing helps in improving the performance of a query

A well-designed index can reduce the need for additional sorting and lower the use of temporary storage in some queries. When indexes are designed around common query patterns, the database may be able to return results in the required order with less additional processing.

This alignment offers performance gains in the following ways:

• Data comes back in sorted order because the index already stores it that way.
• Queries can pull results directly without additional processing steps.
• CPU and memory usage drop because the database isn’t doing redundant work.

Therefore, when an index already reflects the order a query needs, the database can return results directly without extra sorting or disk spillover.

Tradeoffs between indexing, sorting, and storage

Note that improving the performance of a database is not as easy as simply adding more indexes or allocating more memory, as adjustments in one area tend to shift the burden somewhere else. It’s important to know where displaced pressures will land to ensure thoughtful optimization.

Keep in mind these common tradeoffs:

• Adding indexes makes reads faster, but introduces overhead on every write operation.
• Removing indexes frees up storage, but pushes more work onto sorting during query execution.
• Leaning on sorting to compensate for missing indexes drives up memory consumption and risks spilling to disk.

Indexes are really useful for query speed, but each one requires storage space and has to be maintained properly whenever data is inserted, updated, or deleted.

Common performance issues caused by imbalance

When the three processes aren’t in sync, performance problems can appear over time as query patterns change or data volumes grow beyond system capacity.

Some of the most commonly found issues include:

• Sorting overhead that accumulates when key indexes are missing
• Gradually increasing disk usage as queries rely more and more on temporary storage
• Write performance that degrades when too many indexes have to be updated with each transaction
• Query plans that become inefficient as the database struggles to find a clean execution path

Left unaddressed, these issues can start small but will eventually affect the broader system, especially under load.

How to approach optimization decisions

Not every database works the same way, so optimization decisions must always be grounded in how the system is being used. This means looking at workload patterns before making any changes.

Consider these factors that should inform those decisions:

• How often reads occur relative to writes, since this affects how aggressively you should index
• What query patterns and filtering conditions look like, since indexes need to match how data is actually being queried
• How large the dataset is and how fast it’s growing, since strategies that work today might not hold up a few months later
• What memory and storage resources are available, since these set the limit on what’s feasible without additional infrastructure

Getting this balance right requires some upfront analysis, but it pays off in the long run by solving problems without creating new ones.

How to improve the performance of database systems through smarter query design

Sorting, indexing, and temporary storage each have a distinct role in how a database handles query execution, but they all work together to make the process work. What database administrators must monitor is how these factors interact, which determines if the system runs efficiently or not. Remember, the goal is not to eliminate tradeoffs, but to understand them well enough to make deliberate decisions for building a database environment that holds up as demands grow.

Related topics:

PakarPBN

A Private Blog Network (PBN) is a collection of websites that are controlled by a single individual or organization and used primarily to build backlinks to a “money site” in order to influence its ranking in search engines such as Google. The core idea behind a PBN is based on the importance of backlinks in Google’s ranking algorithm. Since Google views backlinks as signals of authority and trust, some website owners attempt to artificially create these signals through a controlled network of sites.

In a typical PBN setup, the owner acquires expired or aged domains that already have existing authority, backlinks, and history. These domains are rebuilt with new content and hosted separately, often using different IP addresses, hosting providers, themes, and ownership details to make them appear unrelated. Within the content published on these sites, links are strategically placed that point to the main website the owner wants to rank higher. By doing this, the owner attempts to pass link equity (also known as “link juice”) from the PBN sites to the target website.

The purpose of a PBN is to give the impression that the target website is naturally earning links from multiple independent sources. If done effectively, this can temporarily improve keyword rankings, increase organic visibility, and drive more traffic from search results.

Jasa Backlink

Download Anime Batch

PakarPBN

A Private Blog Network (PBN) is a collection of websites that are controlled by a single individual or organization and used primarily to build backlinks to a “money site” in order to influence its ranking in search engines such as Google. The core idea behind a PBN is based on the importance of backlinks in Google’s ranking algorithm. Since Google views backlinks as signals of authority and trust, some website owners attempt to artificially create these signals through a controlled network of sites.

In a typical PBN setup, the owner acquires expired or aged domains that already have existing authority, backlinks, and history. These domains are rebuilt with new content and hosted separately, often using different IP addresses, hosting providers, themes, and ownership details to make them appear unrelated. Within the content published on these sites, links are strategically placed that point to the main website the owner wants to rank higher. By doing this, the owner attempts to pass link equity (also known as “link juice”) from the PBN sites to the target website.

The purpose of a PBN is to give the impression that the target website is naturally earning links from multiple independent sources. If done effectively, this can temporarily improve keyword rankings, increase organic visibility, and drive more traffic from search results.

Jasa Backlink

Download Anime Batch

Most conversations about NinjaOne center around what technicians can do. The end user portal flips that. It’s a dedicated, self-service space for the people using the devices you manage, giving them direct access to their own devices, tickets, files, and shared content, all scoped to exactly what you allow.

What the end user portal is

The end user portal is a separate login experience built for the people using the devices you manage. Once an end user has an account, they log into the NinjaOne instance through a browser, or through the NinjaOne Assist mobile app, and see a list of devices they have access to along with each device’s status.

Getting a user into the portal starts with creating an account for them and granting them access to specific devices, which is a separate action from making them the device owner. You can add as many devices as needed to a user’s access list, and multiple users can be granted access to the same device.

Access itself is governed by roles, the same permission structure technicians use. You decide what a given role can see and do, and if a user belongs to multiple roles, NinjaOne applies the highest level of access across all of them. A user in a role without remote access permissions who’s also in a role that grants them remote access will end up with remote access, not the more restrictive setting.

Users only get what’s explicitly turned on for their role, regardless of whether they log in through a browser or through NinjaOne Assist.

What end users can do

Remote access to their own devices:
Once granted access, end users can connect to their devices using whichever remote access tool you’ve enabled for that operating system. No waiting on a technician to remote in for something they could do themselves.

Across Windows, macOS, and Linux, NinjaOne supports multiple connection types, and you decide which ones a given role can use:

• NinjaOne Remote – a full remote control session
• User command line – a terminal session running in the context of the logged-in-user
• System command line – a terminal session running with system-level privileges

Since these are set per role and per operating system, you can be as narrow or as broad as needed. A general staff role might only get NinjaOne Remote, while a more technical role, like an internal developer, might also get command line access.

Submit and track tickets with NinjaOne Ticketing:
Users can create, update, and respond to NinjaOne tickets straight from the portal. You control what forms they see, and within those forms, you can control whether any fields are required to submit, ensuring you get the information needed on initial submission.

By default, users can only see the tickets they personally submitted. With ticketing permissions, you can also grant organization-wide access, giving visibility into every ticket tied to their organization, regardless of who reported it. That’s useful for someone like an office manager or department lead who needs to track every open request across their location, not just the ones they personally filed.

Restore their own backups:
If backup is enabled and the permission is granted, users can open the backup manager, browse through completed backup plans for their device, and download the files or folders they need. No ticket required to get a file back.

This is one of the more overlooked self-service wins. A user who accidentally deletes a file or overwrites something usually files a ticket, waits for the technician to pick it up, and waits again for the restore. Giving them direct access to their own backup history turns that into something they resolve in a couple of minutes on their own, without anyone on your team touching it.

Access shared documentation:
Folders can be shared directly with end user roles from the system dashboard, giving users a place to find setup guides, policies and procedures, or reference material without asking IT where to look.

When you share a folder, you can choose to make it available to all end-user roles or scope it to specific ones, and you can display the folder’s contents directly rather than requiring users to click into it. This is useful if you’re sharing multiple folders at once and want to keep things organized. Shared folders also show on the End User Roles tab inside the documentation app’s configuration page, giving you a central place to see and manage what’s been shared with whom.

This can be found by navigating to Administration > Apps > Documentation > End User Roles.

Note that this sharing option is only available from the system dashboard.

Wake devices remotely:
End users can use Wake-on-LAN to bring a sleeping device back online, as long as it’s connected to the same network as another online device.

Extending access with the NinjaOne Assist mobile app

For end users who split their time between office and remote work, or who just need to check a device while away from a desktop, NinjaOne Assist removes the dependency on being at a specific computer to get help or get connected. It’s the same self-service access as the portal: connect to a device, check details and status, submit and update tickets, all from a phone or mobile device with access to the iOS App Store or Google Play Store.

The app carries over the same role-based permissions as the browser portal. A user doesn’t gain broader access by switching to mobile, and they don’t lose functionality either. If their role has NinjaOne Remote enabled, they can launch a remote session from their phone. It’s the same experience, just built for a smaller screen and a different context.

That consistency matters for deployment. You’re not managing two separate permission sets or explaining two different tools to your users, mobile is just another way in. For distributed teams, field staff, or anyone more likely to notice a device problem away from their desk than at it, that matters.

Keeping accounts accurate with SCIM

Manually creating end user accounts works fine for a handful of users. It falls apart fast once you’re managing dozens or hundreds of them, whether that’s across departments in a single company or across multiple client organizations.

Syncing NinjaOne with Microsoft Entra ID (or another IDP) through SCIM solves that. You set up user roles in Entra ID, map them to groups, and NinjaOne provisions the matching end user and technician accounts automatically as those groups change. Add someone to the right group in Entra ID and they show up in NinjaOne with the correct role and organization already assigned. Remove them, and their access goes with it.

For internal IT, this is usually simple since most users sit in a single organization, sometimes split by department. For MSPs, it’s the mechanism that keeps each client’s users mapped to the right organization automatically. Either way, each synced user needs an OrganizationID attribute so NinjaOne knows where they belong, and for users who need access across every organization, that attribute can be set to “All.”

The result is an end user provisioning process that scales with your environment instead of adding a manual step every time someone joins, changes roles, or leaves.

The end user journey

It’s worth walking through what this looks like from the end user’s side, since that’s usually the part that’s hardest to picture from the admin view.

Getting an account:
An end user’s account gets created one of two ways: manually, when you add them and grant device access yourself, or automatically, when they’re synced in through Entra ID or another SCIM-supported identity provider. Either way, the user doesn’t do anything to trigger this step. It happens on your side.

Getting invited:
Once the account exists, a manually created user receives an email invitation to set up their login. A user created through a SCIM sync doesn’t receive an invite email, but can still navigate to the portal and log in directly.

Visibility in the portal:
Once logged in, the user sees a straightforward list of devices they have access to, along with each device’s current status. No admin panels, no unrelated organization data, just what’s relevant to them that you allowed.

Taking action:
From there, whatever’s turned on for their role is available directly: connecting to a device, submitting or checking a ticket, pulling a file from a backup, browsing shared documentation, or waking a sleeping device. All of it happens without a support request, and all of it stays inside the boundaries you’ve set for that role.

Why this matters

Without a sanctioned self-service option, users find their own way around IT anyway. They install their own remote access tools, email files to themselves instead of restoring from backup, or ask a coworker for help instead of opening a ticket. None of that is logged, none of it is controlled, and none of it is visible to you until something goes wrong. The end user portal gives users a legitimate channel for the things they’re going to try to do regardless, and keeps every action inside a system you control.

Paired with IDP sync, it also removes the administrative overhead of keeping end user accounts current by hand. Access follows your identity provider, roles stay accurate, and your team spends less time on account management and more time on the work only they can do.

PakarPBN

A Private Blog Network (PBN) is a collection of websites that are controlled by a single individual or organization and used primarily to build backlinks to a “money site” in order to influence its ranking in search engines such as Google. The core idea behind a PBN is based on the importance of backlinks in Google’s ranking algorithm. Since Google views backlinks as signals of authority and trust, some website owners attempt to artificially create these signals through a controlled network of sites.

In a typical PBN setup, the owner acquires expired or aged domains that already have existing authority, backlinks, and history. These domains are rebuilt with new content and hosted separately, often using different IP addresses, hosting providers, themes, and ownership details to make them appear unrelated. Within the content published on these sites, links are strategically placed that point to the main website the owner wants to rank higher. By doing this, the owner attempts to pass link equity (also known as “link juice”) from the PBN sites to the target website.

The purpose of a PBN is to give the impression that the target website is naturally earning links from multiple independent sources. If done effectively, this can temporarily improve keyword rankings, increase organic visibility, and drive more traffic from search results.

Jasa Backlink

Download Anime Batch

Artificial intelligence is all over the news. Last month, France hosted the AI Action Summit, where leaders from around the world met to discuss the challenges of the technology.

SensioLabs didn’t wait long to ask about how to apply artificial intelligence in Symfony development projects. Did you know that it is possible to integrate AI into Symfony?

Talking Symfony and AI

On October 3rd, Symfony and AI converged on the rooftops of Paris for an exclusive event at Morning Laffitte, near the Opéra Garnier.

We had some fascinating conversations about these two technologies and their challenges, with Nicolas Grekas, Principal Core Team Member for Symfony, the team from our partner Codéin, and OPPBTP, the professional prevention organization for the building and public works sector. OPPBTP has used artificial intelligence in a Symfony-based development project.

We covered a few topics during the evening:

• The latest features in Symfony 7.2 to optimize developer experience.

• Tips for optimizing AI integration in your Symfony projects.

• Using AI to extract data from a Symfony application with a Python script and ChatGPT.

Using AI in a Symfony application raises some key questions about data, its confidentiality, and how it will be managed by the framework. On top of that, there is also the question of interoperability of AI models, as several competing models are under development right now.

It was also a chance to learn that Symfony and AI can be used to develop very specific projects for enterprise applications. Like here for OPPBTP with info on chemical products to improve accident prevention in the building and construction sector.

Watch the full video of the event

A lot of you asked on social media if the event was filmed. We’re happy to share the video with you on our YouTube channel. If you missed the event, you can now watch it again in its entirety in a high-quality, subtitled video in French.

Here is the URL to go to the video, or you can just click on the image below: https://youtu.be/b-shilFNkI8. You can add automatic English subtitles directly on Youtube.

The video is about an hour long and includes speeches by Nicolas Grekas, Damien Piquet (the head of OPPBTP’s Digital Factory), Nicolas Fernandez (PHP/Symfony Lead Developer), and Romain Bonnal (Associate Director of Codéin).

We hope the video answers some of the questions you may have about Symfony and AI.

If you are thinking about using artificial intelligence with your Symfony or PHP application, our team would love to hear about it. As the creator of Symfony, we are closely watching community projects related to this technology. We would be happy to share our knowledge.

PakarPBN

A Private Blog Network (PBN) is a collection of websites that are controlled by a single individual or organization and used primarily to build backlinks to a “money site” in order to influence its ranking in search engines such as Google. The core idea behind a PBN is based on the importance of backlinks in Google’s ranking algorithm. Since Google views backlinks as signals of authority and trust, some website owners attempt to artificially create these signals through a controlled network of sites.

In a typical PBN setup, the owner acquires expired or aged domains that already have existing authority, backlinks, and history. These domains are rebuilt with new content and hosted separately, often using different IP addresses, hosting providers, themes, and ownership details to make them appear unrelated. Within the content published on these sites, links are strategically placed that point to the main website the owner wants to rank higher. By doing this, the owner attempts to pass link equity (also known as “link juice”) from the PBN sites to the target website.

The purpose of a PBN is to give the impression that the target website is naturally earning links from multiple independent sources. If done effectively, this can temporarily improve keyword rankings, increase organic visibility, and drive more traffic from search results.

Jasa Backlink

Download Anime Batch

View the video of this post here.

Enjoying this newsletter?

Don’t miss the next one.

Subscribe to The Week in Charts Here to get it directly in your inbox.

The most important charts and themes in markets and investing…

1) Moving One Step Closer to a Debt Crisis

The US National Debt is now $40 trillion.

How did we get here?

Washington’s solution to every problem remains the same:

Borrow more. Spend more. Let our children and grandchildren deal with the consequences.

There is simply no fiscal discipline in sight. Unfortunately, it will take a crisis before anything changes.

2) A Desperate Attempt at Financial Repression

As the National Debt hit $40 trillion, long-term government bond yields hit their highest level since June 2007, with the 30-year rising above 5.3%.

The very next day, the Treasury announced that it would be doubling the size of their “debt buybacks” to $4 billion. But this is not a debt reduction, just a debt reshuffling, with the Treasury buying longer-dated bonds and issuing more shorter-dated bills.

When yields barely budged, they announced that they would consider tapping the $1 trillion General Account in an attempt to suppress bond yields.

So instead of cutting spending and reducing deficits – which would actually be a long-term solution to the problem – they are resorting to financial engineering.

Step 1: Create the problem.

Step 2: Refuse to fix the problem.

Step 3: Manipulate the market to hide the problem.

Will this help bring long-term bond yields down?

Perhaps in the short run, if they throw enough money at it.

But as Stan Druckenmiller said:

“Governments defending prices against fundamentals always lose. The only variable is how much they spend before conceding.”

3) The “Debasement Trade” Is Back

Immediately after the Treasury buyback announcement, we saw a resurgence in the so-called “debasement trade.”

Bitcoin spiked 19%, Gold rallied 6%, and the US Dollar fell 1%.

Washington won’t get its fiscal house in order, so investors are buying alternatives to the Dollar.

4) The Housing Market Still Has an Affordability Problem

10 years ago, the 30-year mortgage rate was 3.4% and the median existing home price in the U.S. was $243k.

Today, the 30-year mortgage rate is 6.7% and the median existing home price is $434k.

The result: a $38k increase in the required down payment (assuming 20% down) and 160% increase in the monthly mortgage payment (from $862 to $2,240).

Needless to say, incomes are not up anywhere near 160% in the past decade, leading to a collapse in affordability.

The good news: supply is slowly coming back to the market. There are now over 1.1 million homes for sale in the US, the highest inventory since 2019.

5) The Most Overpriced Product in America?

Here’s an absolutely insane stat: 15 U.S. colleges now cost more than $100,000 per year…

That’s $400,000+ for a four-year degree.

Most students are not getting anywhere near $400,000 worth of value from these schools.

Which means that higher education may be the most overpriced product in America, and one that is ripe for disruption.

Over the last 40 years, College Tuition and Fees in the US have increased by 655% (7.5x) while overall Consumer Prices (US CPI) are up 204% (3x).

The next 40 years will likely look very different given economics, changing demographics, and technological forces. More and more students are questioning the value they are getting and enrollment is expected to drop 13% by 2041 due to a projected decline in the number of 18-year-olds.

With the advent of AI, the cost of delivering a high-quality education should fall dramatically. How quickly colleges will pass those savings on to students is another question, but the current trend is not sustainable.

6) The Off-Balance Sheet Surge

Big Tech’s AI spending spree is much bigger than it looks.

Nine major tech companies have roughly $3 trillion in off-balance-sheet commitments, far above reported capex ($600 billion).

The AI arms race is creating enormous obligations investors may be underestimating.

When Nvidia reports earnings this week, a bigger focus will be placed on those obligations. Nvidia is increasingly tying its own fortunes to those of its customers. Rather than simply selling its chips and letting demand stand on its own, the company is helping to finance, backstop, and guarantee the very investments driving that demand.

7) A Few Interesting Stats…

a) The total amount wagered on sports in the US has increased by 25x over the past 7 years.

Related: More than half of Gen Z investors redirected investing dollars into sports betting over the last year. And 26% now consider betting part of their long-term financial strategy.

b) Self-driving taxi company Waymo is now doing over 1.4 million rides per month in California, a 10x increase over the past two years.

c) 25 years ago Walmart’s revenue was 68x larger than Amazon. Today, Amazon has surpassed Walmart to become the largest company by revenue in the world.

d) 55 million Americans (15% of the population) are projected to be on GLP-1 weight loss drugs by 2035. The biggest beneficiary of this trend: Eli Lilly ($LLY), who’s market cap has grown from $88 billion to $1.2 trillion over the last decade.

And that’s it for this week. Thanks for reading!

Every week I do a video breaking down the most important charts and themes in markets and investing. Subscribe to our YouTube channel HERE for the latest content.

Disclaimer: All information provided is for educational purposes only and does not constitute investment, legal or tax advice, or an offer to buy or sell any security. Read our full disclosures here.

PakarPBN

A Private Blog Network (PBN) is a collection of websites that are controlled by a single individual or organization and used primarily to build backlinks to a “money site” in order to influence its ranking in search engines such as Google. The core idea behind a PBN is based on the importance of backlinks in Google’s ranking algorithm. Since Google views backlinks as signals of authority and trust, some website owners attempt to artificially create these signals through a controlled network of sites.

In a typical PBN setup, the owner acquires expired or aged domains that already have existing authority, backlinks, and history. These domains are rebuilt with new content and hosted separately, often using different IP addresses, hosting providers, themes, and ownership details to make them appear unrelated. Within the content published on these sites, links are strategically placed that point to the main website the owner wants to rank higher. By doing this, the owner attempts to pass link equity (also known as “link juice”) from the PBN sites to the target website.

The purpose of a PBN is to give the impression that the target website is naturally earning links from multiple independent sources. If done effectively, this can temporarily improve keyword rankings, increase organic visibility, and drive more traffic from search results.

Jasa Backlink

Download Anime Batch

Port 445 supports Server Message Block (SMB), which lets users share files, printers, and other device resources. This port can create potential risks if left open on a public network. This guide provides a vendor-neutral framework on how MSPs can safely block or scope TCP 445 port number in Windows.

How can I secure Port 445: A step-by-step guide

Although blocking TCP 445 seems like a logical solution, doing so can disrupt domain operations, file transfers, and critical management workflows. The steps below outline how IT administrators can mitigate risks associated with TCP 445 without causing operational disruptions.

📌 Prerequisites: The following items allow the steps below to be done more efficiently:

• Inventory of SMB-dependent services and hosts
• Change the window and pilot ring selection
• Ability to deploy Windows Defender Firewall or equivalent rules via GPO or MDM
• Centralized logging for firewall events and authentication failures

Step 1: Identify where SMB is required

Server Message Block (SMB) is a network communication protocol that allows computers to share files, printers, serial ports, and other resources over a network. Knowing where SMB is required, and what legitimate SMB pathways are inside your organization is the first step to reducing risks associated with TCP 445.

This first step involves:

• Identifying file servers, domain controllers, print servers, and admin shares that must remain reachable.
• Mapping client groups that legitimately access those servers.
• Noting remote access use cases and alternatives such as VPN, SMB over QUIC, or file gateways.

Step 2: Block TCP 445 at the perimeter and untrusted zones

Blocking TCP 445 for untrusted zones is crucial, as it reduces exposure to cyber threats. Additionally, it is essential to ensure that SMB traffic is never exposed to the internet edge to prevent internet-borne SMB attacks.

Some ways you can secure TCP 445 in such zones include:

Perimeter blocks

Apply inbound and outbound 445 blocking at the firewall or cloud edge to eliminate internet-borne threats such as scanners, exploits, and ransomware payloads.

Segmentation protections

Untrusted or unmanaged segments—such as guest Wi-Fi, IoT sensors, and BYOD devices—should be prevented from communicating with corporate SMB services.

Remote user protection

Ensure remote endpoints do not accidentally publish 445 on home or public networks. Enforce host firewall rules to block inbound SMB unless on a trusted domain network.

Step 3: Scope internal access with least privilege

Limiting internal access for users reduces internal traffic, thereby containing lateral movement. By establishing internal access protocols based on privilege, IT admins can ensure that only approved SMB flows are successful.

Some ways to do this include:

• Creating Windows firewall rules that allow 445 only between approved client subnets and approved SMB hosts
• Choosing group-based policy targeting for exceptions and maintaining an explicit allowlist
• Denying all other 445 traffic within the LAN and inter-site links

Step 4: Harden SMB before and after blocking

Hardening your SMB is an essential step in safely blocking or scoping TCP port 445. In fact, for most organizations, it should be a part of a defense-in-depth strategy. This step enhances SMB protocol security, ensuring fewer successful authentication and relay attempts, even on blocked paths.

Some practices you can incorporate include:

• Disabling SMB1 on all systems
• Requiring SMB signing by default
• Reviewing controller and file server settings
• Using SMB over QUIC for remote scenarios to avoid exposing 445 across networks

Step 5: Deploy rules via GPO or MDM

The previous steps focused on enhancing security; this step tackles deployment across the different endpoints on your network. Deploying such changes via GPO or MDM allows IT admins to roll out new policies in a safe and reversible manner. In addition, rolling out changes via GPO or MDM can help detect unintended breakage more quickly and remediate it more efficiently.

Some best practices include:

• Piloting with a small ring and enabling verbose firewall logging
• Rolling out inbound and outbound rules with clear precedence and documentation
• Keeping a tested rollback script to remove or relax rules quickly if needed

Step 6: Verify and monitor your changes

Updates to your environment should always be documented, verifiable, and monitored. This step allows IT admins to verify that the changes made work as intended and are not disruptive to critical workflows.

During this phase, the following practices should be done:

• Testing network reachability with Test-NetConnection -ComputerName <server> -Port 445
• Validating file share access, GPO processing, and authentication, where applicable
• Reviewing firewall logs for denials, especially if these correlate with help desk tickets
• Adjusting allow lists as needed based on observed data

Step 7: Govern exceptions and lifecycles

Finally, maintaining governance ensures adequate control over SMB protocols and prevents the growth of uncontrolled exceptions that can weaken security over time.

This is an ongoing step, similar to monitoring, and involves:

• Keeping records of the owner, reason, and expiry for each 445 exception
• Reviewing exceptions consistently (usually on a monthly basis) and removing or tightening security where possible and necessary
• Adding necessary control to your hardening baseline and auditing it in quarterly checks

Integrating NinjaOne with your SMB protocols

With NinjaOne, IT admins can help you manage your IT infrastructure strategically. Some ways you can incorporate into your security strategy include:

Firewall rule deployment

NinjaOne allows you to create and enforce firewall rules, scope and block specific TCP ports, and automate security configurations efficiently across your entire network.

Comprehensive logging

With the platform, IT admins can collect detailed authentication and security logs, track SMB protocol usage, and identify potential security events. In addition, NinjaOne’s reporting feature enables IT admins to generate comprehensive exception reports for monthly client reviews.

Proactive monitoring

Stay ahead of the game with proactive monitoring protocols. These allow you to detect and alert on SMB1 presence and automatically trigger the appropriate remediation scripts (available on NinjaOne). Layered with your other security measures, these features can help ensure that your network remains secure despite risks.

Protect your network with safety measures for TCP 445

Blocking or tightly scoping TCP 445 meaningfully reduces SMB risk when done with discovery, staged deployment, and ongoing verification. Pair network controls with SMB hardening and disciplined exception management for durable protection.

Related topics:

PakarPBN

A Private Blog Network (PBN) is a collection of websites that are controlled by a single individual or organization and used primarily to build backlinks to a “money site” in order to influence its ranking in search engines such as Google. The core idea behind a PBN is based on the importance of backlinks in Google’s ranking algorithm. Since Google views backlinks as signals of authority and trust, some website owners attempt to artificially create these signals through a controlled network of sites.

In a typical PBN setup, the owner acquires expired or aged domains that already have existing authority, backlinks, and history. These domains are rebuilt with new content and hosted separately, often using different IP addresses, hosting providers, themes, and ownership details to make them appear unrelated. Within the content published on these sites, links are strategically placed that point to the main website the owner wants to rank higher. By doing this, the owner attempts to pass link equity (also known as “link juice”) from the PBN sites to the target website.

The purpose of a PBN is to give the impression that the target website is naturally earning links from multiple independent sources. If done effectively, this can temporarily improve keyword rankings, increase organic visibility, and drive more traffic from search results.

Jasa Backlink

Download Anime Batch