What it does

Responsive canvas layout means turning off the app's automatic scaling and instead sizing every control with formulas or auto-layout containers, so the app uses the space it's actually given rather than being stretched to fit.

Key facts

• Scale to fit is on by default. Until you turn it off in Settings > Display, the whole app is scaled as one image to the available space — bigger pixels, not more content. Turning it off also turns off Lock aspect ratio.
• Screen Width and Height default to Max(App.Width, App.MinScreenWidth) and Max(App.Height, App.MinScreenHeight). App.Width and App.Height track the real browser window or device and change live on resize or rotate.
• The screen's Size property returns a ScreenSize constant: Small (1), Medium (2), Large (3), ExtraLarge (4). It's derived by comparing screen width to App.SizeBreakpoints.
• App.SizeBreakpoints defaults to [600, 900, 1200] for tablet and web apps and [1200, 1800, 2400] for phone apps — phone coordinates are effectively doubled. You can edit the table, add more breakpoints, or use fewer.
• Horizontal and vertical containers are auto-layout: children never get X and Y set, and space is distributed using Fill portions, Align, Justify and Gap.
• Drag-and-drop is disabled inside layout containers. Reorder via Tree view or arrow keys.
• Data table, Charts and Add Picture controls aren't supported inside layout containers.
• Inside a gallery template, use Parent.TemplateWidth and Parent.TemplateHeight — Parent.Width and Parent.Height refer to the whole gallery.

When to use / skip

Build responsive if the app will be used on more than one form factor, or on desktop at all — a fixed-ratio app in a maximised browser window looks like a scaled-up phone app because that's exactly what it is. Skip the full responsive treatment for a genuinely single-device app, like a warehouse scanner app on one model of handheld, where the effort buys nothing. Everything in between: use containers, not hand-written X/Y maths, because the maths is where the maintenance cost lives.

Configuration decisions

• Whether to go responsive at all, decided at the start — retrofitting responsiveness onto a positioned layout is a rebuild of every screen.
• Containers versus formula-based positioning. Containers are faster to build and easier to hand over; formulas give finer control and let you reference sibling controls.
• Where the breakpoints sit, and whether the defaults match the client's actual device estate rather than Microsoft's assumptions.
• What happens at Small — controls hidden, stacked vertically, or a separate screen entirely.
• MinScreenWidth and MinScreenHeight, which decide the point at which the app stops shrinking and starts scrolling.

Gotchas

• Write a formula in X, Y, Width or Height, then nudge the control on the canvas, and your formula is silently replaced with a constant. This catches everyone at least once.
• The authoring canvas doesn't honour your sizing formulas. The only real test is save, publish, and open it in browser windows of different sizes.
• Container Wrap and Align fight each other — with Wrap on, Align is ignored on children. And with Wrap off, primary-axis overflow set to Scroll, and Justify set to Center or End, children can become unreachable even though scrolling is enabled.
• Some container properties are hidden on child controls. You can still set them from the formula bar or the advanced pane, and they'll still be ignored.

Consultant notes

• Agree the target devices in writing during discovery, including whether "tablet" means a 10-inch iPad or a Surface in a laptop dock. That sentence decides the entire layout approach.
• Demo the app in a resized browser window at the first showcase, not the last. Clients notice layout problems late and treat them as defects.
• Containers make an app dramatically easier for someone else to maintain. That's the argument to use with the client's internal team, not "responsiveness".
• Budget explicit time for responsive work. It is not a finishing touch, it's a structural decision that affects every screen you build afterwards.

---

Worth revisiting if the container controls pick up constraint-based fixed layout, or if the default breakpoints change.