What are some tactics you can use as a junior/intermediate developer in a company with a lack of senior developers to mitigate the risks you discussed and foster growth?
That resonated with me quite a bit, I feel like what she described to me is something all great developers I know do instinctually. I think at the end of the day, that constant honest reflection is the single most important thing to do for us. Our profession loves to pull ideas from math and other hard sciences, but at least from my part of it (product/business development), I think we can learn just as much from social sciences, if not more.
So what does that mean to a developer? When you see a problem somewhere, don't just stop at identifying it, try to classify it. What other problems are like it? Why did it happen in the first place? Read a lot of books about how to build software, but when you implement things from those books, try to reflect on the idea behind the solution, not just the solution. When it is done, reflect on how it worked out, and how the code looks at the end, what you like and what you don't like. If you go back to it, try to remember your initial feelings, and see how it panned out.
But a senior has more experience with the "why" behind the coding. What are the requirements in terms of schedule, user experience, stability, maintainability, performance, development process, QA, etc. A junior can be great at one of these, but a senior has to take responsibility for all of them. So you need to understand the needs of all the stakeholders outside the dev team. (At least the basics; functional details deserve an expert of their own.)
(Yet all the interviews I turn up to these days want an hour and a half timed coding challenge to be completed).
I think an interview that focuses on coding challenges isn't really looking for a senior. Point them to a junior that's more appropriate to their needs.
In most interviews I do, we do talk about abstractions and maintainability and stuff like that. Although I have recently done one that involved a coding kata, which was kind of interesting because during the kata we also moved through a couple of (small scale) levels of abstraction while discussing them, and particularly the appropriate time to abstract some stuff.