rss.livelink.threads-in-node

Microsoft Edge on Android shows blocked sites on my son's phone

paul_moloney — Sat, 12 Sep 2026 15:41:33 GMT

I've set up my son's laptop with Edge and have blocked sites such as Youtube via Family Safety. I can verify that on the laptop.

On his Android phone, I have:

* Installed Family Safety and logged his account into it.
* Turned off batter optimisation for the app.
* Installed Edge, and logged him in with his account, the same account as on the laptop.

However, it allows him to see Youtube.

When I check Family Safety online, I can see under Mobile that it sees the phone and is tracking the amount of screen time he is using. However, the Edge settings are not being applied to Edge on the phone.

Expanding model choice in Copilot with Grok

xiasong — Sat, 12 Sep 2026 15:00:30 GMT

Today we are expanding model choice in Copilot with the addition of Grok models from SpaceXAI¹. This continues our commitment to bring the latest AI innovation in the industry to Copilot, tuned for work and tailored to business needs.

Adding SpaceXAI as a subprocessor

To support access to SpaceXAI models in Copilot, SpaceXAI has been added to Microsoft's Online Services Subprocessor List. Access to SpaceXAI models is managed through a dedicated administrative setting that is disabled by default.

Organizations that want to use these models enable the setting first, and administrators keep transparency and control over the data processed by SpaceXAI models in supported Copilot experiences.

Access to Grok models is rolling out through the Microsoft Frontier Program in Microsoft Word, Excel, and PowerPoint. We are starting with a focused release to gather customer feedback and learn how customers use the model across common productivity scenarios.

Grok is not available to Frontier customers in the European Union (EU), European Free Trade Association (EFTA), and the United Kingdom during the preview.

Expanding based on customer feedback and usage

Our multi-model strategy gives customers access to leading AI models while maintaining the trusted Copilot experience, and what we learn in the public preview shapes what comes next. We will evaluate customer feedback, usage patterns, and product fit before broadening model availability across additional Copilot experiences and surfaces.

Before models are made available to customers, Microsoft evaluates them through testing, safety validation, and Responsible AI reviews.

¹ Grok is the model family from SpaceXAI available as a preview to eligible Frontier customers.

PST Export New Functionality in New Outlook For Windows

Teresa_Cyrus — Sat, 12 Sep 2026 13:46:54 GMT

New Outlook for Windows PST Export has received a useful update.

You can now choose between:

Export Copy to PST (the standard method)
Export Move to PST (new)

Export Copy to PST is the method we already had. The exported items remain in the mailbox unless you delete them manually.

Export Move to PST is different. It exports the items, then automatically moves the originals to the Deleted Items folder.

The two options serve different purposes, especially when deciding whether you are creating a backup or archiving content you no longer want to keep in the mailbox.

I created a short walkthrough showing the Export PST Move vs. Copy process, Deleted Items behavior, and when to use each option.

👉🏾Watch Video: New Outlook: Move to PST vs Copy to PST — What's New & When to Use It

If you use PST files in New Outlook for Windows, I’d be interested in hearing which option you expect to use most: Export Move to PST or Export Copy to PST?

For the full PST Export process,
- Watch this video: New Outlook PST Export: What You Need to Know in 2026

- Read this blog: How to Export Mailbox to PST from New Outlook (Complete Guide)

If this post was helpful, please like it to assist others.

traccreations4e-p26 9/12/2026

Our experience migrating from Exchange Server to Microsoft 365

KastroMoff — Sat, 12 Sep 2026 12:32:16 GMT

We recently performed a migration from an on-premises Exchange Server to Microsoft 365. Our goal was to transfer mailbox data while minimizing disruption to users.

Before starting, we reviewed the source mailboxes, Microsoft 365 accounts, permissions, network availability and mailbox mapping. We then migrated a few test mailboxes to confirm the connection and verify emails, calendars, contacts and folder structures.

For this migration, we used EdbMails Exchange Migration to connect the source and destination environments, map mailboxes and perform the migration in stages.

Most historical data was transferred during the initial migration while users continued working. Before the final cutover, we ran an incremental migration to transfer newly received and modified items.

After migration, we checked:

Emails, folders, calendars and contacts
Recent and sent messages
Archive and shared mailboxes
Item counts and migration logs
Mail flow after the DNS changes

Overall, the staged approach made the migration easier to manage and reduced the amount of work required during the final cutover.

Our main lessons were:

Always begin with a pilot migration.
Verify permissions and mailbox mapping early.
Run an incremental migration before cutover.
Validate the migrated data before retiring the source server.

The migration was completed successfully, and the structured approach helped us maintain data integrity while keeping disruption to users to a minimum.

Windows Server 2022 Datacenter Azure Edition: unable create a ODBC source

LorenzoSoncini — Sat, 12 Sep 2026 05:25:41 GMT

I need create a ODBC datasource on the server for a IIS web site.

Using the ODBC Data Sources (64-bit) don't have any error but DSN is not create.

If I use powershell the same problem (and no error):

Thanks for any help

Lessons Learned #554: I Have Used BCP for Years — But How Does It Actually Work?

Jose_Manuel_Jurado — Sat, 12 Sep 2026 05:14:19 GMT

BCP is one of those SQL Server tools that many of us have been using for years. It is simple, reliable, and extremely fast when we need to move large amounts of data. We execute it, and millions of rows can be loaded into SQL Server or Azure SQL Database.

But after using BCP many times, I had a question that stayed in my mind: Why is BCP so fast?

And that question led me to another one: What does BCP actually send to SQL Server? Is it simply executing thousands or millions of INSERT statements behind the scenes? And finally: Could I create my own BCP-like application in C++, .NET, Java, or another programming language and adapt it to my own requirements?

That curiosity is what motivated this article. The answer is quite interesting. BCP is not simply a faster way to execute INSERT statements. It uses a different model for moving data.

A Very Simple BCP Example

A typical import might look like this:

bcp MyDatabase.dbo.Customers in customers.csv -S myserver.database.windows.net -d MyDatabase -c -t"," -T

The bcp utility bulk copies data between SQL Server and a data file in a user-specified format. Microsoft also exposes bulk-copy functionality programmatically through SQL Server drivers. At a very high level, we normally think of the process as: File -> BCP -> SQL Server. But there is much more happening in between.

My First Question: Is BCP Sending INSERT Statements?

Imagine that we need to load one million rows. A traditional application could repeatedly execute something like:

INSERT INTO dbo.Customers ( CustomerId, CustomerName, Amount ) VALUES ( @CustomerId, @CustomerName, @Amount );

Even when the connection is reused and the statement is parameterized, we are still performing a very large number of individual database operations.

BCP works differently. And this is probably the most important concept in this article: BCP is not a faster way to send millions of INSERT statements. It avoids sending those INSERT statements in the first place. Instead, BCP establishes a bulk data stream with SQL Server.

Going One Level Lower: TDS

