Full Stack Engineering Day 4
Frontend & Mobile Masterclass
Full Stack Engineering · Day 4

Frontend & Mobile Application Development

From HTML, CSS and JavaScript to browser rendering, component architecture, responsive interfaces, native apps, Flutter and store releases.

Browser fundamentalsBundles & CDNReact & AngularResponsive UINative mobileFlutter & React Native
01

The frontend is what users see, touch and operate.

For the web, every framework eventually produces HTML, CSS and JavaScript that the browser can execute.

HTML

Structure and meaning: headings, navigation, forms, articles and controls.

CSS

Layout and presentation: spacing, typography, colour and responsive behaviour.

JavaScript

Events and behaviour: API calls, validation, state and screen updates.

Backend API

Authoritative data, authentication, permissions and business rules.

The smallest interactive frontend
<button id="load">Load products</button>
<ul id="products"></ul>

<script>
document.querySelector("#load").onclick = async () => {
  const response = await fetch("/api/products");
  const products = await response.json();
  document.querySelector("#products").innerHTML =
    products.map(p => "<li>" + p.name + "</li>").join("");
};
</script>
02

A URL becomes files, browser structures and finally pixels.

How a frontend travels from URL through hosting to browser rendering and API updates
URLDNSCDN / Nginx / S3HTML + CSS + JSDOM + CSSOMPixels

Static delivery

The browser downloads HTML, styles, JavaScript, images and fonts from a static host or CDN.

Dynamic data

JavaScript sends HTTPS requests to a backend API, receives JSON and updates visible state.

The server delivering the JavaScript bundle and the backend implementing business logic are different roles, even when they share one domain.
03

Developers write source modules; users receive production bundles.

Frontend source compiled bundled and deployed through storage and CDN

Source

Components, TypeScript or JSX, styles, tests and assets in a repository.

Build

Compile, bundle, tree-shake, minify, code-split and generate content hashes.

Deploy

Place generated files on Nginx, object storage or a frontend platform, then distribute through a CDN.

Typical production output
dist/
├── index.html
├── assets/app.a82fd9.js
├── assets/styles.91bc7.css
├── assets/vendor.27ac1.js
└── assets/logo.8b19.png
Nginx SPA fallback
location /assets/ {
  try_files $uri =404;
  expires 1y;
  add_header Cache-Control "public, immutable";
}

location / {
  try_files $uri $uri/ /index.html;
}

location /api/ {
  proxy_pass http://backend:8080/;
}
04

Rendering is about where and when HTML is produced.

Comparison of client-side server-side and static-site rendering

CSR

The browser receives a shell. JavaScript fetches data and builds most of the page.

SSR

A server produces HTML per request; client JavaScript hydrates it for interaction.

SSG

The build produces HTML ahead of time and the CDN serves it quickly.

A product may combine these models. Choose by content freshness, interaction, SEO, latency, hosting and operational needs.
05

Frameworks organize complexity; they do not replace the web platform.

The transferable ideas are components, state, events, routing, services, rendering and build tooling.

OptionHigh-level modelUseful perspective
Plain JavaScriptDirect browser APIsThe foundation
jQueryImperative DOM manipulationExisting and legacy interfaces
ReactComposable UI libraryComponents driven by props and state
AngularOpinionated frameworkComponents, DI, services, forms and routing
VueProgressive frameworkTemplates and reactive UI
SvelteCompiler-oriented frameworkMore work at build time
Imperative
count += 1;
document.querySelector("#count").textContent = count;
Declarative React
function Counter() {
  const [count, setCount] = useState(0);
  return <button onClick={() => setCount(count + 1)}>
    {count}
  </button>;
}
06

Nested components, routing and state form the application skeleton.

Nested component architecture with router local global and server state

Props down

A parent provides data and configuration to a child component.

Events up

A child reports a click, selection or edit to its owner.

State has a home

Keep state as close as practical to the components that need it.

State typeExampleNatural home
LocalModal openComponent
FormEmail and errorsForm
URLSearch and pageRouter
ServerAPI productsQuery/cache layer
GlobalUser, theme, cartProvider or store
Route map
const routes = [
  { path: "/", element: <HomePage /> },
  { path: "/products", element: <ProductList /> },
  { path: "/products/:id", element: <ProductDetails /> },
  { path: "/account", element: <RequireLogin><Account /></RequireLogin> }
];
07

React and Angular express many of the same core concepts.

React

Flexible UI library. Components are JavaScript functions, JSX describes UI, hooks manage state and effects, and ecosystem libraries provide routing and server-state tools.

Angular

Integrated framework. Components use templates, services use dependency injection, and routing, forms and HTTP support follow framework conventions.

React: data, state and API lifecycle
function ProductPage() {
  const [products, setProducts] = useState([]);
  const [status, setStatus] = useState("loading");

  useEffect(() => {
    fetch("/api/products")
      .then(r => r.ok ? r.json() : Promise.reject())
      .then(data => { setProducts(data); setStatus("success"); })
      .catch(() => setStatus("error"));
  }, []);

  if (status === "loading") return <p>Loading…</p>;
  if (status === "error") return <p>Could not load products.</p>;
  return <ProductList products={products} />;
}
Angular: component inputs and outputs
@Component({
  selector: "app-product-card",
  template: "<button (click)='selected.emit(product.id)'>" +
            "{{ product.name }}</button>"
})
export class ProductCardComponent {
  @Input() product!: Product;
  @Output() selected = new EventEmitter<number>();
}
08

