Bay Equity sets the bar for a new kind of mortgage lender with Surface devices

When brothers Brett, Casey and Jon McGovern decided to set up a full-service retail mortgage lending company in California’s San Francisco Bay Area in 2007, they couldn’t have picked a more inopportune time. Just a month after the McGovern brothers capitalized their business, the impending 2007-2008 global financial crisis hit full swing and was swiftly considered as the worst financial crash since the Great Depression of the 1930s. During this time of crisis, Bay Equity embraced digital transformation and invested in Surface Pro devices which helped them attract and retain great talent and enabled them to provide exceptional service to their clients.

Today, Bay Equity’s employees are completely powered by Surface Pro.

The company has rolled out more than 1,200 of the devices, alongside services such as Microsoft Skype for Business, and Microsoft Office 365 to facilitate quick and seamless communication and collaboration. Standardizing on Surface Pro devices has meant slashing redundant PCs and non-Windows tablets from the company’s device inventory, resulting in a saving of about $1.37 million.

Bay Equity’s employees are completely powered by Surface Pro.

Unlike many other mortgage lenders who were closing their doors, Bay Equity Home Loans’ founders remained dedicated to their dream of creating a family-oriented mortgage lending company that would provide high-quality customer services and lasting partnerships. “While everyone was running away from mortgage financing, we ran towards it,” co-founder and CEO Brett McGovern recalls. Bay Equity funded its first loan just one month after opening, and its rapid growth was recognized by San Francisco Business Times on its list of the Top 100 Fastest-Growing Private Companies in the San Francisco Bay Area in both 2011 and 2012. Fast forward to 2017, and the company now has operations centers and retail branches in more than 130 locations across states on both the east and west coasts of the US.

“The most talented people in our industry expect to have the best tools to allow them to execute at the highest level possible,” Brett says. “People see us as forward thinking and as having made the right investments in our company, which in turn is going to provide them a platform to be successful – and that’s what Surface represents for us.”

https://youtu.be/SRf_TIfBpBc]

Choosing the right device went deeper than just hardware specs and software packages- it had to make the right impression on the employees using the device, and reflect the ethos of Bay Equity to their customers. “We provide a premium service, and having a premium device is important,” CIO Phil Mikolaj said.

 “A lot of companies offer an appealing vision, but if their technology is difficult to work with, loan officers hesitate to join them. They don’t want to struggle to use the tools. That isn’t a problem for us; rather than being a barrier to recruiting, our technology attracts excellent people.”

One of these impressed end-users is seasoned mortgage banker, Kathryn Pedersen. Kathryn has spent fifteen years helping families find the perfect home, and she knows how much thought and consideration goes into a purchasing decision.

“Having a device that I can put in front of the client, and not have that division of them versus me, is great because we can work on something together as a team.”

She loves using Surface Pen to provide an intuitive writing experience on features like Sticky Notes and OneNote, helping her meetings with customer flow naturally, while making sure she never misses a thing. The security of her clients’ data is of the utmost importance.

“Security is really important, and Windows Hello is a feature that I can log in quickly using facial recognition. My kids tried to break into my Surface and neither one of them were successful, even though my daughter looks a lot like me.”

Kathryn credits Surface with helping her better balance her work life with her family life, and enabling her to make time for own family, too.

And Kathryn’s not the only one with more hours in her day. Surface is saving the Bay Equity’s IT department time integrating and supporting devices while their employees are saving time on training because of the familiar Windows ecosystem.

“We’ve gone from deploying PCs and laptops over a course of days to deploying Surface Pro devices in hours,” shares Phil Mikolaj.
 

Surface has proved so popular in fact, that the firm has replaced all of its previous desktop and laptops with over 1,200 Surface devices across the business, consolidating the number of devices they need and helping them foster a digitally enabled, totally mobile culture of workers.

“When I realized that I could dock it on my desk, I got rid of my PC, my iPad, and my laptop and only carried a Surface Pro from that point forward,” Phil says. “I cannot believe how it’s changing my efficiency as an individual employee.”

And with the introduction of the new Surface Pro’s upcoming LTE functionality, companies like Bay Equity will be able to work even more flexibly and productively, accelerating their path to full digital transformation.

Read more on how Surface gives financial professionals the tools they need to transform the way they work. For financial services companies like Bay Equity, security is a priority. Their businesses are built on clients’ data and trust. This whitepaper explores why cloud-based control of your devices, information, and users is so important.

Command-Line Activation of Universal Windows Apps

As we continue to close the gap between Win32 and Universal Windows Apps, one of the features we’ve recently introduced is the ability to activate a UWA from a command line and pass the app arbitrary command-line arguments. This is available to Insiders from build 16226.