SQL Server clients communicate with the database engine using TDS — Tabular Data Stream. TDS carries SQL requests, result sets, metadata, errors, authentication information, bulk data, and other messages between the client and SQL Server.

For bulk loading, TDS defines a dedicated bulk-load stream. At a simplified level, it looks like this:

Conceptually, SQL Server first receives metadata describing the incoming row shape, followed by the row stream and a completion token.

This is a completely different model from repeatedly submitting:

INSERT
INSERT
INSERT
INSERT
INSERT

SQL Server is told what the incoming data looks like, and then rows are streamed continuously through the connection.

There Is an INSERT BULK Operation

This was one of the details I found most interesting. When we execute bcp.exe, we do not manually write an INSERT BULK statement. However, the bulk-load protocol requires the client to identify the destination and incoming structure before sending the actual row stream.

A simplified sequence looks like this:

The important point is that the rows themselves are not represented as complete SQL statements. They are part of a structured bulk stream.

What Is COLMETADATA?

Suppose our destination table is:

CREATE TABLE dbo.Customers ( CustomerId int, CustomerName varchar(100), Amount decimal(10,2) );

Before SQL Server can interpret the incoming row data, it needs information about the shape and types of the columns.

Conceptually, the metadata describes something similar to:

Column 1
    INT

Column 2
    VARCHAR
    Length = 100

Column 3
    DECIMAL
    Precision = 10
    Scale = 2

Then the row stream follows:

ROW
    1001
    Juan
    42.50

ROW
    1002
    Pedro
    18.75

ROW
    1003
    Jose
    91.00

The real TDS representation is binary and structured, not human-readable like this, but the mental model is useful:BCP sends structured row data through the bulk protocol instead of generating SQL text for every record.

From a CSV File to SQL Server

Imagine the source file contains:

1001,Juan,42.50
1002,Pedro,18.75
1003,Jose,91.00

and we execute:

bcp MyDatabase.dbo.Customers in customers.csv -S myserver -c -t"," -T

Because we are using character mode, the source contains character representations. BCP reads the file, recognizes the fields according to the specified format, and feeds the values into the bulk-copy path.

For example, the character value "1001" ultimately has to become an INT, and "42.50" has to become a DECIMAL(10,2). So BCP is fast, but it is not magic. Data still has to be interpreted and converted into the destination SQL Server data types.

What About Memory?

This was another thing I wanted to understand. Suppose I need to import a 100-GB file. Does BCP need 100 GB of memory? No. A better mental model is a streaming pipeline. The complete file does not need to reside in memory at the same time. Buffers can be filled, transmitted, reused, filled again, and transmitted again. The amount of data being transferred is not the same as the amount of memory required to transfer it.

A Row Is Not Necessarily a Network Packet

Sending one row through the BCP API does not necessarily mean that one network packet is immediately sent for that row. The bulk-copy implementation can accumulate rows while filling network packets. Conceptually:

Row 1 ----\
Row 2 -----\
Row 3 ------> Network packet ---> SQL Server
Row 4 -----/
Row 5 ----/

This is much more efficient than treating every row as an independent network operation. The command-line utility also exposes a packet-size option through -a packet_size. Larger is not automatically better; the optimal value depends on the environment, row size, driver, network, and workload.

Then I Discovered the BCP API

This was probably my favorite part of the investigation. BCP is not only a command-line utility. Microsoft exposes bulk-copy functionality programmatically through the ODBC bulk-copy API.

Among the available functions are:

bcp_init()
bcp_bind()
bcp_sendrow()
bcp_batch()
bcp_done()

That means we can create our own bulk loader instead of launching bcp.exe.

Understanding bcp_bind()

Imagine that our application contains:

int CustomerId;
char CustomerName[100];

With the BCP API, those variables can be associated with destination columns. The application can then populate the same variables repeatedly and call bcp_sendrow() to feed another row into the bulk stream.

CustomerId = 1;
strcpy(CustomerName, "Customer A");
bcp_sendrow(hdbc);

CustomerId = 2;
strcpy(CustomerName, "Customer B");
bcp_sendrow(hdbc);

The application is not building and submitting a new INSERT INTO... statement each time. It keeps populating values and feeding rows into the existing bulk-copy pipeline.

The Source Does Not Even Need to Be a File

Once we understand the API, another interesting possibility appears: the source can be anything our application knows how to read.

For example, the source could be a REST API, a message stream, another database, generated data, or an in-memory structure. bcp.exe is therefore one implementation of the bulk-copy concept, not the only way to use it.

Can I Create My Own BCP in Another Programming Language?

Yes. The exact interface depends on the language and driver.

C / C++

The ODBC BCP API gives low-level access using functions such as:

bcp_init
bcp_bind
bcp_sendrow
bcp_batch
bcp_done

.NET

For .NET applications, Microsoft provides SqlBulkCopy:

using var connection = new SqlConnection(connectionString);

await connection.OpenAsync();

using var bulkCopy = new SqlBulkCopy(connection);

bulkCopy.DestinationTableName = "dbo.Customers";
bulkCopy.BatchSize = 10000;

await bulkCopy.WriteToServerAsync(reader);

Java

The Microsoft JDBC Driver provides SQLServerBulkCopy:

SQLServerBulkCopy bulkCopy =
    new SQLServerBulkCopy(connection);

bulkCopy.setDestinationTableName("dbo.Customers");

bulkCopy.writeToServer(resultSet);

The important concept is that the same bulk-copy model can be consumed directly by applications.

Batches: Another Piece of the Puzzle

There is another important concept: transaction batching. Using the BCP API, an application can send multiple rows and then call: bcp_batch();

The command-line utility exposes the same general idea through -b batch_size. Batching can affect transaction duration, rollback scope, transaction-log behavior, error recovery, and throughput. Batch size is not the same thing as memory buffer size. If we specify -b 100000, we are primarily defining a transactional boundary. We are not saying that BCP must hold exactly 100,000 rows in RAM.

What Happens When the Stream Arrives at SQL Server?

Successfully delivering rows to SQL Server is only part of the operation. On the server side, a simplified path looks like this:

TDS bulk stream-> Decode metadata and rows -> Bulk-load processing -> Storage Engine -> Data pages -> Transaction log

SQL Server still needs to store those rows. Depending on the destination, that can involve data-type processing, page allocation, transaction logging, index maintenance, constraint validation, identity handling, triggers, locking, and dirty data pages.

So Why Is BCP So Fast?

After looking at the mechanism, I do not think there is one single magic optimization. BCP is fast because several efficiencies work together.

Traditional row-by-row processing	BCP / Bulk Copy
Many individual SQL operations	Continuous bulk stream
Repeated execution overhead	Bulk-oriented processing
Potentially many client/server interactions	Persistent streaming pipeline
SQL statement representation	Structured row representation
Small network operations possible	Rows can be packed efficiently into packets
Frequent transaction boundaries possible	Controlled batching
Generic DML execution pattern	Bulk-copy-oriented path

