diff --git a/maplibre-demo/src/headless.rs b/maplibre-demo/src/headless.rs
index b7faa1cb..e2af984e 100644
--- a/maplibre-demo/src/headless.rs
+++ b/maplibre-demo/src/headless.rs
@@ -35,7 +35,15 @@ pub async fn run_headless(tile_size: u32, min: LatLon, max: LatLon) {
         .await
         .expect("Failed to initialize renderer");
 
-    let mut map = HeadlessMap::new(Style::default(), renderer, kernel).unwrap();
+    let style = Style::default();
+
+    let requested_layers = style
+        .layers
+        .iter()
+        .map(|layer| layer.source_layer.as_ref().unwrap().clone())
+        .collect::<Vec<_>>();
+
+    let mut map = HeadlessMap::new(style, renderer, kernel).unwrap();
 
     let tile_limits = google_mercator().tile_limits(
         extent_wgs84_to_merc(&Extent {
@@ -51,10 +59,16 @@ pub async fn run_headless(tile_size: u32, min: LatLon, max: LatLon) {
         let coords = WorldTileCoords::from((x as i32, y as i32, z.into()));
         println!("Rendering {}", &coords);
         let tile = map
-            .fetch_tile(coords, &["water"])
+            .fetch_tile(
+                coords,
+                &requested_layers
+                    .iter()
+                    .map(|layer| layer.as_str())
+                    .collect::<Vec<_>>(),
+            )
             .await
-            .expect("Failed to fetch and process!");
+            .expect("Failed to fetch and process");
 
-        map.render_tile(tile);
+        map.render_tile(tile).expect("Rendering failed");
     }
 }
diff --git a/maplibre/src/headless/map.rs b/maplibre/src/headless/map.rs
index eedc27ce..8bc80e37 100644
--- a/maplibre/src/headless/map.rs
+++ b/maplibre/src/headless/map.rs
@@ -46,11 +46,9 @@ impl HeadlessMap {
             window_size,
             WorldCoords::from((TILE_SIZE / 2., TILE_SIZE / 2.)),
             Zoom::default(),
-            cgmath::Deg(110.0),
+            cgmath::Deg(0.0),
         );
 
-        let mut schedule = Schedule::default();
-
         let mut graph = create_default_render_graph()?;
         let draw_graph = graph
             .get_sub_graph_mut(draw_graph::NAME)
@@ -60,8 +58,8 @@ impl HeadlessMap {
             .add_node_edge(draw_graph::node::MAIN_PASS, draw_graph::node::COPY)
             .unwrap(); // TODO: remove unwrap
 
+        let mut schedule = Schedule::default();
         register_default_render_stages(graph, &mut schedule);
-
         schedule.add_stage(
             RenderStageLabel::Cleanup,
             WriteSurfaceBufferStage::default(),
@@ -78,13 +76,17 @@ impl HeadlessMap {
         })
     }
 
-    pub async fn render_tile(&mut self, tile: StoredTile) -> Result<(), Error> {
+    pub fn render_tile(&mut self, tile: StoredTile) -> Result<(), Error> {
         let context = &mut self.map_context;
 
         if let Eventually::Initialized(pool) = context.renderer.state.buffer_pool_mut() {
             pool.clear();
+        } else {
+            // TODO return error
         }
 
+        context.world.tile_repository.clear();
+
         context.world.tile_repository.put_tile(tile);
 
         self.schedule.run(&mut self.map_context);
@@ -103,10 +105,11 @@ impl HeadlessMap {
         let mut pipeline_context = PipelineContext::new(HeadlessPipelineProcessor::default());
         let pipeline = build_vector_tile_pipeline();
 
+        let target_coords = WorldTileCoords::default(); // load to 0,0,0
         pipeline.process(
             (
                 TileRequest {
-                    coords: WorldTileCoords::default(),
+                    coords: target_coords,
                     layers: source_layers
                         .iter()
                         .map(|layer| layer.to_string())
@@ -121,7 +124,7 @@ impl HeadlessMap {
             .take_processor::<HeadlessPipelineProcessor>()
             .expect("Unable to get processor");
 
-        Ok(StoredTile::success(coords, processor.layers))
+        Ok(StoredTile::success(target_coords, processor.layers))
     }
 }