This feature builds on the App Execution Alias extension already available for Desktop Bridge apps. To use this feature in a UWA, there are two key additions to your app:

  • Add an appExecutionAlias extension to your app manifest.
  • Override OnActivated and handle the incoming arguments.

For the manifest entry, you first need to declare the XML namespace for the AppExecutionAlias element:


<Package
  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
  xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest"
  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
  xmlns:uap5="http://schemas.microsoft.com/appx/manifest/uap/windows10/5" 
  IgnorableNamespaces="uap mp uap5">

The AppExecutionAlias is declared as an Extension within your Application. This is quite simple and almost the same as for a Desktop Bridge app:


<Application ...>
      
  <Extensions>
      <uap5:Extension 
        Category="windows.appExecutionAlias" 
        Executable="MyCompany.Something.Another.exe" 
        EntryPoint=" MyCompany.Something.Another.App">
        <uap5:AppExecutionAlias>
          <uap5:ExecutionAlias Alias="MyApp.exe" />
        </uap5:AppExecutionAlias>
      </uap5:Extension>
  </Extensions>

</Application>

The Executable is the name of your UWA app EXE, and the EntryPoint is the fully qualified name of your App class. The ExecutionAlias is the name that users will type in at the command-line: This can be any arbitrary name, and it must end with “.exe.” You should choose a meaningful alias that you can reasonably expect the user to associate with your app. Note that if you choose an alias that conflicts with an app that is already installed, your alias won’t be used. Similarly, if your app is installed first, and then the user installs another app later that declares the same alias – then your app will take precedence. The rule here is that the first one wins.

The manifest entry is obviously the same for VB and C++ projects, but for a JavaScript web app, it’s slightly different. Instead of Executable, you specify a StartPage, and you don’t specify EntryPoint at all:


<Extensions>
    <uap5:Extension 
      Category="windows.appExecutionAlias" 
      StartPage="index.html">
      <uap5:AppExecutionAlias>
        <uap5:ExecutionAlias Alias="MyApp.exe" />
      </uap5:AppExecutionAlias>
    </uap5:Extension>
</Extensions>

For the OnActivated override, the first thing to do is to check the ActivationKind – this is standard practice if your app supports multiple activation kinds (file associations, custom protocols and so on). In this scenario, if the ActivationKind is CommandLineLaunch, the incoming IActivatedEventArgs will be an object of type CommandLineActivatedEventArgs. From this, you can get the CommandLineActivationOperation, and from this in turn, you can get the Arguments string. You also get the CurrentDirectoryPath, which is the directory current when the command-line activation request was made. This is typically not the install location of the app itself, but could be any arbitrary path.