For a few rows, the difference might not matter much. Multiply those savings by millions of rows, and the result becomes significant.

References

Detecting corrupted data in under 1ms: what changes when Spark stops waiting for the micro-batch

Wiliam_Rosa — Sat, 12 Sep 2026 02:37:15 GMT

Streaming anomaly detection almost always runs into the same wall: the micro-batch. Traditional Structured Streaming processes data in one-to-two-second windows, which is fast enough for most use cases, but terrible when the very act of waiting for the batch to close is already too late. Fraud, sensitive payload validation, corrupted data entering a critical pipeline — these scenarios can't tolerate even a second of structural delay. Apache Spark's Real-time mode exists to attack exactly that gap, and Databricks published an experiment that uses a concrete use case to prove the point: analyzing Ethereum transactions in real time.

What structurally changes in Real-time mode

Unlike the micro-batch trigger, Real-time mode processes data as it arrives, without waiting for a window to close. That's possible through three combined architectural changes: a continuous flow of data between stages (instead of materializing an intermediate result on every batch), scheduling all stages of the query simultaneously (instead of scheduling stage by stage), and an in-memory streaming shuffle between stages, eliminating the cost of writing and reading shuffle files on every round.

In practice, this brings Spark Structured Streaming closer to a continuous processing model, something historically associated with engines like Flink, but within the same runtime that already runs the rest of your organization's batch and streaming pipeline.

The experiment: Ethereum transactions as a stress test

The Databricks team built a pipeline that ingests blocks and transactions from the Ethereum network and classifies each event as ALLOW or QUARANTINE, based on two checks:

Protocol invariant validation: a block where gas_used is greater than gas_limit is logically impossible under the Ethereum protocol's own rules, so it becomes an automatic signal of corrupted or malformed data.
Payload hygiene: the block's extra_data field is scanned for patterns that shouldn't be there, such as a fragment of PII, a JWT token, or an AWS access key leaked by accident.

The cluster used was Databricks Runtime 16.4 LTS, four i3.xlarge workers, a dedicated (single-user) cluster, with Photon deliberately disabled to isolate the effect of Real-time mode itself.

The numbers behind the promise

Sustained input rate of approximately 65,592 rows per second.
Sustained processing rate of approximately 69,713 rows per second (the engine was able to absorb the input without building up backlog).
More than 23.2 million messages processed over the course of the experiment.
P95 latency under 0.5 millisecond.
P99 latency of 1 millisecond.

For context: a traditional 1-2 second micro-batch represents a three-order-of-magnitude difference in detection latency. If the goal is to stop a suspicious transaction before it propagates, that difference isn't cosmetic.

Hands-on: a skeleton for real-time classification

The "classify and route" pattern described in the experiment can be reproduced on any structured event schema. Here's a simplified example using transformWithState, the operator that gives you access to custom stateful logic inside Structured Streaming:

from pyspark.sql.streaming import StatefulProcessor, StatefulProcessorHandle
from pyspark.sql.types import StructType, StructField, StringType, LongType

class BlockValidator(StatefulProcessor):
    def init(self, handle: StatefulProcessorHandle):
        self.handle = handle

    def handleInputRows(self, key, rows, timer_values):
        for row in rows:
            status = "ALLOW"
            if row["gas_used"] > row["gas_limit"]:
                status = "QUARANTINE"
            elif self._contains_sensitive_pattern(row["extra_data"]):
                status = "QUARANTINE"
            yield {"block_id": row["block_id"], "status": status}

    def _contains_sensitive_pattern(self, payload: str) -> bool:
        markers = ["AKIA", "eyJhbGciOi", "-----BEGIN"]
        return any(m in (payload or "") for m in markers)

query = (
    spark.readStream.table("bronze.eth_blocks")
    .groupBy("block_id")
    .transformWithState(
        statefulProcessor=BlockValidator(),
        outputStructType=StructType([
            StructField("block_id", LongType()),
            StructField("status", StringType()),
        ]),
    )
    .writeStream
    .trigger(availableNow=False)  # real-time trigger is configured at the cluster/runtime level
    .toTable("silver.eth_blocks_classified")
)

Worth reinforcing: enabling Real-time mode itself depends on runtime- and cluster-level configuration, it's not just a matter of swapping the trigger in the API, so the official reference documentation should be consulted before running this in production.

In practice: I'd test this kind of pipeline under real load spikes, not just a constant rate, before blindly trusting the p99 number. Real Ethereum network traffic has much more irregular transaction bursts than a synthetic constant-throughput test, and it's under bursts that any low-latency system tends to reveal its real queueing behavior.

Why Ethereum was a smart benchmark choice

It's worth pausing for a moment on why Ethereum was chosen as the test scenario, because it isn't obvious at first glance. Ethereum transactions have two properties that make them an honest stress test for an anomaly detection system: first, the volume is public and replicable, anyone can audit the dataset used, which reduces the chance of an artificially favorable benchmark. Second, and more important, the protocol's invariant rules (like gas_used never being allowed to exceed gas_limit) are known and deterministically verifiable, so there's no ambiguity about what counts as a real anomaly versus a false positive. That removes a confounding variable common in anomaly-detection benchmarks, where the very definition of "anomaly" is already subjective. Applied to a corporate scenario, the equivalent would be having clear, auditable business rules (credit limit, expected value range, field format) before trying to apply this kind of real-time classification; without that, the technical pipeline works fine, but classification quality collapses.

What this doesn't solve

Real-time mode drastically reduces processing latency, but it doesn't replace the need for a good response strategy for suspicious data. Classifying something as QUARANTINE in one millisecond is pointless if the human or automated process that handles that alert still takes minutes or hours to act. It's also important to note the documented limitations of transformWithState in real-time mode: transformWithStateInPandas isn't supported in this mode, and state management (timers, TTL) has its own rules that differ from the traditional micro-batch mode, which requires extra care when migrating an existing pipeline.

Wrapping up

The Ethereum experiment works as a proof of concept for something broader: once Spark Structured Streaming itself can operate in the millisecond range, scenarios that used to require leaving the Spark ecosystem (fraud, critical validation, immediate operational alerting) start to fit inside the same runtime that already processes the rest of your data pipeline. It's worth testing, but with a realistic expectation of what still depends on human decision-making and response after detection.

References