Responsive design is a baseline capability, not a later patch.

Mobile-first product grid
.product-grid {
  display: grid;
  grid-template-columns: 1fr;
  gap: 1rem;
}

@media (min-width: 48rem) {
  .product-grid { grid-template-columns: repeat(2, 1fr); }
}

@media (min-width: 72rem) {
  .product-grid { grid-template-columns: repeat(4, 1fr); }
}

Layout

Flexible grids, images and containers.

Interaction

Touch targets, keyboard access and clear focus.

Content

Long text, localization, empty and error states.

Devices

Portrait, landscape, tablets and foldables.

A responsive website remains a browser application. A mobile app is installed, participates in the operating-system lifecycle and can integrate more deeply with device capabilities.
09

Mobile development offers four fundamentally different approaches.

Comparison of native cross-platform hybrid and PWA approaches
ApproachTechnologiesBest considered when
NativeKotlin/Compose; Swift/SwiftUIDeep platform integration and platform-first UX
Cross-platformFlutter; React NativeShared product code across Android and iOS
HybridIonic; CapacitorMaximum web reuse with plugin device access
PWAWeb platform; service workerWeb distribution plus install and offline capabilities
Choose using device access, UI fidelity, performance, team skills, code reuse, release cadence and long-term maintenance.
10

Mobile development continues well beyond drawing screens.

Mobile development lifecycle from design to app store release and layered architecture
Design screensWrite codeEmulatorAPIs & device featuresDevice testsSign & release
A durable architecture separates Screen → ViewModel or State → Repository → Local database or backend API.
11

Native development uses the platform's language, UI toolkit and lifecycle.

Android

Android Studio, Kotlin, Jetpack Compose, Navigation, ViewModel, repositories, Room, manifest permissions, emulator/device testing, signed AAB or APK and Play release tracks.

iOS

Xcode, Swift, SwiftUI, NavigationStack, observable state, local persistence, entitlements, privacy descriptions, simulator/device testing, certificates and App Store Connect.

Jetpack Compose screen state
@Composable
fun ProductScreen(state: ProductUiState) {
  when {
    state.loading -> CircularProgressIndicator()
    state.error != null -> Text(state.error)
    else -> LazyColumn {
      items(state.products) { product ->
        ListItem(headlineContent = { Text(product.name) })
      }
    }
  }
}
SwiftUI navigation
struct ProductListView: View {
  let products: [Product]

  var body: some View {
    NavigationStack {
      List(products) { product in
        NavigationLink(product.name) {
          ProductDetailsView(product: product)
        }
      }
    }
  }
}
12

Cross-platform and hybrid tools share code in different ways.

Flutter

Dart widgets describe a shared UI rendered by Flutter. Plugins or platform channels connect to native services.

React Native

React's component and state model targets mobile components and native capabilities rather than HTML elements.

Hybrid

HTML, CSS and JavaScript run in a native container; plugins expose capabilities such as camera and location.

Flutter widget
class ProductCard extends StatelessWidget {
  final Product product;
  const ProductCard({required this.product, super.key});

  Widget build(BuildContext context) {
    return Card(
      child: ListTile(title: Text(product.name))
    );
  }
}
React Native component
function ProductCard({ product, onPress }) {
  return (
    <Pressable onPress={() => onPress(product.id)}>
      <Text>{product.name}</Text>
      <Text>₹{product.price}</Text>
    </Pressable>
  );
}
13

Mobile engineering must handle interruption, permission and unreliable networks.

Navigation

Stacks, tabs, drawers and deep links must preserve expected back behaviour.

Lifecycle

Foreground, background, suspension and termination can interrupt work at any moment.

Permissions

Explain why a capability is needed and design granted, denied and unavailable paths.

Cache first, refresh second
async function loadProducts() {
  render(await localDatabase.products.all());

  try {
    const fresh = await api.products.list();
    await localDatabase.products.replaceAll(fresh);
    render(fresh);
  } catch {
    showOfflineIndicator();
  }
}
Offline-first is a product and data-consistency decision. Queues need stable identifiers, safe retries and explicit conflict rules.
14

Every client has a different production artifact and delivery path.

TargetArtifactDistribution
WebHTML, CSS, JavaScript and assetsNginx, object storage, CDN or managed platform
AndroidAPK or Android App BundleGoogle Play or managed distribution
iOSSigned archive/application packageApp Store Connect or managed distribution

Before release

Environment, identifiers, versions, signing, permissions, privacy metadata and device tests.

During release

Store submission, review, staged rollout, compatibility and rollback planning.

After release

Crash reporting, performance, analytics, feedback and backward-compatible APIs.

Web and mobile bundles are distributed to users. Never place database passwords, private API keys or confidential secrets inside them.

Final mental model

  1. The browser consumes HTML, CSS and JavaScript.
  2. Source becomes an optimized production bundle.
  3. Components, state, events, routing and services transfer across frameworks.
  4. Responsive web and installed mobile apps are different delivery models.
  5. Mobile engineering includes device lifecycle, permissions, offline data, signing and store distribution.
  6. Web and mobile clients can share backend APIs while keeping platform-specific experiences.