async protected override void OnActivated(IActivatedEventArgs args)
{
    switch (args.Kind)
    {
        case ActivationKind.CommandLineLaunch:
            CommandLineActivatedEventArgs cmdLineArgs = 
                args as CommandLineActivatedEventArgs;
            CommandLineActivationOperation operation = cmdLineArgs.Operation;
            string cmdLineString = operation.Arguments;
            string activationPath = operation.CurrentDirectoryPath;

It’s important to remember that the command-line arguments are supplied by the caller, which means that you have no control over them. You should treat these arguments as untrustworthy and parse them very carefully. They might not have any malicious intent, but they could easily be badly formed, so you need to allow for this.

After the initial checks, you can create a window as normal, and optionally pass in the (parsed and validated) command-line arguments – or some data extracted from the arguments – to that window.


            Frame rootFrame = Window.Current.Content as Frame;
            if (rootFrame == null)
            {
                rootFrame = new Frame();
                Window.Current.Content = rootFrame;
            }
            rootFrame.Navigate(typeof(MainPage), 
                string.Format("CurrentDirectory={0}, Arguments={1}",
                activationPath, cmdLineString));
            Window.Current.Activate();

Finally, in your page’s OnNavigatedTo, you can retrieve the payload from the event args, and use the information in any way you like:


protected override void OnNavigatedTo(NavigationEventArgs e)
{
    string cmdLineString = e.Parameter as string;
}

When you build and run the app on your dev machine – or when the end user installs your app – the  alias is registered. From that point, the user can go to a command line and activate your app.

Note that by “command line,” we mean any common command line mechanism such as cmd.exe,  powershell.exe, Windows-R and so on. Here’s a slightly more sophisticated example in which the app implements a custom parser to construct command-payload tuples from the command-line arguments:


protected override void OnActivated(IActivatedEventArgs args)
{
    switch (args.Kind)
    {
        case ActivationKind.CommandLineLaunch:
            CommandLineActivatedEventArgs cmdLineArgs = 
                args as CommandLineActivatedEventArgs;
            CommandLineActivationOperation operation = cmdLineArgs.Operation;
            string cmdLineString = operation.Arguments;
            string activationPath = operation.CurrentDirectoryPath;

            Frame rootFrame = Window.Current.Content as Frame;
            if (rootFrame == null)
            {
                rootFrame = new Frame();
                Window.Current.Content = rootFrame;
            }

            ParsedCommands parsedCommands = 
                CommandLineParser.ParseUntrustedArgs(cmdLineString);
            if (parsedCommands != null && parsedCommands.Count > 0)
            {
                foreach (ParsedCommand command in parsedCommands)
                {
                    switch (command.Type)
                    {
                        case ParsedCommandType.SelectItem:
                            rootFrame.Navigate(typeof(SelectItemPage), command.Payload);
                            break;
                        case ParsedCommandType.LoadConfig:
                            rootFrame.Navigate(typeof(LoadConfigPage), command.Payload);
                            break;
                        case ParsedCommandType.Unknown:
                            rootFrame.Navigate(typeof(HelpPage), cmdLineString);
                            break;
                    }
                }
            }
            else
            {
                rootFrame.Navigate(typeof(MainPage));
            }

            Window.Current.Activate();
            break;
    }
}

The app’s logic uses these more structured commands to navigate to different pages and handle the payload in different ways. The point is that you can define whatever argument options and payload rules you like in your app.

A common scenario is testing: You can activate your app with a defined set of values for each test run – for example, to start on a particular page with boundary values set for key items – or to start a game at a particular level, with values set for player attributes, enemy count, damage levels, fuel and weaponry and so on.

If the data you provide is too long or too complex for command-line arguments, you can supply a filename on the command-line which the app can then load. One option is to include such files as content in your package (and most likely strip them out before building your release build). You can also create the files at any time later, so long as you put them in a location to which the app has access. If you want to avoid showing any filepicker UX in your app, the simplest option is to put the files in the install location for the app, which would be somewhere like %userprofile%AppDataLocalPackages<Package ID>LocalState.

You should also allow for incoming arguments that are badly formed or otherwise unrecognized:

And a reasonable UX here would be to navigate to a page where you show the user the correct usage options:

Also, bear in mind that the UWP platform has a single-instance app model. This means that your app can be running, and you can then continue to execute command-line activation requests at any point thereafter. Each activation will result in a call into OnActivated. This is unlikely to be useful in end-user scenarios of course – but it can be a useful debugging/profiling strategy during development.

Command-line activation of UWAs is just one example of how we’re gradually closing the gaps between traditional Win32 development and UWA development. This feature brings you yet another missing piece from the old world that you can now leverage in your modern apps.

Announcing UWP Community Toolkit 1.5

Today marks the sixth release of the UWP Community Toolkit – all packages are updated to version 1.5. Thanks to the UWP developer community, the UWP Community Toolkit has seen great improvements and stability to the existing controls and services. The community partnership has led to several new additions to this release.

To highlight a few of the new additions, the UWP Community Toolkit now includes:

  1. Menu: A classic control used by traditional desktop applications, adapted for the Universal Windows Platform. As requested by the community on UserVoice, the Menu allows the developer to provide a hierarchical list of menus and submenus that support any input modality and can adapt to the screen size to provide a natural and fluid interaction.
  2. OrbitView: A new ItemsControl that arranges elements around a center element and provides flexibility for size and distance for each element, as well as the ability to show orbits or anchors for each item.
  3. RadialProgressBar: A XAML Control that displays a value within a range using a circular sector that grows clockwise until it becomes a full ring. A fantastic variation of the ProgressBar.
  4. RoundImageEx: Similar to the ImageEx control, the RoundImageEx control downloads and locally caches images asynchronously while showing loading indicators. In addition, the RoundImageEx allows images to be clipped as circles.
  5. ExpressionBuilder: A type-safe way to build powerful composition ExpressionAnimation.
  6. BluetoothLEHelper: The BluetoothLEHelper class provides functionality to easily enumerate, connect to and interact with Bluetooth LE Peripherals.

For a complete overview of what’s new in version 1.5, please read our release notes on GitHub.

The release of Windows 10 Creators Update (build 10.0.15063) has enabled several new APIs that make it possible to improve several controls used in apps targeting the latest update. Therefore, several packages are now targeting the Windows 10 Creators Update and can take advantage of these new APIs. We encourage all developers using the toolkit to update their apps to the latest version of the UWP Community Toolkit.

As a reminder, the UWP Community Toolkit can be used in any UWP app across PC, Xbox One, mobile, HoloLens and Surface Hub devices. You can get started by following this tutorial, or preview the latest features by installing the UWP Community Toolkit Sample App from the Windows Store.

If you would like to contribute, please join us on GitHub!

Windows 10 Tip: Keep your apps organized with virtual desktops

Happy Monday! We’ve showed you how you can easily view and manage all the apps and programs you have open at once with Task View and Snap – today, we’re going to show you how you can keep your open apps better organized with virtual desktops in Windows 10.

Here’s how to get started with virtual desktops:

To create a new virtual desktop, select the Task View button on the Windows Taskbar (or hit Windows key + Tab)

To create a new virtual desktop, select the Task View button on the Windows Taskbar (or hit Windows key + Tab) – then, select New desktop near the lower-right corner of the screen. You can switch between virtual desktops by selecting the Task View button, and then the thumbnail for the virtual desktop you want.

Move an app from one virtual desktop to another:

Move an app from one virtual desktop to another. Select the Task View button, and right-click on the thumbnail of the app you want to move

Select the Task View button, and right-click on the thumbnail of the app you want to move. Select Move to, and then select the virtual desktop where you want to move the app.

Have a great week!

What tools troubleshoot Autodiscover in Exchange Online?

Think a move to the cloud means you’ll never have to troubleshoot connectivity issues again? In reality, these…

“;
}
});