Ultra-fast anomaly detection using Apache Spark Real-Time Mode (https://www.databricks.com/blog/ultra-fast-anomaly-detection-using-apache-spark-real-time-mode) (official Databricks blog)
Apache Spark Structured Streaming Real-Time Mode: concepts (https://docs.databricks.com/aws/en/structured-streaming/real-time/concepts) (official documentation)
Real-time mode concepts (https://learn.microsoft.com/en-us/azure/databricks/structured-streaming/real-time/concepts) (Microsoft Learn)
Stateful applications with transformWithState (https://docs.databricks.com/aws/en/stateful-applications/) (official documentation)
Build a custom stateful application with transformWithState (https://learn.microsoft.com/en-us/azure/databricks/stateful-applications/) (Microsoft Learn)

Windows Stopped updating and failed to install updates

Michplay — Fri, 11 Sep 2026 23:56:12 GMT

Windows Update stopped updating after i restarted the pc apparently during a update.

there was an icon when i was preventing me from turning off the pc but it hadn't had an clear icon and text on it so i assumed it was nko big deal

bur from that day windows refuses to update

and it keeps failing updates to " try again" (opnieuw proberen) and insist i download and install "windows 11 25h2 (restore)" file

but even when i want to try installing it and its set for a restart. even then the restore fails and says "try again"

i think my only option is to "upgrade" the same windows again to keep my files right? or is there still another option or a tool that can fix the system or update files?

because i also have tried DISM restore health option and i even let it check with an windows restore usb stick with the windows ISO on it and check it with the install.swm file and that resulted in a "no problems found"

also the windows update troubleshooter diagnostic failed to run

any idea how i can still fix this without reinstalling windows ?

Microsoft JDBC Driver 13.6 for SQL Server is now available

DavidLevy — Fri, 11 Sep 2026 22:00:00 GMT

Microsoft JDBC Driver 13.6 for SQL Server is now available. This release helps Java applications get more work from the same infrastructure, diagnose latency with better context, strengthen critical connection paths, and adopt the latest capabilities in SQL Server and Azure SQL.

Version 13.6 includes everything you saw in the 13.5 preview cycle and the final compatibility, security, performance, and quality work completed for general availability. Existing applications keep the established JDBC programming model, while teams can opt into new capabilities.

What you get in 13.6

If you run...	You get...
Large, wide, or numeric-heavy queries	Less allocation and garbage collection work in the ResultSet read path
High-concurrency parameterized workloads	New parameter length hints that can reduce oversized SQL Server memory grants
Always Encrypted with secure enclaves	Cached Column Encryption Key lookups that reduce remote key-store calls
Production performance telemetry	Nanosecond timing and SQL, statement, application, and pool context
Azure SQL Hyperscale reader endpoints	Automatic routing to named read replicas with the correct database context
Vector, JDK 26, or cross-driver migration projects	Stronger vector validation, JDK 26 support, and more portable connection strings

Spend less time and memory moving data

Data access performance matters at application scale because small costs in a hot path repeat for every value in every row. Driver 13.6 reduces allocations and unnecessary work across several frequently used paths:

ResultSet processing uses faster paths for common synchronous reads.
DECIMAL, NUMERIC, MONEY, and SMALLMONEY decoding creates fewer temporary objects.
Common string and BigDecimal operations avoid intermediate allocations.
Driver API entry and exit logging avoids work when detailed logging isn't enabled.

These changes are automatic. Applications don't need a new connection property or code change to benefit. Workloads that read large, wide, or numeric-heavy result sets should see lower garbage collection pressure and more consistent throughput.

Always Encrypted with secure enclaves also gets a targeted performance improvement. Enclave queries now reuse Column Encryption Keys through the driver's existing symmetric key cache instead of returning to the key store for the same key on every execution. For deployments backed by Azure Key Vault or another remote key store, this reduces network round trips, lowers query latency, and helps avoid key-store throttling under load.

Give SQL Server better parameter size information

Prepared statements can be efficient on the client and still request more server memory than the query needs. When the driver doesn't know the expected length of a varchar, nvarchar, char, nchar, varbinary, or binary parameter, it can send a much larger type definition than the application typically uses. SQL Server then uses that declared width when estimating row size and memory grants.

Driver 13.6 lets applications provide parameter length hints through:

SQLServerPreparedStatement.defineParameterType(int parameterIndex, int sqlType, int maxLength)
Existing setObject overloads that accept scaleOrLength

Accurate length information can reduce oversized memory grants, leave more workspace memory available for concurrent queries, and improve throughput when many parameterized statements run at the same time.

The two APIs serve different needs. defineParameterType sets an enforced parameter definition when the application knows the contract. The setObject length value is an advisory hint for supported character and binary types. If a value is larger than the hint, the driver widens the definition rather than truncating data. Applications that don't provide a hint keep the existing behavior.

Connect performance events to the work that produced them

The performance logging callback now provides more of the context needed to investigate latency in production:

Optional nanosecond timing for fine-grained measurements
The current SQL text
The current statement type
The connection's applicationName

The callback still uses millisecond timing by default, and the new methods preserve compatibility with existing callback implementations.

This additional context helps telemetry systems answer practical questions: Which pool or application emitted the event? Was the operation a prepared statement or another statement type? Which SQL text was executing when time accumulated in authentication, network I/O, request construction, or server response?

Strengthen security without changing application behavior

Security hardening spans authentication, encryption, XML processing, class loading, Java Naming and Directory Interface (JNDI), Bulk Copy, and dependencies.

Driver 13.6:

Strengthens Always Encrypted secure enclave attestation validation.
Omits sensitive connection properties when a SQLServerDataSource creates a JNDI Reference.
Applies secure-processing, document type definition, and external-entity protections across SQLXML parser paths.
Validates configured Java binary class names before reflective class loading.
Escapes multipart destination identifiers before adding them to Bulk Copy and useBulkCopyForBatchInsert SQL.
Hardens the ActiveDirectoryInteractive authentication callback flow.
Updates optional Bouncy Castle, Azure Identity, Azure Key Vault, and Netty dependencies to pick up security and reliability fixes.

These changes reduce exposure in common enterprise integration points while preserving existing configuration semantics for valid applications.

Scale reads on Azure SQL Hyperscale

Driver 13.6 supports enhanced routing for Azure SQL Hyperscale reader endpoints. The driver can negotiate the enhanced routing capability, follow routing information to a named read replica, and preserve the correct database context when it reconnects.

Applications can use reader endpoints for read scale-out without adding replica-specific routing logic. The server can distribute new connections across named replicas, while the driver handles the network target and database name required for the routed connection. Servers that don't support enhanced routing continue to use the existing connection behavior.

Managed Identity connections are also more resilient. If a cached Managed Identity or default credential fails to acquire a token, the driver evicts that failed credential. A later connection attempt can create a fresh credential and recover without an application or Java virtual machine restart.

Build AI applications with stronger vector validation

SQL Server and Azure SQL vector support continues to expand in Driver 13.6. The release adds negotiated version validation when applications send vector columns through table-valued parameters.

The driver checks the server's negotiated vector capability before writing vector metadata or data to the wire. Unsupported vector versions and unsupported FLOAT16 values fail early with a clear driver error. Applications get more predictable behavior for embeddings, vector search, and retrieval-augmented generation workloads, especially when they move between environments with different vector capabilities.

Move configurations between Microsoft data drivers

Teams often share configuration across tools, languages, or application frameworks. Driver 13.6 recognizes additional case-insensitive connection string aliases used by other Microsoft data drivers:

Alias	JDBC property
uid	user
trusted_connection	integratedSecurity
app	applicationName
connectTimeout	loginTimeout
columnEncryption	columnEncryptionSetting
quotedId	quotedIdentifier

Existing JDBC property names continue to work. The aliases reduce configuration changes when applications migrate to JDBC or share settings across Microsoft's SQL connectivity stack.

Keep existing applications compatible

We preserved the established microsoft.sql.DateTimeOffset type and keeps the existing getDateTimeOffset, setDateTimeOffset, and updateDateTimeOffset APIs free of deprecation annotations. Standard JDBC getObject(..., OffsetDateTime.class) support remains available.

The release also improves compatibility and diagnostics in several application-visible areas:

getGeneratedKeys() returns an empty ResultSet when an insert produces no generated key, rather than a row containing NULL.
Calling parameter-related methods on a closed prepared or callable statement returns the standard closed-statement SQLServerException instead of a NullPointerException.
Repeated metadata discovery avoids an unnecessary failed sp_columns_170 call on servers that don't support that procedure.
Socket, I/O, and custom access-token callback errors retain their original cause chains.
Android applications using Conscrypt no longer hang in the affected TLS login path.

Driver 13.6 also adds JDK 26 build and test support. The jre11 artifact supports Java 11 and later versions, including JDK 26. Java 8 applications can continue to use the jre8 artifact.

Get Driver 13.6

For Java 11 and later versions, add the following dependency:

<dependency> <groupId>com.microsoft.sqlserver</groupId> <artifactId>mssql-jdbc</artifactId> <version>13.6.0.jre11</version> </dependency>

For Java 8, use version 13.6.0.jre8.

Download the release and review the complete change list:

Download Driver 13.6 and test it with your application's most important data access paths.

The Gap Between Applications and Analytics, and "How Lakebase Solves It"

Wiliam_Rosa — Fri, 11 Sep 2026 21:18:48 GMT

The Problem Nobody Likes to Admit.

Imagine this scenario: your data team has built a flawless lakehouse. Ingest pipelines, bronze/silver/gold tiers, gleaming dashboards. Everything is working perfectly.

Until someone asks: "And the production app? Where does it store the transactional data?"

That's where the headache begins. You need a separate OLTP database (Postgres, MySQL, DynamoDB...), CDC pipelines to bring data into the lakehouse, reverse ETL to return enriched data to the app, and an infrastructure team to keep it all running.

The result? Data silos, synchronization latency, operational complexity, and ever-increasing costs.

Traditional Architecture (and Its Pain Points)

Here's how most companies operate today:

Pain points in this architecture:

Multiple tools and suppliers for managing
Significant latency between writing on OLTP and availability on Lakehouse.
Fragmented governance — Unity Catalog doesn't see the external bank.
High operational costs associated with synchronization pipelines.

What is Lakebase?

Lakebase is a fully managed Postgres database natively integrated with the Databricks Data Intelligence Platform. It is designed to bridge the gap between transactional (OLTP) and analytical (OLAP) workloads, unifying everything into a single ecosystem .

In simple terms: it's like having a high-performance Postgres server living inside your lakehouse , with unified governance via Unity Catalog, native bidirectional synchronization, and modern capabilities such as autoscaling, scale-to-zero, and database branching.

The New Architecture with Lakebase:

What changes?

Zero external database infrastructure
Native bidirectional synchronization (no Debezium, no Airflow, no pain)
Unified governance through the Unity Catalog
A single control plane for OLTP + OLAP

The Architectural Innovations of Lakebase

Lakebase is not "just another managed Postgres." It brings modern data engineering concepts to the transactional world.

1. Separation of Compute and Storage

Unlike traditional data banks where CPU and disk are coupled, Lakebase completely separates computing resources from storage. This means you scale each independently, paying only for what you use.

2. Copy-on-Write Storage

The storage system uses a copy-on-write approach. In practice, when you create a branch of the database, there is no data duplication —only the changes are stored separately. This makes operations like branching and restoring virtually instantaneous.

3. Autoscaling and Scale-to-Zero

The compute system automatically adjusts its capacity based on demand. During periods of inactivity, the database scales to zero , eliminating costs. When a request arrives, it "wakes up" in seconds.

Database Branching: Git for Your Data

This is probably the most innovative feature. Just as developers create branches in Git to work on isolated features, Lakebase allows you to create branches for the entire database .

Powerful use cases:

Development : each developer has their own branch of the database, without interfering with production.
Migration testing : test schema changes in an isolated branch before applying them to production.
Instant Restore : Restore the database to any point in time (configurable window from 0 to 30 days) by creating a branch from that point.

Two-Way Synchronization: The End of Reverse ETL

One of the biggest advantages is the native synchronization between Lakehouse and Lakebase:

Synced Tables (Lakehouse → Lakebase)

Unity Catalog tables are automatically synchronized to Lakebase, allowing applications to query rich analytical data with low latency. Supports Snapshot, Triggered, and Continuous modes.

Lakehouse Sync (Lakebase → Lakehouse)

Transactional data from Lakebase is continuously replicated to Delta tables in the Unity Catalog using Change Data Capture (CDC). The destination tables follow the SCD Type 2 standard , maintaining a complete history of changes.

This completely eliminates the need for:

External CDC tools (Debezium, Fivetran)
Reverse ETL pipelines (Census, Hightouch)
Custom synchronization jobs in Airflow/Prefect

Three Strategic Use Cases

Feature Serving for Real-Time ML

Lakebase functions as an online store for Databricks' Feature Store. Features computed in the lakehouse are synchronized via Synced Tables to Lakebase, from where ML models query them with millisecond latency.

State of AI Agents

AI agents need to persist state between requests — conversation context, action history, workflow data. Lakebase provides a native transactional database to store this state with ACID consistency.

Transactional Data for Applications

Databricks Apps (or any external application) can use Lakebase as their primary database. The integration is native: simply add the Lakebase project as a resource in your app. Additionally, the Data API offers a PostgREST-compatible REST interface for direct HTTP access.

Comparison: Before and After

Availability

Lakebase Autoscaling is available in the following AWS regions:

us-east-1, us-east-2,us-west-2
ca-central-1, sa-east-1
eu-central-1, eu-west-1,eu-west-2
ap-south-1, ap-southeast-1,ap-southeast-2

The presence in sa-east-1 is particularly relevant for us in the Brazilian community, ensuring low latency for applications hosted in Brazil.

Conclusion

Lakebase represents a paradigm shift: instead of treating OLTP and OLAP as separate worlds that need complex "bridges," it unifies them into a single platform.

For Brazilian data teams, this means:

Fewer tools to manage and integrate.
Fewer pipelines that silently break down at 3 a.m.
More time focused on generating value with data.
Real governance across the entire data lifecycle — from transactional writing to the executive dashboard.

Lakehouse finally has its native transactional database. And it speaks Postgres.

This post was inspired by concepts from the official Databricks documentation. For more technical details, please refer to the Lakebase documentation .

Wiliam Rosa
Data Engineer | Machine Learning Engineer
linkedin.com/in/wiliamrosa
Blog: https://wiliamrosa.github.io

Hands on webinar: Build Student Skills with Learning Accelerators in Microsoft Teams

MikeTholfsen — Fri, 11 Sep 2026 20:21:50 GMT

Join us on Wednesday, September 16th @ 8am Pacific Time and discover how Learning Accelerators in Microsoft Teams for Education can help students build foundational and future ready skills while giving educators actionable insights to personalize instruction. In this webinar, we’ll explore the latest capabilities across the Learning Accelerators suite, including:

📖 Reading Progress - Help students build reading fluency with personalized practice and AI-powered feedback
🎤 Speaker Progress – Develop confident presentation and communication skills with real-time coaching
➗ Math Progress – Create, assign, and review math practice while gaining deeper insight into student understanding
🔎 Search Progress – Teach students how to search effectively, evaluate sources, and build information literacy skills
📊 Education Insights – Turn learning activity into actionable data to identify trends and better support individual students

We’ll walk through practical classroom scenarios, demonstrate key features, and share tips for getting the most from Learning Accelerators in Microsoft Teams. Join us to see how Learning Accelerators can help educators save time, personalize learning, and give every student more opportunities to practice, improve, and succeed.

Wednesday, September 16th @ 8am Pacific time:
Register here: https://df.events.teams.microsoft.com/event/df.2cc31453-8761-4442-9b9e-eceb4a80859f@72f988bf-86f1-41af-91ab-2d7cd011db47?source=copyLinkOneEventsShareDialog

Mike Tholfsen
Group Product Manager
Microsoft Education

mssql-python 1.15.0: Faster, More Reliable, and Built for Your Applications

DavidLevy — Fri, 11 Sep 2026 20:00:00 GMT

I am excited to share the release of mssql-python 1.15.0, our 15th release since General Availability.

We build mssql-python for Python developers connecting their applications to SQL Server, Azure SQL, and Azure Synapse. Every release is an opportunity to make that experience faster, simpler, and more dependable. Version 1.15.0 delivers improvements across all three.

Faster parameterized execution

setinputsizes() parameter handling now runs through the native C++ execution pipeline.

If your application uses wide statements, batches, or frequently executed parameterized queries, it will spend less time processing parameters in Python. This work moves more of the execution path into the native driver, where it can be handled more efficiently.

We also made decimal parameter binding more consistent. Python Decimal values are now bound as SQL_NUMERIC regardless of their runtime value, so parameter types remain stable across queries and batches.

The driver now uses current ODBC 3.x parameter type identifiers in place of obsolete ODBC 2.x identifiers. This brings parameter binding in line with the current ODBC standard and avoids mismatches caused by legacy type definitions.

Better support for Python data

Binary() now accepts memoryview objects directly.

Applications using buffer-protocol data sources and zero-copy views no longer need to convert a memoryview to bytes before sending binary data. You can pass the value you already have.

SQL Server-specific type constants are also available directly from the mssql_python module. This makes them easier to discover and use when working with parameter declarations or SQL Server type metadata.

More reliable production behavior

Several fixes in this release address failures that can be difficult to diagnose because they occur under concurrency, during deployment, or while a process is shutting down.

We corrected GIL and mutex lock ordering in the native logging path. Multithreaded applications can now use driver logging without risking a deadlock when multiple threads log concurrently.

We also corrected native cleanup ordering for connections containing cursors in different lifecycle states. Applications that create multiple cursors and leave some cleanup to process shutdown will no longer encounter the native crash addressed by this fix.

On Windows, bundled driver and authentication DLLs are now loaded from directories inside the installed package. Applications no longer have to depend on process-wide DLL search path configuration for those components to resolve correctly.

Windows ARM64 wheels now include the matching ARM64 Rust core used by bulk copy. This gives Windows ARM64 applications architecture-compatible native components and working bulk-copy support from the installed wheel.

Finally, Connection.getinfo(SQL_DATABASE_NAME) now decodes the returned value correctly, so applications inspecting the active database receive a Python string as expected.

Thank you

Thank you to everyone who reported an issue, tested a fix, contributed code, or told us where the driver was getting in your way.

We are building this driver for you, and your feedback continues to shape what we improve next.

Install or upgrade today:

pip install --upgrade mssql-python

Read the mssql-python 1.15.0 release notes, visit the package on PyPI, or explore the mssql-python repository.

Is there a way to create role-specific competency frameworks in Microsoft 365?

HarryP — Fri, 11 Sep 2026 19:58:05 GMT

We already have a lot of employee information in Entra ID, like job title, department, manager, location, and other user attributes. What I’m trying to figure out is whether we can use those attributes to automatically assign different competency frameworks to different groups of employees.

For example, engineers would have one set of competencies, sales another, and managers would have additional leadership competencies. Ideally this would update automatically when someone changes role or department in Entra rather than HR maintaining everything manually.

Has anyone built something like this with Entra + SharePoint/Power Automate, or is there a better way to manage competency frameworks while still keeping Microsoft 365 as the source of employee data?

Best way to automatically bring unfinished 1:1 action items into the next meeting?

EmmaHastings — Fri, 11 Sep 2026 19:55:07 GMT

One thing our managers keep running into is losing track of action items between recurring 1:1s. They might agree on 2–3 follow-ups during one meeting, but by the time the next one comes around those notes are sitting in Loop, OneNote, a Teams chat, or someone’s personal task list.

Ideally, I’d like unfinished action items from the previous 1:1 to automatically show up in the next meeting agenda so both sides can quickly review what was actually completed.

Title Plan Update - September 11, 2026

anbordianu — Fri, 11 Sep 2026 19:23:00 GMT

📁September 11, 2026 - Title Plan Now Available

Access the latest Instructor-Led Training (ILT) updates anytime at http://aka.ms/Courseware_Title_Plan to ensure you're always working from the most current version.

📌 Reminder: To help you stay informed more quickly and consistently, we’ve moved to a weekly publishing cadence for the title plan. This means each update may include fewer changes but ensures you’re always up to date.

Azure App Service is now a trigger destination for Azure Managed Connectors

jordanselig — Fri, 11 Sep 2026 18:41:02 GMT

Azure Managed Connectors, currently in public preview, now lets you choose Azure App Service as a trigger destination. Connector events can be delivered directly to applications running on App Service, including ASP.NET Core, Java, Node.js, and Python applications.

This is a new capability in the Managed Connectors public preview. It is not the announcement of a separate App Service preview.

What's new

When you create a trigger in the Managed Connectors portal, App Service now appears as a first-class destination alongside Azure Functions and the generic HTTP endpoint option.

After selecting an existing App Service app, you configure:

The application route that receives the event. New triggers default to POST /api/webhook, and the route can be edited.
The Connector Namespace managed identity used to authenticate the callback.
The Microsoft Entra audience expected by the receiving application.

Managed Connectors then records the selected App Service resource, route, managed identity, and audience as part of the trigger configuration. You no longer need to select the generic HTTP destination and manually assemble the App Service callback URL.

What are managed connectors?

Managed connectors provide a consistent way for applications to integrate with services such as Office 365, SharePoint, Teams, Dataverse, and Salesforce. A Connector Namespace manages connections and connector operations so developers do not need to build a separate OAuth flow and service-specific client for every integration.

Managed connectors support both directions:

Triggers deliver events to your application, such as a new Outlook email or a file added to SharePoint.
Actions let your application call operations such as posting a Teams message, flagging an email, or creating a list item.

The App Service destination makes the trigger side a first-class option for existing web applications and APIs.

How it works

In the Managed Connectors portal, create a trigger and select App Service as its destination.
Select the web app, callback route, Connector Namespace managed identity, and Microsoft Entra audience.
When the source event occurs, Managed Connectors requests a token using the selected managed identity and sends the event to the App Service route.
App Service built-in authentication validates the token before the request reaches application code.
The application processes the event and can use Managed Connectors actions to continue the workflow.

The callback is an ordinary authenticated HTTP request, so the application can use its normal framework, routing, dependency injection, logging, monitoring, and deployment practices.

Configure receiving-app authentication

The App Service destination configures the Managed Connectors side of the callback. The receiving application must still be configured to trust it.

The reference sample uses App Service built-in authentication, also known as Easy Auth, with:

A Microsoft Entra application that identifies the receiving application and its audience.
A secretless federated credential configuration.
The Connector Namespace managed identity pinned as an allowed principal.
Authentication required for requests reaching the application.

This configuration rejects unauthenticated requests and allows callbacks carrying the expected managed-identity token. The Managed Connectors trigger wizard does not currently create or update the App Service authentication configuration automatically.

Try the end-to-end sample

The Managed Connectors on Azure App Service email-triage sample demonstrates a complete workflow:

An Office 365 Outlook trigger delivers a new email to an ASP.NET Core application on App Service.
App Service built-in authentication validates the managed-identity callback.
The application classifies the message and enriches the sender through the Office 365 Users connector.
Important mail produces a Microsoft Teams triage card.
The application flags the source email in Outlook.

The repository includes the application, Bicep infrastructure, App Service authentication configuration, Connector Namespace connections, and an Azure Developer CLI deployment flow.

We validated the complete workflow end to end: the authenticated callback reached POST /api/webhook, the application processed the event, a Teams card was posted, and the source Outlook message was flagged.

Current limitations

The capability is configured through the Managed Connectors portal, not the App Service portal.
The wizard configures the Managed Connectors trigger but does not configure App Service built-in authentication on the selected web app.
The current sample authentication setup requires a Microsoft Entra application, audience configuration, federated credential, and allowed-principal configuration.
Depending on the application's Easy Auth configuration, authentication can apply to the whole application rather than only the connector callback route.
The reference sample validates one push-trigger scenario; it is not a compatibility statement for every connector and operation.

What's next

The first-class App Service destination removes the generic callback URL step and provides an App Service-aware trigger experience in Azure Managed Connectors.

We are also exploring ways to simplify receiving-side authentication so applications can establish connector-scoped trust without manually assembling the App Service authentication configuration.

Try the reference sample and share feedback on the connectors and App Service scenarios you want to use.

Microsoft Marketplace Partner Digest

v-kylecallahan — Fri, 11 Sep 2026 18:20:54 GMT

What's new in Marketplace

Marketplace innovations are simplifying every stage of the customer journey.

Microsoft Marketplace continues to make it easier for customers to discover, purchase, and manage the solutions that power their businesses. This month, we're highlighting new AI-powered discovery experiences that help customers find and evaluate solutions faster, innovative healthcare opportunities through Dragon Copilot Physician apps and agents, and new capabilities that support procurement, billing, and subscription management at scale. Together, these investments help reduce friction across the customer journey while creating new opportunities for partners to grow through Marketplace.

✨ Find the right solutions faster with intelligent discovery

What's new

Microsoft Marketplace now includes intelligent discovery, an AI-powered experience that helps customers discover, compare, and evaluate solutions using natural language rather than traditional keyword searches. Customers can describe their business needs in everyday language and receive tailored recommendations, side-by-side product comparisons, and deeper product analysis to support purchasing decisions.

Key capabilities include:

Use natural language to describe requirements and business goals
Automatically identify relevant filters and narrow results
Compare solutions side-by-side based on Marketplace metadata
Explore solution details using AI-assisted product analysis
Move from discovery to evaluation with greater confidence

Why it matters

Customers increasingly expect AI-assisted buying experiences. Intelligent discovery helps buyers navigate a growing Marketplace catalog more efficiently, reducing the time required to find relevant solutions and evaluate alternatives. This can help partners improve visibility, attract more qualified prospects, and create stronger pathways from discovery to purchase. Marketplace AI offerings continue to grow rapidly, with more than 6,500 AI apps and agents now available in the catalog.

Recommended action

Review your Marketplace listings to ensure product descriptions, categories, industries, use cases, and solution metadata accurately reflect the problems your solution solves. High-quality Marketplace content helps intelligent discovery surface your offerings to the right customers.

🔎 Learn more about searching and comparing products with intelligent discovery in Microsoft Marketplace

⚡ Help customers align Marketplace purchases of your products with their internal procurement and financial processes

What’s new

Purchase order management and spend mapping capabilities are now generally available in Microsoft Marketplace, helping organizations associate Marketplace purchases with internal procurement identifiers and financial reporting requirements. These capabilities help customers connect Marketplace transactions to purchase orders, cost centers, departments, business units, and other financial controls.

Key capabilities include:

Associate Marketplace purchases with purchase orders
Map Marketplace spend to internal financial identifiers
Improve chargeback and allocation reporting
Support invoice reconciliation and procurement processes
Increase visibility into Marketplace spending against budgets

Why it matters

Customers consistently identify invoicing, procurement integration, spend visibility, and financial governance as important considerations when scaling Marketplace purchasing. Helping customers align Marketplace transactions with existing procurement workflows can reduce operational friction and support broader Marketplace adoption.

Recommended action

Review customer-facing sales materials and deployment discussions to understand how purchase orders, spend mapping, and financial governance capabilities may support procurement, finance, and FinOps stakeholders during the buying process.

📍Learn more about purchase orders and allocating Marketplace spend in Azure portal

🐉Reach healthcare customers through Dragon Copilot

What's new

Microsoft Marketplace now supports Dragon Copilot Physician Apps and Agents, the first offer type in a planned family of Dragon Copilot offers. Available in the United States, these partner solutions can be discovered and purchased through Microsoft Marketplace, configured through the Dragon Admin Center, and surfaced directly within physician workflows in Dragon Copilot.

Key capabilities include:

Publish healthcare-focused apps and agents through a dedicated Marketplace offer type
Reach healthcare organizations adopting Dragon Copilot and deliver capabilities directly within clinician workflows
Utilize Microsoft Marketplace for commerce, discovery, and fulfillment

Why it matters

Healthcare organizations are looking for AI solutions that fit naturally into existing clinical workflows. Dragon Copilot Physician apps and agents give partners a scalable route to market: solutions can be purchased through Microsoft Marketplace, configured through the Dragon Admin Center, and made available directly within clinical workflows.

Recommended action

Evaluate whether your healthcare solution could benefit from integration with Dragon Copilot and explore the new Marketplace offer type for physician apps and agents.

Learn more about Dragon Copilot Physician apps and agents

Events

Recent events

Announcing Frontier Accelerate for Marketplace

Frontier Accelerate for Marketplace is an upcoming Microsoft AI Cloud Partner Program offering that guides software development companies to build AI-powered solutions, monetize through Microsoft Marketplace, and scale revenue through Microsoft expertise, skilling, and investments.

📺 Watch the briefing now
🔗 Learn more: aka.ms/FA-for-Marketplace

How leading partners drive co-sell success with Marketplace

Learn how successful software companies use Microsoft Marketplace to expand reach, strengthen co-sell relationships, and drive repeatable revenue growth. Join Reis Barrie of Carve Partners for insights into building Marketplace momentum and creating co-sell opportunities across the Microsoft partner ecosystem.

Watch on-demand

Evaluate and buy solutions with Microsoft Marketplace

Help customers evaluate and buy solutions with greater confidence. This Microsoft Marketplace session explores intelligent discovery, free trials, private offer requests, flexible contract durations, and practical ways partners and sellers can create purchasing arrangements aligned to customer priorities.

Watch on-demand

Upcoming events

New monthly partner skilling series

📆Beginning Sept. 23, 2026, 8:00 AM and 5:00 PM PDT

Microsoft is launching Partnering for Success Together, a new monthly partner skilling series designed to help partners stay up to date on Microsoft's latest investments, go-to-market priorities, and customer opportunities.

Hosted through the Microsoft Partner Skilling Hub, each session provides guidance and updates across Microsoft's commercial solution areas, helping partners understand what's new and how to translate announcements into customer impact.

Two live sessions will be provided at different times to accommodate global audiences. Register for the first event scheduled September 23 and add future monthly skilling events to your development plan.

Microsoft co-sell playbook: From co-sell ready to close-won

📆 Wednesday, Oct 07, 2026, 8:30 AM PDT

Join this partner-focused session to learn how successful organizations turn co-sell opportunities into closed-won business. Kevin Flitcroft of Spektra Systems shares proven strategies for stakeholder alignment, commercial readiness, Microsoft Marketplace positioning, and customer-focused sales execution.

Get the details and add to your calendar

Next steps

Position your solution for AI-powered discovery

The Marketplace experience continues to evolve to help customers discover, evaluate, and purchase solutions more efficiently. By improving how your solution is represented in Marketplace and taking advantage of new Marketplace capabilities, you can increase visibility, engage more qualified buyers, and accelerate growth through Microsoft's commercial ecosystem. Not sure where to start? Get guidance and recommendations through App Advisor.

Windows Server Datacenter: Azure Edition preview build 29659 now available in Azure

StaceyCL_RM — Fri, 11 Sep 2026 17:12:40 GMT

Hello Windows Server Insiders!

We welcome you to try Windows Server vNext Datacenter: Azure Edition preview build 29659 in both Desktop experience and Core version on the Microsoft Server Operating Systems Preview offer in Azure. Azure Edition is optimized for operation in the Azure environment. For additional information, see Preview: Windows Server VNext Datacenter (Azure Edition) for Azure Automanage on Microsoft Docs. For more information about this build, see https://techcommunity.microsoft.com/discussions/windowsserverinsiders/announcing-windows-server-vnext-preview-build-29659/4554949.

Partner Blog | Agentic support: Why AI-powered operations are becoming a competitive core for CSP partners

JillArmourMicrosoft — Fri, 11 Sep 2026 17:00:00 GMT

Cloud Solution Provider (CSP) support teams are being asked to cover more ground as customer environments become more complex. A single incident can cross identity, security, data, Azure, Microsoft 365, Dynamics 365, and AI workloads before the root cause is clear. Every handoff takes time and pulls engineering capacity away from adoption, architecture, and other higher-value work.

Frontier Firms offer a useful benchmark for what happens when AI becomes part of the operating model. Microsoft research shows that Frontier Firms are seeing roughly three times higher returns than slow adopters.¹ For CSP partners, support is one of the clearest places to put that approach into practice inside your own business, building capability that can scale across the customer lifecycle.

Agents can support triage, gather diagnostics, run approved remediation steps, and provide an engineer with consolidated case information when human expertise is required. That changes how much work a support team can handle and where technical talent spends its time.

This is the first in a four-part series on building a customer success operating system in the CSP channel. We will start with AI-powered support operations, then look at partner and Microsoft engagement, followed by a post on logical workload growth, and finally, a full execution roadmap.

Why the CSP support model is changing

The services opportunity around CSP continues to grow. Omdia forecasts $276 billion^* in partner services and opportunities surrounding generative and agentic AI by 2030.²

Capturing more of that opportunity means staying involved well beyond the initial transaction. Customers need partners that can operate across connected workloads, resolve problems quickly, and keep technology adoption moving.

Traditional tiered support becomes harder to manage as those environments expand. An issue that starts in one product may depend on identity, infrastructure, security, data, or another service. Cases move between people and teams; context gets rebuilt, and experienced engineers spend time on work that could be diagnosed or resolved earlier.

Support teams also see customer adoption problems before they show up in a renewal conversation. Repeated tickets, configuration issues, and low usage can expose where a customer is struggling to get value from what they have purchased.

A more efficient support operation protects engineering capacity and gives partners more room for adoption, optimization, and advisory services.

What agentic support means for CSP partners

Agentic support goes beyond using a chatbot to answer questions. Agents can execute multi-step workflows such as collecting diagnostic information, identifying likely causes, taking approved remediation actions, and escalating an issue when human judgment is needed.

At the service desk, that capability can develop in stages.

Human with assistant: AI supports service professionals with triage, knowledge retrieval, summarization, and recommended actions.
Human-agent teams: Agents take on defined tasks while people manage exceptions and higher-risk decisions.
Human-led, agent-operated: Agents execute larger portions of a workflow within defined controls, bringing people in when required.

The scale is expected to grow quickly as organizations increasingly integrate agentic AI into their operating models.

Continue reading here

Duplicate subscriptions for a specific resource

sandy73 — Fri, 11 Sep 2026 15:50:16 GMT

Hello,

Previously, we were not allowed to create duplicate subscriptions for the same resource. But now we can create duplicate subscriptions for a specific resource.

Could you please confirm whether this functionality has been newly enabled or supported?

Why duplicate subscriptions are now allowed for the same resource like (/users, /groups &
communications/callRecords).
Whether this is a change or a bug.

We would appreciate clarification on the expected behavior and the supported use cases.