/**
* remove unnecessary class from ul
*/
$(“#inlineregform”).find( “ul” ).removeClass(“default-list”);

/**
* Replace “errorMessageInput” class with “sign-up-error-msg” class
*/
function renameErrorMsgClass() {
$(“.errorMessageInput”).each(function() {
if ($(this).hasClass(“hidden”)) {
$(this).removeClass(“errorMessageInput hidden”).addClass(“sign-up-error-msg hidden”);
} else {
$(this).removeClass(“errorMessageInput”).addClass(“sign-up-error-msg”);
}
});
}

/**
* when validation function is called, replace “errorMessageInput” with “sign-up-error-msg”
* before return
*/
function validateThis(v, form) {
var validateReturn = urValidation.validate(v, form);
renameErrorMsgClass();
return validateReturn;
}

/**
* DoC pop-up window js – included in moScripts.js which is not included in responsive page
*/
$(“#inlineRegistration”).on(“click”,”a.consentWindow”, function(e) {
window.open(this.href, “Consent”, “width=500,height=600,scrollbars=1”);
e.preventDefault();
});

types of problems won’t disappear and might be more difficult to solve because you only have control and visibility into part of the application.

Various tools diagnose and troubleshoot problems with Autodiscover, a web service in Microsoft Exchange Online that enables mailbox admins to configure user profile settings.

Use the Outlook troubleshooting utility

Outlook has a built-in Autodiscover troubleshooting tool. To access it, hold down Ctrl and right-click the Outlook icon in the system tray. This brings up a box labeled “Test Email AutoConfiguration,” as shown in Figure 1.

Outlook Autodiscover tool
Figure 1: The Outlook Autodiscover tool displays how Office 365 sends Autodiscover information to the client.

This test shows how the client receives — or does not receive — Autodiscover information from Office 365. This tool runs as part of Outlook on the user’s PC: If the organization’s network configuration causes the Autodiscover problem, this tool responds as if the Autodiscover endpoint is offline. To get the correct results, run the test several times from both inside and outside the organization’s network.

Try the Remote Connectivity Analyzer

The Microsoft Remote Connectivity Analyzer is a web-based tool that identifies issues with Office 365 applications (Figure 2). Click on the Office 365 tab and select the Outlook Autodiscover test under Microsoft Office Outlook Connectivity Tests.

Microsoft Remote Connectivity Analyzer
Figure 2: Use the Microsoft Remote Connectivity Analyzer to address Office 365 problems.

The Microsoft Remote Connectivity Analyzer runs tests external to the organization’s network. If these tests pass, but the test run from the Outlook client does not, the issue resides with network access to Office 365.

Run the Support and Recovery Assistant

The last tool to try is the Microsoft Support and Recovery Assistant for Office 365 (Figure 3).

Support and Recovery Assistant
Figure 3: The Microsoft Support and Recovery Assistant for Office 365 walks the administrator through the diagnostic process with a series of questions to identify the Autodiscover problem.

The Support and Recovery Assistant asks a series of questions to assist administrators with various Office 365 issues. Depending on the test, the Support and Recovery Assistant might connect to Office 365 from the PC or from test resources that Microsoft maintains, such as the Remote Connectivity Analyzer.

If the Autodiscover issue remains unresolved, open a case with Microsoft Support.

Next Steps

Methods to correct mail flow trouble in Exchange

How Autodiscover works in a hybrid configuration

Free utilities to help admins monitor, manage Exchange

Dig Deeper on Microsoft Outlook

Have a question for an expert?

Please add a title for your question

Get answers from a TechTarget expert on whatever’s puzzling you.

Powered by WPeMatico

VMware Workspace One

Key integrations with AirWatch and Horizon make Workspace One a tempting proposition for companies already invested in the VMware ecosystem. Shortcomings in areas like reporting or a simplified setup path may have the opposite effect on potential customers that don’t already have an investment in VMware.